List[int]:\n ...","def getnextbyte(data, index):\n v = data[index]\n index += 1\n if v == 0x10:\n v = data[index]\n index += 1\n\n return v,index","def test_bytes_to_ihex_inner_extended_linear_address_record():\n data = b'A' * 32\n expected_result = '\\n'.join([\n ':020000040003F7',\n ':10FFF00D41414141414141414141414141414141E4',\n ':020000040004F6',\n ':1000000D41414141414141414141414141414141D3',\n ])\n\n result = uflash.bytes_to_ihex(0x3FFF0, data, universal_data_record=True)\n\n assert result == expected_result","def test_bytes_to_intel_hex():\n data = [1, 2, 3, 4, 5]\n expected_hex_str = \"\\n\".join([\":050000000102030405EC\", INTEL_HEX_EOF])\n\n result = cmds._bytes_to_intel_hex(data=data)\n\n assert expected_hex_str == result","def hex_list(self):\r\n return [''.join(['{:02X}'.format(b) for b in data]) for data in self.buffers()]","def save_byte_index(index, fp):\n encoded_index = dict()\n for key, offset in index.items():\n encoded_index[key.decode(\"utf8\")] = offset\n json.dump(encoded_index, fp)\n return fp","def render_list_as_hex(self, data):\n s = '[ '\n for c in data:\n s += '%02x ' % c\n s += ']'\n return s","def test_bytes_to_ihex():\n data = b'A' * 32\n expected_result = '\\n'.join([\n ':020000040003F7',\n ':108C10004141414141414141414141414141414144',\n ':108C20004141414141414141414141414141414134',\n ])\n\n result = uflash.bytes_to_ihex(0x38C10, data, universal_data_record=False)\n\n assert result == expected_result","def hx(i):\n a = hex(i)[2:]\n if len(a)<2: a = ''.join(['0',a])\n return a","def load_byte_index(fp):\n data = json.load(fp)\n index = xml.ByteEncodingOrderedDict()\n for key, value in sorted(data.items(), key=lambda x: x[1]):\n index[key] = value\n return index","def wkb_hex(self): # -> str:\n ...","def decode_bytes_hex(buf, pos):\n value, pos = decode_bytes(buf, pos)\n return binascii.hexlify(value), pos","def index_to_bytes(i):\n lead = i // 188;\n lead_offset = 0x81 if lead < 0x1F else 0xC1\n trail = i % 188\n trail_offset = 0x40 if trail < 0x3F else 0x41\n return (lead + lead_offset, trail + trail_offset)","def getHexwords(msg):\n hexwords = []\n for i in range(0, len(msg), 8):\n msgBlock = msg[i:i+8]\n m = stringToHex(msgBlock)\n hexwords.append(m)\n\n last = hexwords[-1]\n hexwords[-1] += ''.join(['0'] * (16-len(last)))\n return hexwords","def OffsetToStringData(self) -> int:","def test_wire_index():\n assert jet.Wire(id_=1, depth=2).index == \"1-2\"","def test_bytearray_doesnt_overfill(self):\n self._doesnt_overfill_test(bytearray)","def test_bytes_to_ihex_universal():\n data = b'A' * 32\n expected_result = '\\n'.join([\n ':020000040003F7',\n ':108C100D4141414141414141414141414141414137',\n ':108C200D4141414141414141414141414141414127',\n ])\n\n result = uflash.bytes_to_ihex(0x38C10, data, universal_data_record=True)\n\n assert result == expected_result","def test_bytes_to_pretty_hexinvalid_data():\n try:\n cmds._bytes_to_pretty_hex(data=[1, 2, 3, 4, \"500\"])\n except Exception:\n # The exception that bubbles up from IntelHex is implementation detail\n # from that library, so it could be anything\n assert True, \"Exception raised\"\n else:\n raise AssertionError(\"Exception NOT raised\")","def _text_array(text):\n text = \"<mxit/>\" + text\n \n ar = map(ord, text)\n pads = 16 - (len(ar) % 16)\n ar += [0] * (pads-1)\n ar.append(pads)\n \n return ar","def GetElementsFaceNumberingHex(self):\n\n if isinstance(self.face_to_element,np.ndarray):\n if self.face_to_element.shape[0] > 1:\n return self.face_to_element\n\n assert self.elements is not None\n\n # GET ALL FACES FROM ELEMENT CONNECTIVITY\n if self.all_faces is None:\n self.GetFacesHex()\n\n C = self.InferPolynomialDegree() - 1\n node_arranger = NodeArrangementHex(C)[0]\n\n all_faces = np.concatenate((np.concatenate((\n np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],\n self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),\n self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),\n self.elements[:,node_arranger[5,:]]),axis=0).astype(self.all_faces.dtype)\n\n _,idx = unique2d(all_faces,consider_sort=True,order=False, return_index=True)\n face_elements = np.zeros((self.all_faces.shape[0],2),dtype=np.int64)\n\n face_elements[:,0] = idx % self.elements.shape[0]\n face_elements[:,1] = idx // self.elements.shape[0]\n\n self.face_to_element = face_elements\n return self.face_to_element","def bytes_as_char_array(b):\n return \"{ \" + \", \".join(\"0x%02x\" % x for x in b) + \" }\"","def GetElementsWithBoundaryFacesHex(self):\n\n # DO NOT COMPUTE FACES AND RAISE BECAUSE OF CYCLIC DEPENDENCIES\n assert self.elements is not None\n assert self.faces is not None\n\n if self.boundary_face_to_element is not None:\n return self.boundary_face_to_element\n\n # THIS METHOD ALWAYS RETURNS THE FACE TO ELEMENT ARRAY, AND DOES NOT CHECK\n # IF THIS HAS BEEN COMPUTED BEFORE, THE REASON BEING THAT THE FACES CAN COME\n # EXTERNALLY WHOSE ARRANGEMENT WOULD NOT CORRESPOND TO THE ONE USED INTERNALLY\n # HENCE THIS MAPPING BECOMES NECESSARY\n\n C = self.InferPolynomialDegree() - 1\n node_arranger = NodeArrangementHex(C)[0]\n\n all_faces = np.concatenate((np.concatenate((\n np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],\n self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),\n self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),\n self.elements[:,node_arranger[5,:]]),axis=0).astype(self.faces.dtype)\n\n all_faces_in_faces = in2d(all_faces,self.faces[:,:4],consider_sort=True)\n all_faces_in_faces = np.where(all_faces_in_faces==True)[0]\n\n boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)\n boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]\n boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]\n\n\n # SO FAR WE HAVE COMPUTED THE ELEMENTS THAT CONTAIN FACES, HOWEVER\n # NOTE THAT WE STILL HAVE NOT COMPUTED A MAPPING BETWEEN ELEMENTS AND\n # FACES. WE ONLY KNOW WHICH ELEMENTS CONTAIN FACES FROM in2d.\n # WE NEED TO FIND THIS MAPPING NOW\n\n # WE NEED TO DO THIS DUMMY RECONSTRUCTION OF FACES BASED ON ELEMENTS\n faces = self.elements[boundary_face_to_element[:,0][:,None],\n node_arranger[boundary_face_to_element[:,1],:]].astype(self.faces.dtype)\n\n # CHECK FOR THIS CONDITION AS ARRANGEMENT IS NO LONGER MAINTAINED\n assert np.sum(faces[:,:4].astype(np.int64) - self.faces[:,:4].astype(np.int64)) == 0\n\n # NOW GET THE ROW MAPPING BETWEEN OLD FACES AND NEW FACES\n from Florence.Tensor import shuffle_along_axis\n row_mapper = shuffle_along_axis(faces[:,:4],self.faces[:,:4],consider_sort=True)\n\n # UPDATE THE MAP\n boundary_face_to_element[:,:] = boundary_face_to_element[row_mapper,:]\n self.boundary_face_to_element = boundary_face_to_element\n\n return self.boundary_face_to_element","def index2qindexb(self, index):\n r = index // 0x10\n c = index % 0x10\n return self.index(r, c)","def get_val(i):\r\n\t\t\treturn bytearray([int(i/256),int(i)-int(i/256)*256])","def _char_to_array_index(self, ch):\n return ord(ch) - ord('a')","def testGetOne(self):\n data = b'0123456789'\n inst = WireData(data)\n for i, byte in enumerate(bytearray(data)):\n self.assertEqual(inst[i], byte)\n for i in range(-1, len(data) * -1, -1):\n self.assertEqual(inst[i], bytearray(data)[i])","def get_byte_string(self):\n return \"\".join(['%02X' % i for i in self._data]).decode('hex')","def _encode(self, obj, ctx):\n\n # enforce unicode\n if not isinstance(obj, unicode):\n obj = obj.decode('utf8')\n\n ordlist = []\n\n for chr_ in obj:\n ord_ = get_ord(chr_)\n if ord_ == 0xFFFF:\n break\n ordlist.append(ord_)\n \n while len(ordlist) < (self.bytes - 1):\n ordlist.append(0xFFFF)\n \n ordlist = ordlist[:(self.bytes - 1)]\n ordlist.append(0xFFFF) # enforce term byte\n\n return ordlist","def test_bytes_to_pretty_hex():\n data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]\n expected = (\n \"0000 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 \"\n \"|................|\\n\"\n )\n\n result = cmds._bytes_to_pretty_hex(data=data)\n\n assert expected == result","def test_bytearray_really_doesnt_overfill(self):\n self._doesnt_overfill_test(bytearray)","def index(self, example):\n for i in xrange(self.length):\n binary = bin(i).lstrip('0b')\n for i in xrange(self.variables-len(binary)):\n binary = '0'+binary\n for j in xrange(self.variables):\n index = True\n if example[j] == -1:\n example[j] = 0\n if int(binary[j]) != example[j]:\n index = False\n if index:\n return i\n return False","def test_bytes_to_intel_hex_invalid_data():\n data = [1, 2, 3, 4, \"500\"]\n\n try:\n cmds._bytes_to_intel_hex(data=data)\n except Exception:\n # The exception that bubbles up from IntelHex is implementation detail\n # from that library, so it could be anything\n assert True, \"Exception raised\"\n else:\n raise AssertionError(\"Exception NOT raised\")","def getAddressOfIndex(self) -> long:\n ...","def test_int_to_hex():\n hex_values = ['61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f',\n '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f']\n index = 0\n for x in range(97, 123):\n assert pi_finder.int_to_hex(x, hex_dict) == hex_values[index]\n index += 1","def idx2off(i):\n return i * 32 - (24 * (i//4))","def test00(self):\n a = np.arange(1, 111)\n b = bcolz.fromiter(iter(a), dtype='i4', count=len(a))\n assert_array_equal(b[:], a, \"fromiter does not work correctly\")","def to_index(self, char):\n return ord(char) - ord(\"A\") - 32","def _parse_atom_index(index):\n try:\n return int(index)\n except:\n return int(index, 16) - 0xA0000 + 100000","def indices(self):\n\n # We used lookup tables here. Read more about other methods here:\n # https://chessprogramming.wikispaces.com/Bitboard+Serialization\n\n if self.num == 0:\n return []\n\n bits = []\n\n for i in [0, 1, 2, 3, 4, 5, 6, 7]:\n row = (self.num >> UINT64_PADDING[i]) & EIGHT_ONES\n indices = row_to_indices[row]\n for index in indices:\n bits.append(index + i*8)\n\n return bits","def _extract_first_bytes(self, func):\n return str(Web3.toHex(Web3.sha3(text=func)[0:4]))[2:]","def __bytes__(self):\n byteout = bytearray()\n for index in range(1, 15):\n key = \"d\" + str(index)\n if self._user_data.get(key) is not None:\n byteout.append(self._user_data[key])\n else:\n byteout.append(0x00)\n return bytes(byteout)","def to_bytes(self):\n pref = Utf8String(self.prefix)\n string = MultiByteInt31(self.index)\n\n bytes = (super(DictionaryElementRecord, self).to_bytes() +\n pref.to_bytes() +\n string.to_bytes())\n\n for attr in self.attributes:\n bytes += attr.to_bytes()\n return bytes","def part_two(data):\r\n\r\n tl = TwistList(256)\r\n\r\n ascii_codes = [ord(char) for char in data]\r\n ascii_codes += [17, 31, 73, 47, 23] #add padding\r\n\r\n for _ in range(64):\r\n for length in ascii_codes:\r\n tl.twist(int(length))\r\n\r\n return to_hex_str(hash_reduce(tl.list))","def put(num, ind, arr):\r\n out = shift(arr)\r\n while out[ind] != str(num):\r\n arr[ind%16] += 1\r\n arr[ind%16] %= 10\r\n out = shift(arr)\r\n return arr, out","def test_utf8_bytes_in_an_array(self):\n # Python3 doesn't support bytestrings, don't run this test\n if str is unicode:\n return\n input = \"A r\\xc3\\xa9sum\\xc3\\xa9, also spelled resum\\xc3\\xa9 or resume\"\n output = input.split(\" \")\n output[1] = output[1][0:-1]\n input = array.array('c', input)\n output = [array.array('c', w) for w in output]\n for (itmO, itmV) in zip(output, tokenize_en(array.array('c', input))):\n self.assertEqual(itmO, itmV[0])\n self.assertEqual(input[itmV[1]:itmV[1] + len(itmV[0])], itmO)","def keyIndex(self, key):\n key ^= bsr(key, 33)\n key *= 0xff51afd7ed558ccdL\n key ^= bsr(key, 33)\n key *= 0xc4ceb9fe1a85ec53L\n key ^= bsr(key, 33)\n return key","def test04(self):\n a = np.arange(1, 101)\n b = bcolz.carray(a)\n idx = np.array([1.1, 3.3], dtype='f8')\n self.assertRaises(IndexError, b.__getitem__, idx)","def rgb_bytes_tuple(self, x):\n return self.rgba_bytes_tuple(x)[:3]","def getByteArray2D(self) -> typing.List[typing.List[int]]:\n ...","def from_hex(x):\n\treturn numpy.fromstring(\n\t\tbinascii.a2b_hex(x),\n\t\tdtype=numpy.uint8\n\t)","def decodeindexes(self, idx):\n text = \"\"\n for elem in idx:\n char = self.index2char[elem]\n if char not in SPCHARS:\n text += char\n\n return text","def get_usint(bytearray_, byte_index):\n data = bytearray_[byte_index] & 0xff\n packed = struct.pack('B', data)\n value = struct.unpack('>B', packed)[0]\n return value","def test00(self):\n a = np.arange(1, 111)\n b = bcolz.carray(a)\n c = b[[3, 1]]\n r = a[[3, 1]]\n assert_array_equal(c, r, \"fancy indexing does not work correctly\")","def bytestoint(self, byte_list: list):\n return int.from_bytes(byte_list, 'big' if self.big_endian_ints else 'little')","def _allocate_index_bytes(self):\n id_placeholder = self.max_idx_len * b\"\\x01\"\n offset_placeholder = self.max_offset_len * b\"\\x01\"\n for i in range(self.max_idx_num):\n self.file_out.write(id_placeholder)\n self.file_out.write(offset_placeholder)\n self.file_out.write(b\"\\x00\")\n return","def bytes_to_uuid_list(byte_array):\n result = []\n for i in range(0, len(byte_array)//16):\n result.append(uuid.UUID(bytes=bytes(byte_array[i*16:i*16+16])))\n return result","def setByteArray(self, name: unicode, value: List[int]) -> None:\n ...","def parse_arrayindexandlength(number):\n # Could just use >> and & for this, but since we have to be more\n # careful with LinkIdAndLinkedBehavior anyway, since that one's\n # weirder, we may as well just use struct here, as well.\n number = int(number)\n byteval = struct.pack('>i', number)\n return struct.unpack('>HH', byteval)","def as_bytearray(self):\n\n if self.index < 7:\n return self.buf + bytearray([self.byte])\n else:\n return self.buf","def test_analyze_syntax_utf16():\n test_string = \"a \\u00e3 \\u0201 \\U0001f636 b\"\n byte_array = test_string.encode(\"utf16\")\n # Remove the byte order marker, which the offsets don't account for\n byte_array = byte_array[2:]\n result = analyze.analyze_syntax(test_string, encoding=\"UTF16\")\n tokens = result[\"tokens\"]\n\n assert tokens[0][\"text\"][\"content\"] == \"a\"\n # The offset is an offset into an array where each entry is 16 bits. Since\n # we have an 8-bit array, the offsets should be doubled to index into our\n # array.\n offset = 2 * tokens[0][\"text\"].get(\"beginOffset\", 0)\n assert (\n byte_array[offset : offset + 2].decode(\"utf16\") == tokens[0][\"text\"][\"content\"]\n )\n\n assert tokens[1][\"text\"][\"content\"] == \"\\u00e3\"\n offset = 2 * tokens[1][\"text\"].get(\"beginOffset\", 0)\n # A UTF16 character with a low codepoint is 16 bits (2 bytes) long, so\n # slice out 2 bytes starting from the offset. Then interpret the bytes as\n # utf16 for comparison.\n assert (\n byte_array[offset : offset + 2].decode(\"utf16\") == tokens[1][\"text\"][\"content\"]\n )\n\n assert tokens[2][\"text\"][\"content\"] == \"\\u0201\"\n offset = 2 * tokens[2][\"text\"].get(\"beginOffset\", 0)\n # A UTF16 character with a low codepoint is 16 bits (2 bytes) long, so\n # slice out 2 bytes starting from the offset. Then interpret the bytes as\n # utf16 for comparison.\n assert (\n byte_array[offset : offset + 2].decode(\"utf16\") == tokens[2][\"text\"][\"content\"]\n )\n\n assert tokens[3][\"text\"][\"content\"] == \"\\U0001f636\"\n offset = 2 * tokens[3][\"text\"].get(\"beginOffset\", 0)\n # A UTF16 character with a high codepoint is 32 bits (4 bytes) long, so\n # slice out 4 bytes starting from the offset. Then interpret those bytes as\n # utf16 for comparison.\n assert (\n byte_array[offset : offset + 4].decode(\"utf16\") == tokens[3][\"text\"][\"content\"]\n )\n\n # This demonstrates that the offset takes into account the variable-length\n # characters before the target token.\n assert tokens[4][\"text\"][\"content\"] == \"b\"\n offset = 2 * tokens[4][\"text\"].get(\"beginOffset\", 0)\n # Even though 'b' is only one byte long, utf16 still encodes it using 16\n # bits\n assert (\n byte_array[offset : offset + 2].decode(\"utf16\") == tokens[4][\"text\"][\"content\"]\n )","def bytes_arr_to_hex_str(bytes_arr: List[int]) -> str:\n return \", \".join(\"0x%02x\" % b for b in bytes_arr)","def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode) -> ghidra.program.model.address.Address:\n ...","def test_tile_read_tuple_index():\n bounds = (\n -11663507.036777973,\n 4715018.0897710975,\n -11663487.927520901,\n 4715037.199028169,\n )\n with rasterio.open(S3_PATH) as src_dst:\n arr, mask = reader.part(src_dst, bounds, 16, 16, indexes=(1,))\n assert arr.shape == (1, 16, 16)\n assert mask.shape == (16, 16)","def Read2000256List(self):\n items = []\n for i in range(0, 2000):\n data = self.ReadBytes(64)\n ba = bytearray(binascii.unhexlify(data))\n ba.reverse()\n items.append(ba.hex().encode('utf-8'))\n return items","def offset(self):\r\n return self.buf[0].unib[9:11]","def ByteToHex( byteStr ):\r\n \r\n # Uses list comprehension which is a fractionally faster implementation than\r\n # the alternative, more readable, implementation below\r\n # \r\n # hex = []\r\n # for aChar in byteStr:\r\n # hex.append( \"%02X \" % ord( aChar ) )\r\n #\r\n # return ''.join( hex ).strip() \r\n\r\n return ''.join( [ \"%02X \" % ord( x ) for x in byteStr ] ).strip()","def _get_index(self, character):\n OFFSET = 65 # ascii value of 'A' since the first element should be 'A'\n index = ord(character) - OFFSET\n return index","def byteIndex(self):\n return self.offset","def _hashable_content(self) -> Tuple[int]:\n return (self.index,)","def test02(self):\n a = np.arange(101)\n b = bcolz.carray(a)\n c = b[[]]\n r = a[[]]\n assert_array_equal(c, r, \"fancy indexing does not work correctly\")","def decode_ihex(text):\n lines = text.split('\\n')\n\n data = bytearray()\n for lineno, one in enumerate(lines):\n e = SyntaxError()\n e.lineno = lineno + 1\n e.text = one\n\n subp = one.strip()\n if one[0] != ':': \n e.msg = \"unexcept start symbol '{}'.\".format(one[0])\n e.offset = 0\n raise e\n \n subp = subp[1:]\n if subp == \"00000001FF\":\n #end of the file\n break\n \n\n # 用字符表示的二进制，忽略第0个固定的':'字符，每两个字符作为一个byte\n # : | 03 | 00-00 | 00 |02-0A-58| 99\n # 开头 数据长度 开始地址(大端) 类型 数据 校验和\n # （不用管） （只要管00） （不用管)\n # (01 end of file, see line 11)\n data_len = int(subp[0:2],16)\n start_addr = int(subp[2:6],16)\n data_type = int(subp[6:8],16)\n\n if data_type != 0x00:\n e.msg = \"unexcept segment type {}.\".format(data_type)\n e.offset = 6\n raise e\n\n for _ in range(len(data), start_addr + data_len):\n data.append(0)\n \n for i in range(data_len):\n offset = 2*i + 8\n data[start_addr + i] = int(subp[offset:offset + 2], 16)\n \n return data","def getBitArrayIndices(self, key):\n\t\treturnList = []\n\t\tfor i in range(1, self.k + 1):\n\t\t\treturnList.append((hash(key) + i * mmh3.hash(key)) % self.m)\n\t\t#print \"Indices list for key: \", key, \" is: \", str(returnList)\n\t\treturn returnList","def bytes_as_printed_to_hex(b):\n a = \"\"\n skip = 0\n for i in range(len(b)):\n if skip > 0:\n skip -= 1\n continue\n if b[i] == \"\\\\\":\n if b[i+1] == \"x\":\n a += b[i+2]\n a += b[i+3]\n skip = 3\n else:\n a += str(hex(ord(b[i]))[2:])\n\n return a","def idx_to_list(bytez):\n # byte 0: 0\n # byte 1: 0\n if not (bytez[0] == 0 and bytez[1] == 0):\n raise IOError(\"IDX file should start with two 0 bytes\")\n\n # byte 2: The number of dimensions\n # byte 3: The type code\n typebyte = bytez[2]\n numdims = bytez[3]\n\n # 4 bytes for each dimension: size of dimensions\n fmtstring = '>' + 'i'*numdims\n dimension_sizes = struct.unpack(fmtstring, bytez[4:4+4*numdims])\n\n # Rest of the data starts here\n startoffset = 4 + 4*numdims\n\n typedata = {\n 0x08: ('B', 1),\n 0x09: ('b', 1),\n 0x0B: ('h', 2),\n 0x0C: ('i', 4),\n 0x0D: ('f', 4),\n 0x0E: ('d', 8)\n }\n\n typecode = typedata[typebyte][0]\n flatarray = array.array(typecode, bytez[startoffset:])\n if sys.byteorder == 'little':\n flatarray.byteswap()\n\n if flatarray.itemsize != typedata[typebyte][1]:\n raise EnvironmentError(\"It's assumed a C int is 4 bytes\")\n\n def _recursive(inputlst, dimsizes):\n \"\"\"Recursively split the flat list into chunks and merge them back into a\n nested list structure.\"\"\"\n if len(dimsizes) == 1:\n return list(inputlst)\n\n outerlist = []\n chunksize = len(inputlst)//dimsizes[0]\n for i in range(0, len(inputlst), chunksize):\n chunk = inputlst[i:i+chunksize]\n outerlist.append(_recursive(chunk, dimsizes[1:]))\n\n return outerlist\n\n return _recursive(flatarray, dimension_sizes)","def sub_bytes(state, s_box=s_box):\n for i in range(4):\n for j in range(4):\n state[i][j] = s_box[state[i][j]]","def test_hex_bytes_empty():\n assert hex_bytes(bytes([]), truncate=1) == '(0 bytes)'\n assert hex_bytes(bytes([]), truncate=0) == '(0 bytes)'","def test_hex_straining():\n\n for protocol in LEGACY_PROTOCOLS:\n p = protocol([])\n\n # single non-hex message\n r = p([\"12.8 Volts\"])\n assert len(r) == 1\n assert r[0].ecu == ECU.UNKNOWN\n assert len(r[0].frames) == 1\n\n\n # multiple non-hex message\n r = p([\"12.8 Volts\", \"NO DATA\"])\n assert len(r) == 2\n\n for m in r:\n assert m.ecu == ECU.UNKNOWN\n assert len(m.frames) == 1\n\n # mixed hex and non-hex\n r = p([\"NO DATA\", \"48 6B 10 41 00 00 01 02 03 FF\"])\n assert len(r) == 2\n\n # first message should be the valid, parsable hex message\n # NOTE: the parser happens to process the valid one's first\n check_message(r[0], 1, 0x10, [0x41, 0x00, 0x00, 0x01, 0x02, 0x03])\n\n # second message: invalid, non-parsable non-hex\n assert r[1].ecu == ECU.UNKNOWN\n assert len(r[1].frames) == 1\n assert len(r[1].data) == 0 # no data","def ConvertTetsToHexes(self):\n\n self.__do_essential_memebers_exist__()\n if self.element_type == \"hex\":\n return\n assert self.element_type == \"tet\"\n if self.IsHighOrder:\n raise ValueError('High order tetrahedral elements cannot be converted to low/high order hexahedrals')\n\n tconv = time()\n\n # SPLIT THE TET INTO 4 QUADS\n\n # FIND MEDIAN OF TETS\n # median = self.Median()\n median = np.sum(self.points[self.elements,:],axis=1)/self.elements.shape[1]\n # FIND EDGE MIDPOINTS OF TETS\n mid01 = np.sum(self.points[self.elements[:,[0,1]],:],axis=1)/2.\n mid02 = np.sum(self.points[self.elements[:,[2,0]],:],axis=1)/2.\n mid03 = np.sum(self.points[self.elements[:,[0,3]],:],axis=1)/2.\n mid12 = np.sum(self.points[self.elements[:,[1,2]],:],axis=1)/2.\n mid13 = np.sum(self.points[self.elements[:,[1,3]],:],axis=1)/2.\n mid23 = np.sum(self.points[self.elements[:,[2,3]],:],axis=1)/2.\n # FIND MEDIAN OF FACES\n med012 = np.sum(self.points[self.elements[:,[0,1,2]],:],axis=1)/3.\n med013 = np.sum(self.points[self.elements[:,[0,1,3]],:],axis=1)/3.\n med023 = np.sum(self.points[self.elements[:,[0,2,3]],:],axis=1)/3.\n med123 = np.sum(self.points[self.elements[:,[1,2,3]],:],axis=1)/3.\n\n # # STABLE APPROACH\n # points = np.zeros((1,3))\n # for elem in range(self.nelem):\n # hex0 = np.concatenate((self.points[self.elements[elem,0],:][None,:], mid01[elem,:][None,:],\n # med012[elem,:][None,:], mid02[elem,:][None,:],\n # mid03[elem,:][None,:], med013[elem,:][None,:],\n # median[elem,:][None,:], med023[elem,:][None,:]),axis=0)\n\n # hex1 = np.concatenate((self.points[self.elements[elem,1],:][None,:], mid13[elem,:][None,:],\n # med123[elem,:][None,:], mid12[elem,:][None,:],\n # mid01[elem,:][None,:], med013[elem,:][None,:],\n # median[elem,:][None,:], med012[elem,:][None,:]),axis=0)\n\n # hex2 = np.concatenate((self.points[self.elements[elem,3],:][None,:], mid23[elem,:][None,:],\n # med123[elem,:][None,:], mid13[elem,:][None,:],\n # mid03[elem,:][None,:], med023[elem,:][None,:],\n # median[elem,:][None,:], med013[elem,:][None,:]),axis=0)\n\n # hex3 = np.concatenate((self.points[self.elements[elem,2],:][None,:], mid02[elem,:][None,:],\n # med012[elem,:][None,:], mid12[elem,:][None,:],\n # mid23[elem,:][None,:], med023[elem,:][None,:],\n # median[elem,:][None,:],med123[elem,:][None,:]),axis=0)\n\n # points = np.concatenate((points,hex0,hex1,hex2,hex3))\n # points = points[1:,:]\n\n points = np.zeros((4*self.nelem*8,3))\n points[0::4*8,:] = self.points[self.elements[:,0],:]\n points[1::32,:] = mid01\n points[2::32,:] = med012\n points[3::32,:] = mid02\n points[4::32,:] = mid03\n points[5::32,:] = med013\n points[6::32,:] = median\n points[7::32,:] = med023\n\n points[8::32,:] = self.points[self.elements[:,1],:]\n points[9::32,:] = mid13\n points[10::32,:] = med123\n points[11::32,:] = mid12\n points[12::32,:] = mid01\n points[13::32,:] = med013\n points[14::32,:] = median\n points[15::32,:] = med012\n\n points[16::32,:] = self.points[self.elements[:,3],:]\n points[17::32,:] = mid23\n points[18::32,:] = med123\n points[19::32,:] = mid13\n points[20::32,:] = mid03\n points[21::32,:] = med023\n points[22::32,:] = median\n points[23::32,:] = med013\n\n points[24::32,:] = self.points[self.elements[:,2],:]\n points[25::32,:] = mid02\n points[26::32,:] = med012\n points[27::32,:] = mid12\n points[28::32,:] = mid23\n points[29::32,:] = med023\n points[30::32,:] = median\n points[31::32,:] = med123\n\n # KEEP ZEROFY ON, OTHERWISE YOU GET STRANGE BEHVAIOUR\n Decimals = 10\n rounded_points = points.copy()\n makezero(rounded_points)\n rounded_repoints = np.round(rounded_points,decimals=Decimals)\n points, inv_points = unique2d(rounded_points,order=False,\n consider_sort=False,return_inverse=True)\n\n\n elements = np.arange(points.shape[0])[inv_points].reshape(4*self.nelem,8)\n\n\n self.__reset__()\n\n self.element_type = \"hex\"\n self.elements = elements\n self.points = points\n self.nelem = self.elements.shape[0]\n self.nnode = self.points.shape[0]\n self.GetBoundaryFacesHex()\n self.GetBoundaryEdgesHex()\n\n print(\"Tetrahedral to hexahedral mesh conversion took\", time() - tconv, \"seconds\")","def test_find_string():\n assert pi_finder.find_string('j', hex_dict) == (5, 6)\n assert pi_finder.find_string('l', hex_dict) == (61, 62)\n assert pi_finder.find_string('c', hex_dict) == (72, 73)","def _write_to_lsb(tribit: str, rgb_binary: tuple):\n pixel = []\n for idx, bit in enumerate(tribit):\n color = rgb_binary[idx]\n color = color[:-1] + bit\n pixel.append(color)\n\n return pixel","def dump_hex(memory, startad, endad, width =4):\n res = \"\"\n gap = 0\n CHUNK_SIZE = 16\n \n addr = startad\n while addr < endad:\n if endad - addr < CHUNK_SIZE:\n read_chunk = endad - addr\n else:\n read_chunk = CHUNK_SIZE\n membytes = cpu.read_memory(addr, read_chunk) \n if membytes != bytearray(CHUNK_SIZE):\n if gap > 0:\n res += \"*** gap of {:d} bytes\\n\".format(gap)\n gap = 0\n res += \"{:08x} \".format(addr)\n for i in range(0,len(membytes),width):\n reversed_bytes=bytearray(width)\n if len(membytes)-i < width:\n #print(\"Partial line length= {0}\", len(bytes)-i)\n k = width-1\n for j in range(len(membytes)-1,i,-1): #Error here\n reversed_bytes[k] = membytes[j]\n k = k-1\n \n else:\n if width == 4:\n reversed_bytes = (membytes[i+3],membytes[i+2],\n membytes[i+1],membytes[i])\n else:\n reversed_bytes = (membytes[i+1],membytes[i])\n res += my_hex(reversed_bytes)+\" \"\n \n res += char_repr(membytes) +\"\\n\"\n else:\n gap += CHUNK_SIZE\n addr += CHUNK_SIZE\n \n return res","def bytes_value(self) -> global___Expression.BytesValue:","def javaByteArray(a):\n b = jarray.zeros(len(a), 'b')\n for i in range(len(a)):\n b[i] = struct.unpack('b', struct.pack('B', a[i]))[0]\n return b","def elem_ords(self):\n pass","def test01(self):\n a = np.arange(1, 1e4)\n b = bcolz.carray(a)\n idx = np.random.randint(1000, size=1000)\n c = b[idx]\n r = a[idx]\n assert_array_equal(c, r, \"fancy indexing does not work correctly\")","def generate_index(size=20):\n return hexlify(np.random.rand(100))[:size].decode()","def test_decompress_offset_less_len1(self):\n b_array = bytearray([32]) + bytearray(b'ab') + bytearray([0, 18])\n actual = LZ77.decompress(b_array)\n expected = 'ababab'\n self.assertEqual(actual, expected)","def lookup_table(self):\n if hasattr(self, '_m_lookup_table'):\n return self._m_lookup_table if hasattr(self, '_m_lookup_table') else None\n\n self._m_lookup_table = [b\"\\x00\\x00\", b\"\\x4E\\xBA\", b\"\\x00\\x08\", b\"\\x4E\\x75\", b\"\\x00\\x0C\", b\"\\x4E\\xAD\", b\"\\x20\\x53\", b\"\\x2F\\x0B\", b\"\\x61\\x00\", b\"\\x00\\x10\", b\"\\x70\\x00\", b\"\\x2F\\x00\", b\"\\x48\\x6E\", b\"\\x20\\x50\", b\"\\x20\\x6E\", b\"\\x2F\\x2E\", b\"\\xFF\\xFC\", b\"\\x48\\xE7\", b\"\\x3F\\x3C\", b\"\\x00\\x04\", b\"\\xFF\\xF8\", b\"\\x2F\\x0C\", b\"\\x20\\x06\", b\"\\x4E\\xED\", b\"\\x4E\\x56\", b\"\\x20\\x68\", b\"\\x4E\\x5E\", b\"\\x00\\x01\", b\"\\x58\\x8F\", b\"\\x4F\\xEF\", b\"\\x00\\x02\", b\"\\x00\\x18\", b\"\\x60\\x00\", b\"\\xFF\\xFF\", b\"\\x50\\x8F\", b\"\\x4E\\x90\", b\"\\x00\\x06\", b\"\\x26\\x6E\", b\"\\x00\\x14\", b\"\\xFF\\xF4\", b\"\\x4C\\xEE\", b\"\\x00\\x0A\", b\"\\x00\\x0E\", b\"\\x41\\xEE\", b\"\\x4C\\xDF\", b\"\\x48\\xC0\", b\"\\xFF\\xF0\", b\"\\x2D\\x40\", b\"\\x00\\x12\", b\"\\x30\\x2E\", b\"\\x70\\x01\", b\"\\x2F\\x28\", b\"\\x20\\x54\", b\"\\x67\\x00\", b\"\\x00\\x20\", b\"\\x00\\x1C\", b\"\\x20\\x5F\", b\"\\x18\\x00\", b\"\\x26\\x6F\", b\"\\x48\\x78\", b\"\\x00\\x16\", b\"\\x41\\xFA\", b\"\\x30\\x3C\", b\"\\x28\\x40\", b\"\\x72\\x00\", b\"\\x28\\x6E\", b\"\\x20\\x0C\", b\"\\x66\\x00\", b\"\\x20\\x6B\", b\"\\x2F\\x07\", b\"\\x55\\x8F\", b\"\\x00\\x28\", b\"\\xFF\\xFE\", b\"\\xFF\\xEC\", b\"\\x22\\xD8\", b\"\\x20\\x0B\", b\"\\x00\\x0F\", b\"\\x59\\x8F\", b\"\\x2F\\x3C\", b\"\\xFF\\x00\", b\"\\x01\\x18\", b\"\\x81\\xE1\", b\"\\x4A\\x00\", b\"\\x4E\\xB0\", b\"\\xFF\\xE8\", b\"\\x48\\xC7\", b\"\\x00\\x03\", b\"\\x00\\x22\", b\"\\x00\\x07\", b\"\\x00\\x1A\", b\"\\x67\\x06\", b\"\\x67\\x08\", b\"\\x4E\\xF9\", b\"\\x00\\x24\", b\"\\x20\\x78\", b\"\\x08\\x00\", b\"\\x66\\x04\", b\"\\x00\\x2A\", b\"\\x4E\\xD0\", b\"\\x30\\x28\", b\"\\x26\\x5F\", b\"\\x67\\x04\", b\"\\x00\\x30\", b\"\\x43\\xEE\", b\"\\x3F\\x00\", b\"\\x20\\x1F\", b\"\\x00\\x1E\", b\"\\xFF\\xF6\", b\"\\x20\\x2E\", b\"\\x42\\xA7\", b\"\\x20\\x07\", b\"\\xFF\\xFA\", b\"\\x60\\x02\", b\"\\x3D\\x40\", b\"\\x0C\\x40\", b\"\\x66\\x06\", b\"\\x00\\x26\", b\"\\x2D\\x48\", b\"\\x2F\\x01\", b\"\\x70\\xFF\", b\"\\x60\\x04\", b\"\\x18\\x80\", b\"\\x4A\\x40\", b\"\\x00\\x40\", b\"\\x00\\x2C\", b\"\\x2F\\x08\", b\"\\x00\\x11\", b\"\\xFF\\xE4\", b\"\\x21\\x40\", b\"\\x26\\x40\", b\"\\xFF\\xF2\", b\"\\x42\\x6E\", b\"\\x4E\\xB9\", b\"\\x3D\\x7C\", b\"\\x00\\x38\", b\"\\x00\\x0D\", b\"\\x60\\x06\", b\"\\x42\\x2E\", b\"\\x20\\x3C\", b\"\\x67\\x0C\", b\"\\x2D\\x68\", b\"\\x66\\x08\", b\"\\x4A\\x2E\", b\"\\x4A\\xAE\", b\"\\x00\\x2E\", b\"\\x48\\x40\", b\"\\x22\\x5F\", b\"\\x22\\x00\", b\"\\x67\\x0A\", b\"\\x30\\x07\", b\"\\x42\\x67\", b\"\\x00\\x32\", b\"\\x20\\x28\", b\"\\x00\\x09\", b\"\\x48\\x7A\", b\"\\x02\\x00\", b\"\\x2F\\x2B\", b\"\\x00\\x05\", b\"\\x22\\x6E\", b\"\\x66\\x02\", b\"\\xE5\\x80\", b\"\\x67\\x0E\", b\"\\x66\\x0A\", b\"\\x00\\x50\", b\"\\x3E\\x00\", b\"\\x66\\x0C\", b\"\\x2E\\x00\", b\"\\xFF\\xEE\", b\"\\x20\\x6D\", b\"\\x20\\x40\", b\"\\xFF\\xE0\", b\"\\x53\\x40\", b\"\\x60\\x08\", b\"\\x04\\x80\", b\"\\x00\\x68\", b\"\\x0B\\x7C\", b\"\\x44\\x00\", b\"\\x41\\xE8\", b\"\\x48\\x41\"]\n return self._m_lookup_table if hasattr(self, '_m_lookup_table') else None","def getbytes(data, offset):\n if data[offset] == 0xFF and data[offset + 1] == 0xFF:\n return b'', offset + 2 # Blank string\n length, offset = getint(data, offset, 2) # 2-byte length\n value = data[offset:offset + length]\n return value, (offset + length)"],"string":"[\n \"def test_byte_array_conversion():\\n ob = ConversionTest()\\n\\n assert ob.ByteArrayField is None\\n\\n ob.ByteArrayField = [0, 1, 2, 3, 4]\\n array = ob.ByteArrayField\\n assert len(array) == 5\\n assert array[0] == 0\\n assert array[4] == 4\\n\\n value = b\\\"testing\\\"\\n ob.ByteArrayField = value\\n array = ob.ByteArrayField\\n for i, _ in enumerate(value):\\n assert array[i] == operator.getitem(value, i)\",\n \"def test_sbyte_array_conversion():\\n ob = ConversionTest()\\n\\n assert ob.SByteArrayField is None\\n\\n ob.SByteArrayField = [0, 1, 2, 3, 4]\\n array = ob.SByteArrayField\\n assert len(array) == 5\\n assert array[0] == 0\\n assert array[4] == 4\\n\\n value = b\\\"testing\\\"\\n ob.SByteArrayField = value\\n array = ob.SByteArrayField\\n for i, _ in enumerate(value):\\n assert array[i] == operator.getitem(value, i)\",\n \"def asIndex(i):\\n return u\\\"\\\".join([unichr(0x2050 + ord(c)) for c in str(i)])\",\n \"def asIndex(i):\\n return u\\\"\\\".join([unichr(0x2050 + ord(c)) for c in str(i)])\",\n \"def test_bytes_to_intel_hex_offset():\\n data = [1, 2, 3, 4, 5]\\n offset = 0x2000000\\n expected_hex_str = \\\"\\\\n\\\".join(\\n [\\\":020000040200F8\\\", \\\":050000000102030405EC\\\", INTEL_HEX_EOF]\\n )\\n\\n result = cmds._bytes_to_intel_hex(data=data, offset=offset)\\n\\n assert expected_hex_str == result\",\n \"def bytes_to_index(lead, tail):\\n lead_offset = 0x81 if lead < 0xA0 else 0xC1\\n tail_offset = 0x40 if tail < 0x7F else 0x41\\n return (lead - lead_offset) * 188 + tail - tail_offset\",\n \"def test_string_to_hex():\\n strings = ['helloworld', 'HelloWorld', 'HELLOWORLD', 'Hello WorLd', 'hElLo W Or L d', 'h e l l o w o r l d']\\n\\n for i, word in enumerate(strings):\\n assert pi_finder.string_to_hex(word, hex_dict) == '68656c6c6f776f726c64'\",\n \"def _hexbyte(b):\\n return _hexchar(b[0]) * 16 + _hexchar(b[1])\",\n \"def swap_byte(byte_array, index):\\n\\n if byte_array[index] == 0:\\n changed_byte_array = byte_array[0:index] + b\\\"\\\\xff\\\" + byte_array[index + 1 :]\\n changed_byte_array = byte_array[0:index] + b\\\"\\\\x00\\\" + byte_array[index + 1 :]\\n return changed_byte_array\",\n \"def _key_array(key):\\n key = map(ord, key)[:16]\\n initial = map(ord, \\\"6170383452343567\\\")\\n while len(key) < len(initial):\\n key.append(initial[len(key)])\\n return key\",\n \"def test_bytes_to_pretty_hex_offset():\\n data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]\\n offset = 0x2000001\\n expected = (\\n \\\"2000000 -- 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F \\\"\\n \\\"| ...............|\\\\n\\\"\\n \\\"2000010 10 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \\\"\\n \\\"|. |\\\\n\\\"\\n )\\n\\n result = cmds._bytes_to_pretty_hex(data=data, offset=offset)\\n\\n assert expected == result\",\n \"def getByteArray(self, name: unicode) -> List[int]:\\n ...\",\n \"def getnextbyte(data, index):\\n v = data[index]\\n index += 1\\n if v == 0x10:\\n v = data[index]\\n index += 1\\n\\n return v,index\",\n \"def test_bytes_to_ihex_inner_extended_linear_address_record():\\n data = b'A' * 32\\n expected_result = '\\\\n'.join([\\n ':020000040003F7',\\n ':10FFF00D41414141414141414141414141414141E4',\\n ':020000040004F6',\\n ':1000000D41414141414141414141414141414141D3',\\n ])\\n\\n result = uflash.bytes_to_ihex(0x3FFF0, data, universal_data_record=True)\\n\\n assert result == expected_result\",\n \"def test_bytes_to_intel_hex():\\n data = [1, 2, 3, 4, 5]\\n expected_hex_str = \\\"\\\\n\\\".join([\\\":050000000102030405EC\\\", INTEL_HEX_EOF])\\n\\n result = cmds._bytes_to_intel_hex(data=data)\\n\\n assert expected_hex_str == result\",\n \"def hex_list(self):\\r\\n return [''.join(['{:02X}'.format(b) for b in data]) for data in self.buffers()]\",\n \"def save_byte_index(index, fp):\\n encoded_index = dict()\\n for key, offset in index.items():\\n encoded_index[key.decode(\\\"utf8\\\")] = offset\\n json.dump(encoded_index, fp)\\n return fp\",\n \"def render_list_as_hex(self, data):\\n s = '[ '\\n for c in data:\\n s += '%02x ' % c\\n s += ']'\\n return s\",\n \"def test_bytes_to_ihex():\\n data = b'A' * 32\\n expected_result = '\\\\n'.join([\\n ':020000040003F7',\\n ':108C10004141414141414141414141414141414144',\\n ':108C20004141414141414141414141414141414134',\\n ])\\n\\n result = uflash.bytes_to_ihex(0x38C10, data, universal_data_record=False)\\n\\n assert result == expected_result\",\n \"def hx(i):\\n a = hex(i)[2:]\\n if len(a)<2: a = ''.join(['0',a])\\n return a\",\n \"def load_byte_index(fp):\\n data = json.load(fp)\\n index = xml.ByteEncodingOrderedDict()\\n for key, value in sorted(data.items(), key=lambda x: x[1]):\\n index[key] = value\\n return index\",\n \"def wkb_hex(self): # -> str:\\n ...\",\n \"def decode_bytes_hex(buf, pos):\\n value, pos = decode_bytes(buf, pos)\\n return binascii.hexlify(value), pos\",\n \"def index_to_bytes(i):\\n lead = i // 188;\\n lead_offset = 0x81 if lead < 0x1F else 0xC1\\n trail = i % 188\\n trail_offset = 0x40 if trail < 0x3F else 0x41\\n return (lead + lead_offset, trail + trail_offset)\",\n \"def getHexwords(msg):\\n hexwords = []\\n for i in range(0, len(msg), 8):\\n msgBlock = msg[i:i+8]\\n m = stringToHex(msgBlock)\\n hexwords.append(m)\\n\\n last = hexwords[-1]\\n hexwords[-1] += ''.join(['0'] * (16-len(last)))\\n return hexwords\",\n \"def OffsetToStringData(self) -> int:\",\n \"def test_wire_index():\\n assert jet.Wire(id_=1, depth=2).index == \\\"1-2\\\"\",\n \"def test_bytearray_doesnt_overfill(self):\\n self._doesnt_overfill_test(bytearray)\",\n \"def test_bytes_to_ihex_universal():\\n data = b'A' * 32\\n expected_result = '\\\\n'.join([\\n ':020000040003F7',\\n ':108C100D4141414141414141414141414141414137',\\n ':108C200D4141414141414141414141414141414127',\\n ])\\n\\n result = uflash.bytes_to_ihex(0x38C10, data, universal_data_record=True)\\n\\n assert result == expected_result\",\n \"def test_bytes_to_pretty_hexinvalid_data():\\n try:\\n cmds._bytes_to_pretty_hex(data=[1, 2, 3, 4, \\\"500\\\"])\\n except Exception:\\n # The exception that bubbles up from IntelHex is implementation detail\\n # from that library, so it could be anything\\n assert True, \\\"Exception raised\\\"\\n else:\\n raise AssertionError(\\\"Exception NOT raised\\\")\",\n \"def _text_array(text):\\n text = \\\"<mxit/>\\\" + text\\n \\n ar = map(ord, text)\\n pads = 16 - (len(ar) % 16)\\n ar += [0] * (pads-1)\\n ar.append(pads)\\n \\n return ar\",\n \"def GetElementsFaceNumberingHex(self):\\n\\n if isinstance(self.face_to_element,np.ndarray):\\n if self.face_to_element.shape[0] > 1:\\n return self.face_to_element\\n\\n assert self.elements is not None\\n\\n # GET ALL FACES FROM ELEMENT CONNECTIVITY\\n if self.all_faces is None:\\n self.GetFacesHex()\\n\\n C = self.InferPolynomialDegree() - 1\\n node_arranger = NodeArrangementHex(C)[0]\\n\\n all_faces = np.concatenate((np.concatenate((\\n np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],\\n self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),\\n self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),\\n self.elements[:,node_arranger[5,:]]),axis=0).astype(self.all_faces.dtype)\\n\\n _,idx = unique2d(all_faces,consider_sort=True,order=False, return_index=True)\\n face_elements = np.zeros((self.all_faces.shape[0],2),dtype=np.int64)\\n\\n face_elements[:,0] = idx % self.elements.shape[0]\\n face_elements[:,1] = idx // self.elements.shape[0]\\n\\n self.face_to_element = face_elements\\n return self.face_to_element\",\n \"def bytes_as_char_array(b):\\n return \\\"{ \\\" + \\\", \\\".join(\\\"0x%02x\\\" % x for x in b) + \\\" }\\\"\",\n \"def GetElementsWithBoundaryFacesHex(self):\\n\\n # DO NOT COMPUTE FACES AND RAISE BECAUSE OF CYCLIC DEPENDENCIES\\n assert self.elements is not None\\n assert self.faces is not None\\n\\n if self.boundary_face_to_element is not None:\\n return self.boundary_face_to_element\\n\\n # THIS METHOD ALWAYS RETURNS THE FACE TO ELEMENT ARRAY, AND DOES NOT CHECK\\n # IF THIS HAS BEEN COMPUTED BEFORE, THE REASON BEING THAT THE FACES CAN COME\\n # EXTERNALLY WHOSE ARRANGEMENT WOULD NOT CORRESPOND TO THE ONE USED INTERNALLY\\n # HENCE THIS MAPPING BECOMES NECESSARY\\n\\n C = self.InferPolynomialDegree() - 1\\n node_arranger = NodeArrangementHex(C)[0]\\n\\n all_faces = np.concatenate((np.concatenate((\\n np.concatenate((np.concatenate((np.concatenate((self.elements[:,node_arranger[0,:]],\\n self.elements[:,node_arranger[1,:]]),axis=0),self.elements[:,node_arranger[2,:]]),axis=0),\\n self.elements[:,node_arranger[3,:]]),axis=0),self.elements[:,node_arranger[4,:]]),axis=0),\\n self.elements[:,node_arranger[5,:]]),axis=0).astype(self.faces.dtype)\\n\\n all_faces_in_faces = in2d(all_faces,self.faces[:,:4],consider_sort=True)\\n all_faces_in_faces = np.where(all_faces_in_faces==True)[0]\\n\\n boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)\\n boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]\\n boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]\\n\\n\\n # SO FAR WE HAVE COMPUTED THE ELEMENTS THAT CONTAIN FACES, HOWEVER\\n # NOTE THAT WE STILL HAVE NOT COMPUTED A MAPPING BETWEEN ELEMENTS AND\\n # FACES. WE ONLY KNOW WHICH ELEMENTS CONTAIN FACES FROM in2d.\\n # WE NEED TO FIND THIS MAPPING NOW\\n\\n # WE NEED TO DO THIS DUMMY RECONSTRUCTION OF FACES BASED ON ELEMENTS\\n faces = self.elements[boundary_face_to_element[:,0][:,None],\\n node_arranger[boundary_face_to_element[:,1],:]].astype(self.faces.dtype)\\n\\n # CHECK FOR THIS CONDITION AS ARRANGEMENT IS NO LONGER MAINTAINED\\n assert np.sum(faces[:,:4].astype(np.int64) - self.faces[:,:4].astype(np.int64)) == 0\\n\\n # NOW GET THE ROW MAPPING BETWEEN OLD FACES AND NEW FACES\\n from Florence.Tensor import shuffle_along_axis\\n row_mapper = shuffle_along_axis(faces[:,:4],self.faces[:,:4],consider_sort=True)\\n\\n # UPDATE THE MAP\\n boundary_face_to_element[:,:] = boundary_face_to_element[row_mapper,:]\\n self.boundary_face_to_element = boundary_face_to_element\\n\\n return self.boundary_face_to_element\",\n \"def index2qindexb(self, index):\\n r = index // 0x10\\n c = index % 0x10\\n return self.index(r, c)\",\n \"def get_val(i):\\r\\n\\t\\t\\treturn bytearray([int(i/256),int(i)-int(i/256)*256])\",\n \"def _char_to_array_index(self, ch):\\n return ord(ch) - ord('a')\",\n \"def testGetOne(self):\\n data = b'0123456789'\\n inst = WireData(data)\\n for i, byte in enumerate(bytearray(data)):\\n self.assertEqual(inst[i], byte)\\n for i in range(-1, len(data) * -1, -1):\\n self.assertEqual(inst[i], bytearray(data)[i])\",\n \"def get_byte_string(self):\\n return \\\"\\\".join(['%02X' % i for i in self._data]).decode('hex')\",\n \"def _encode(self, obj, ctx):\\n\\n # enforce unicode\\n if not isinstance(obj, unicode):\\n obj = obj.decode('utf8')\\n\\n ordlist = []\\n\\n for chr_ in obj:\\n ord_ = get_ord(chr_)\\n if ord_ == 0xFFFF:\\n break\\n ordlist.append(ord_)\\n \\n while len(ordlist) < (self.bytes - 1):\\n ordlist.append(0xFFFF)\\n \\n ordlist = ordlist[:(self.bytes - 1)]\\n ordlist.append(0xFFFF) # enforce term byte\\n\\n return ordlist\",\n \"def test_bytes_to_pretty_hex():\\n data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]\\n expected = (\\n \\\"0000 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 \\\"\\n \\\"|................|\\\\n\\\"\\n )\\n\\n result = cmds._bytes_to_pretty_hex(data=data)\\n\\n assert expected == result\",\n \"def test_bytearray_really_doesnt_overfill(self):\\n self._doesnt_overfill_test(bytearray)\",\n \"def index(self, example):\\n for i in xrange(self.length):\\n binary = bin(i).lstrip('0b')\\n for i in xrange(self.variables-len(binary)):\\n binary = '0'+binary\\n for j in xrange(self.variables):\\n index = True\\n if example[j] == -1:\\n example[j] = 0\\n if int(binary[j]) != example[j]:\\n index = False\\n if index:\\n return i\\n return False\",\n \"def test_bytes_to_intel_hex_invalid_data():\\n data = [1, 2, 3, 4, \\\"500\\\"]\\n\\n try:\\n cmds._bytes_to_intel_hex(data=data)\\n except Exception:\\n # The exception that bubbles up from IntelHex is implementation detail\\n # from that library, so it could be anything\\n assert True, \\\"Exception raised\\\"\\n else:\\n raise AssertionError(\\\"Exception NOT raised\\\")\",\n \"def getAddressOfIndex(self) -> long:\\n ...\",\n \"def test_int_to_hex():\\n hex_values = ['61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f',\\n '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f']\\n index = 0\\n for x in range(97, 123):\\n assert pi_finder.int_to_hex(x, hex_dict) == hex_values[index]\\n index += 1\",\n \"def idx2off(i):\\n return i * 32 - (24 * (i//4))\",\n \"def test00(self):\\n a = np.arange(1, 111)\\n b = bcolz.fromiter(iter(a), dtype='i4', count=len(a))\\n assert_array_equal(b[:], a, \\\"fromiter does not work correctly\\\")\",\n \"def to_index(self, char):\\n return ord(char) - ord(\\\"A\\\") - 32\",\n \"def _parse_atom_index(index):\\n try:\\n return int(index)\\n except:\\n return int(index, 16) - 0xA0000 + 100000\",\n \"def indices(self):\\n\\n # We used lookup tables here. Read more about other methods here:\\n # https://chessprogramming.wikispaces.com/Bitboard+Serialization\\n\\n if self.num == 0:\\n return []\\n\\n bits = []\\n\\n for i in [0, 1, 2, 3, 4, 5, 6, 7]:\\n row = (self.num >> UINT64_PADDING[i]) & EIGHT_ONES\\n indices = row_to_indices[row]\\n for index in indices:\\n bits.append(index + i*8)\\n\\n return bits\",\n \"def _extract_first_bytes(self, func):\\n return str(Web3.toHex(Web3.sha3(text=func)[0:4]))[2:]\",\n \"def __bytes__(self):\\n byteout = bytearray()\\n for index in range(1, 15):\\n key = \\\"d\\\" + str(index)\\n if self._user_data.get(key) is not None:\\n byteout.append(self._user_data[key])\\n else:\\n byteout.append(0x00)\\n return bytes(byteout)\",\n \"def to_bytes(self):\\n pref = Utf8String(self.prefix)\\n string = MultiByteInt31(self.index)\\n\\n bytes = (super(DictionaryElementRecord, self).to_bytes() +\\n pref.to_bytes() +\\n string.to_bytes())\\n\\n for attr in self.attributes:\\n bytes += attr.to_bytes()\\n return bytes\",\n \"def part_two(data):\\r\\n\\r\\n tl = TwistList(256)\\r\\n\\r\\n ascii_codes = [ord(char) for char in data]\\r\\n ascii_codes += [17, 31, 73, 47, 23] #add padding\\r\\n\\r\\n for _ in range(64):\\r\\n for length in ascii_codes:\\r\\n tl.twist(int(length))\\r\\n\\r\\n return to_hex_str(hash_reduce(tl.list))\",\n \"def put(num, ind, arr):\\r\\n out = shift(arr)\\r\\n while out[ind] != str(num):\\r\\n arr[ind%16] += 1\\r\\n arr[ind%16] %= 10\\r\\n out = shift(arr)\\r\\n return arr, out\",\n \"def test_utf8_bytes_in_an_array(self):\\n # Python3 doesn't support bytestrings, don't run this test\\n if str is unicode:\\n return\\n input = \\\"A r\\\\xc3\\\\xa9sum\\\\xc3\\\\xa9, also spelled resum\\\\xc3\\\\xa9 or resume\\\"\\n output = input.split(\\\" \\\")\\n output[1] = output[1][0:-1]\\n input = array.array('c', input)\\n output = [array.array('c', w) for w in output]\\n for (itmO, itmV) in zip(output, tokenize_en(array.array('c', input))):\\n self.assertEqual(itmO, itmV[0])\\n self.assertEqual(input[itmV[1]:itmV[1] + len(itmV[0])], itmO)\",\n \"def keyIndex(self, key):\\n key ^= bsr(key, 33)\\n key *= 0xff51afd7ed558ccdL\\n key ^= bsr(key, 33)\\n key *= 0xc4ceb9fe1a85ec53L\\n key ^= bsr(key, 33)\\n return key\",\n \"def test04(self):\\n a = np.arange(1, 101)\\n b = bcolz.carray(a)\\n idx = np.array([1.1, 3.3], dtype='f8')\\n self.assertRaises(IndexError, b.__getitem__, idx)\",\n \"def rgb_bytes_tuple(self, x):\\n return self.rgba_bytes_tuple(x)[:3]\",\n \"def getByteArray2D(self) -> typing.List[typing.List[int]]:\\n ...\",\n \"def from_hex(x):\\n\\treturn numpy.fromstring(\\n\\t\\tbinascii.a2b_hex(x),\\n\\t\\tdtype=numpy.uint8\\n\\t)\",\n \"def decodeindexes(self, idx):\\n text = \\\"\\\"\\n for elem in idx:\\n char = self.index2char[elem]\\n if char not in SPCHARS:\\n text += char\\n\\n return text\",\n \"def get_usint(bytearray_, byte_index):\\n data = bytearray_[byte_index] & 0xff\\n packed = struct.pack('B', data)\\n value = struct.unpack('>B', packed)[0]\\n return value\",\n \"def test00(self):\\n a = np.arange(1, 111)\\n b = bcolz.carray(a)\\n c = b[[3, 1]]\\n r = a[[3, 1]]\\n assert_array_equal(c, r, \\\"fancy indexing does not work correctly\\\")\",\n \"def bytestoint(self, byte_list: list):\\n return int.from_bytes(byte_list, 'big' if self.big_endian_ints else 'little')\",\n \"def _allocate_index_bytes(self):\\n id_placeholder = self.max_idx_len * b\\\"\\\\x01\\\"\\n offset_placeholder = self.max_offset_len * b\\\"\\\\x01\\\"\\n for i in range(self.max_idx_num):\\n self.file_out.write(id_placeholder)\\n self.file_out.write(offset_placeholder)\\n self.file_out.write(b\\\"\\\\x00\\\")\\n return\",\n \"def bytes_to_uuid_list(byte_array):\\n result = []\\n for i in range(0, len(byte_array)//16):\\n result.append(uuid.UUID(bytes=bytes(byte_array[i*16:i*16+16])))\\n return result\",\n \"def setByteArray(self, name: unicode, value: List[int]) -> None:\\n ...\",\n \"def parse_arrayindexandlength(number):\\n # Could just use >> and & for this, but since we have to be more\\n # careful with LinkIdAndLinkedBehavior anyway, since that one's\\n # weirder, we may as well just use struct here, as well.\\n number = int(number)\\n byteval = struct.pack('>i', number)\\n return struct.unpack('>HH', byteval)\",\n \"def as_bytearray(self):\\n\\n if self.index < 7:\\n return self.buf + bytearray([self.byte])\\n else:\\n return self.buf\",\n \"def test_analyze_syntax_utf16():\\n test_string = \\\"a \\\\u00e3 \\\\u0201 \\\\U0001f636 b\\\"\\n byte_array = test_string.encode(\\\"utf16\\\")\\n # Remove the byte order marker, which the offsets don't account for\\n byte_array = byte_array[2:]\\n result = analyze.analyze_syntax(test_string, encoding=\\\"UTF16\\\")\\n tokens = result[\\\"tokens\\\"]\\n\\n assert tokens[0][\\\"text\\\"][\\\"content\\\"] == \\\"a\\\"\\n # The offset is an offset into an array where each entry is 16 bits. Since\\n # we have an 8-bit array, the offsets should be doubled to index into our\\n # array.\\n offset = 2 * tokens[0][\\\"text\\\"].get(\\\"beginOffset\\\", 0)\\n assert (\\n byte_array[offset : offset + 2].decode(\\\"utf16\\\") == tokens[0][\\\"text\\\"][\\\"content\\\"]\\n )\\n\\n assert tokens[1][\\\"text\\\"][\\\"content\\\"] == \\\"\\\\u00e3\\\"\\n offset = 2 * tokens[1][\\\"text\\\"].get(\\\"beginOffset\\\", 0)\\n # A UTF16 character with a low codepoint is 16 bits (2 bytes) long, so\\n # slice out 2 bytes starting from the offset. Then interpret the bytes as\\n # utf16 for comparison.\\n assert (\\n byte_array[offset : offset + 2].decode(\\\"utf16\\\") == tokens[1][\\\"text\\\"][\\\"content\\\"]\\n )\\n\\n assert tokens[2][\\\"text\\\"][\\\"content\\\"] == \\\"\\\\u0201\\\"\\n offset = 2 * tokens[2][\\\"text\\\"].get(\\\"beginOffset\\\", 0)\\n # A UTF16 character with a low codepoint is 16 bits (2 bytes) long, so\\n # slice out 2 bytes starting from the offset. Then interpret the bytes as\\n # utf16 for comparison.\\n assert (\\n byte_array[offset : offset + 2].decode(\\\"utf16\\\") == tokens[2][\\\"text\\\"][\\\"content\\\"]\\n )\\n\\n assert tokens[3][\\\"text\\\"][\\\"content\\\"] == \\\"\\\\U0001f636\\\"\\n offset = 2 * tokens[3][\\\"text\\\"].get(\\\"beginOffset\\\", 0)\\n # A UTF16 character with a high codepoint is 32 bits (4 bytes) long, so\\n # slice out 4 bytes starting from the offset. Then interpret those bytes as\\n # utf16 for comparison.\\n assert (\\n byte_array[offset : offset + 4].decode(\\\"utf16\\\") == tokens[3][\\\"text\\\"][\\\"content\\\"]\\n )\\n\\n # This demonstrates that the offset takes into account the variable-length\\n # characters before the target token.\\n assert tokens[4][\\\"text\\\"][\\\"content\\\"] == \\\"b\\\"\\n offset = 2 * tokens[4][\\\"text\\\"].get(\\\"beginOffset\\\", 0)\\n # Even though 'b' is only one byte long, utf16 still encodes it using 16\\n # bits\\n assert (\\n byte_array[offset : offset + 2].decode(\\\"utf16\\\") == tokens[4][\\\"text\\\"][\\\"content\\\"]\\n )\",\n \"def bytes_arr_to_hex_str(bytes_arr: List[int]) -> str:\\n return \\\", \\\".join(\\\"0x%02x\\\" % b for b in bytes_arr)\",\n \"def findBytes(self, start: ghidra.program.model.address.Address, byteString: unicode) -> ghidra.program.model.address.Address:\\n ...\",\n \"def test_tile_read_tuple_index():\\n bounds = (\\n -11663507.036777973,\\n 4715018.0897710975,\\n -11663487.927520901,\\n 4715037.199028169,\\n )\\n with rasterio.open(S3_PATH) as src_dst:\\n arr, mask = reader.part(src_dst, bounds, 16, 16, indexes=(1,))\\n assert arr.shape == (1, 16, 16)\\n assert mask.shape == (16, 16)\",\n \"def Read2000256List(self):\\n items = []\\n for i in range(0, 2000):\\n data = self.ReadBytes(64)\\n ba = bytearray(binascii.unhexlify(data))\\n ba.reverse()\\n items.append(ba.hex().encode('utf-8'))\\n return items\",\n \"def offset(self):\\r\\n return self.buf[0].unib[9:11]\",\n \"def ByteToHex( byteStr ):\\r\\n \\r\\n # Uses list comprehension which is a fractionally faster implementation than\\r\\n # the alternative, more readable, implementation below\\r\\n # \\r\\n # hex = []\\r\\n # for aChar in byteStr:\\r\\n # hex.append( \\\"%02X \\\" % ord( aChar ) )\\r\\n #\\r\\n # return ''.join( hex ).strip() \\r\\n\\r\\n return ''.join( [ \\\"%02X \\\" % ord( x ) for x in byteStr ] ).strip()\",\n \"def _get_index(self, character):\\n OFFSET = 65 # ascii value of 'A' since the first element should be 'A'\\n index = ord(character) - OFFSET\\n return index\",\n \"def byteIndex(self):\\n return self.offset\",\n \"def _hashable_content(self) -> Tuple[int]:\\n return (self.index,)\",\n \"def test02(self):\\n a = np.arange(101)\\n b = bcolz.carray(a)\\n c = b[[]]\\n r = a[[]]\\n assert_array_equal(c, r, \\\"fancy indexing does not work correctly\\\")\",\n \"def decode_ihex(text):\\n lines = text.split('\\\\n')\\n\\n data = bytearray()\\n for lineno, one in enumerate(lines):\\n e = SyntaxError()\\n e.lineno = lineno + 1\\n e.text = one\\n\\n subp = one.strip()\\n if one[0] != ':': \\n e.msg = \\\"unexcept start symbol '{}'.\\\".format(one[0])\\n e.offset = 0\\n raise e\\n \\n subp = subp[1:]\\n if subp == \\\"00000001FF\\\":\\n #end of the file\\n break\\n \\n\\n # 用字符表示的二进制，忽略第0个固定的':'字符，每两个字符作为一个byte\\n # : | 03 | 00-00 | 00 |02-0A-58| 99\\n # 开头 数据长度 开始地址(大端) 类型 数据 校验和\\n # （不用管） （只要管00） （不用管)\\n # (01 end of file, see line 11)\\n data_len = int(subp[0:2],16)\\n start_addr = int(subp[2:6],16)\\n data_type = int(subp[6:8],16)\\n\\n if data_type != 0x00:\\n e.msg = \\\"unexcept segment type {}.\\\".format(data_type)\\n e.offset = 6\\n raise e\\n\\n for _ in range(len(data), start_addr + data_len):\\n data.append(0)\\n \\n for i in range(data_len):\\n offset = 2*i + 8\\n data[start_addr + i] = int(subp[offset:offset + 2], 16)\\n \\n return data\",\n \"def getBitArrayIndices(self, key):\\n\\t\\treturnList = []\\n\\t\\tfor i in range(1, self.k + 1):\\n\\t\\t\\treturnList.append((hash(key) + i * mmh3.hash(key)) % self.m)\\n\\t\\t#print \\\"Indices list for key: \\\", key, \\\" is: \\\", str(returnList)\\n\\t\\treturn returnList\",\n \"def bytes_as_printed_to_hex(b):\\n a = \\\"\\\"\\n skip = 0\\n for i in range(len(b)):\\n if skip > 0:\\n skip -= 1\\n continue\\n if b[i] == \\\"\\\\\\\\\\\":\\n if b[i+1] == \\\"x\\\":\\n a += b[i+2]\\n a += b[i+3]\\n skip = 3\\n else:\\n a += str(hex(ord(b[i]))[2:])\\n\\n return a\",\n \"def idx_to_list(bytez):\\n # byte 0: 0\\n # byte 1: 0\\n if not (bytez[0] == 0 and bytez[1] == 0):\\n raise IOError(\\\"IDX file should start with two 0 bytes\\\")\\n\\n # byte 2: The number of dimensions\\n # byte 3: The type code\\n typebyte = bytez[2]\\n numdims = bytez[3]\\n\\n # 4 bytes for each dimension: size of dimensions\\n fmtstring = '>' + 'i'*numdims\\n dimension_sizes = struct.unpack(fmtstring, bytez[4:4+4*numdims])\\n\\n # Rest of the data starts here\\n startoffset = 4 + 4*numdims\\n\\n typedata = {\\n 0x08: ('B', 1),\\n 0x09: ('b', 1),\\n 0x0B: ('h', 2),\\n 0x0C: ('i', 4),\\n 0x0D: ('f', 4),\\n 0x0E: ('d', 8)\\n }\\n\\n typecode = typedata[typebyte][0]\\n flatarray = array.array(typecode, bytez[startoffset:])\\n if sys.byteorder == 'little':\\n flatarray.byteswap()\\n\\n if flatarray.itemsize != typedata[typebyte][1]:\\n raise EnvironmentError(\\\"It's assumed a C int is 4 bytes\\\")\\n\\n def _recursive(inputlst, dimsizes):\\n \\\"\\\"\\\"Recursively split the flat list into chunks and merge them back into a\\n nested list structure.\\\"\\\"\\\"\\n if len(dimsizes) == 1:\\n return list(inputlst)\\n\\n outerlist = []\\n chunksize = len(inputlst)//dimsizes[0]\\n for i in range(0, len(inputlst), chunksize):\\n chunk = inputlst[i:i+chunksize]\\n outerlist.append(_recursive(chunk, dimsizes[1:]))\\n\\n return outerlist\\n\\n return _recursive(flatarray, dimension_sizes)\",\n \"def sub_bytes(state, s_box=s_box):\\n for i in range(4):\\n for j in range(4):\\n state[i][j] = s_box[state[i][j]]\",\n \"def test_hex_bytes_empty():\\n assert hex_bytes(bytes([]), truncate=1) == '(0 bytes)'\\n assert hex_bytes(bytes([]), truncate=0) == '(0 bytes)'\",\n \"def test_hex_straining():\\n\\n for protocol in LEGACY_PROTOCOLS:\\n p = protocol([])\\n\\n # single non-hex message\\n r = p([\\\"12.8 Volts\\\"])\\n assert len(r) == 1\\n assert r[0].ecu == ECU.UNKNOWN\\n assert len(r[0].frames) == 1\\n\\n\\n # multiple non-hex message\\n r = p([\\\"12.8 Volts\\\", \\\"NO DATA\\\"])\\n assert len(r) == 2\\n\\n for m in r:\\n assert m.ecu == ECU.UNKNOWN\\n assert len(m.frames) == 1\\n\\n # mixed hex and non-hex\\n r = p([\\\"NO DATA\\\", \\\"48 6B 10 41 00 00 01 02 03 FF\\\"])\\n assert len(r) == 2\\n\\n # first message should be the valid, parsable hex message\\n # NOTE: the parser happens to process the valid one's first\\n check_message(r[0], 1, 0x10, [0x41, 0x00, 0x00, 0x01, 0x02, 0x03])\\n\\n # second message: invalid, non-parsable non-hex\\n assert r[1].ecu == ECU.UNKNOWN\\n assert len(r[1].frames) == 1\\n assert len(r[1].data) == 0 # no data\",\n \"def ConvertTetsToHexes(self):\\n\\n self.__do_essential_memebers_exist__()\\n if self.element_type == \\\"hex\\\":\\n return\\n assert self.element_type == \\\"tet\\\"\\n if self.IsHighOrder:\\n raise ValueError('High order tetrahedral elements cannot be converted to low/high order hexahedrals')\\n\\n tconv = time()\\n\\n # SPLIT THE TET INTO 4 QUADS\\n\\n # FIND MEDIAN OF TETS\\n # median = self.Median()\\n median = np.sum(self.points[self.elements,:],axis=1)/self.elements.shape[1]\\n # FIND EDGE MIDPOINTS OF TETS\\n mid01 = np.sum(self.points[self.elements[:,[0,1]],:],axis=1)/2.\\n mid02 = np.sum(self.points[self.elements[:,[2,0]],:],axis=1)/2.\\n mid03 = np.sum(self.points[self.elements[:,[0,3]],:],axis=1)/2.\\n mid12 = np.sum(self.points[self.elements[:,[1,2]],:],axis=1)/2.\\n mid13 = np.sum(self.points[self.elements[:,[1,3]],:],axis=1)/2.\\n mid23 = np.sum(self.points[self.elements[:,[2,3]],:],axis=1)/2.\\n # FIND MEDIAN OF FACES\\n med012 = np.sum(self.points[self.elements[:,[0,1,2]],:],axis=1)/3.\\n med013 = np.sum(self.points[self.elements[:,[0,1,3]],:],axis=1)/3.\\n med023 = np.sum(self.points[self.elements[:,[0,2,3]],:],axis=1)/3.\\n med123 = np.sum(self.points[self.elements[:,[1,2,3]],:],axis=1)/3.\\n\\n # # STABLE APPROACH\\n # points = np.zeros((1,3))\\n # for elem in range(self.nelem):\\n # hex0 = np.concatenate((self.points[self.elements[elem,0],:][None,:], mid01[elem,:][None,:],\\n # med012[elem,:][None,:], mid02[elem,:][None,:],\\n # mid03[elem,:][None,:], med013[elem,:][None,:],\\n # median[elem,:][None,:], med023[elem,:][None,:]),axis=0)\\n\\n # hex1 = np.concatenate((self.points[self.elements[elem,1],:][None,:], mid13[elem,:][None,:],\\n # med123[elem,:][None,:], mid12[elem,:][None,:],\\n # mid01[elem,:][None,:], med013[elem,:][None,:],\\n # median[elem,:][None,:], med012[elem,:][None,:]),axis=0)\\n\\n # hex2 = np.concatenate((self.points[self.elements[elem,3],:][None,:], mid23[elem,:][None,:],\\n # med123[elem,:][None,:], mid13[elem,:][None,:],\\n # mid03[elem,:][None,:], med023[elem,:][None,:],\\n # median[elem,:][None,:], med013[elem,:][None,:]),axis=0)\\n\\n # hex3 = np.concatenate((self.points[self.elements[elem,2],:][None,:], mid02[elem,:][None,:],\\n # med012[elem,:][None,:], mid12[elem,:][None,:],\\n # mid23[elem,:][None,:], med023[elem,:][None,:],\\n # median[elem,:][None,:],med123[elem,:][None,:]),axis=0)\\n\\n # points = np.concatenate((points,hex0,hex1,hex2,hex3))\\n # points = points[1:,:]\\n\\n points = np.zeros((4*self.nelem*8,3))\\n points[0::4*8,:] = self.points[self.elements[:,0],:]\\n points[1::32,:] = mid01\\n points[2::32,:] = med012\\n points[3::32,:] = mid02\\n points[4::32,:] = mid03\\n points[5::32,:] = med013\\n points[6::32,:] = median\\n points[7::32,:] = med023\\n\\n points[8::32,:] = self.points[self.elements[:,1],:]\\n points[9::32,:] = mid13\\n points[10::32,:] = med123\\n points[11::32,:] = mid12\\n points[12::32,:] = mid01\\n points[13::32,:] = med013\\n points[14::32,:] = median\\n points[15::32,:] = med012\\n\\n points[16::32,:] = self.points[self.elements[:,3],:]\\n points[17::32,:] = mid23\\n points[18::32,:] = med123\\n points[19::32,:] = mid13\\n points[20::32,:] = mid03\\n points[21::32,:] = med023\\n points[22::32,:] = median\\n points[23::32,:] = med013\\n\\n points[24::32,:] = self.points[self.elements[:,2],:]\\n points[25::32,:] = mid02\\n points[26::32,:] = med012\\n points[27::32,:] = mid12\\n points[28::32,:] = mid23\\n points[29::32,:] = med023\\n points[30::32,:] = median\\n points[31::32,:] = med123\\n\\n # KEEP ZEROFY ON, OTHERWISE YOU GET STRANGE BEHVAIOUR\\n Decimals = 10\\n rounded_points = points.copy()\\n makezero(rounded_points)\\n rounded_repoints = np.round(rounded_points,decimals=Decimals)\\n points, inv_points = unique2d(rounded_points,order=False,\\n consider_sort=False,return_inverse=True)\\n\\n\\n elements = np.arange(points.shape[0])[inv_points].reshape(4*self.nelem,8)\\n\\n\\n self.__reset__()\\n\\n self.element_type = \\\"hex\\\"\\n self.elements = elements\\n self.points = points\\n self.nelem = self.elements.shape[0]\\n self.nnode = self.points.shape[0]\\n self.GetBoundaryFacesHex()\\n self.GetBoundaryEdgesHex()\\n\\n print(\\\"Tetrahedral to hexahedral mesh conversion took\\\", time() - tconv, \\\"seconds\\\")\",\n \"def test_find_string():\\n assert pi_finder.find_string('j', hex_dict) == (5, 6)\\n assert pi_finder.find_string('l', hex_dict) == (61, 62)\\n assert pi_finder.find_string('c', hex_dict) == (72, 73)\",\n \"def _write_to_lsb(tribit: str, rgb_binary: tuple):\\n pixel = []\\n for idx, bit in enumerate(tribit):\\n color = rgb_binary[idx]\\n color = color[:-1] + bit\\n pixel.append(color)\\n\\n return pixel\",\n \"def dump_hex(memory, startad, endad, width =4):\\n res = \\\"\\\"\\n gap = 0\\n CHUNK_SIZE = 16\\n \\n addr = startad\\n while addr < endad:\\n if endad - addr < CHUNK_SIZE:\\n read_chunk = endad - addr\\n else:\\n read_chunk = CHUNK_SIZE\\n membytes = cpu.read_memory(addr, read_chunk) \\n if membytes != bytearray(CHUNK_SIZE):\\n if gap > 0:\\n res += \\\"*** gap of {:d} bytes\\\\n\\\".format(gap)\\n gap = 0\\n res += \\\"{:08x} \\\".format(addr)\\n for i in range(0,len(membytes),width):\\n reversed_bytes=bytearray(width)\\n if len(membytes)-i < width:\\n #print(\\\"Partial line length= {0}\\\", len(bytes)-i)\\n k = width-1\\n for j in range(len(membytes)-1,i,-1): #Error here\\n reversed_bytes[k] = membytes[j]\\n k = k-1\\n \\n else:\\n if width == 4:\\n reversed_bytes = (membytes[i+3],membytes[i+2],\\n membytes[i+1],membytes[i])\\n else:\\n reversed_bytes = (membytes[i+1],membytes[i])\\n res += my_hex(reversed_bytes)+\\\" \\\"\\n \\n res += char_repr(membytes) +\\\"\\\\n\\\"\\n else:\\n gap += CHUNK_SIZE\\n addr += CHUNK_SIZE\\n \\n return res\",\n \"def bytes_value(self) -> global___Expression.BytesValue:\",\n \"def javaByteArray(a):\\n b = jarray.zeros(len(a), 'b')\\n for i in range(len(a)):\\n b[i] = struct.unpack('b', struct.pack('B', a[i]))[0]\\n return b\",\n \"def elem_ords(self):\\n pass\",\n \"def test01(self):\\n a = np.arange(1, 1e4)\\n b = bcolz.carray(a)\\n idx = np.random.randint(1000, size=1000)\\n c = b[idx]\\n r = a[idx]\\n assert_array_equal(c, r, \\\"fancy indexing does not work correctly\\\")\",\n \"def generate_index(size=20):\\n return hexlify(np.random.rand(100))[:size].decode()\",\n \"def test_decompress_offset_less_len1(self):\\n b_array = bytearray([32]) + bytearray(b'ab') + bytearray([0, 18])\\n actual = LZ77.decompress(b_array)\\n expected = 'ababab'\\n self.assertEqual(actual, expected)\",\n \"def lookup_table(self):\\n if hasattr(self, '_m_lookup_table'):\\n return self._m_lookup_table if hasattr(self, '_m_lookup_table') else None\\n\\n self._m_lookup_table = [b\\\"\\\\x00\\\\x00\\\", b\\\"\\\\x4E\\\\xBA\\\", b\\\"\\\\x00\\\\x08\\\", b\\\"\\\\x4E\\\\x75\\\", b\\\"\\\\x00\\\\x0C\\\", b\\\"\\\\x4E\\\\xAD\\\", b\\\"\\\\x20\\\\x53\\\", b\\\"\\\\x2F\\\\x0B\\\", b\\\"\\\\x61\\\\x00\\\", b\\\"\\\\x00\\\\x10\\\", b\\\"\\\\x70\\\\x00\\\", b\\\"\\\\x2F\\\\x00\\\", b\\\"\\\\x48\\\\x6E\\\", b\\\"\\\\x20\\\\x50\\\", b\\\"\\\\x20\\\\x6E\\\", b\\\"\\\\x2F\\\\x2E\\\", b\\\"\\\\xFF\\\\xFC\\\", b\\\"\\\\x48\\\\xE7\\\", b\\\"\\\\x3F\\\\x3C\\\", b\\\"\\\\x00\\\\x04\\\", b\\\"\\\\xFF\\\\xF8\\\", b\\\"\\\\x2F\\\\x0C\\\", b\\\"\\\\x20\\\\x06\\\", b\\\"\\\\x4E\\\\xED\\\", b\\\"\\\\x4E\\\\x56\\\", b\\\"\\\\x20\\\\x68\\\", b\\\"\\\\x4E\\\\x5E\\\", b\\\"\\\\x00\\\\x01\\\", b\\\"\\\\x58\\\\x8F\\\", b\\\"\\\\x4F\\\\xEF\\\", b\\\"\\\\x00\\\\x02\\\", b\\\"\\\\x00\\\\x18\\\", b\\\"\\\\x60\\\\x00\\\", b\\\"\\\\xFF\\\\xFF\\\", b\\\"\\\\x50\\\\x8F\\\", b\\\"\\\\x4E\\\\x90\\\", b\\\"\\\\x00\\\\x06\\\", b\\\"\\\\x26\\\\x6E\\\", b\\\"\\\\x00\\\\x14\\\", b\\\"\\\\xFF\\\\xF4\\\", b\\\"\\\\x4C\\\\xEE\\\", b\\\"\\\\x00\\\\x0A\\\", b\\\"\\\\x00\\\\x0E\\\", b\\\"\\\\x41\\\\xEE\\\", b\\\"\\\\x4C\\\\xDF\\\", b\\\"\\\\x48\\\\xC0\\\", b\\\"\\\\xFF\\\\xF0\\\", b\\\"\\\\x2D\\\\x40\\\", b\\\"\\\\x00\\\\x12\\\", b\\\"\\\\x30\\\\x2E\\\", b\\\"\\\\x70\\\\x01\\\", b\\\"\\\\x2F\\\\x28\\\", b\\\"\\\\x20\\\\x54\\\", b\\\"\\\\x67\\\\x00\\\", b\\\"\\\\x00\\\\x20\\\", b\\\"\\\\x00\\\\x1C\\\", b\\\"\\\\x20\\\\x5F\\\", b\\\"\\\\x18\\\\x00\\\", b\\\"\\\\x26\\\\x6F\\\", b\\\"\\\\x48\\\\x78\\\", b\\\"\\\\x00\\\\x16\\\", b\\\"\\\\x41\\\\xFA\\\", b\\\"\\\\x30\\\\x3C\\\", b\\\"\\\\x28\\\\x40\\\", b\\\"\\\\x72\\\\x00\\\", b\\\"\\\\x28\\\\x6E\\\", b\\\"\\\\x20\\\\x0C\\\", b\\\"\\\\x66\\\\x00\\\", b\\\"\\\\x20\\\\x6B\\\", b\\\"\\\\x2F\\\\x07\\\", b\\\"\\\\x55\\\\x8F\\\", b\\\"\\\\x00\\\\x28\\\", b\\\"\\\\xFF\\\\xFE\\\", b\\\"\\\\xFF\\\\xEC\\\", b\\\"\\\\x22\\\\xD8\\\", b\\\"\\\\x20\\\\x0B\\\", b\\\"\\\\x00\\\\x0F\\\", b\\\"\\\\x59\\\\x8F\\\", b\\\"\\\\x2F\\\\x3C\\\", b\\\"\\\\xFF\\\\x00\\\", b\\\"\\\\x01\\\\x18\\\", b\\\"\\\\x81\\\\xE1\\\", b\\\"\\\\x4A\\\\x00\\\", b\\\"\\\\x4E\\\\xB0\\\", b\\\"\\\\xFF\\\\xE8\\\", b\\\"\\\\x48\\\\xC7\\\", b\\\"\\\\x00\\\\x03\\\", b\\\"\\\\x00\\\\x22\\\", b\\\"\\\\x00\\\\x07\\\", b\\\"\\\\x00\\\\x1A\\\", b\\\"\\\\x67\\\\x06\\\", b\\\"\\\\x67\\\\x08\\\", b\\\"\\\\x4E\\\\xF9\\\", b\\\"\\\\x00\\\\x24\\\", b\\\"\\\\x20\\\\x78\\\", b\\\"\\\\x08\\\\x00\\\", b\\\"\\\\x66\\\\x04\\\", b\\\"\\\\x00\\\\x2A\\\", b\\\"\\\\x4E\\\\xD0\\\", b\\\"\\\\x30\\\\x28\\\", b\\\"\\\\x26\\\\x5F\\\", b\\\"\\\\x67\\\\x04\\\", b\\\"\\\\x00\\\\x30\\\", b\\\"\\\\x43\\\\xEE\\\", b\\\"\\\\x3F\\\\x00\\\", b\\\"\\\\x20\\\\x1F\\\", b\\\"\\\\x00\\\\x1E\\\", b\\\"\\\\xFF\\\\xF6\\\", b\\\"\\\\x20\\\\x2E\\\", b\\\"\\\\x42\\\\xA7\\\", b\\\"\\\\x20\\\\x07\\\", b\\\"\\\\xFF\\\\xFA\\\", b\\\"\\\\x60\\\\x02\\\", b\\\"\\\\x3D\\\\x40\\\", b\\\"\\\\x0C\\\\x40\\\", b\\\"\\\\x66\\\\x06\\\", b\\\"\\\\x00\\\\x26\\\", b\\\"\\\\x2D\\\\x48\\\", b\\\"\\\\x2F\\\\x01\\\", b\\\"\\\\x70\\\\xFF\\\", b\\\"\\\\x60\\\\x04\\\", b\\\"\\\\x18\\\\x80\\\", b\\\"\\\\x4A\\\\x40\\\", b\\\"\\\\x00\\\\x40\\\", b\\\"\\\\x00\\\\x2C\\\", b\\\"\\\\x2F\\\\x08\\\", b\\\"\\\\x00\\\\x11\\\", b\\\"\\\\xFF\\\\xE4\\\", b\\\"\\\\x21\\\\x40\\\", b\\\"\\\\x26\\\\x40\\\", b\\\"\\\\xFF\\\\xF2\\\", b\\\"\\\\x42\\\\x6E\\\", b\\\"\\\\x4E\\\\xB9\\\", b\\\"\\\\x3D\\\\x7C\\\", b\\\"\\\\x00\\\\x38\\\", b\\\"\\\\x00\\\\x0D\\\", b\\\"\\\\x60\\\\x06\\\", b\\\"\\\\x42\\\\x2E\\\", b\\\"\\\\x20\\\\x3C\\\", b\\\"\\\\x67\\\\x0C\\\", b\\\"\\\\x2D\\\\x68\\\", b\\\"\\\\x66\\\\x08\\\", b\\\"\\\\x4A\\\\x2E\\\", b\\\"\\\\x4A\\\\xAE\\\", b\\\"\\\\x00\\\\x2E\\\", b\\\"\\\\x48\\\\x40\\\", b\\\"\\\\x22\\\\x5F\\\", b\\\"\\\\x22\\\\x00\\\", b\\\"\\\\x67\\\\x0A\\\", b\\\"\\\\x30\\\\x07\\\", b\\\"\\\\x42\\\\x67\\\", b\\\"\\\\x00\\\\x32\\\", b\\\"\\\\x20\\\\x28\\\", b\\\"\\\\x00\\\\x09\\\", b\\\"\\\\x48\\\\x7A\\\", b\\\"\\\\x02\\\\x00\\\", b\\\"\\\\x2F\\\\x2B\\\", b\\\"\\\\x00\\\\x05\\\", b\\\"\\\\x22\\\\x6E\\\", b\\\"\\\\x66\\\\x02\\\", b\\\"\\\\xE5\\\\x80\\\", b\\\"\\\\x67\\\\x0E\\\", b\\\"\\\\x66\\\\x0A\\\", b\\\"\\\\x00\\\\x50\\\", b\\\"\\\\x3E\\\\x00\\\", b\\\"\\\\x66\\\\x0C\\\", b\\\"\\\\x2E\\\\x00\\\", b\\\"\\\\xFF\\\\xEE\\\", b\\\"\\\\x20\\\\x6D\\\", b\\\"\\\\x20\\\\x40\\\", b\\\"\\\\xFF\\\\xE0\\\", b\\\"\\\\x53\\\\x40\\\", b\\\"\\\\x60\\\\x08\\\", b\\\"\\\\x04\\\\x80\\\", b\\\"\\\\x00\\\\x68\\\", b\\\"\\\\x0B\\\\x7C\\\", b\\\"\\\\x44\\\\x00\\\", b\\\"\\\\x41\\\\xE8\\\", b\\\"\\\\x48\\\\x41\\\"]\\n return self._m_lookup_table if hasattr(self, '_m_lookup_table') else None\",\n \"def getbytes(data, offset):\\n if data[offset] == 0xFF and data[offset + 1] == 0xFF:\\n return b'', offset + 2 # Blank string\\n length, offset = getint(data, offset, 2) # 2-byte length\\n value = data[offset:offset + length]\\n return value, (offset + length)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61879593","0.6169586","0.5947031","0.5947031","0.5886045","0.5635032","0.56292176","0.5617642","0.56158674","0.5572353","0.55332905","0.5514198","0.5507884","0.5505075","0.5501913","0.5480814","0.5480478","0.5449285","0.5448715","0.5439642","0.54233086","0.54149634","0.5406213","0.5399217","0.5363143","0.53219026","0.5319401","0.53112584","0.5310335","0.5309402","0.5306038","0.5274012","0.52710605","0.5270011","0.52600616","0.5258395","0.5247047","0.5224173","0.5222693","0.51872665","0.5179587","0.51683307","0.5161587","0.51590616","0.5151855","0.51441723","0.5138021","0.5136574","0.5117007","0.51159227","0.5110719","0.51102096","0.5099464","0.5097396","0.5092506","0.5091127","0.50906706","0.50867695","0.508123","0.507482","0.5072821","0.50692946","0.5060662","0.5055582","0.5049701","0.5044797","0.5031178","0.5017838","0.5012223","0.50108176","0.50093657","0.49890143","0.4988114","0.49877363","0.49812692","0.49731478","0.49724025","0.4968266","0.49608597","0.49604285","0.49453282","0.49448898","0.49394804","0.49377927","0.49367663","0.49340203","0.4933314","0.49313164","0.4928074","0.49264804","0.49256814","0.49239606","0.49233985","0.49149448","0.49050087","0.4903837","0.49035776","0.4901787","0.48990777","0.4892838","0.48862416"],"string":"[\n \"0.61879593\",\n \"0.6169586\",\n \"0.5947031\",\n \"0.5947031\",\n \"0.5886045\",\n \"0.5635032\",\n \"0.56292176\",\n \"0.5617642\",\n \"0.56158674\",\n \"0.5572353\",\n \"0.55332905\",\n \"0.5514198\",\n \"0.5507884\",\n \"0.5505075\",\n \"0.5501913\",\n \"0.5480814\",\n \"0.5480478\",\n \"0.5449285\",\n \"0.5448715\",\n \"0.5439642\",\n \"0.54233086\",\n \"0.54149634\",\n \"0.5406213\",\n \"0.5399217\",\n \"0.5363143\",\n \"0.53219026\",\n \"0.5319401\",\n \"0.53112584\",\n \"0.5310335\",\n \"0.5309402\",\n \"0.5306038\",\n \"0.5274012\",\n \"0.52710605\",\n \"0.5270011\",\n \"0.52600616\",\n \"0.5258395\",\n \"0.5247047\",\n \"0.5224173\",\n \"0.5222693\",\n \"0.51872665\",\n \"0.5179587\",\n \"0.51683307\",\n \"0.5161587\",\n \"0.51590616\",\n \"0.5151855\",\n \"0.51441723\",\n \"0.5138021\",\n \"0.5136574\",\n \"0.5117007\",\n \"0.51159227\",\n \"0.5110719\",\n \"0.51102096\",\n \"0.5099464\",\n \"0.5097396\",\n \"0.5092506\",\n \"0.5091127\",\n \"0.50906706\",\n \"0.50867695\",\n \"0.508123\",\n \"0.507482\",\n \"0.5072821\",\n \"0.50692946\",\n \"0.5060662\",\n \"0.5055582\",\n \"0.5049701\",\n \"0.5044797\",\n \"0.5031178\",\n \"0.5017838\",\n \"0.5012223\",\n \"0.50108176\",\n \"0.50093657\",\n \"0.49890143\",\n \"0.4988114\",\n \"0.49877363\",\n \"0.49812692\",\n \"0.49731478\",\n \"0.49724025\",\n \"0.4968266\",\n \"0.49608597\",\n \"0.49604285\",\n \"0.49453282\",\n \"0.49448898\",\n \"0.49394804\",\n \"0.49377927\",\n \"0.49367663\",\n \"0.49340203\",\n \"0.4933314\",\n \"0.49313164\",\n \"0.4928074\",\n \"0.49264804\",\n \"0.49256814\",\n \"0.49239606\",\n \"0.49233985\",\n \"0.49149448\",\n \"0.49050087\",\n \"0.4903837\",\n \"0.49035776\",\n \"0.4901787\",\n \"0.48990777\",\n \"0.4892838\",\n \"0.48862416\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":74276,"cells":{"query":{"kind":"string","value":"Removes the genesis block of the proof"},"document":{"kind":"string","value":"def remove_genesis(proof):\n\n old_size = len(proof)\n print(\"Removing genesis block from proof ...\")\n proof.pop(-1)\n print(\"OK\")\n print(\"old size:\", old_size, \"-> new size:\", len(proof))"},"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_block(self, block):\n raise NotImplementedError()","def remove_from_block(self):\n self.enclosing_block.remove_ops([self])","def delete_block(self, block):\n raise NotImplementedError('delete_block')","def remove(self, block):\n try:\n self.blocks[block.height]\n except:\n raise ValueError(\"cant remove block: \" + str(block))\n\n removed = False\n for b in self.blocks[block.height]:\n # only delete the one with equal hash\n if b.hash() == block.hash():\n self.blocks[block.height].remove(b)\n removed = True\n if self.blocks[block.height] == []:\n self.blocks.pop(block.height)\n\n if not removed:\n raise ValueError(\"cant remove block: \" + str(block))","def _generate_genesis() -> None:\n logging.debug(\"Generating the genesis block\")\n new_recv_block(Block.genesis())","def erase_block(self):\n self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]] = '0'","def die(self):\n self.pjs.bombermen.remove(self)\n for block in self.physics.blocks[self.stype]:\n if block == self.rects[0]:\n self.physics.blocks[self.stype].remove(block)","def skip_blocks(proof, block_index, skipped_blocks=1):\n\n if block_index >= len(proof):\n return proof\n\n for i in range(block_index, block_index + skipped_blocks):\n print(\"Deleting block\", i)\n del proof[i]\n\n return proof","def removeMemoryBlock(self, block: ghidra.program.model.mem.MemoryBlock) -> None:\n ...","def genesisBlock():\n return Block(0, \"0\", 1465154705, \"my genesis block!!\",\n \"816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7\");","def genesis():\n #return Block(\n #GENESIS_DATA['timestamp'],\n #GENESIS_DATA['last_hash'],\n #GENESIS_DATA['hash'],\n #GENESIS_DATA['data']\n #)\n return Block(**GENESIS_DATA)","def invalidate(self):\n self._compute_merkle_tree()\n self.block_header.merkle_root_hash = self.merkle_tree.hash","def remove(self):\n if self.function is None:\n raise IRError('Basic block is not in function')\n self.function.basic_blocks.remove(self)\n self.function = None","def test_genesis_block(self):\n genesis_block = self.blockchain.last_block[\"index\"]\n self.assertEqual(genesis_block, 1)","def make_genesis_block():\n block = Block(index=0,\n timestamp=datetime.now(),\n data=\"Genesis Block\",\n previous_hash=\"0\")\n return block","def removeBlock(self, aBlock: gp.Block):\n \n for y, row in iter(self.blocks):\n for x, block in iter(row):\n if block is aBlock:\n self.blocks[y][x] = None\n self.playerSprites.remove(aBlock.sprite)\n return","def create_genesis_block(self):\r\n genesis_block = Block(0, [], time.time(), \"0\")\r\n genesis_block.hash = genesis_block.compute_hash()\r\n self.chain.append(genesis_block)","def exit_block(self, parent=None, **kwargs):\n block = self.newblock(parent, have_code=False, is_exit=True, **kwargs)\n self.blocks.pop()\n return block","def remove_blocks(draft):\n for symbol in draft.Blocks:\n if symbol.Name in blocks_to_delete:\n print(\"[-] %s, \\tdeleted\" % symbol.Name)\n symbol.delete()\n\n # for ball in draft.ActiveSheet.Balloons:\n if draft.Balloons:\n for ball in draft.Balloons:\n if ball.BalloonType == 7: # type 7 filter the triangle balloons.\n print(\"[-] %s, \\tdeleted\" % ball.Name)\n ball.Delete()\n else:\n pass","def removeBlock(self, block: ghidra.program.model.mem.MemoryBlock, monitor: ghidra.util.task.TaskMonitor) -> None:\n ...","def remove_block(self, name):\n\n if not self._ast or not name in self._block_map:\n raise ValueError(u\"Block '{0}' does not exist\"\n .format(common.from_utf8(name)))\n\n block_idx = self._block_map[name]\n\n # remove block\n self._ast[2].pop(block_idx)\n del self._block_map[name]","def finalize_block_construction(self, pyomo_block):\n pass","def create_genesis_block(self):\n genesis_block = Block(0, [], time.time(), \"0\")\n genesis_block.hash = genesis_block.compute_hash()\n self.chain.append(genesis_block)","def rollback_block(self, block):\n # TODO: 0.007-12c changes\n current_length = self.db.get('length')\n if block['length'] != current_length:\n # Block is not at the top the chain\n return False\n\n for tx in block['txs']:\n tx_owner_address = tools.tx_owner_address(tx)\n owner_account = self.get_account(tx_owner_address)\n if tx['type'] == 'mint':\n owner_account['amount'] -= tools.block_reward(block['length'])\n self.db.put(tx_owner_address, owner_account)\n elif tx['type'] == 'spend':\n owner_account['amount'] += tx['amount']\n owner_account['count'] -= 1\n owner_account['tx_blocks'].remove(block['length'])\n\n receiver_account = self.db.get(tx['to'])\n receiver_account['amount'] -= tx['amount']\n receiver_account['tx_blocks'].remove(block['length'])\n\n self.db.put(tx_owner_address, owner_account)\n self.db.put(tx['to'], receiver_account)","def genesis_block(self):\n block = Block(target=self.target, transactions=[])\n self.current_transactions.append(block)","def createGenesisBlock(self):\n return Block(\"Genesis Block\")","def create_genesis_block(self):\n genesis_block = Block(0, [], 0, \"0\")\n genesis_block.hash = genesis_block.compute_hash()\n self.chain.append(genesis_block)","def create_genesis_block(self):\n genesis_block = Block(0, [], 0, \"0\")\n genesis_block.hash = genesis_block.compute_hash()\n self.chain.append(genesis_block)","def delete(self, flow):\n for parent in self.parents:\n parent.children.remove(self)\n for child in self.children:\n child.parents.remove(self)\n\n flow.blocks.remove(self)","def mine(self):\n last_block = self.chain[-1]\n\n nonce = self.proof_of_work()\n previous_hash = self.hash(last_block)\n self.create_block(nonce, previous_hash)","def trim(self) -> TrimmedBlock:\n hashes = [self.consensus_data.hash()] + [t.hash() for t in self.transactions]\n return TrimmedBlock(version=self.version,\n prev_hash=self.prev_hash,\n merkle_root=self.merkle_root,\n timestamp=self.timestamp,\n index=self.index,\n next_consensus=self.next_consensus,\n witness=self.witness,\n hashes=hashes,\n consensus_data=self.consensus_data\n )","def clearUndoBlock(self):\n if self.undoBlock:\n callback = self.undoBlock\n self.undoBlock = None\n callback()","def create_genesis(self):\n return Block(0, 0, b'0', b'0', b'')","def proof_of_work(self, block):\n block.nonce = 0 \n computed_hash = block.compute_hash()\n while not computed_hash.starswith('0' * Blockchain.difficulty):\n block.nonce += 1 \n computed_hash = block.compute_hash()","def __init__(self):\n self.unconfirmed_transactions = [] \n self.chain = []\n self.create_genesis_block()","def init_with_genesis_block(self, block):\n\n genesis_tx = block.transactions # Genesis block contains single seed transaction from God\n\n if not signature.verify(genesis_tx.from_pk, genesis_tx.to_string_for_hashing(), genesis_tx.signature):\n print(\"Genesis transaction signature is NOT valid.\")\n return\n\n self.blocks.append(block)\n return self","def remove_blocks(self, *vertices):\n for vertex in vertices:\n try:\n self.world[vertex] = None\n self.shown.pop(vertex)\n for vtx in self._shown[vertex]:\n vtx.delete()\n except KeyError:\n pass\n except IndexError:\n pass","def test_fork_missing_predecessor(self):\n bvh = self.BlockValidationHandler()\n\n root = self.btm.chain_head\n\n # generate candidate chain 3 long off the current head.\n new_block = self.btm.generate_chain(root, 3,\n {'add_to_cache': True})\n # remove one of the new blocks\n del self.btm.block_cache[new_block[1].identifier]\n\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\n bv.run()\n\n self.assertTrue(bvh.has_result())\n self.assertTrue(new_block[-1].status == BlockStatus.Invalid)\n self.assertFalse(bvh.result[\"commit_new_block\"])","def replace_block(proof, headers_map, interlink_map, block_index):\n\n prevous_block = proof[block_index - 1][0]\n block_hash = prevous_block[36:68]\n block = headers_map[block_hash]\n interlink = list_flatten(interlink_map[block.GetHash()])\n\n block_2 = mine_block(\n block.hashPrevBlock, block.nBits - 1, interlink, hashMerkleRoot=b\"\\x00\" * 32\n )\n return (\n proof[0:block_index]\n + [[block_2.serialize(), proof[block_index][1]]]\n + proof[block_index + 1 :]\n )","def _delete_if_true_orphan(self, orphan, structure):\r\n if not self._get_parents_from_structure(orphan, structure):\r\n encoded_block_id = LocMapperStore.encode_key_for_mongo(orphan)\r\n for child in structure['blocks'][encoded_block_id]['fields'].get('children', []):\r\n self._delete_if_true_orphan(child, structure)\r\n del structure['blocks'][encoded_block_id]","def test_valid_balance_genesis(self):\n db = MockDatabase()\n prev = TestBlock(block_type=BlockTypes.CHECKPOINT, transaction={'balance': 0})\n result, errors = prev.validate_transaction(db)\n self.assertEqual(result, ValidationResult.valid)\n self.assertEqual(errors, [])\n db.add_block(prev)","def clear_blockages(self):\n debug.info(3,\"Clearing all blockages\")\n self.rg.clear_blockages()","def remove_point(mutated_genome,index):\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n del mutated_genome[index][2][point_index]","def _remove_snapshot(self) -> None:\n assert self._is_transaction_boundary\n\n if not self.nested and self.session.expire_on_commit:\n for s in self.session.identity_map.all_states():\n s._expire(s.dict, self.session.identity_map._modified)\n\n statelib.InstanceState._detach_states(\n list(self._deleted), self.session\n )\n self._deleted.clear()\n elif self.nested:\n parent = self._parent\n assert parent is not None\n parent._new.update(self._new)\n parent._dirty.update(self._dirty)\n parent._deleted.update(self._deleted)\n parent._key_switches.update(self._key_switches)","def clear(self):\n self.blocks.clear()","def checkpoint_unset():\n unwind(checkpoints.pop())","def new_block(self, proof, previous_hash=None):\n \n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n\n # Reset the current list of transactions\n self.current_transactions = []\n # Add block to existing chain\n self.chain.append(block)\n return block","def remove_subtree(block_id):\r\n encoded_block_id = LocMapperStore.encode_key_for_mongo(block_id)\r\n for child in new_blocks[encoded_block_id]['fields'].get('children', []):\r\n remove_subtree(child)\r\n del new_blocks[encoded_block_id]","def new_block(self, proof, previous_hash=None):\r\n block = {\r\n 'index': len(self.chain) + 1,\r\n 'timestamp': time(),\r\n 'transactions': self.current_transactions,\r\n 'proof': proof,\r\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\r\n }\r\n\r\n # reseta a atual lista de transacoes\r\n self.current_transactions = []\r\n\r\n self.chain.append(block)\r\n return block","def new_block(self, proof, previous_hash=None):\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions':self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n self.current_transactions = []\n self.chain.append(block)\n return block","def valid_chain(chain):\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n #print(last_block)\n #print(block)\n #print(\"\\n-----------\\n\")\n # Check that the hash of the block is correct\n if block['previous_hash'] != hash(last_block):\n return False\n\n # Check that the Proof of Work is correct\n #Delete the reward transaction\n transactions = block['transactions'][:-1]\n # Need to make sure that the dictionary is ordered. Otherwise we'll get a different hash\n transaction_elements = ['sender_address', 'recipient_address', 'value']\n transactions = [OrderedDict((k, transaction[k]) for k in transaction_elements) for transaction in transactions]\n\n if not valid_proof(transactions, block['previous_hash'], block['nonce'], MINING_DIFFICULTY):\n return False\n\n last_block = block\n current_index += 1\n\n return True","def create_genesis_block(self):\n index = 0\n transactions = []\n timestamp = 0.0\n previous_hash = \"0\"*64\n block = Block(index=index, transactions=transactions, timestamp=timestamp,previous_hash=previous_hash)\n block.hash = block.compute_hash()\n self.chain.append(block)","def valid_proof(block):\n return Blockchain.hash(block) [:4] == \"0000\"","def new_block(self, proof, previous_hash=None):\n\n\t\tblock = {\n\t\t\t'index': len(self.chain) + 1,\n\t\t\t'timestamp': time(),\n\t\t\t'transactions': self.current_transactions,\n\t\t\t'proof': proof,\n\t\t\t'previous_hash': previous_hash or self.hash(self.chain[-1]),\t\t\n\t\t}\n\n\t\t#Reset current list of transactions\n\t\tself.current_transactions = []\n\n\t\tself.chain.append(block)\n\t\treturn block","def test_fork_different_genesis(self):\n bvh = self.BlockValidationHandler()\n\n # create a new valid chain 5 long from the current root\n new_head = self.btm.generate_chain(self.btm.chain_head, 5,\n {'add_to_store': True})\n self.btm.set_chain_head(new_head[-1])\n\n # generate candidate chain 5 long from it's own genesis\n new_block = self.btm.generate_chain(None, 5,\n {'add_to_cache': True})\n\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\n bv.run()\n\n self.assertTrue(bvh.has_result())\n self.assertTrue(new_block[-1].status == BlockStatus.Invalid)\n self.assertFalse(bvh.result[\"commit_new_block\"])","def proof_of_work(header: Header) -> Header:\n logger.info(\n \"Mining block for %s version and %s difficulty\",\n header.version,\n header.difficulty,\n )\n while not Verification.valid_nonce(header):\n header.nonce += 1\n\n return header","def new_block(self, proof, previous_hash = None):\n #create a new Block & adds it to the chain.\n \n block = {\n 'index' : len(self.chain) + 1,\n 'timestamp' : time(),\n 'transactions' : self.pending_transactions,\n 'proof' : proof,\n 'previous_hash' : previous_hash or self.hash(self.chain[-1])\n }\n\n # Reset the current list of transactions\n self.pending_transactions = []\n\n self.chain.append(block)\n return block\n #pass","def new_block(self, proof, previous_hash=None):\n block = {\n 'index': len( self.chain ) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'merkle': self.hash(self.current_transactions),\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1])\n }\n\n # Reset the current list of transactions\n self.current_transactions = []\n\n # Add the block to the chain\n self.chain.append( block )\n self._write_chain()\n\n return block","def deleteCheckpoint(self):\n if len(self.__stack) == 0:\n raise EmptyStackException()\n self.__stack = self.__stack[:-1]","def pruneblockchain(self) -> None:\n return self.rpc_call(\"pruneblockchain\")","def consolidate_empty_blocks(self):\n new_blocks = []\n for block in self.blocks:\n if isinstance(block, BasicBlock) and not block.statements:\n self.remove_block(block)\n else:\n new_blocks.append(block)\n self.blocks = new_blocks","def test_single_fork_not_best(self):\n self.assertEqual(len(self.genesis_blocks), 1)\n manager = self.create_peer('testnet', tx_storage=self.tx_storage)\n\n # The initial score is the sum of the genesis\n score = self.genesis_blocks[0].weight\n for tx in self.genesis_txs:\n score = sum_weights(score, tx.weight)\n\n # Mine 30 blocks in a row with no transactions\n blocks = add_new_blocks(manager, 30, advance_clock=15)\n for i, block in enumerate(blocks):\n meta = block.get_metadata()\n score = sum_weights(score, block.weight)\n self.assertAlmostEqual(score, meta.score)\n\n # Add some transactions between blocks\n txs = add_new_transactions(manager, 5, advance_clock=15)\n for tx in txs:\n score = sum_weights(score, tx.weight)\n\n # Mine 1 blocks\n blocks = add_new_blocks(manager, 1, advance_clock=15)\n for i, block in enumerate(blocks):\n meta = block.get_metadata()\n score = sum_weights(score, block.weight)\n self.assertAlmostEqual(score, meta.score)\n\n # Generate a block which will be a fork in the middle of the chain\n # Change the order of the transactions to change the hash\n fork_block1 = manager.generate_mining_block()\n fork_block1.parents = [fork_block1.parents[0]] + fork_block1.parents[:0:-1]\n fork_block1.resolve()\n fork_block1.verify()\n\n # Mine 8 blocks in a row\n blocks = add_new_blocks(manager, 8, advance_clock=15)\n for i, block in enumerate(blocks):\n meta = block.get_metadata()\n score = sum_weights(score, block.weight)\n self.assertAlmostEqual(score, meta.score)\n\n # Fork block must have the same parents as blocks[0] as well as the same score\n self.assertEqual(set(blocks[0].parents), set(fork_block1.parents))\n\n # Propagate fork block.\n # This block belongs to case (ii).\n self.assertTrue(manager.propagate_tx(fork_block1))\n fork_meta1 = fork_block1.get_metadata()\n self.assertEqual(fork_meta1.voided_by, {fork_block1.hash})\n\n # Add some transactions between blocks\n txs = add_new_transactions(manager, 5, advance_clock=15)\n for tx in txs:\n score = sum_weights(score, tx.weight)\n\n # Mine 5 blocks in a row\n # These blocks belong to case (i).\n blocks = add_new_blocks(manager, 5, advance_clock=15)\n for i, block in enumerate(blocks):\n meta = block.get_metadata()\n score = sum_weights(score, block.weight)\n self.assertAlmostEqual(score, meta.score)\n\n # Add some transactions between blocks\n txs = add_new_transactions(manager, 2, advance_clock=15)\n for tx in txs:\n score = sum_weights(score, tx.weight)\n\n # Propagate a block connected to the voided chain\n # These blocks belongs to case (iii).\n sidechain1 = add_new_blocks(manager, 3, parent_block_hash=fork_block1.hash)\n for block in sidechain1:\n meta = block.get_metadata(force_reload=True)\n self.assertEqual(meta.voided_by, {block.hash})\n\n # Add some transactions between blocks\n txs = add_new_transactions(manager, 2, advance_clock=15)\n for tx in txs:\n score = sum_weights(score, tx.weight)\n\n # Propagate a block connected to the voided chain\n # This block belongs to case (iv).\n fork_block3 = manager.generate_mining_block(parent_block_hash=fork_block1.hash)\n fork_block3.resolve()\n fork_block3.verify()\n self.assertTrue(manager.propagate_tx(fork_block3))\n fork_meta3 = fork_block3.get_metadata()\n self.assertEqual(fork_meta3.voided_by, {fork_block3.hash})\n\n self.assertConsensusValid(manager)","def mine(self):\n if self.unconfirmed_transactions == []:\n return False\n\n transactions = self.unconfirmed_transactions\n for transaction in transactions:\n author = transaction['author']\n public_key_path = author + '_public.pem'\n content = transaction['content']\n signature = transaction['signature']\n verify = rsa_verify(content, signature, public_key_path)\n if verify == False:\n print('Transaction not verified.')\n return \n previous_block = self.last_block\n last_index = previous_block.index\n\n index = last_index + 1\n timestamp = time.time()\n previous_hash = previous_block.hash\n\n newblock = Block(index=index, transactions=transactions, timestamp=timestamp, previous_hash=previous_hash)\n proof = Blockchain.proof_of_work(newblock)\n\n self.add_block(newblock, proof)\n self.unconfirmed_transactions = []\n return newblock.index","async def remove_block(\n self,\n position: typing.Union[\n typing.Tuple[int, int, int],\n typing.Any,\n ],\n immediate: bool = True,\n block_update: bool = True,\n block_update_self: bool = True,\n network_sync=True,\n reason=None,\n ):\n raise NotImplementedError","def remove_line(self, id):\n id = id_force_tuple(id)\n prf = self.prf.get_parent_proof(id)\n split = id[-1]\n prf.items = prf.items[:split] + prf.items[split+1:]\n for item in prf.items[split:]:\n decr_proof_item(item, id)\n\n self.check_proof(compute_only=True)","def destroy(self):\n self._set_block(self._pos, _AIR)\n self._set_block(self._pos + _Vec3(0, 1, 0), _AIR)","def proof_of_work(self, block):\r\n block.nonce = 0\r\n\r\n computed_hash = block.compute_hash()\r\n while not computed_hash.startswith('0' * Blockchain.difficulty):\r\n block.nonce += 1\r\n computed_hash = block.compute_hash()\r\n\r\n return computed_hash","def _delete_if_true_orphan(self, orphan, structure):\n if len(self._get_parents_from_structure(orphan, structure)) == 0:\n orphan_data = structure['blocks'].pop(orphan)\n for child in orphan_data.fields.get('children', []):\n self._delete_if_true_orphan(BlockKey(*child), structure)","def delete_this_region(self):","def remove_block(self, block, take_branch=None):\n for source, source_label in block.incoming_edges:\n source.outgoing_edges.remove((block, source_label))\n for sink, sink_label in block.outgoing_edges:\n sink.incoming_edges.remove((block, sink_label))\n for source, source_label in block.incoming_edges:\n if isinstance(source, Branch):\n if len(block.outgoing_edges) == 1:\n sink, sink_label = list(block.outgoing_edges)[0]\n add_edge(source, sink, source_label)\n if source_label == \"F\":\n source.false_edge = sink\n elif source_label == \"T\":\n source.true_edge = sink\n else: # pragma: no cover\n assert False\n elif block.outgoing_edges:\n assert isinstance(block, Branch), \"Encountered non branch with more than one out edge\"\n assert take_branch, \"Cannot remove branch without knowing which edge to take\"\n if take_branch is True:\n sink = block.true_edge\n else:\n sink = block.false_edge\n add_edge(source, sink, source_label)\n if source_label == \"F\":\n source.false_edge = sink\n elif source_label == \"T\":\n source.true_edge = sink\n else: # pragma: no cover\n assert False\n else:\n if isinstance(block, Branch):\n if take_branch is True:\n sink = block.true_edge\n add_edge(source, sink)\n else:\n sink = block.false_edge\n add_edge(source, sink)\n else:\n for sink, sink_label in block.outgoing_edges:\n add_edge(source, sink, source_label)","def delete(self, block, name):\n self._kvs.delete(self._key(block, name))","def proof_of_work(self, block):\n block.nonce = 0\n\n computed_hash = block.compute_hash()\n while not computed_hash.startswith('0' * Blockchain.difficulty):\n block.nonce += 1\n computed_hash = block.compute_hash()\n\n return computed_hash","def __delitem__(self, index):\n def _removeBlock(blockIndex):\n block = self._doc.findBlockByNumber(blockIndex)\n if block.next().isValid(): # not the last\n cursor = QTextCursor(block)\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\n elif block.previous().isValid(): # the last, not the first\n cursor = QTextCursor(block.previous())\n cursor.movePosition(QTextCursor.EndOfBlock)\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\n else: # only one block\n cursor = QTextCursor(block)\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\n cursor.removeSelectedText()\n\n if isinstance(index, int):\n index = self._checkAndConvertIndex(index)\n _removeBlock(index)\n elif isinstance(index, slice):\n \"\"\"List of indexes is reversed for make sure \n not processed indexes are not shifted during document modification\n \"\"\"\n start, stop, step = index.indices(self._doc.blockCount())\n if step > 0:\n start, stop, step = stop - 1, start - 1, step * -1\n\n for blockIndex in range(start, stop, step):\n _removeBlock(blockIndex)","def remove_blocks(self, block_ids):\n self.smd3.remove_blocks(block_ids)\n self.logic.update(self.smd3)\n self.header.update(self.smd3)","def proof_of_work(block):\n block.nonce = 0\n\n computed_hash = block.compute_hash()\n while not computed_hash.startswith('0' * Blockchain.difficulty):\n block.nonce += 1\n computed_hash = block.compute_hash()\n\n return computed_hash","def remove_checkpoint(cls, checkpoint):\n cls.log.info('Removing checkpoint: {}'.format(checkpoint))\n # TODO: remove ckpt\n cls.log.info('Checkpoint successfully removed.')\n raise NotImplementedError","def remove_node(self, name):\n parent_names = self.get_parents(name)\n self.source_net.remove_node(name)\n\n # Remove sole private parents\n for p in parent_names:\n if p[0] == '_' and self.source_net.degree(p) == 0:\n self.remove_node(p)","def mine(self):\n if not self.unconfirmed_transactions: \n return False\n \n last_block = self.last_block\n \n new_block = Block(index= last_block.index + 1, \n transactions = self.unconfirmed_transactions,\n timestamp = time.time(),\n previous_hash = last_block.hash)\n\n proof = self.proof_of_work(new_block)\n self.add_block(new_block, proof)\n self.unconfirmed_transactions = []\n return new_block.index","def removeNode(self, node):","def remove(self):\n if self.basic_block is None:\n if self not in self.module.global_insts:\n raise IRError('Instruction is not in basic block or module')\n self.module.global_insts.remove(self)\n return\n self.basic_block.insts.remove(self)\n self.basic_block = None","def _do_remove_block(self, args):\r\n bus_type = args[1]\r\n slave_id = int(args[2])\r\n name = args[3]\r\n if bus_type == 'rtu':\r\n slave = self.server._servers[0].get_slave(slave_id)\r\n elif bus_type == 'tcp':\r\n slave = self.server._servers[1].get_slave(slave_id)\r\n slave.remove_block(name)","def _remove_from_weakref(self, tx: BaseTransaction) -> None:\n if self._tx_weakref_disabled:\n return\n assert tx.hash is not None\n self._tx_weakref.pop(tx.hash, None)","def remove(self, str):\n if str in self.settings['Core::Blocks']:\n self.settings['Core::Blocks'].remove(str)\n self.rebuild()\n self.settings.save()","def remove():","def mine():\n last_block = blockchain.get_last_block\n print(last_block)\n last_proof = last_block['proof']\n proof = blockchain.proof_of_work(last_proof)\n\n blockchain.add_transaction(sender=0, recipient=node_identifier, amount=1)\n block = blockchain.add_block(proof)\n block['message'] = 'New block added'\n\n return jsonify(block), 200","def clear(self):\n self.need_rebuild = False\n\n # txid -> int\n self.validity = {}\n\n # [address] -> set of \"prevouthash:n\" for that address\n self.txo_byaddr = {}\n\n # [token_id_hex] -> dict of [\"prevouthash:n\"] -> qty (-1 for qty indicates\n # minting baton)\n self.token_quantities = {}\n\n # [\"prevouthash:n\"] -> \"token_id_hex\"\n self.txo_token_id = {}","def destroy(self, coords):\n\n block = blocks[self.get_block(coords)]\n self.set_block(coords, block.replace)\n self.set_metadata(coords, 0)","def eraseLastSeg(self):\n self.can.delete(self.segs.pop().getGraphicObject())","def add_block(self, block):\n # Create a list of transaction objects\n transactions = [Transaction(\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']] \n chipsactions = [Chipsaction(\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']] \n messsactions = [Messsaction(\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']] \n # Validate the proof of work of the block and store the result (True or False) in a variable\n proof_is_valid = Verification.valid_proof(\n transactions[:-1], chipsactions, messsactions, block['previous_hash'], block['proof'])\n # Check if previous_hash stored in the block is equal to the local blockchain's last block's hash and store the result in a block\n hashes_match = hash_block(self.chain[-1]) == block['previous_hash']\n if not proof_is_valid or not hashes_match:\n return False\n # Create a Block object\n converted_block = Block(\n block['index'], block['previous_hash'], transactions, chipsactions, messsactions, block['proof'], block['timestamp'])\n self.__chain.append(converted_block)\n stored_transactions = self.__open_transactions[:]\n stored_chipsactions = self.__open_chipsactions[:]\n stored_messsactions = self.__open_messsactions[:]\n # Check which open transactions were included in the received block and remove them\n # This could be improved by giving each transaction an ID that would uniquely identify it\n for itx in block['transactions']:\n for opentx in stored_transactions:\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\n try:\n self.__open_transactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n\n for itx in block['chipsactions']:\n for opentx in stored_chipsactions:\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.sender == itx['follow'] and opentx.recipient == itx['message'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\n try:\n self.__open_chipsactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n for itx in block['messsactions']:\n for opentx in stored_messsactions:\n if opentx.sender == itx['sender'] and opentx.sender == itx['follower'] and opentx.recipient == itx['message'] and opentx.signature == itx['signature']:\n try:\n self.__open_messsactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n self.save_data()\n return True","def _save_genesis_block(self, genesis_file=GENESIS):\n genesis = json.load(open(genesis_file))\n self.client.bulk_index(docs=genesis, index=self.indices[\"internal_transaction\"], doc_type=\"itx\",\n id_field=\"hash\", refresh=True)","def remove_coin(self, index):\n if index < 0:\n raise ValueError('Invalid Index: Coin index cannot be below zero')\n if index in self.coins:\n coin = self.coins[index]\n self.weight -= coin.weight\n del self.coins[index]\n return coin\n else:\n raise ValueError('Index is not in this bin')","def remove_piece(self) -> None:\r\n if self.has_piece():\r\n self.piece.square = None\r\n self.piece = None","def removeFromAtlas(self):\n self.doesHaveAtlasPos = False\n self.atlasPos = Vec2(0)","def new_block(self, proof, previous_hash=None):\n\n # Create the block\n my_block = Block(proof=proof,\n previous_hash=previous_hash or self.hash(self.last_block))\n my_block.save()\n\n # Update current_transactions with this new block.\n my_block_trans = self.current_transactions_obj\n\n for trans in Transaction.objects.filter(block__isnull=True):\n trans.block = my_block\n trans.save()\n\n block = {\n 'index': my_block.id,\n 'timestamp': my_block.timestamp,\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\n 'proof': my_block.proof,\n 'previous_hash': my_block.previous_hash,\n }\n\n return block","def add_block(self, block, proof):\n previous_hash = self.last_block.hash\n \n if previous_hash != block.previous: \n return False\n \n if not Blockchain.is_valid_proof(block, proof):\n return False\n \n block.hash = proof \n self.chain.append(block)\n return True","def proof_of_work(block):\n while not Blockchain.valid_proof(block):\n block[\"proof\"] += 1","def main():\n\n parser = argparse.ArgumentParser(\n description=\"Create and store proof from create_blockchain_new.py\"\n )\n group = parser.add_mutually_exclusive_group()\n group.add_argument(\"--blocks\", type=int, help=\"Number of blocks\")\n group.add_argument(\"--proof\", type=str, help=\"Name of proof\")\n args = parser.parse_args()\n blocks = args.blocks\n proof_name = args.proof\n\n proof_tool = ProofTool(\"../../data/proofs/\")\n\n proof = []\n if blocks is not None:\n # proof = proof_tool.fetch_proof(blocks)\n proof = proof_tool.create_proof(blocks)\n elif proof_name is not None:\n proof = proof_tool.fetch_proof(proof_name)\n else:\n print(\"Provide --blocks or --proof argument\")\n sys.exit()\n\n print(\"Proof size:\", len(proof))","def new_block(self, proof, previous_hash=None):\n servers = [\n \"1.us.pool.ntp.org\",\n \"2.us.pool.ntp.org\",\n \"3.us.pool.ntp.org\"\n ]\n\n response = {}\n\n try:\n response = self.c.request('0.us.pool.ntp.org')\n except Exception:\n for server in servers:\n try:\n response = self.c.request(server)\n\n if response:\n break\n\n except Exception:\n print('\\n //// alternate ntp server didnt work')\n\n block = {\n 'message': 'New Block Forged',\n 'index': len(self.chain) + 1,\n 'timestamp': response.tx_time or time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.chain[-1]['hash'],\n }\n\n # Calculate the hash of this new Block\n block['hash'] = self.hash(block)\n\n # Reset the current list of transactions\n self.current_transactions = []\n\n self.chain.append(block)\n return block","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 _del_node_no_children(self, parent, node):\n if parent:\n if parent._rkid == node:\n parent._rkid = None\n else:\n parent._lkid = None\n else:\n self._root = None"],"string":"[\n \"def remove_block(self, block):\\n raise NotImplementedError()\",\n \"def remove_from_block(self):\\n self.enclosing_block.remove_ops([self])\",\n \"def delete_block(self, block):\\n raise NotImplementedError('delete_block')\",\n \"def remove(self, block):\\n try:\\n self.blocks[block.height]\\n except:\\n raise ValueError(\\\"cant remove block: \\\" + str(block))\\n\\n removed = False\\n for b in self.blocks[block.height]:\\n # only delete the one with equal hash\\n if b.hash() == block.hash():\\n self.blocks[block.height].remove(b)\\n removed = True\\n if self.blocks[block.height] == []:\\n self.blocks.pop(block.height)\\n\\n if not removed:\\n raise ValueError(\\\"cant remove block: \\\" + str(block))\",\n \"def _generate_genesis() -> None:\\n logging.debug(\\\"Generating the genesis block\\\")\\n new_recv_block(Block.genesis())\",\n \"def erase_block(self):\\n self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]] = '0'\",\n \"def die(self):\\n self.pjs.bombermen.remove(self)\\n for block in self.physics.blocks[self.stype]:\\n if block == self.rects[0]:\\n self.physics.blocks[self.stype].remove(block)\",\n \"def skip_blocks(proof, block_index, skipped_blocks=1):\\n\\n if block_index >= len(proof):\\n return proof\\n\\n for i in range(block_index, block_index + skipped_blocks):\\n print(\\\"Deleting block\\\", i)\\n del proof[i]\\n\\n return proof\",\n \"def removeMemoryBlock(self, block: ghidra.program.model.mem.MemoryBlock) -> None:\\n ...\",\n \"def genesisBlock():\\n return Block(0, \\\"0\\\", 1465154705, \\\"my genesis block!!\\\",\\n \\\"816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7\\\");\",\n \"def genesis():\\n #return Block(\\n #GENESIS_DATA['timestamp'],\\n #GENESIS_DATA['last_hash'],\\n #GENESIS_DATA['hash'],\\n #GENESIS_DATA['data']\\n #)\\n return Block(**GENESIS_DATA)\",\n \"def invalidate(self):\\n self._compute_merkle_tree()\\n self.block_header.merkle_root_hash = self.merkle_tree.hash\",\n \"def remove(self):\\n if self.function is None:\\n raise IRError('Basic block is not in function')\\n self.function.basic_blocks.remove(self)\\n self.function = None\",\n \"def test_genesis_block(self):\\n genesis_block = self.blockchain.last_block[\\\"index\\\"]\\n self.assertEqual(genesis_block, 1)\",\n \"def make_genesis_block():\\n block = Block(index=0,\\n timestamp=datetime.now(),\\n data=\\\"Genesis Block\\\",\\n previous_hash=\\\"0\\\")\\n return block\",\n \"def removeBlock(self, aBlock: gp.Block):\\n \\n for y, row in iter(self.blocks):\\n for x, block in iter(row):\\n if block is aBlock:\\n self.blocks[y][x] = None\\n self.playerSprites.remove(aBlock.sprite)\\n return\",\n \"def create_genesis_block(self):\\r\\n genesis_block = Block(0, [], time.time(), \\\"0\\\")\\r\\n genesis_block.hash = genesis_block.compute_hash()\\r\\n self.chain.append(genesis_block)\",\n \"def exit_block(self, parent=None, **kwargs):\\n block = self.newblock(parent, have_code=False, is_exit=True, **kwargs)\\n self.blocks.pop()\\n return block\",\n \"def remove_blocks(draft):\\n for symbol in draft.Blocks:\\n if symbol.Name in blocks_to_delete:\\n print(\\\"[-] %s, \\\\tdeleted\\\" % symbol.Name)\\n symbol.delete()\\n\\n # for ball in draft.ActiveSheet.Balloons:\\n if draft.Balloons:\\n for ball in draft.Balloons:\\n if ball.BalloonType == 7: # type 7 filter the triangle balloons.\\n print(\\\"[-] %s, \\\\tdeleted\\\" % ball.Name)\\n ball.Delete()\\n else:\\n pass\",\n \"def removeBlock(self, block: ghidra.program.model.mem.MemoryBlock, monitor: ghidra.util.task.TaskMonitor) -> None:\\n ...\",\n \"def remove_block(self, name):\\n\\n if not self._ast or not name in self._block_map:\\n raise ValueError(u\\\"Block '{0}' does not exist\\\"\\n .format(common.from_utf8(name)))\\n\\n block_idx = self._block_map[name]\\n\\n # remove block\\n self._ast[2].pop(block_idx)\\n del self._block_map[name]\",\n \"def finalize_block_construction(self, pyomo_block):\\n pass\",\n \"def create_genesis_block(self):\\n genesis_block = Block(0, [], time.time(), \\\"0\\\")\\n genesis_block.hash = genesis_block.compute_hash()\\n self.chain.append(genesis_block)\",\n \"def rollback_block(self, block):\\n # TODO: 0.007-12c changes\\n current_length = self.db.get('length')\\n if block['length'] != current_length:\\n # Block is not at the top the chain\\n return False\\n\\n for tx in block['txs']:\\n tx_owner_address = tools.tx_owner_address(tx)\\n owner_account = self.get_account(tx_owner_address)\\n if tx['type'] == 'mint':\\n owner_account['amount'] -= tools.block_reward(block['length'])\\n self.db.put(tx_owner_address, owner_account)\\n elif tx['type'] == 'spend':\\n owner_account['amount'] += tx['amount']\\n owner_account['count'] -= 1\\n owner_account['tx_blocks'].remove(block['length'])\\n\\n receiver_account = self.db.get(tx['to'])\\n receiver_account['amount'] -= tx['amount']\\n receiver_account['tx_blocks'].remove(block['length'])\\n\\n self.db.put(tx_owner_address, owner_account)\\n self.db.put(tx['to'], receiver_account)\",\n \"def genesis_block(self):\\n block = Block(target=self.target, transactions=[])\\n self.current_transactions.append(block)\",\n \"def createGenesisBlock(self):\\n return Block(\\\"Genesis Block\\\")\",\n \"def create_genesis_block(self):\\n genesis_block = Block(0, [], 0, \\\"0\\\")\\n genesis_block.hash = genesis_block.compute_hash()\\n self.chain.append(genesis_block)\",\n \"def create_genesis_block(self):\\n genesis_block = Block(0, [], 0, \\\"0\\\")\\n genesis_block.hash = genesis_block.compute_hash()\\n self.chain.append(genesis_block)\",\n \"def delete(self, flow):\\n for parent in self.parents:\\n parent.children.remove(self)\\n for child in self.children:\\n child.parents.remove(self)\\n\\n flow.blocks.remove(self)\",\n \"def mine(self):\\n last_block = self.chain[-1]\\n\\n nonce = self.proof_of_work()\\n previous_hash = self.hash(last_block)\\n self.create_block(nonce, previous_hash)\",\n \"def trim(self) -> TrimmedBlock:\\n hashes = [self.consensus_data.hash()] + [t.hash() for t in self.transactions]\\n return TrimmedBlock(version=self.version,\\n prev_hash=self.prev_hash,\\n merkle_root=self.merkle_root,\\n timestamp=self.timestamp,\\n index=self.index,\\n next_consensus=self.next_consensus,\\n witness=self.witness,\\n hashes=hashes,\\n consensus_data=self.consensus_data\\n )\",\n \"def clearUndoBlock(self):\\n if self.undoBlock:\\n callback = self.undoBlock\\n self.undoBlock = None\\n callback()\",\n \"def create_genesis(self):\\n return Block(0, 0, b'0', b'0', b'')\",\n \"def proof_of_work(self, block):\\n block.nonce = 0 \\n computed_hash = block.compute_hash()\\n while not computed_hash.starswith('0' * Blockchain.difficulty):\\n block.nonce += 1 \\n computed_hash = block.compute_hash()\",\n \"def __init__(self):\\n self.unconfirmed_transactions = [] \\n self.chain = []\\n self.create_genesis_block()\",\n \"def init_with_genesis_block(self, block):\\n\\n genesis_tx = block.transactions # Genesis block contains single seed transaction from God\\n\\n if not signature.verify(genesis_tx.from_pk, genesis_tx.to_string_for_hashing(), genesis_tx.signature):\\n print(\\\"Genesis transaction signature is NOT valid.\\\")\\n return\\n\\n self.blocks.append(block)\\n return self\",\n \"def remove_blocks(self, *vertices):\\n for vertex in vertices:\\n try:\\n self.world[vertex] = None\\n self.shown.pop(vertex)\\n for vtx in self._shown[vertex]:\\n vtx.delete()\\n except KeyError:\\n pass\\n except IndexError:\\n pass\",\n \"def test_fork_missing_predecessor(self):\\n bvh = self.BlockValidationHandler()\\n\\n root = self.btm.chain_head\\n\\n # generate candidate chain 3 long off the current head.\\n new_block = self.btm.generate_chain(root, 3,\\n {'add_to_cache': True})\\n # remove one of the new blocks\\n del self.btm.block_cache[new_block[1].identifier]\\n\\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\\n bv.run()\\n\\n self.assertTrue(bvh.has_result())\\n self.assertTrue(new_block[-1].status == BlockStatus.Invalid)\\n self.assertFalse(bvh.result[\\\"commit_new_block\\\"])\",\n \"def replace_block(proof, headers_map, interlink_map, block_index):\\n\\n prevous_block = proof[block_index - 1][0]\\n block_hash = prevous_block[36:68]\\n block = headers_map[block_hash]\\n interlink = list_flatten(interlink_map[block.GetHash()])\\n\\n block_2 = mine_block(\\n block.hashPrevBlock, block.nBits - 1, interlink, hashMerkleRoot=b\\\"\\\\x00\\\" * 32\\n )\\n return (\\n proof[0:block_index]\\n + [[block_2.serialize(), proof[block_index][1]]]\\n + proof[block_index + 1 :]\\n )\",\n \"def _delete_if_true_orphan(self, orphan, structure):\\r\\n if not self._get_parents_from_structure(orphan, structure):\\r\\n encoded_block_id = LocMapperStore.encode_key_for_mongo(orphan)\\r\\n for child in structure['blocks'][encoded_block_id]['fields'].get('children', []):\\r\\n self._delete_if_true_orphan(child, structure)\\r\\n del structure['blocks'][encoded_block_id]\",\n \"def test_valid_balance_genesis(self):\\n db = MockDatabase()\\n prev = TestBlock(block_type=BlockTypes.CHECKPOINT, transaction={'balance': 0})\\n result, errors = prev.validate_transaction(db)\\n self.assertEqual(result, ValidationResult.valid)\\n self.assertEqual(errors, [])\\n db.add_block(prev)\",\n \"def clear_blockages(self):\\n debug.info(3,\\\"Clearing all blockages\\\")\\n self.rg.clear_blockages()\",\n \"def remove_point(mutated_genome,index):\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n del mutated_genome[index][2][point_index]\",\n \"def _remove_snapshot(self) -> None:\\n assert self._is_transaction_boundary\\n\\n if not self.nested and self.session.expire_on_commit:\\n for s in self.session.identity_map.all_states():\\n s._expire(s.dict, self.session.identity_map._modified)\\n\\n statelib.InstanceState._detach_states(\\n list(self._deleted), self.session\\n )\\n self._deleted.clear()\\n elif self.nested:\\n parent = self._parent\\n assert parent is not None\\n parent._new.update(self._new)\\n parent._dirty.update(self._dirty)\\n parent._deleted.update(self._deleted)\\n parent._key_switches.update(self._key_switches)\",\n \"def clear(self):\\n self.blocks.clear()\",\n \"def checkpoint_unset():\\n unwind(checkpoints.pop())\",\n \"def new_block(self, proof, previous_hash=None):\\n \\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n # Add block to existing chain\\n self.chain.append(block)\\n return block\",\n \"def remove_subtree(block_id):\\r\\n encoded_block_id = LocMapperStore.encode_key_for_mongo(block_id)\\r\\n for child in new_blocks[encoded_block_id]['fields'].get('children', []):\\r\\n remove_subtree(child)\\r\\n del new_blocks[encoded_block_id]\",\n \"def new_block(self, proof, previous_hash=None):\\r\\n block = {\\r\\n 'index': len(self.chain) + 1,\\r\\n 'timestamp': time(),\\r\\n 'transactions': self.current_transactions,\\r\\n 'proof': proof,\\r\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\r\\n }\\r\\n\\r\\n # reseta a atual lista de transacoes\\r\\n self.current_transactions = []\\r\\n\\r\\n self.chain.append(block)\\r\\n return block\",\n \"def new_block(self, proof, previous_hash=None):\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions':self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n self.current_transactions = []\\n self.chain.append(block)\\n return block\",\n \"def valid_chain(chain):\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n #print(last_block)\\n #print(block)\\n #print(\\\"\\\\n-----------\\\\n\\\")\\n # Check that the hash of the block is correct\\n if block['previous_hash'] != hash(last_block):\\n return False\\n\\n # Check that the Proof of Work is correct\\n #Delete the reward transaction\\n transactions = block['transactions'][:-1]\\n # Need to make sure that the dictionary is ordered. Otherwise we'll get a different hash\\n transaction_elements = ['sender_address', 'recipient_address', 'value']\\n transactions = [OrderedDict((k, transaction[k]) for k in transaction_elements) for transaction in transactions]\\n\\n if not valid_proof(transactions, block['previous_hash'], block['nonce'], MINING_DIFFICULTY):\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def create_genesis_block(self):\\n index = 0\\n transactions = []\\n timestamp = 0.0\\n previous_hash = \\\"0\\\"*64\\n block = Block(index=index, transactions=transactions, timestamp=timestamp,previous_hash=previous_hash)\\n block.hash = block.compute_hash()\\n self.chain.append(block)\",\n \"def valid_proof(block):\\n return Blockchain.hash(block) [:4] == \\\"0000\\\"\",\n \"def new_block(self, proof, previous_hash=None):\\n\\n\\t\\tblock = {\\n\\t\\t\\t'index': len(self.chain) + 1,\\n\\t\\t\\t'timestamp': time(),\\n\\t\\t\\t'transactions': self.current_transactions,\\n\\t\\t\\t'proof': proof,\\n\\t\\t\\t'previous_hash': previous_hash or self.hash(self.chain[-1]),\\t\\t\\n\\t\\t}\\n\\n\\t\\t#Reset current list of transactions\\n\\t\\tself.current_transactions = []\\n\\n\\t\\tself.chain.append(block)\\n\\t\\treturn block\",\n \"def test_fork_different_genesis(self):\\n bvh = self.BlockValidationHandler()\\n\\n # create a new valid chain 5 long from the current root\\n new_head = self.btm.generate_chain(self.btm.chain_head, 5,\\n {'add_to_store': True})\\n self.btm.set_chain_head(new_head[-1])\\n\\n # generate candidate chain 5 long from it's own genesis\\n new_block = self.btm.generate_chain(None, 5,\\n {'add_to_cache': True})\\n\\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\\n bv.run()\\n\\n self.assertTrue(bvh.has_result())\\n self.assertTrue(new_block[-1].status == BlockStatus.Invalid)\\n self.assertFalse(bvh.result[\\\"commit_new_block\\\"])\",\n \"def proof_of_work(header: Header) -> Header:\\n logger.info(\\n \\\"Mining block for %s version and %s difficulty\\\",\\n header.version,\\n header.difficulty,\\n )\\n while not Verification.valid_nonce(header):\\n header.nonce += 1\\n\\n return header\",\n \"def new_block(self, proof, previous_hash = None):\\n #create a new Block & adds it to the chain.\\n \\n block = {\\n 'index' : len(self.chain) + 1,\\n 'timestamp' : time(),\\n 'transactions' : self.pending_transactions,\\n 'proof' : proof,\\n 'previous_hash' : previous_hash or self.hash(self.chain[-1])\\n }\\n\\n # Reset the current list of transactions\\n self.pending_transactions = []\\n\\n self.chain.append(block)\\n return block\\n #pass\",\n \"def new_block(self, proof, previous_hash=None):\\n block = {\\n 'index': len( self.chain ) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'merkle': self.hash(self.current_transactions),\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1])\\n }\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n\\n # Add the block to the chain\\n self.chain.append( block )\\n self._write_chain()\\n\\n return block\",\n \"def deleteCheckpoint(self):\\n if len(self.__stack) == 0:\\n raise EmptyStackException()\\n self.__stack = self.__stack[:-1]\",\n \"def pruneblockchain(self) -> None:\\n return self.rpc_call(\\\"pruneblockchain\\\")\",\n \"def consolidate_empty_blocks(self):\\n new_blocks = []\\n for block in self.blocks:\\n if isinstance(block, BasicBlock) and not block.statements:\\n self.remove_block(block)\\n else:\\n new_blocks.append(block)\\n self.blocks = new_blocks\",\n \"def test_single_fork_not_best(self):\\n self.assertEqual(len(self.genesis_blocks), 1)\\n manager = self.create_peer('testnet', tx_storage=self.tx_storage)\\n\\n # The initial score is the sum of the genesis\\n score = self.genesis_blocks[0].weight\\n for tx in self.genesis_txs:\\n score = sum_weights(score, tx.weight)\\n\\n # Mine 30 blocks in a row with no transactions\\n blocks = add_new_blocks(manager, 30, advance_clock=15)\\n for i, block in enumerate(blocks):\\n meta = block.get_metadata()\\n score = sum_weights(score, block.weight)\\n self.assertAlmostEqual(score, meta.score)\\n\\n # Add some transactions between blocks\\n txs = add_new_transactions(manager, 5, advance_clock=15)\\n for tx in txs:\\n score = sum_weights(score, tx.weight)\\n\\n # Mine 1 blocks\\n blocks = add_new_blocks(manager, 1, advance_clock=15)\\n for i, block in enumerate(blocks):\\n meta = block.get_metadata()\\n score = sum_weights(score, block.weight)\\n self.assertAlmostEqual(score, meta.score)\\n\\n # Generate a block which will be a fork in the middle of the chain\\n # Change the order of the transactions to change the hash\\n fork_block1 = manager.generate_mining_block()\\n fork_block1.parents = [fork_block1.parents[0]] + fork_block1.parents[:0:-1]\\n fork_block1.resolve()\\n fork_block1.verify()\\n\\n # Mine 8 blocks in a row\\n blocks = add_new_blocks(manager, 8, advance_clock=15)\\n for i, block in enumerate(blocks):\\n meta = block.get_metadata()\\n score = sum_weights(score, block.weight)\\n self.assertAlmostEqual(score, meta.score)\\n\\n # Fork block must have the same parents as blocks[0] as well as the same score\\n self.assertEqual(set(blocks[0].parents), set(fork_block1.parents))\\n\\n # Propagate fork block.\\n # This block belongs to case (ii).\\n self.assertTrue(manager.propagate_tx(fork_block1))\\n fork_meta1 = fork_block1.get_metadata()\\n self.assertEqual(fork_meta1.voided_by, {fork_block1.hash})\\n\\n # Add some transactions between blocks\\n txs = add_new_transactions(manager, 5, advance_clock=15)\\n for tx in txs:\\n score = sum_weights(score, tx.weight)\\n\\n # Mine 5 blocks in a row\\n # These blocks belong to case (i).\\n blocks = add_new_blocks(manager, 5, advance_clock=15)\\n for i, block in enumerate(blocks):\\n meta = block.get_metadata()\\n score = sum_weights(score, block.weight)\\n self.assertAlmostEqual(score, meta.score)\\n\\n # Add some transactions between blocks\\n txs = add_new_transactions(manager, 2, advance_clock=15)\\n for tx in txs:\\n score = sum_weights(score, tx.weight)\\n\\n # Propagate a block connected to the voided chain\\n # These blocks belongs to case (iii).\\n sidechain1 = add_new_blocks(manager, 3, parent_block_hash=fork_block1.hash)\\n for block in sidechain1:\\n meta = block.get_metadata(force_reload=True)\\n self.assertEqual(meta.voided_by, {block.hash})\\n\\n # Add some transactions between blocks\\n txs = add_new_transactions(manager, 2, advance_clock=15)\\n for tx in txs:\\n score = sum_weights(score, tx.weight)\\n\\n # Propagate a block connected to the voided chain\\n # This block belongs to case (iv).\\n fork_block3 = manager.generate_mining_block(parent_block_hash=fork_block1.hash)\\n fork_block3.resolve()\\n fork_block3.verify()\\n self.assertTrue(manager.propagate_tx(fork_block3))\\n fork_meta3 = fork_block3.get_metadata()\\n self.assertEqual(fork_meta3.voided_by, {fork_block3.hash})\\n\\n self.assertConsensusValid(manager)\",\n \"def mine(self):\\n if self.unconfirmed_transactions == []:\\n return False\\n\\n transactions = self.unconfirmed_transactions\\n for transaction in transactions:\\n author = transaction['author']\\n public_key_path = author + '_public.pem'\\n content = transaction['content']\\n signature = transaction['signature']\\n verify = rsa_verify(content, signature, public_key_path)\\n if verify == False:\\n print('Transaction not verified.')\\n return \\n previous_block = self.last_block\\n last_index = previous_block.index\\n\\n index = last_index + 1\\n timestamp = time.time()\\n previous_hash = previous_block.hash\\n\\n newblock = Block(index=index, transactions=transactions, timestamp=timestamp, previous_hash=previous_hash)\\n proof = Blockchain.proof_of_work(newblock)\\n\\n self.add_block(newblock, proof)\\n self.unconfirmed_transactions = []\\n return newblock.index\",\n \"async def remove_block(\\n self,\\n position: typing.Union[\\n typing.Tuple[int, int, int],\\n typing.Any,\\n ],\\n immediate: bool = True,\\n block_update: bool = True,\\n block_update_self: bool = True,\\n network_sync=True,\\n reason=None,\\n ):\\n raise NotImplementedError\",\n \"def remove_line(self, id):\\n id = id_force_tuple(id)\\n prf = self.prf.get_parent_proof(id)\\n split = id[-1]\\n prf.items = prf.items[:split] + prf.items[split+1:]\\n for item in prf.items[split:]:\\n decr_proof_item(item, id)\\n\\n self.check_proof(compute_only=True)\",\n \"def destroy(self):\\n self._set_block(self._pos, _AIR)\\n self._set_block(self._pos + _Vec3(0, 1, 0), _AIR)\",\n \"def proof_of_work(self, block):\\r\\n block.nonce = 0\\r\\n\\r\\n computed_hash = block.compute_hash()\\r\\n while not computed_hash.startswith('0' * Blockchain.difficulty):\\r\\n block.nonce += 1\\r\\n computed_hash = block.compute_hash()\\r\\n\\r\\n return computed_hash\",\n \"def _delete_if_true_orphan(self, orphan, structure):\\n if len(self._get_parents_from_structure(orphan, structure)) == 0:\\n orphan_data = structure['blocks'].pop(orphan)\\n for child in orphan_data.fields.get('children', []):\\n self._delete_if_true_orphan(BlockKey(*child), structure)\",\n \"def delete_this_region(self):\",\n \"def remove_block(self, block, take_branch=None):\\n for source, source_label in block.incoming_edges:\\n source.outgoing_edges.remove((block, source_label))\\n for sink, sink_label in block.outgoing_edges:\\n sink.incoming_edges.remove((block, sink_label))\\n for source, source_label in block.incoming_edges:\\n if isinstance(source, Branch):\\n if len(block.outgoing_edges) == 1:\\n sink, sink_label = list(block.outgoing_edges)[0]\\n add_edge(source, sink, source_label)\\n if source_label == \\\"F\\\":\\n source.false_edge = sink\\n elif source_label == \\\"T\\\":\\n source.true_edge = sink\\n else: # pragma: no cover\\n assert False\\n elif block.outgoing_edges:\\n assert isinstance(block, Branch), \\\"Encountered non branch with more than one out edge\\\"\\n assert take_branch, \\\"Cannot remove branch without knowing which edge to take\\\"\\n if take_branch is True:\\n sink = block.true_edge\\n else:\\n sink = block.false_edge\\n add_edge(source, sink, source_label)\\n if source_label == \\\"F\\\":\\n source.false_edge = sink\\n elif source_label == \\\"T\\\":\\n source.true_edge = sink\\n else: # pragma: no cover\\n assert False\\n else:\\n if isinstance(block, Branch):\\n if take_branch is True:\\n sink = block.true_edge\\n add_edge(source, sink)\\n else:\\n sink = block.false_edge\\n add_edge(source, sink)\\n else:\\n for sink, sink_label in block.outgoing_edges:\\n add_edge(source, sink, source_label)\",\n \"def delete(self, block, name):\\n self._kvs.delete(self._key(block, name))\",\n \"def proof_of_work(self, block):\\n block.nonce = 0\\n\\n computed_hash = block.compute_hash()\\n while not computed_hash.startswith('0' * Blockchain.difficulty):\\n block.nonce += 1\\n computed_hash = block.compute_hash()\\n\\n return computed_hash\",\n \"def __delitem__(self, index):\\n def _removeBlock(blockIndex):\\n block = self._doc.findBlockByNumber(blockIndex)\\n if block.next().isValid(): # not the last\\n cursor = QTextCursor(block)\\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\\n elif block.previous().isValid(): # the last, not the first\\n cursor = QTextCursor(block.previous())\\n cursor.movePosition(QTextCursor.EndOfBlock)\\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\\n else: # only one block\\n cursor = QTextCursor(block)\\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\\n cursor.removeSelectedText()\\n\\n if isinstance(index, int):\\n index = self._checkAndConvertIndex(index)\\n _removeBlock(index)\\n elif isinstance(index, slice):\\n \\\"\\\"\\\"List of indexes is reversed for make sure \\n not processed indexes are not shifted during document modification\\n \\\"\\\"\\\"\\n start, stop, step = index.indices(self._doc.blockCount())\\n if step > 0:\\n start, stop, step = stop - 1, start - 1, step * -1\\n\\n for blockIndex in range(start, stop, step):\\n _removeBlock(blockIndex)\",\n \"def remove_blocks(self, block_ids):\\n self.smd3.remove_blocks(block_ids)\\n self.logic.update(self.smd3)\\n self.header.update(self.smd3)\",\n \"def proof_of_work(block):\\n block.nonce = 0\\n\\n computed_hash = block.compute_hash()\\n while not computed_hash.startswith('0' * Blockchain.difficulty):\\n block.nonce += 1\\n computed_hash = block.compute_hash()\\n\\n return computed_hash\",\n \"def remove_checkpoint(cls, checkpoint):\\n cls.log.info('Removing checkpoint: {}'.format(checkpoint))\\n # TODO: remove ckpt\\n cls.log.info('Checkpoint successfully removed.')\\n raise NotImplementedError\",\n \"def remove_node(self, name):\\n parent_names = self.get_parents(name)\\n self.source_net.remove_node(name)\\n\\n # Remove sole private parents\\n for p in parent_names:\\n if p[0] == '_' and self.source_net.degree(p) == 0:\\n self.remove_node(p)\",\n \"def mine(self):\\n if not self.unconfirmed_transactions: \\n return False\\n \\n last_block = self.last_block\\n \\n new_block = Block(index= last_block.index + 1, \\n transactions = self.unconfirmed_transactions,\\n timestamp = time.time(),\\n previous_hash = last_block.hash)\\n\\n proof = self.proof_of_work(new_block)\\n self.add_block(new_block, proof)\\n self.unconfirmed_transactions = []\\n return new_block.index\",\n \"def removeNode(self, node):\",\n \"def remove(self):\\n if self.basic_block is None:\\n if self not in self.module.global_insts:\\n raise IRError('Instruction is not in basic block or module')\\n self.module.global_insts.remove(self)\\n return\\n self.basic_block.insts.remove(self)\\n self.basic_block = None\",\n \"def _do_remove_block(self, args):\\r\\n bus_type = args[1]\\r\\n slave_id = int(args[2])\\r\\n name = args[3]\\r\\n if bus_type == 'rtu':\\r\\n slave = self.server._servers[0].get_slave(slave_id)\\r\\n elif bus_type == 'tcp':\\r\\n slave = self.server._servers[1].get_slave(slave_id)\\r\\n slave.remove_block(name)\",\n \"def _remove_from_weakref(self, tx: BaseTransaction) -> None:\\n if self._tx_weakref_disabled:\\n return\\n assert tx.hash is not None\\n self._tx_weakref.pop(tx.hash, None)\",\n \"def remove(self, str):\\n if str in self.settings['Core::Blocks']:\\n self.settings['Core::Blocks'].remove(str)\\n self.rebuild()\\n self.settings.save()\",\n \"def remove():\",\n \"def mine():\\n last_block = blockchain.get_last_block\\n print(last_block)\\n last_proof = last_block['proof']\\n proof = blockchain.proof_of_work(last_proof)\\n\\n blockchain.add_transaction(sender=0, recipient=node_identifier, amount=1)\\n block = blockchain.add_block(proof)\\n block['message'] = 'New block added'\\n\\n return jsonify(block), 200\",\n \"def clear(self):\\n self.need_rebuild = False\\n\\n # txid -> int\\n self.validity = {}\\n\\n # [address] -> set of \\\"prevouthash:n\\\" for that address\\n self.txo_byaddr = {}\\n\\n # [token_id_hex] -> dict of [\\\"prevouthash:n\\\"] -> qty (-1 for qty indicates\\n # minting baton)\\n self.token_quantities = {}\\n\\n # [\\\"prevouthash:n\\\"] -> \\\"token_id_hex\\\"\\n self.txo_token_id = {}\",\n \"def destroy(self, coords):\\n\\n block = blocks[self.get_block(coords)]\\n self.set_block(coords, block.replace)\\n self.set_metadata(coords, 0)\",\n \"def eraseLastSeg(self):\\n self.can.delete(self.segs.pop().getGraphicObject())\",\n \"def add_block(self, block):\\n # Create a list of transaction objects\\n transactions = [Transaction(\\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']] \\n chipsactions = [Chipsaction(\\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']] \\n messsactions = [Messsaction(\\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']] \\n # Validate the proof of work of the block and store the result (True or False) in a variable\\n proof_is_valid = Verification.valid_proof(\\n transactions[:-1], chipsactions, messsactions, block['previous_hash'], block['proof'])\\n # Check if previous_hash stored in the block is equal to the local blockchain's last block's hash and store the result in a block\\n hashes_match = hash_block(self.chain[-1]) == block['previous_hash']\\n if not proof_is_valid or not hashes_match:\\n return False\\n # Create a Block object\\n converted_block = Block(\\n block['index'], block['previous_hash'], transactions, chipsactions, messsactions, block['proof'], block['timestamp'])\\n self.__chain.append(converted_block)\\n stored_transactions = self.__open_transactions[:]\\n stored_chipsactions = self.__open_chipsactions[:]\\n stored_messsactions = self.__open_messsactions[:]\\n # Check which open transactions were included in the received block and remove them\\n # This could be improved by giving each transaction an ID that would uniquely identify it\\n for itx in block['transactions']:\\n for opentx in stored_transactions:\\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_transactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n\\n for itx in block['chipsactions']:\\n for opentx in stored_chipsactions:\\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.sender == itx['follow'] and opentx.recipient == itx['message'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_chipsactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n for itx in block['messsactions']:\\n for opentx in stored_messsactions:\\n if opentx.sender == itx['sender'] and opentx.sender == itx['follower'] and opentx.recipient == itx['message'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_messsactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n self.save_data()\\n return True\",\n \"def _save_genesis_block(self, genesis_file=GENESIS):\\n genesis = json.load(open(genesis_file))\\n self.client.bulk_index(docs=genesis, index=self.indices[\\\"internal_transaction\\\"], doc_type=\\\"itx\\\",\\n id_field=\\\"hash\\\", refresh=True)\",\n \"def remove_coin(self, index):\\n if index < 0:\\n raise ValueError('Invalid Index: Coin index cannot be below zero')\\n if index in self.coins:\\n coin = self.coins[index]\\n self.weight -= coin.weight\\n del self.coins[index]\\n return coin\\n else:\\n raise ValueError('Index is not in this bin')\",\n \"def remove_piece(self) -> None:\\r\\n if self.has_piece():\\r\\n self.piece.square = None\\r\\n self.piece = None\",\n \"def removeFromAtlas(self):\\n self.doesHaveAtlasPos = False\\n self.atlasPos = Vec2(0)\",\n \"def new_block(self, proof, previous_hash=None):\\n\\n # Create the block\\n my_block = Block(proof=proof,\\n previous_hash=previous_hash or self.hash(self.last_block))\\n my_block.save()\\n\\n # Update current_transactions with this new block.\\n my_block_trans = self.current_transactions_obj\\n\\n for trans in Transaction.objects.filter(block__isnull=True):\\n trans.block = my_block\\n trans.save()\\n\\n block = {\\n 'index': my_block.id,\\n 'timestamp': my_block.timestamp,\\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\\n 'proof': my_block.proof,\\n 'previous_hash': my_block.previous_hash,\\n }\\n\\n return block\",\n \"def add_block(self, block, proof):\\n previous_hash = self.last_block.hash\\n \\n if previous_hash != block.previous: \\n return False\\n \\n if not Blockchain.is_valid_proof(block, proof):\\n return False\\n \\n block.hash = proof \\n self.chain.append(block)\\n return True\",\n \"def proof_of_work(block):\\n while not Blockchain.valid_proof(block):\\n block[\\\"proof\\\"] += 1\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"Create and store proof from create_blockchain_new.py\\\"\\n )\\n group = parser.add_mutually_exclusive_group()\\n group.add_argument(\\\"--blocks\\\", type=int, help=\\\"Number of blocks\\\")\\n group.add_argument(\\\"--proof\\\", type=str, help=\\\"Name of proof\\\")\\n args = parser.parse_args()\\n blocks = args.blocks\\n proof_name = args.proof\\n\\n proof_tool = ProofTool(\\\"../../data/proofs/\\\")\\n\\n proof = []\\n if blocks is not None:\\n # proof = proof_tool.fetch_proof(blocks)\\n proof = proof_tool.create_proof(blocks)\\n elif proof_name is not None:\\n proof = proof_tool.fetch_proof(proof_name)\\n else:\\n print(\\\"Provide --blocks or --proof argument\\\")\\n sys.exit()\\n\\n print(\\\"Proof size:\\\", len(proof))\",\n \"def new_block(self, proof, previous_hash=None):\\n servers = [\\n \\\"1.us.pool.ntp.org\\\",\\n \\\"2.us.pool.ntp.org\\\",\\n \\\"3.us.pool.ntp.org\\\"\\n ]\\n\\n response = {}\\n\\n try:\\n response = self.c.request('0.us.pool.ntp.org')\\n except Exception:\\n for server in servers:\\n try:\\n response = self.c.request(server)\\n\\n if response:\\n break\\n\\n except Exception:\\n print('\\\\n //// alternate ntp server didnt work')\\n\\n block = {\\n 'message': 'New Block Forged',\\n 'index': len(self.chain) + 1,\\n 'timestamp': response.tx_time or time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.chain[-1]['hash'],\\n }\\n\\n # Calculate the hash of this new Block\\n block['hash'] = self.hash(block)\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n\\n self.chain.append(block)\\n return block\",\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 _del_node_no_children(self, parent, node):\\n if parent:\\n if parent._rkid == node:\\n parent._rkid = None\\n else:\\n parent._lkid = None\\n else:\\n self._root = None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6290408","0.5996669","0.59115857","0.5884244","0.5854443","0.58376217","0.58081526","0.57852006","0.57547975","0.5726658","0.56836265","0.5676911","0.5623997","0.5612229","0.5596398","0.55962217","0.55749035","0.5566368","0.5550208","0.5549425","0.5524756","0.550436","0.550218","0.54987615","0.54504","0.54338706","0.54197973","0.54197973","0.5397411","0.53944856","0.53713226","0.5359174","0.53483504","0.53372794","0.5277538","0.5271333","0.5268611","0.5242385","0.52382016","0.52272946","0.52188015","0.52182215","0.52000326","0.5189032","0.5188731","0.5181998","0.5159087","0.5155235","0.51519686","0.5148335","0.51339495","0.51284033","0.5121877","0.5113563","0.5105755","0.5104964","0.5088399","0.5087619","0.5087209","0.508162","0.50796306","0.50762546","0.5051782","0.50512856","0.5051116","0.5044316","0.50374347","0.5035925","0.5031787","0.50220686","0.5006988","0.4994546","0.4994067","0.4993686","0.49918222","0.4985689","0.49780738","0.4978047","0.4976361","0.49673474","0.49659124","0.49584776","0.4957847","0.4952076","0.49463162","0.49338162","0.49223426","0.49201313","0.4914858","0.49121585","0.4907461","0.49025217","0.48999646","0.48862502","0.4885828","0.4884756","0.4883666","0.48826918","0.48790318","0.4877717"],"string":"[\n \"0.6290408\",\n \"0.5996669\",\n \"0.59115857\",\n \"0.5884244\",\n \"0.5854443\",\n \"0.58376217\",\n \"0.58081526\",\n \"0.57852006\",\n \"0.57547975\",\n \"0.5726658\",\n \"0.56836265\",\n \"0.5676911\",\n \"0.5623997\",\n \"0.5612229\",\n \"0.5596398\",\n \"0.55962217\",\n \"0.55749035\",\n \"0.5566368\",\n \"0.5550208\",\n \"0.5549425\",\n \"0.5524756\",\n \"0.550436\",\n \"0.550218\",\n \"0.54987615\",\n \"0.54504\",\n \"0.54338706\",\n \"0.54197973\",\n \"0.54197973\",\n \"0.5397411\",\n \"0.53944856\",\n \"0.53713226\",\n \"0.5359174\",\n \"0.53483504\",\n \"0.53372794\",\n \"0.5277538\",\n \"0.5271333\",\n \"0.5268611\",\n \"0.5242385\",\n \"0.52382016\",\n \"0.52272946\",\n \"0.52188015\",\n \"0.52182215\",\n \"0.52000326\",\n \"0.5189032\",\n \"0.5188731\",\n \"0.5181998\",\n \"0.5159087\",\n \"0.5155235\",\n \"0.51519686\",\n \"0.5148335\",\n \"0.51339495\",\n \"0.51284033\",\n \"0.5121877\",\n \"0.5113563\",\n \"0.5105755\",\n \"0.5104964\",\n \"0.5088399\",\n \"0.5087619\",\n \"0.5087209\",\n \"0.508162\",\n \"0.50796306\",\n \"0.50762546\",\n \"0.5051782\",\n \"0.50512856\",\n \"0.5051116\",\n \"0.5044316\",\n \"0.50374347\",\n \"0.5035925\",\n \"0.5031787\",\n \"0.50220686\",\n \"0.5006988\",\n \"0.4994546\",\n \"0.4994067\",\n \"0.4993686\",\n \"0.49918222\",\n \"0.4985689\",\n \"0.49780738\",\n \"0.4978047\",\n \"0.4976361\",\n \"0.49673474\",\n \"0.49659124\",\n \"0.49584776\",\n \"0.4957847\",\n \"0.4952076\",\n \"0.49463162\",\n \"0.49338162\",\n \"0.49223426\",\n \"0.49201313\",\n \"0.4914858\",\n \"0.49121585\",\n \"0.4907461\",\n \"0.49025217\",\n \"0.48999646\",\n \"0.48862502\",\n \"0.4885828\",\n \"0.4884756\",\n \"0.4883666\",\n \"0.48826918\",\n \"0.48790318\",\n \"0.4877717\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8608646"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74277,"cells":{"query":{"kind":"string","value":"Changes a specific byte in a byte array"},"document":{"kind":"string","value":"def swap_byte(byte_array, index):\n\n if byte_array[index] == 0:\n changed_byte_array = byte_array[0:index] + b\"\\xff\" + byte_array[index + 1 :]\n changed_byte_array = byte_array[0:index] + b\"\\x00\" + byte_array[index + 1 :]\n return changed_byte_array"},"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 set_bit(self, index_of_byte, index_of_bit, new_value):\n if index_of_bit >= self.binary_size:\n print(\"You tried to modify a byte at %d index. This cannot be done. The maximum index is %d.\"%(index_of_bit, self.binary_size - 1))\n else:\n new_value = str(new_value)\n byte = self.binary_array[index_of_byte]\n new_byte = byte[0:index_of_bit] + new_value\n if index_of_bit < self.binary_size - 1: # you aren't changing the final bit in the byte\n new_byte += byte[index_of_bit + 1:]\n #apply changes\n self.binary_array[index_of_byte] = new_byte","def updatebyte(byte, bit, value):\n if value == 0:\n return byte & ~(1 << bit)\n elif value == 1:\n return byte | (1 << bit)","def setByte(self, addr: ghidra.program.model.address.Address, value: int) -> None:\n ...","def setByte(self, address: ghidra.program.model.address.Address, value: int) -> None:\n ...","def update_binary_bytes(self):\n self.binary_array = data_manipulation.convert_byte_array(self.bytes, self.binary_size)","def set_byte(ea, value):\n if not ida_bytes.patch_byte(ea, value):\n raise RuntimeError(\"Unable to set value {} at {}\".format(ea, value))","def update_bytes_array(self):\n self.bytes = data_manipulation.convert_from_binary_array(self.binary_array)","def modify_byte(byte: int, message_bit: bool) -> int:\n byte = bin(byte)\n byte_new_last_bit = int(message_bit)\n new_byte = int(byte[:-1] + str(byte_new_last_bit), base=2)\n return new_byte","def update_binary(self, offset, data):\n log.debug(\"write binary {0} to {1}\".format(offset, offset+len(data)))\n cmd = bytearray([0x00, 0xD6, offset/256, offset%256, len(data)])\n cmd = cmd + bytearray(data)\n rsp = self.transceive(cmd)\n if rsp[-2:] != \"\\x90\\x00\":\n raise Type4TagError(rsp[-2:])","def add_byte(self, newbyte):\n self._data.append(newbyte)","def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int]) -> None:\n ...","def setByteArray(self, name: unicode, value: List[int]) -> None:\n ...","def set_usint(bytearray_, byte_index, _int):\n _int = int(_int)\n _bytes = struct.unpack('B', struct.pack('>B', _int))\n bytearray_[byte_index] = _bytes[0]\n return bytearray_","def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int], sIndex: int, size: int) -> None:\n ...","def set_bytes(self, b):\n if not self._readonly:\n self._bytes = b\n else:\n raise ReadOnlyError(\"This memory element cannot be written to.\")","def set_bytes(ea, byt):\n if is_py3() and isinstance(byt, str):\n byt = bytearray(byt, 'latin-1')\n else:\n byt = bytearray(byt)\n for i in range(len(byt)):\n value = byt[i]\n if not ida_bytes.patch_byte(ea + i, value):\n raise RuntimeError(\"Unable to set value {} at {}\".format(ea, value))","def LD_Vx_byte(self, x, byte):\n\t\tself.V[x] = byte","def set_byte(self, register: str, byte: str):\n register = self.check_and_convert_add(register)\n\n if len(byte) != 2:\n raise Exception(\"Data to be written must be two digit hex.\")\n\n with SMBus(self.bus) as bus:\n bus.write_byte_data(self.device_address, register, int(byte, 16))","def _write_byte(self, byte):\n\n # Setup io pin as output\n self.gpio.setup(self._io_pin, GPIO.OUT)\n\n for _ in range(8):\n # Write data on the rising edge of clk\n self.gpio.output(self._clk_pin, GPIO.LOW)\n self._sleep()\n\n self.gpio.output(self._io_pin, byte & 0x01)\n\n byte >>= 1\n self.gpio.output(self._clk_pin, GPIO.HIGH)\n self._sleep()","def write_byte(self, addr, data):\n raise NotImplementedError()","def set_pixel(self, x, y, v):\n self.buf[y][x] = v & 0x07","def set_offset(self, offset):\r\n for b in self.buf:\r\n b.set_offset(offset)","def test_bit_set_bit_random_byte_random_offset(self):\n value = bytearray()\n rand_byte = random.randint(0, 255)\n value.append(rand_byte)\n rand_offset = random.randint(0, 4) * 8\n ops = [bitwise_operations.bit_set(self.test_bin_zeroes, rand_offset, 8, 1, value, None)]\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([0] * 5)\n expected_result[rand_offset // 8] = rand_byte\n assert bins[self.test_bin_zeroes] == expected_result\n # should set the byte at rand_offset/8 to rand_byte","def write_byte(fd, reg, b):\n write_read_i2c(fd, bytes([reg, b]), 0)","def _writeByte(self, val):\n self.__writeValue(self.byteFormat, val)","def shift_bytes(self,bytes):\n data_read = self.e.write_SPI_bytes_to_portA(bytes)\n return data_read","def setBytes(self, address: ghidra.program.model.address.Address, values: List[int]) -> None:\n ...","def bytes(self, bytes: int):\n\n self._bytes = bytes","def send_byte(self, byte: str):\n if len(byte) != 2:\n raise Exception(\"Data to be send must be two digit hex.\")\n return None\n with SMBus(self.bus) as bus:\n bus.write_byte(self.device_address, int(byte, 16))","def put_byte(self, *args) -> \"int\":\n return _ida_fpro.qfile_t_put_byte(self, *args)","def RND_Vx_byte(self, x, byte):\n\t\tself.V[x] = random.randint(0, 255) & byte","def lsb_update(self, index, new_lsb):\n self.set_bit(index, self.binary_size - 1, new_lsb)","def ADD_Vx_byte(self, x, byte):\n\t\tself.V[x] += byte\n\t\tself.V[x] &= 255","def inc_bytes(a):\n out = list(a)\n for i in reversed(range(len(out))):\n if out[i] == 0xFF:\n out[i] = 0\n else:\n out[i] += 1\n break\n return bytes(out)","def Write_Byte(self, byte, delay = True):\r\n self.Port.write(bytes([byte]))\r\n if delay == True: time.sleep(self.MinDelay * 10)","def setbit(self, key, offset, value):\n key = self._encode(key)\n index, bits, mask = self._get_bits_and_offset(key, offset)\n\n if index >= len(bits):\n bits.extend(b\"\\x00\" * (index + 1 - len(bits)))\n\n prev_val = 1 if (bits[index] & mask) else 0\n\n if value:\n bits[index] |= mask\n else:\n bits[index] &= ~mask\n\n self.redis[key] = bytes(bits)\n\n return prev_val","def send_byte(self, byte: int) -> Optional[int]:\n pass","def write(self, address: int, value: bytearray):\n for i, val in enumerate(value):\n self.mem[address+i] = value","def AdvanceToByteBoundary(self):\n bits_to_advance = (8 - self.idx_boff) % 8\n if bits_to_advance:\n self.idx_boff += bits_to_advance\n self.idx_boff %= 8\n self.idx_byte += 1","def _writeBytes(self, b):\n self.socket.send(b)","def encrypt_byte(self, _byte):\n beta = (pow(self.keys['public']['y'], self.keys['session'], self.keys['public']['p'])\n * (_byte % self.keys['public']['p'])) % self.keys['public']['p']\n return beta","def writeBytes(self, command):\r\n try:\r\n command += '0a'\r\n req_url = self.url + 'bwrite/' + command\r\n requests.get(url=req_url)\r\n except ValueError:\r\n print(\"uart failed write\")","def writeByte(self, value: int):\n self._pack('c', chr(value).encode('utf-8'))","def test_byte_array_conversion():\n ob = ConversionTest()\n\n assert ob.ByteArrayField is None\n\n ob.ByteArrayField = [0, 1, 2, 3, 4]\n array = ob.ByteArrayField\n assert len(array) == 5\n assert array[0] == 0\n assert array[4] == 4\n\n value = b\"testing\"\n ob.ByteArrayField = value\n array = ob.ByteArrayField\n for i, _ in enumerate(value):\n assert array[i] == operator.getitem(value, i)","def process_byte(self, byte):\r\n if self.index == -1:\r\n if byte == 0xff:\r\n self.index = 0\r\n self.checksum = 0\r\n elif self.index == 0:\r\n if byte != 0xff:\r\n self.checksum += byte\r\n self.pkt_bytes[0] = byte\r\n self.index += 1\r\n else:\r\n self.checksum += byte\r\n self.pkt_bytes[self.index] = byte\r\n self.index += 1\r\n if self.index == 7: # packet complete\r\n self.index = -1\r\n if self.checksum & 0xff != 0xff:\r\n return CommanderRx.CHECKSUM\r\n self.lookv = self.pkt_bytes[0] - 128 # 0 - 255 ==> -128 - 127\r\n self.lookh = self.pkt_bytes[1] - 128\r\n self.walkv = self.pkt_bytes[2] - 128\r\n self.walkh = self.pkt_bytes[3] - 128\r\n self.button = self.pkt_bytes[4]\r\n self.ext = self.pkt_bytes[5]\r\n return CommanderRx.SUCCESS\r\n return CommanderRx.NOT_DONE","def bytes_replace(byte_str, start_idx, stop_idx, replacement):\n return byte_str[:start_idx] + replacement + byte_str[stop_idx:]","def swap_bytes(word_val):\n msb = word_val >> 8\n lsb = word_val % 256\n return (lsb << 8) + msb","def update(self, data: bytes):\n self.send(data)","def append_bytes(self, data):\n\n if self.index != 7:\n self.buf.append(self.byte)\n self.byte = 0\n self.index = 7\n\n self.buf.extend(data)","def update(self, idx, add):\n idx += 1\n while idx < len(self.array):\n self.array[idx] += add\n idx += idx & -idx #Adding the last bit","def write_byte_data(self, addr, reg, data):\n raise NotImplementedError()","def _writeBytes(self, b):\n self.stream.write(b)\n self.stream.flush()","def send_byte(byte_out):\n GPIO.output(clock_pin, 0)\n # set the chip select to write\n GPIO.output(chip_select, 1)\n # send the byte \n values = [(ord(byte_out) >> i) % 2 for i in range(0, 8)]\n GPIO.setup(data_pins, GPIO.OUT)\n GPIO.output(data_pins, values)\n # flash the clock pin\n GPIO.output(clock_pin, 1)\n GPIO.output(clock_pin, 0)","def update(self, idx, x):\n while idx < len(self.bit):\n self.bit[idx] += x\n idx |= idx + 1","def write_byte(self, adr, byte):\n self.address_space[adr] = byte\n # when a byte is written, it's data until proven otherwise\n self.meta[adr] = Meta(0) # will create the page if empty\n self.meta[adr].type = _META_VALUES[\"data\"]","def def_char(self, offset, data):\n self.send((\"\\x1b\\x26\\x01%c%c\\x05\") % ((offset&0xff), (offset&0xff)))\n time.sleep(0.01)\n for i in data:\n self.send((\"%c\")%i)","def write_io_byte(self, address, value):\n return self.io.write(self.regs.resolve_address(address), value)","def bytes_transform(byte_str, start_idx, stop_idx, fction):\n return bytes_replace(byte_str, start_idx, stop_idx, fction(byte_str[start_idx:stop_idx]))","def set_pixel(framebuf, x, y, color):\n index = (y * framebuf.stride + x) * 3\n if isinstance(color, tuple):\n framebuf.buf[index : index + 3] = bytes(color)\n else:\n framebuf.buf[index : index + 3] = bytes(\n ((color >> 16) & 255, (color >> 8) & 255, color & 255)\n )","def setData(self,data):\n self.data = struct.pack(\"!Q\",data)","def setData(self,data):\n self.data = struct.pack(\"!Q\",data)","def add_byte(self, value):\n if isinstance(value, int):\n self.add_int8(int(value))\n else:\n if isinstance(value, str):\n value = value.encode(\"utf-8\")\n elif not isinstance(value, (bytes, bytearray)):\n raise Exception(\"value of type {} cannot be added as a single byte\".format(type(value)))\n if len(value) != 1:\n raise j.exceptions.Value(\n \"a single byte has to be accepted, amount of bytes given: {}\".format(len(value))\n )\n self._data += value","def write(self, buf: bytearray) -> int:\n ...","def setPixel(self, x, y, val):\r\n self.__buffer[y][x].setValue(val)","def send_bytes(self, bytearray):\r\n try:\r\n self.socket.send(bytearray)\r\n except:\r\n # print(\"Socket broken in send\")\r\n return","def __setitem__(self, pos, is_on):\n row, column = pos\n self.bits[row][column] = is_on","def setData(self,data):\n self.data = struct.pack(\"!I\",data)","def test_sbyte_array_conversion():\n ob = ConversionTest()\n\n assert ob.SByteArrayField is None\n\n ob.SByteArrayField = [0, 1, 2, 3, 4]\n array = ob.SByteArrayField\n assert len(array) == 5\n assert array[0] == 0\n assert array[4] == 4\n\n value = b\"testing\"\n ob.SByteArrayField = value\n array = ob.SByteArrayField\n for i, _ in enumerate(value):\n assert array[i] == operator.getitem(value, i)","def setData(self, data):\n self.data = struct.pack(\"!I\",data)","def SE_Vx_byte(self, x, byte):\n\t\tif self.V[x] == byte:\n\t\t\tself.IP += 2","def swapNibbles(inputByte):\n return (inputByte << 4 | inputByte >> 4) & 0xff","def __setitem__(self,key, value):\n cArray.cModule.set_element(self.arrayRef,ctypes.c_int(key),ctypes.c_int(value))","def SPItrans8(self,byte):\n data=self.SPItrans([byte]);\n return ord(data[0]);","def increment(self):\n self.data[self.pointer] += 1\n self.data[self.pointer] %= 256","def byte_swap(data, word_size):\n \n bs_data = [0]*len(data)\n for ii in range(0, len(data), word_size):\n bs_data[ii:ii+word_size] = data[ii:ii+4][::-1]\n return(bytes(bs_data))","def set_pixel(framebuf, x, y, color):\n index = (y * framebuf.stride + x) // 8\n offset = 7 - x & 0x07\n framebuf.buf[index] = (framebuf.buf[index] & ~(0x01 << offset)) | (\n (color != 0) << offset\n )","def write(self, data: bytes) -> None:\n self.device.write(binascii.unhexlify(data))","def command(self, arr):\n self.bitmap(arr, 0)","def __setitem__(self, n, bit):\n self.num ^= (np.uint64(-bit) ^ self.num) & (UINT64_ONE << np.uint64(n))","def set_pixel(self, framebuf, x, y, color):\n index = (y * framebuf.stride + x) * 2\n framebuf.buf[index : index + 2] = self.color_to_rgb565(color)","def write(self, value: int):\n self.data[self.pointer] = value","def _increment_last_byte(byte_string):\n s = bytearray(byte_string)\n s[-1] = s[-1] + 1\n return bytes(s)","def sub_bytes(state, s_box=s_box):\n for i in range(4):\n for j in range(4):\n state[i][j] = s_box[state[i][j]]","def set_pixel(framebuf, x, y, color):\n index = (y >> 3) * framebuf.stride + x\n offset = y & 0x07\n framebuf.buf[index] = (framebuf.buf[index] & ~(0x01 << offset)) | (\n (color != 0) << offset\n )","def test_short_bytearray(self):\n server, client = loopback()\n count = server.send(bytearray(b\"xy\"))\n assert count == 2\n assert client.recv(2) == b\"xy\"","def Write_Bytes(self, inputarr, delay = True):\r\n self.Port.write(inputarr)\r\n if delay == True: time.sleep(self.MinDelay * 10)","def test_bit_set_bit_inbetween_bytes(self):\n value = bytearray()\n value.append(255)\n ops = [bitwise_operations.bit_set(self.test_bin_zeroes, 4, 8, 1, value, None)]\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([15] * 1 + [240] * 1 + [0] * 3)\n assert bins[self.test_bin_zeroes] == expected_result","def __setitem__(self, index, value):\n self.buffer[index] = value","def update(self, m):\n if not six.PY3:\n m = ord(m)\n if ++self._buffpos >= self._size:\n self._bufpos = 0\n om = self._buff[self._buffpos]\n self._buff[self._buffpos] = m\n self._fingerprint = self._add_byte(self._fingerprint & self._u[om], m)\n return self._fingerprint","def __transfer(self, data: int):\n self.__spi.writebytes(data)","def __set_internal(self, pixel, r, g, b):\n if pixel < 0 or pixel > self.last_index:\n return # don't go out of bounds\n\n for channel, color in zip(self.c_order, [r, g, b]):\n self.pixel_buffer[pixel][channel] = \\\n self.gamma[int(color * self.master_brightness)]","def nibble(self, b):\n out = self.file[:b]\n self.file = self.file[b:]\n #print \"nibbled: \" + out\n return out","def setData(self,data):\n self.data = struct.pack(\"!d\",data)","def write(self, x, y, value):\n i = self.size * x + y\n self._write_bit(i, value)","def set_bit(self, port, bit):\n hw = self.device.peripherals[port]\n hw.BSRR.wr(1 << (bit & 15))","def update(self, i, v):\n # index in BTree is 1 more than index in arr[]\n i += 1\n\n # Traverse to ancestors of BITree[i]\n while i <= self.size:\n self.BITree[i] += v\n\n # Update index to next set bit in binary representation\n i += i & (-i)","def write(self, b):\n return self._write_at(b, self._offset)","def _setReg(address, new_value):\n mem[address:address+4] = struct.pack(\"<L\", new_value)","def data(self, arr):\n self.bitmap(arr, 1)","def setData(self,data):\n self.data = struct.pack(\"!f\",data)"],"string":"[\n \"def set_bit(self, index_of_byte, index_of_bit, new_value):\\n if index_of_bit >= self.binary_size:\\n print(\\\"You tried to modify a byte at %d index. This cannot be done. The maximum index is %d.\\\"%(index_of_bit, self.binary_size - 1))\\n else:\\n new_value = str(new_value)\\n byte = self.binary_array[index_of_byte]\\n new_byte = byte[0:index_of_bit] + new_value\\n if index_of_bit < self.binary_size - 1: # you aren't changing the final bit in the byte\\n new_byte += byte[index_of_bit + 1:]\\n #apply changes\\n self.binary_array[index_of_byte] = new_byte\",\n \"def updatebyte(byte, bit, value):\\n if value == 0:\\n return byte & ~(1 << bit)\\n elif value == 1:\\n return byte | (1 << bit)\",\n \"def setByte(self, addr: ghidra.program.model.address.Address, value: int) -> None:\\n ...\",\n \"def setByte(self, address: ghidra.program.model.address.Address, value: int) -> None:\\n ...\",\n \"def update_binary_bytes(self):\\n self.binary_array = data_manipulation.convert_byte_array(self.bytes, self.binary_size)\",\n \"def set_byte(ea, value):\\n if not ida_bytes.patch_byte(ea, value):\\n raise RuntimeError(\\\"Unable to set value {} at {}\\\".format(ea, value))\",\n \"def update_bytes_array(self):\\n self.bytes = data_manipulation.convert_from_binary_array(self.binary_array)\",\n \"def modify_byte(byte: int, message_bit: bool) -> int:\\n byte = bin(byte)\\n byte_new_last_bit = int(message_bit)\\n new_byte = int(byte[:-1] + str(byte_new_last_bit), base=2)\\n return new_byte\",\n \"def update_binary(self, offset, data):\\n log.debug(\\\"write binary {0} to {1}\\\".format(offset, offset+len(data)))\\n cmd = bytearray([0x00, 0xD6, offset/256, offset%256, len(data)])\\n cmd = cmd + bytearray(data)\\n rsp = self.transceive(cmd)\\n if rsp[-2:] != \\\"\\\\x90\\\\x00\\\":\\n raise Type4TagError(rsp[-2:])\",\n \"def add_byte(self, newbyte):\\n self._data.append(newbyte)\",\n \"def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int]) -> None:\\n ...\",\n \"def setByteArray(self, name: unicode, value: List[int]) -> None:\\n ...\",\n \"def set_usint(bytearray_, byte_index, _int):\\n _int = int(_int)\\n _bytes = struct.unpack('B', struct.pack('>B', _int))\\n bytearray_[byte_index] = _bytes[0]\\n return bytearray_\",\n \"def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int], sIndex: int, size: int) -> None:\\n ...\",\n \"def set_bytes(self, b):\\n if not self._readonly:\\n self._bytes = b\\n else:\\n raise ReadOnlyError(\\\"This memory element cannot be written to.\\\")\",\n \"def set_bytes(ea, byt):\\n if is_py3() and isinstance(byt, str):\\n byt = bytearray(byt, 'latin-1')\\n else:\\n byt = bytearray(byt)\\n for i in range(len(byt)):\\n value = byt[i]\\n if not ida_bytes.patch_byte(ea + i, value):\\n raise RuntimeError(\\\"Unable to set value {} at {}\\\".format(ea, value))\",\n \"def LD_Vx_byte(self, x, byte):\\n\\t\\tself.V[x] = byte\",\n \"def set_byte(self, register: str, byte: str):\\n register = self.check_and_convert_add(register)\\n\\n if len(byte) != 2:\\n raise Exception(\\\"Data to be written must be two digit hex.\\\")\\n\\n with SMBus(self.bus) as bus:\\n bus.write_byte_data(self.device_address, register, int(byte, 16))\",\n \"def _write_byte(self, byte):\\n\\n # Setup io pin as output\\n self.gpio.setup(self._io_pin, GPIO.OUT)\\n\\n for _ in range(8):\\n # Write data on the rising edge of clk\\n self.gpio.output(self._clk_pin, GPIO.LOW)\\n self._sleep()\\n\\n self.gpio.output(self._io_pin, byte & 0x01)\\n\\n byte >>= 1\\n self.gpio.output(self._clk_pin, GPIO.HIGH)\\n self._sleep()\",\n \"def write_byte(self, addr, data):\\n raise NotImplementedError()\",\n \"def set_pixel(self, x, y, v):\\n self.buf[y][x] = v & 0x07\",\n \"def set_offset(self, offset):\\r\\n for b in self.buf:\\r\\n b.set_offset(offset)\",\n \"def test_bit_set_bit_random_byte_random_offset(self):\\n value = bytearray()\\n rand_byte = random.randint(0, 255)\\n value.append(rand_byte)\\n rand_offset = random.randint(0, 4) * 8\\n ops = [bitwise_operations.bit_set(self.test_bin_zeroes, rand_offset, 8, 1, value, None)]\\n self.as_connection.operate(self.test_key, ops)\\n\\n _, _, bins = self.as_connection.get(self.test_key)\\n expected_result = bytearray([0] * 5)\\n expected_result[rand_offset // 8] = rand_byte\\n assert bins[self.test_bin_zeroes] == expected_result\\n # should set the byte at rand_offset/8 to rand_byte\",\n \"def write_byte(fd, reg, b):\\n write_read_i2c(fd, bytes([reg, b]), 0)\",\n \"def _writeByte(self, val):\\n self.__writeValue(self.byteFormat, val)\",\n \"def shift_bytes(self,bytes):\\n data_read = self.e.write_SPI_bytes_to_portA(bytes)\\n return data_read\",\n \"def setBytes(self, address: ghidra.program.model.address.Address, values: List[int]) -> None:\\n ...\",\n \"def bytes(self, bytes: int):\\n\\n self._bytes = bytes\",\n \"def send_byte(self, byte: str):\\n if len(byte) != 2:\\n raise Exception(\\\"Data to be send must be two digit hex.\\\")\\n return None\\n with SMBus(self.bus) as bus:\\n bus.write_byte(self.device_address, int(byte, 16))\",\n \"def put_byte(self, *args) -> \\\"int\\\":\\n return _ida_fpro.qfile_t_put_byte(self, *args)\",\n \"def RND_Vx_byte(self, x, byte):\\n\\t\\tself.V[x] = random.randint(0, 255) & byte\",\n \"def lsb_update(self, index, new_lsb):\\n self.set_bit(index, self.binary_size - 1, new_lsb)\",\n \"def ADD_Vx_byte(self, x, byte):\\n\\t\\tself.V[x] += byte\\n\\t\\tself.V[x] &= 255\",\n \"def inc_bytes(a):\\n out = list(a)\\n for i in reversed(range(len(out))):\\n if out[i] == 0xFF:\\n out[i] = 0\\n else:\\n out[i] += 1\\n break\\n return bytes(out)\",\n \"def Write_Byte(self, byte, delay = True):\\r\\n self.Port.write(bytes([byte]))\\r\\n if delay == True: time.sleep(self.MinDelay * 10)\",\n \"def setbit(self, key, offset, value):\\n key = self._encode(key)\\n index, bits, mask = self._get_bits_and_offset(key, offset)\\n\\n if index >= len(bits):\\n bits.extend(b\\\"\\\\x00\\\" * (index + 1 - len(bits)))\\n\\n prev_val = 1 if (bits[index] & mask) else 0\\n\\n if value:\\n bits[index] |= mask\\n else:\\n bits[index] &= ~mask\\n\\n self.redis[key] = bytes(bits)\\n\\n return prev_val\",\n \"def send_byte(self, byte: int) -> Optional[int]:\\n pass\",\n \"def write(self, address: int, value: bytearray):\\n for i, val in enumerate(value):\\n self.mem[address+i] = value\",\n \"def AdvanceToByteBoundary(self):\\n bits_to_advance = (8 - self.idx_boff) % 8\\n if bits_to_advance:\\n self.idx_boff += bits_to_advance\\n self.idx_boff %= 8\\n self.idx_byte += 1\",\n \"def _writeBytes(self, b):\\n self.socket.send(b)\",\n \"def encrypt_byte(self, _byte):\\n beta = (pow(self.keys['public']['y'], self.keys['session'], self.keys['public']['p'])\\n * (_byte % self.keys['public']['p'])) % self.keys['public']['p']\\n return beta\",\n \"def writeBytes(self, command):\\r\\n try:\\r\\n command += '0a'\\r\\n req_url = self.url + 'bwrite/' + command\\r\\n requests.get(url=req_url)\\r\\n except ValueError:\\r\\n print(\\\"uart failed write\\\")\",\n \"def writeByte(self, value: int):\\n self._pack('c', chr(value).encode('utf-8'))\",\n \"def test_byte_array_conversion():\\n ob = ConversionTest()\\n\\n assert ob.ByteArrayField is None\\n\\n ob.ByteArrayField = [0, 1, 2, 3, 4]\\n array = ob.ByteArrayField\\n assert len(array) == 5\\n assert array[0] == 0\\n assert array[4] == 4\\n\\n value = b\\\"testing\\\"\\n ob.ByteArrayField = value\\n array = ob.ByteArrayField\\n for i, _ in enumerate(value):\\n assert array[i] == operator.getitem(value, i)\",\n \"def process_byte(self, byte):\\r\\n if self.index == -1:\\r\\n if byte == 0xff:\\r\\n self.index = 0\\r\\n self.checksum = 0\\r\\n elif self.index == 0:\\r\\n if byte != 0xff:\\r\\n self.checksum += byte\\r\\n self.pkt_bytes[0] = byte\\r\\n self.index += 1\\r\\n else:\\r\\n self.checksum += byte\\r\\n self.pkt_bytes[self.index] = byte\\r\\n self.index += 1\\r\\n if self.index == 7: # packet complete\\r\\n self.index = -1\\r\\n if self.checksum & 0xff != 0xff:\\r\\n return CommanderRx.CHECKSUM\\r\\n self.lookv = self.pkt_bytes[0] - 128 # 0 - 255 ==> -128 - 127\\r\\n self.lookh = self.pkt_bytes[1] - 128\\r\\n self.walkv = self.pkt_bytes[2] - 128\\r\\n self.walkh = self.pkt_bytes[3] - 128\\r\\n self.button = self.pkt_bytes[4]\\r\\n self.ext = self.pkt_bytes[5]\\r\\n return CommanderRx.SUCCESS\\r\\n return CommanderRx.NOT_DONE\",\n \"def bytes_replace(byte_str, start_idx, stop_idx, replacement):\\n return byte_str[:start_idx] + replacement + byte_str[stop_idx:]\",\n \"def swap_bytes(word_val):\\n msb = word_val >> 8\\n lsb = word_val % 256\\n return (lsb << 8) + msb\",\n \"def update(self, data: bytes):\\n self.send(data)\",\n \"def append_bytes(self, data):\\n\\n if self.index != 7:\\n self.buf.append(self.byte)\\n self.byte = 0\\n self.index = 7\\n\\n self.buf.extend(data)\",\n \"def update(self, idx, add):\\n idx += 1\\n while idx < len(self.array):\\n self.array[idx] += add\\n idx += idx & -idx #Adding the last bit\",\n \"def write_byte_data(self, addr, reg, data):\\n raise NotImplementedError()\",\n \"def _writeBytes(self, b):\\n self.stream.write(b)\\n self.stream.flush()\",\n \"def send_byte(byte_out):\\n GPIO.output(clock_pin, 0)\\n # set the chip select to write\\n GPIO.output(chip_select, 1)\\n # send the byte \\n values = [(ord(byte_out) >> i) % 2 for i in range(0, 8)]\\n GPIO.setup(data_pins, GPIO.OUT)\\n GPIO.output(data_pins, values)\\n # flash the clock pin\\n GPIO.output(clock_pin, 1)\\n GPIO.output(clock_pin, 0)\",\n \"def update(self, idx, x):\\n while idx < len(self.bit):\\n self.bit[idx] += x\\n idx |= idx + 1\",\n \"def write_byte(self, adr, byte):\\n self.address_space[adr] = byte\\n # when a byte is written, it's data until proven otherwise\\n self.meta[adr] = Meta(0) # will create the page if empty\\n self.meta[adr].type = _META_VALUES[\\\"data\\\"]\",\n \"def def_char(self, offset, data):\\n self.send((\\\"\\\\x1b\\\\x26\\\\x01%c%c\\\\x05\\\") % ((offset&0xff), (offset&0xff)))\\n time.sleep(0.01)\\n for i in data:\\n self.send((\\\"%c\\\")%i)\",\n \"def write_io_byte(self, address, value):\\n return self.io.write(self.regs.resolve_address(address), value)\",\n \"def bytes_transform(byte_str, start_idx, stop_idx, fction):\\n return bytes_replace(byte_str, start_idx, stop_idx, fction(byte_str[start_idx:stop_idx]))\",\n \"def set_pixel(framebuf, x, y, color):\\n index = (y * framebuf.stride + x) * 3\\n if isinstance(color, tuple):\\n framebuf.buf[index : index + 3] = bytes(color)\\n else:\\n framebuf.buf[index : index + 3] = bytes(\\n ((color >> 16) & 255, (color >> 8) & 255, color & 255)\\n )\",\n \"def setData(self,data):\\n self.data = struct.pack(\\\"!Q\\\",data)\",\n \"def setData(self,data):\\n self.data = struct.pack(\\\"!Q\\\",data)\",\n \"def add_byte(self, value):\\n if isinstance(value, int):\\n self.add_int8(int(value))\\n else:\\n if isinstance(value, str):\\n value = value.encode(\\\"utf-8\\\")\\n elif not isinstance(value, (bytes, bytearray)):\\n raise Exception(\\\"value of type {} cannot be added as a single byte\\\".format(type(value)))\\n if len(value) != 1:\\n raise j.exceptions.Value(\\n \\\"a single byte has to be accepted, amount of bytes given: {}\\\".format(len(value))\\n )\\n self._data += value\",\n \"def write(self, buf: bytearray) -> int:\\n ...\",\n \"def setPixel(self, x, y, val):\\r\\n self.__buffer[y][x].setValue(val)\",\n \"def send_bytes(self, bytearray):\\r\\n try:\\r\\n self.socket.send(bytearray)\\r\\n except:\\r\\n # print(\\\"Socket broken in send\\\")\\r\\n return\",\n \"def __setitem__(self, pos, is_on):\\n row, column = pos\\n self.bits[row][column] = is_on\",\n \"def setData(self,data):\\n self.data = struct.pack(\\\"!I\\\",data)\",\n \"def test_sbyte_array_conversion():\\n ob = ConversionTest()\\n\\n assert ob.SByteArrayField is None\\n\\n ob.SByteArrayField = [0, 1, 2, 3, 4]\\n array = ob.SByteArrayField\\n assert len(array) == 5\\n assert array[0] == 0\\n assert array[4] == 4\\n\\n value = b\\\"testing\\\"\\n ob.SByteArrayField = value\\n array = ob.SByteArrayField\\n for i, _ in enumerate(value):\\n assert array[i] == operator.getitem(value, i)\",\n \"def setData(self, data):\\n self.data = struct.pack(\\\"!I\\\",data)\",\n \"def SE_Vx_byte(self, x, byte):\\n\\t\\tif self.V[x] == byte:\\n\\t\\t\\tself.IP += 2\",\n \"def swapNibbles(inputByte):\\n return (inputByte << 4 | inputByte >> 4) & 0xff\",\n \"def __setitem__(self,key, value):\\n cArray.cModule.set_element(self.arrayRef,ctypes.c_int(key),ctypes.c_int(value))\",\n \"def SPItrans8(self,byte):\\n data=self.SPItrans([byte]);\\n return ord(data[0]);\",\n \"def increment(self):\\n self.data[self.pointer] += 1\\n self.data[self.pointer] %= 256\",\n \"def byte_swap(data, word_size):\\n \\n bs_data = [0]*len(data)\\n for ii in range(0, len(data), word_size):\\n bs_data[ii:ii+word_size] = data[ii:ii+4][::-1]\\n return(bytes(bs_data))\",\n \"def set_pixel(framebuf, x, y, color):\\n index = (y * framebuf.stride + x) // 8\\n offset = 7 - x & 0x07\\n framebuf.buf[index] = (framebuf.buf[index] & ~(0x01 << offset)) | (\\n (color != 0) << offset\\n )\",\n \"def write(self, data: bytes) -> None:\\n self.device.write(binascii.unhexlify(data))\",\n \"def command(self, arr):\\n self.bitmap(arr, 0)\",\n \"def __setitem__(self, n, bit):\\n self.num ^= (np.uint64(-bit) ^ self.num) & (UINT64_ONE << np.uint64(n))\",\n \"def set_pixel(self, framebuf, x, y, color):\\n index = (y * framebuf.stride + x) * 2\\n framebuf.buf[index : index + 2] = self.color_to_rgb565(color)\",\n \"def write(self, value: int):\\n self.data[self.pointer] = value\",\n \"def _increment_last_byte(byte_string):\\n s = bytearray(byte_string)\\n s[-1] = s[-1] + 1\\n return bytes(s)\",\n \"def sub_bytes(state, s_box=s_box):\\n for i in range(4):\\n for j in range(4):\\n state[i][j] = s_box[state[i][j]]\",\n \"def set_pixel(framebuf, x, y, color):\\n index = (y >> 3) * framebuf.stride + x\\n offset = y & 0x07\\n framebuf.buf[index] = (framebuf.buf[index] & ~(0x01 << offset)) | (\\n (color != 0) << offset\\n )\",\n \"def test_short_bytearray(self):\\n server, client = loopback()\\n count = server.send(bytearray(b\\\"xy\\\"))\\n assert count == 2\\n assert client.recv(2) == b\\\"xy\\\"\",\n \"def Write_Bytes(self, inputarr, delay = True):\\r\\n self.Port.write(inputarr)\\r\\n if delay == True: time.sleep(self.MinDelay * 10)\",\n \"def test_bit_set_bit_inbetween_bytes(self):\\n value = bytearray()\\n value.append(255)\\n ops = [bitwise_operations.bit_set(self.test_bin_zeroes, 4, 8, 1, value, None)]\\n self.as_connection.operate(self.test_key, ops)\\n\\n _, _, bins = self.as_connection.get(self.test_key)\\n expected_result = bytearray([15] * 1 + [240] * 1 + [0] * 3)\\n assert bins[self.test_bin_zeroes] == expected_result\",\n \"def __setitem__(self, index, value):\\n self.buffer[index] = value\",\n \"def update(self, m):\\n if not six.PY3:\\n m = ord(m)\\n if ++self._buffpos >= self._size:\\n self._bufpos = 0\\n om = self._buff[self._buffpos]\\n self._buff[self._buffpos] = m\\n self._fingerprint = self._add_byte(self._fingerprint & self._u[om], m)\\n return self._fingerprint\",\n \"def __transfer(self, data: int):\\n self.__spi.writebytes(data)\",\n \"def __set_internal(self, pixel, r, g, b):\\n if pixel < 0 or pixel > self.last_index:\\n return # don't go out of bounds\\n\\n for channel, color in zip(self.c_order, [r, g, b]):\\n self.pixel_buffer[pixel][channel] = \\\\\\n self.gamma[int(color * self.master_brightness)]\",\n \"def nibble(self, b):\\n out = self.file[:b]\\n self.file = self.file[b:]\\n #print \\\"nibbled: \\\" + out\\n return out\",\n \"def setData(self,data):\\n self.data = struct.pack(\\\"!d\\\",data)\",\n \"def write(self, x, y, value):\\n i = self.size * x + y\\n self._write_bit(i, value)\",\n \"def set_bit(self, port, bit):\\n hw = self.device.peripherals[port]\\n hw.BSRR.wr(1 << (bit & 15))\",\n \"def update(self, i, v):\\n # index in BTree is 1 more than index in arr[]\\n i += 1\\n\\n # Traverse to ancestors of BITree[i]\\n while i <= self.size:\\n self.BITree[i] += v\\n\\n # Update index to next set bit in binary representation\\n i += i & (-i)\",\n \"def write(self, b):\\n return self._write_at(b, self._offset)\",\n \"def _setReg(address, new_value):\\n mem[address:address+4] = struct.pack(\\\"<L\\\", new_value)\",\n \"def data(self, arr):\\n self.bitmap(arr, 1)\",\n \"def setData(self,data):\\n self.data = struct.pack(\\\"!f\\\",data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7607034","0.7187944","0.6851375","0.6837722","0.6780952","0.6729589","0.6723024","0.6679319","0.64730704","0.6376428","0.6333384","0.62949824","0.62935746","0.6257262","0.6237112","0.6162971","0.6119067","0.6108211","0.61019486","0.609579","0.5928492","0.59275377","0.5881677","0.5880002","0.58734334","0.58541805","0.5797199","0.57902455","0.57517314","0.5746044","0.57446444","0.573055","0.5729091","0.5726328","0.5717332","0.5708353","0.5698457","0.5694253","0.5682046","0.5673966","0.56389153","0.56253713","0.56171376","0.5601791","0.558289","0.55801123","0.5577687","0.5575345","0.55220944","0.55183697","0.55168015","0.5516476","0.5510232","0.5476477","0.5475621","0.54731727","0.546172","0.5454021","0.5452953","0.54314077","0.54314077","0.54309136","0.5395827","0.5387102","0.53766054","0.53643835","0.53616774","0.5354591","0.53542","0.53540355","0.5351171","0.53452444","0.53433955","0.5338029","0.5332275","0.53223366","0.531784","0.5316459","0.530542","0.5292146","0.52802855","0.52782655","0.5273152","0.526348","0.52560693","0.5246734","0.5238097","0.52355117","0.52244043","0.5214629","0.52059966","0.5201004","0.5195456","0.5194366","0.5188749","0.51865834","0.5186532","0.5166367","0.516625","0.5155783"],"string":"[\n \"0.7607034\",\n \"0.7187944\",\n \"0.6851375\",\n \"0.6837722\",\n \"0.6780952\",\n \"0.6729589\",\n \"0.6723024\",\n \"0.6679319\",\n \"0.64730704\",\n \"0.6376428\",\n \"0.6333384\",\n \"0.62949824\",\n \"0.62935746\",\n \"0.6257262\",\n \"0.6237112\",\n \"0.6162971\",\n \"0.6119067\",\n \"0.6108211\",\n \"0.61019486\",\n \"0.609579\",\n \"0.5928492\",\n \"0.59275377\",\n \"0.5881677\",\n \"0.5880002\",\n \"0.58734334\",\n \"0.58541805\",\n \"0.5797199\",\n \"0.57902455\",\n \"0.57517314\",\n \"0.5746044\",\n \"0.57446444\",\n \"0.573055\",\n \"0.5729091\",\n \"0.5726328\",\n \"0.5717332\",\n \"0.5708353\",\n \"0.5698457\",\n \"0.5694253\",\n \"0.5682046\",\n \"0.5673966\",\n \"0.56389153\",\n \"0.56253713\",\n \"0.56171376\",\n \"0.5601791\",\n \"0.558289\",\n \"0.55801123\",\n \"0.5577687\",\n \"0.5575345\",\n \"0.55220944\",\n \"0.55183697\",\n \"0.55168015\",\n \"0.5516476\",\n \"0.5510232\",\n \"0.5476477\",\n \"0.5475621\",\n \"0.54731727\",\n \"0.546172\",\n \"0.5454021\",\n \"0.5452953\",\n \"0.54314077\",\n \"0.54314077\",\n \"0.54309136\",\n \"0.5395827\",\n \"0.5387102\",\n \"0.53766054\",\n \"0.53643835\",\n \"0.53616774\",\n \"0.5354591\",\n \"0.53542\",\n \"0.53540355\",\n \"0.5351171\",\n \"0.53452444\",\n \"0.53433955\",\n \"0.5338029\",\n \"0.5332275\",\n \"0.53223366\",\n \"0.531784\",\n \"0.5316459\",\n \"0.530542\",\n \"0.5292146\",\n \"0.52802855\",\n \"0.52782655\",\n \"0.5273152\",\n \"0.526348\",\n \"0.52560693\",\n \"0.5246734\",\n \"0.5238097\",\n \"0.52355117\",\n \"0.52244043\",\n \"0.5214629\",\n \"0.52059966\",\n \"0.5201004\",\n \"0.5195456\",\n \"0.5194366\",\n \"0.5188749\",\n \"0.51865834\",\n \"0.5186532\",\n \"0.5166367\",\n \"0.516625\",\n \"0.5155783\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7412648"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":74278,"cells":{"query":{"kind":"string","value":"Changes the interlink hash in a block hash Each block is represented with a 112 bytes hash."},"document":{"kind":"string","value":"def change_interlink_hash(proof, block_index):\n\n block_of_interest = proof[block_index][0]\n changed_block = swap_byte(block_of_interest, 0)\n changed_proof = (\n proof[0:block_index]\n + [(changed_block, proof[block_index][1])]\n + proof[block_index + 1 :]\n )\n return changed_proof"},"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 hash_block(self):\n sha = hasher.sha256()\n sha.update((str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash)).endswith('utf-8'))\n return sha.hexdigest()","def hash(self, hash):\n\n self._hash = hash","def hash(self, hash):\n\n self._hash = hash","def set_new_hash(court_id, new_hash):\n seals_data[court_id]['hash'] = new_hash","def hash(block):\n # hashes a block\n #we must make sure that the dictionary is ordered, or we will have inconsistent hashes\n block_string = json.dumps(block, sort_keys = True).encode()\n return hashlib.sha256(block_string).hexdigest()\n #pass","def update_hash(self, h):\n # Generate a sequence of fragments that add up to the canonical\n # version of the expression.\n fragments = []\n self.collect_str_fragments(fragments)\n # Update the hash. Wrapping with 'node<...>' prevents the hash\n # from being extended in a way that would clash with something we can\n # generate. (Probably not an important concern but it doesn't hurt.)\n h.update(\"node<\")\n for f in fragments:\n h.update(f)\n h.update(\">\")","def hash_id(self, hash_id):\n\n self._hash_id = hash_id","def hash(self, block):\n block_string = json.dumps(block, sort_keys=True).encode()\n\n return hashlib.sha256(block_string).hexdigest()","def hash(block):\r\n block_string = json.dumps(block, sort_keys=True).encode()\r\n return hashlib.sha256(block_string).hexdigest()","def hash(self, block):\r\n # Convert Dictionary To String\r\n\r\n encoded_block = json.dumps({'nonce': block['nonce'], # Create a string from the required fields\r\n 'transaction': block['transactions'],\r\n 'previous_hash': block['previous_hash']}, sort_keys=True).encode()\r\n\r\n # Hash The String And Return It\r\n return hashlib.sha256(encoded_block).hexdigest() # Return the hash\r","def hash_block_header(header: Header) -> str:\n hashable_block_header = header.SerializeToString()\n return Verification.hash_bytes_256(hashable_block_header)","def hash(block):\n\t\t#Make sure the Dictionnary is ordered to have consistent hashes\n\t\tblock_string = json.dumps(block, sort_keys=True).encode()\n\t\treturn hashlib.sha256(block_string).hexdigest()","def hash(block):\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash(block):\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash(block):\n # The dictionary MUST be ordered, or we can have inconsistent hashes\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash_block(self):\n # TODO : Refactor the algorithm and improve it. This method only does basic things\n block_string = pickle.dumps(self)\n block_hash = hashlib.sha3_256(block_string).digest()\n # The above lines converts the object into __str__() representation and hashes it using sha3_256 algorithm.\n return block_hash","def set_hash(self, hash_name, data):\n self.hashes[hash_name] = data","def hash(last_block):\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\n block_string = json.dumps(last_block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash_block_content(index: int, prev_bhash: str, timestamp: int,\n data: List[Transaction], difficulty: int, nonce: int):\n return hash_sha256([index, prev_bhash, timestamp, data, difficulty, nonce])","def hash(block):\n\n # Dictionary must be ordered, else hashes will be inconsistent\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def compute_hash(block):\n block_string = json.dumps(self.__dict__, sort_keys= True)\n return sha256(block_string.encode()).hexdigest()","def hash(block):\n\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash(block):\n\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash(block):\n\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash(block):\n\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def hash(block):\n\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\n block_string = json.dumps(block, sort_keys=True).encode()\n return hashlib.sha256(block_string).hexdigest()","def compute_hash(self) -> str:\r\n #block_dict = self.__dict__.pop('hash', None) # Remove hash field value before calculating hash\r\n block_dict = self.__dict__.copy()\r\n block_dict.pop('hash', None) # Remove hash field value before calculating hash\r\n block_string = json.dumps(block_dict, sort_keys=True).encode('utf-8')\r\n return sha256(block_string).hexdigest()","def hash(self):\n return self.block_header.hash","def update_recovered_block(\n self, block_hash: Sha256Hash, block_msg: TBlockMessage\n ) -> None:\n pass","def _rehash(self, hashKey, integer):\n return ( hashKey + integer * integer ) % self.size","def hash_key(self, hash_key):\n\n self._hash_key = hash_key","def hash(self) -> bytes:\n block_string = json.dumps(self.serialize(), sort_keys=True).encode()\n return bytes.fromhex(hashlib.sha256(block_string).hexdigest())","def hash_string(self, hash_string):\n\n self._hash_string = hash_string","def dense_hash(hash_, block_size=16):\n results = list()\n for index in range(0, len(hash_), block_size):\n\n block = hash_[index:index + block_size]\n\n total = 0\n for i in block:\n total ^= i\n\n results.append(total)\n\n return results","def set_primary_object_hash(self, hsh):\n self.hash = hsh","def calculate_hash(self, hash_fn=Crypto.calculate_hash):\n\n self.hash = hash_fn(\n self.index, self.previous_hash, self.timestamp, self.payload, self.nonce\n )","def set_hashes(self, url, hashes):","def hash_block_header(self):\r\n # concatenate all the fields into string\r\n string = str(self.timestamp)\r\n string += self.hash_merkle_root\r\n string += str(self.bits)\r\n string += str(self.nonce)\r\n string += self.hash_prev_block_header\r\n hash_value = sha256(sha256(string.encode()).hexdigest().encode()).hexdigest()\r\n return hash_value","def setHash(self):\n chash_string = str(self.code) + str(\"CAMPAIGN\") + str(self.created_at)\n chash = hashlib.sha1()\n chash.update(chash_string)\n \n self.chash = chash.hexdigest()\n self.save()","def compute_hash(self):\n '''\n s = \"\"\n s += str(self.index)\n for i in range(len(self.transactions)):\n s += self.transactions[i]\n s += str(self.timestamp)\n s += self.previous_hash\n s += str(self.nonce)\n\n s_json = json.dumps(s)\n x = sha256()\n x.update(s_json.encode())\n h = x.hexdigest()\n return h\n '''\n\n block_string = json.dumps(self.__dict__, sort_keys=True)\n return sha256(block_string.encode()).hexdigest()","def _hash(self, hashKey):\n return hashKey % self.size","def update_hash(cls, filelike, digest):\r\n block_size = digest.block_size * 1024\r\n for chunk in iter(lambda: filelike.read(block_size), b''):\r\n digest.update(chunk)","def test_hash_sha256(self):\n block = self.blockchain.new_block(self.proof, self.previous_hash)\n hash_ = self.blockchain.hash(block)\n\n self.assertIsInstance(hash_, str)\n self.assertEqual(hashlib.sha256(json.dumps(block, sort_keys=True).encode()).hexdigest(), hash_)","def _hash(self, item):\r\n pass # TODO\r","def set_hash_digest(self, file_path, row):\n hasher = hashlib.new(hash_algorithm)\n with open(file_path, \"rb\") as f:\n hasher.update(f.read())\n row[_column_name] = hasher.hexdigest()","def current_hash(self):","def store(self, hash, original_url):\n self.r.set(hash, original_url)","def get_block_hash(index):\n # TODO: Require implementation\n pass","def _hash(self, key):\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\n # return hash(key)\n return self._hash_djb2(key)","def compute_hash(self):\n block_string = json.dumps(self.__dict__, sort_keys=True)\n return sha256(block_string.encode()).hexdigest()","def compute_hash(self):\n block_string = json.dumps(self.__dict__, sort_keys=True)\n return sha256(block_string.encode()).hexdigest()","def regist_hash(cobj, hash, handler, dir):\n pass","def get_block_hash(header_bin):\n _hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest()\n return reverse_hash(_hash.hex())","def extended_hash(self, extended_hash):\n\n self._extended_hash = extended_hash","def build_block_hash(index, timestamp, data, previous_hash):\n str_to_hash = str(index) + str(timestamp) + str(data) + str(previous_hash)\n block_hash = sha256(\n bytes(str_to_hash, encoding='utf-8')\n ).hexdigest()\n return block_hash","def compute_payload_block_hash(this):\n\n return hmac.new(\n hashlib.sha512(\n struct.pack('<Q', this._index) +\n hashlib.sha512(\n this._.header.value.dynamic_header.master_seed.data +\n this._.transformed_key + b'\\x01'\n ).digest()\n ).digest(),\n struct.pack('<Q', this._index) +\n struct.pack('<I', len(this.block_data)) +\n this.block_data, hashlib.sha256\n ).digest()","def progression_hash(self, progression_hash):\n\n self._progression_hash = progression_hash","def update_hashes(self, ret=False) -> None:\n self.hash = self.calculate_hash()\n self.stub_hash = self.calculate_hash(include_md=False)","def rehash(self, new_len):\n print(\"!!!!!!!!!Rehash\")\n oldtable = self.table\n self.table = [set() for x in range(new_len)]\n for numberset in oldtable:\n for number in numberset:\n self.insert(number)\n\n print(\"Rehash-table-print\")\n print(self.table)","def calculate_hash(self, base_block_hash: bytes) -> bytes:\n from hathor.merged_mining.bitcoin import build_merkle_root_from_path, sha256d_hash\n coinbase_tx_hash = sha256d_hash(self.coinbase_head + base_block_hash + self.coinbase_tail)\n merkle_root = bytes(reversed(build_merkle_root_from_path([coinbase_tx_hash] + self.merkle_path)))\n return sha256d_hash(self.header_head + merkle_root + self.header_tail)","def hash_method(self, hash_method):\n\n self._hash_method = hash_method","def get_hash(self):\r\n block_data = self.prev_hash\r\n block_data += bytearray(struct.pack(\"f\", self.time))\r\n block_data += self.user_id.encode()\r\n block_data += self.public_key.public_bytes(serialization.Encoding.X962,\r\n serialization.PublicFormat.CompressedPoint)\r\n\r\n digest = hashes.Hash(hashes.SHA256())\r\n digest.update(block_data)\r\n return digest.finalize()","def get_blockHash(self, data):\n blockHash = data['blockHash']\n return blockHash","def hash_save(db: Redis[bytes], hash: hash_t) -> None:\n db.zadd(HASH_INDEX, {str(hash): \"0\"})","def set_hash_prime(self):\n n = int(self.max_int+50)\n prime = getPrimes(n)\n self.hash_prime = prime","def new_block(self, previous_hash):\n\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'information': self.current_information,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n\n # Reset the current list of transactions\n self.current_information = []\n\n self.chain.append(block)\n return block","def init_hash_state(self) -> None:\n self.hash_states = [hashlib.sha1()]","def double_hashing(hash, hash2, A, x):\n i = 0\n s = len(A)\n while A[getRemainder((hash(x) + i*hash2(x)), s)] is not None:\n i = i + 1\n index = getRemainder((hash(x) + i*hash2(x)), s)\n print(f'Double Hashing index is: {index}')\n A[index] = x\n print(f'insertion of {x}: {A}')","def hash(self, key):\n key = str(key)\n h = 0\n a = self.hash_base\n for i in range(len(str(key))):\n h = (h * a + ord(key[i])) % self.table_capacity\n return h","def changed_block(self, old_block, new_block):","def _update_block_in_structure(self, structure, block_key, content):\n structure['blocks'][block_key] = content","def hashFile(filename):\n\tblocks = []\n\twith open(filename, 'rb') as f:\n\t\tblock = f.read(1024)\n\t\twhile block:\n\t\t\tblocks.append(block)\n\t\t\tblock = f.read(1024)\n\t\n\tprevHash = b''\n\tfor block in reversed(blocks):\n\t\thash = sha256(block + prevHash)\n\t\tprevHash = hash\n\treturn prevHash","def semhash(file):\n _hash_helper(file)","def semhash(file):\n _hash_helper(file)","def internal_hash(self): \n return hash(tuple(sorted(self.hashtriples())))","def hxlhash():\n run_script(hxlhash_main)","def getblockhash(self, blockheight):\n for block in self.blocks:\n if block[\"height\"] == int(blockheight):\n return block[\"hash\"]","def _update_block_in_structure(self, structure, block_id, content):\r\n structure['blocks'][LocMapperStore.encode_key_for_mongo(block_id)] = content","def hash(self, key):\n return self._hash_function(key) % self.size # Modular hashing","def hash(self) -> bytes:","def hash(self) -> str:\r\n ...","def commit_hash(self, commit_hash):\n\n self._commit_hash = commit_hash","def _basehash(self):\n if self.baseseed is not None:\n hashinput = (str(self.baseseed) + ',').encode()\n self.basehash = hashlib.sha256(hashinput)\n else:\n self.basehash = None","def get_hash(self):\r\n block_data = self.prev_hash\r\n block_data += bytearray(struct.pack(\"!f\", self.time))\r\n block_data += self.user_id.encode()\r\n block_data += self.signature.encode()\r\n block_data += self.choice.encode()\r\n\r\n digest = hashes.Hash(hashes.SHA256())\r\n digest.update(block_data)\r\n return digest.finalize()","def _hash(self, string, hash_type):\n hash_types = {\n 'TABLE_OFFSET': 0,\n 'HASH_A': 1,\n 'HASH_B': 2,\n 'TABLE': 3\n }\n seed1 = 0x7FED7FED\n seed2 = 0xEEEEEEEE\n\n for ch in string.upper():\n if not isinstance(ch, int): ch = ord(ch)\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\n\n return seed1","def src_hash(self, src_hash):\n\n self._src_hash = src_hash","def _calc_hash(self) -> None:\n self.image = Image.open(self.path)\n self.image = self.image.convert(\"L\")\n self.image = self.image.resize((self.width, self.height), Image.ANTIALIAS)\n lpixels = list(self.image.getdata())\n self.hash = \"0b\"\n for i, pixel in enumerate(lpixels):\n if (i + 1) % self.width == 0 and i != 0:\n continue\n if pixel < lpixels[i + 1]:\n self.hash += \"1\"\n continue\n self.hash += \"0\"\n self.hash_hex = DHash.bin2hex(self.hash)","def hash(x) -> int:\n pass","def calc_statistics_hash(self) -> bytes:\n return b\"somehash\"","def symlink_hash(path):\n hasher = sha1()\n data = path_to_bytes(os.readlink(path))\n hasher.update(('blob %u\\0' % len(data)).encode('ascii'))\n hasher.update(data)\n return hasher","def flow_graph_hash(graph):\n assert isinstance(graph, BasicGraph)\n sources = graph.nodes(in_degree=0)\n\n original_hash = 'original hash'\n new_hash = 'new_hash'\n cls = type(graph)\n hash_graph = cls() # new graph with hashes.\n visited = set()\n\n while sources:\n source = sources[0]\n sources = sources[1:]\n\n suppliers = graph.nodes(to_node=source)\n\n hash_func = hashlib.sha3_256()\n hash_func.update(bytes(str(source), 'utf-8'))\n for supplier in suppliers:\n if graph.depth_first_search(start=source, end=supplier):\n continue # it's a cycle.\n d = hash_graph.node(supplier)\n hash_func.update(bytes(d[new_hash], 'utf-8'))\n source_hash = hash_func.hexdigest()\n\n if source not in hash_graph:\n obj = {original_hash: source, new_hash: source_hash}\n hash_graph.add_node(source, obj=obj)\n else:\n n = hash_graph.node(source)\n n[new_hash] = source_hash\n\n receivers = graph.nodes(from_node=source)\n for receiver in receivers:\n if receiver in visited:\n continue\n visited.add(receiver)\n\n if receiver not in hash_graph:\n obj = {original_hash: receiver, new_hash: None}\n hash_graph.add_node(node_id=receiver, obj=obj)\n hash_graph.add_edge(source, receiver)\n if receiver not in sources:\n sources.append(receiver)\n\n for sink in graph.nodes(out_degree=0):\n n = hash_graph.node(sink)\n assert n[new_hash] is not None, n\n\n return hash_graph","def hash(self) -> str:\n return pulumi.get(self, \"hash\")","def get_num_slots(self):\n Return the load factor for this hash table.\n\n Implement this.\n \"\"\"\n return self.elements / self.capacity\n\n\n def fnv1(self, key):\n \"\"\"\n FNV-1 Hash, 64-bit\n\n Implement this, and/or DJB2.pyy\n \"\"\"\n\n # Your code here\n\n\n def djb2(self, key):\n \"\"\"\n DJB2 hash, 32-bit\n\n Implement this, and/or FNV-1.\n \"\"\"\n # Your code here\n\n\n def hash_index(self, key):\n \"\"\"\n Take an arbitrary key and return a valid integer index\n between within the storage capacity of the hash table.\n \"\"\"\n #return self.fnv1(key) % self.capacity\n<<<<<<< Updated upstream\n return self.djb2(key) % self.capacity\n=======\n return self.djb2(key) % len(self.storage)\n>>>>>>> Stashed changes\n\n def put(self, key, value):\n \"\"\"\n Store the value with the given key.\n\n Hash collisions should be handled with Linked List Chaining.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # need to account for if the key value is the same \n\n i = self.hash_index(key)\n if not self.storage[i]:\n hte = HashTableEntry(key, value)\n self.storage[i] = hte\n self.elements += 1\n hte.head = HashTableEntry(key, value)\n elif self.storage[i] and self.storage[i].key != key:\n self.storage[i].insert_at_head(HashTableEntry(key, value))\n>>>>>>> Stashed changes\n\n\n def delete(self, key):\n \"\"\"\n Remove the value stored with the given key.\n\n Print a warning if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n i = self.hash_index(key)\n node = self.storage[i]\n prev = None\n if node.key == key:\n self.storage[i] = node.next\n return\n while node != None:\n if node.key == key:\n prev.next = node.next\n self.storage[i].next = None\n return\n prev = node\n node = node.next\n self.elements -= 1\n return\n>>>>>>> Stashed changes\n\n\n def get(self, key):\n \"\"\"\n Retrieve the value stored with the given key.\n\n Returns None if the key is not found.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n # - find the index in the hash table for the key\n i = self.hash_index(key)\n # - search the list for that key\n if not self.storage[i]:\n return None\n else:\n if self.storage[i].find_key(key) == key:\n return self.storage[i].value\n>>>>>>> Stashed changes\n\n\n def resize(self, new_capacity):\n \"\"\"\n Changes the capacity of the hash table and\n rehashes all key/value pairs.\n\n Implement this.\n \"\"\"\n<<<<<<< Updated upstream\n # Your code here\n=======\n prev_storage = self.storage\n self.capacity = new_cap\n self.storage = [None] * new_cap\n for i in range(len(prev_storage)):\n prev = prev_storage[i]\n if prev:\n while prev:\n if prev.key:\n self.put(prev.key, prev.value)\n prev = prev.next\n\n>>>>>>> Stashed changes\n\n\n\nif __name__ == \"__main__\":\n ht = HashTable(8)\n\n ht.put(\"line_1\", \"'Twas brillig, and the slithy toves\")\n ht.put(\"line_2\", \"Did gyre and gimble in the wabe:\")\n ht.put(\"line_3\", \"All mimsy were the borogoves,\")\n ht.put(\"line_4\", \"And the mome raths outgrabe.\")\n ht.put(\"line_5\", '\"Beware the Jabberwock, my son!')\n ht.put(\"line_6\", \"The jaws that bite, the claws that catch!\")\n ht.put(\"line_7\", \"Beware the Jubjub bird, and shun\")\n ht.put(\"line_8\", 'The frumious Bandersnatch!\"')\n ht.put(\"line_9\", \"He took his vorpal sword in hand;\")\n ht.put(\"line_10\", \"Long time the manxome foe he sought--\")\n ht.put(\"line_11\", \"So rested he by the Tumtum tree\")\n ht.put(\"line_12\", \"And stood awhile in thought.\")\n\n print(\"\")\n\n # Test storing beyond capacity\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n # Test resizing\n old_capacity = ht.get_num_slots()\n ht.resize(ht.capacity * 2)\n new_capacity = ht.get_num_slots()\n\n print(f\"\\nResized from {old_capacity} to {new_capacity}.\\n\")\n\n # Test if data intact after resizing\n for i in range(1, 13):\n print(ht.get(f\"line_{i}\"))\n\n print(\"\")","def generichash_blake2b_update(state: Blake2State, data: bytes) -> None:\n\n ensure(\n isinstance(state, Blake2State),\n \"State must be a Blake2State object\",\n raising=exc.TypeError,\n )\n\n ensure(\n isinstance(data, bytes),\n \"Input data must be a bytes sequence\",\n raising=exc.TypeError,\n )\n\n rc = lib.crypto_generichash_blake2b_update(\n state._statebuf, data, len(data)\n )\n ensure(rc == 0, \"Unexpected failure\", raising=exc.RuntimeError)","def block_num_from_id(block_hash: str) -> int:\n return int(str(block_hash)[:8], base=16)","def HashAlgorithm(self) -> _n_7_t_0:","def rehash(self):\n primes = [3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761,\n 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,\n 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,\n 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,\n 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369]\n\n temp_list = []\n for i in self.array:\n if i is not None:\n temp_list.append(i)\n\n self.table_capacity = 2 * self.table_capacity\n\n\n try:\n for i in range(len(primes)):\n if primes[i] > self.table_capacity:\n self.table_capacity = primes[i]\n break\n elif i == (len(primes) -1) :\n if not primes[i] > self.table_capacity:\n raise ValueError(\"There is no prime in the list such that prime > \" + self.table_capacity)\n except Exception as error:\n print(error)\n\n self.array = [None] * self.table_capacity\n self.count = 0\n for element in temp_list:\n self.insert(element[0], element[1])\n\n self.rehash_count += 1","def hashing(file,pp):\n\n def myhash(instring):\n # sdbm hash\n res = 0\n for t in instring:\n res = (ord(t) + (res<<6) + (res<<16) - res) % 2**32\n return res\n\n return hex(myhash(file.replace('\\\\','/')+\":\"+pp))","def replace_block(proof, headers_map, interlink_map, block_index):\n\n prevous_block = proof[block_index - 1][0]\n block_hash = prevous_block[36:68]\n block = headers_map[block_hash]\n interlink = list_flatten(interlink_map[block.GetHash()])\n\n block_2 = mine_block(\n block.hashPrevBlock, block.nBits - 1, interlink, hashMerkleRoot=b\"\\x00\" * 32\n )\n return (\n proof[0:block_index]\n + [[block_2.serialize(), proof[block_index][1]]]\n + proof[block_index + 1 :]\n )","def getblockhash(self, index):\n return self.proxy.getblockhash(index)"],"string":"[\n \"def hash_block(self):\\n sha = hasher.sha256()\\n sha.update((str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash)).endswith('utf-8'))\\n return sha.hexdigest()\",\n \"def hash(self, hash):\\n\\n self._hash = hash\",\n \"def hash(self, hash):\\n\\n self._hash = hash\",\n \"def set_new_hash(court_id, new_hash):\\n seals_data[court_id]['hash'] = new_hash\",\n \"def hash(block):\\n # hashes a block\\n #we must make sure that the dictionary is ordered, or we will have inconsistent hashes\\n block_string = json.dumps(block, sort_keys = True).encode()\\n return hashlib.sha256(block_string).hexdigest()\\n #pass\",\n \"def update_hash(self, h):\\n # Generate a sequence of fragments that add up to the canonical\\n # version of the expression.\\n fragments = []\\n self.collect_str_fragments(fragments)\\n # Update the hash. Wrapping with 'node<...>' prevents the hash\\n # from being extended in a way that would clash with something we can\\n # generate. (Probably not an important concern but it doesn't hurt.)\\n h.update(\\\"node<\\\")\\n for f in fragments:\\n h.update(f)\\n h.update(\\\">\\\")\",\n \"def hash_id(self, hash_id):\\n\\n self._hash_id = hash_id\",\n \"def hash(self, block):\\n block_string = json.dumps(block, sort_keys=True).encode()\\n\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\r\\n block_string = json.dumps(block, sort_keys=True).encode()\\r\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(self, block):\\r\\n # Convert Dictionary To String\\r\\n\\r\\n encoded_block = json.dumps({'nonce': block['nonce'], # Create a string from the required fields\\r\\n 'transaction': block['transactions'],\\r\\n 'previous_hash': block['previous_hash']}, sort_keys=True).encode()\\r\\n\\r\\n # Hash The String And Return It\\r\\n return hashlib.sha256(encoded_block).hexdigest() # Return the hash\\r\",\n \"def hash_block_header(header: Header) -> str:\\n hashable_block_header = header.SerializeToString()\\n return Verification.hash_bytes_256(hashable_block_header)\",\n \"def hash(block):\\n\\t\\t#Make sure the Dictionnary is ordered to have consistent hashes\\n\\t\\tblock_string = json.dumps(block, sort_keys=True).encode()\\n\\t\\treturn hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\n # The dictionary MUST be ordered, or we can have inconsistent hashes\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash_block(self):\\n # TODO : Refactor the algorithm and improve it. This method only does basic things\\n block_string = pickle.dumps(self)\\n block_hash = hashlib.sha3_256(block_string).digest()\\n # The above lines converts the object into __str__() representation and hashes it using sha3_256 algorithm.\\n return block_hash\",\n \"def set_hash(self, hash_name, data):\\n self.hashes[hash_name] = data\",\n \"def hash(last_block):\\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\\n block_string = json.dumps(last_block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash_block_content(index: int, prev_bhash: str, timestamp: int,\\n data: List[Transaction], difficulty: int, nonce: int):\\n return hash_sha256([index, prev_bhash, timestamp, data, difficulty, nonce])\",\n \"def hash(block):\\n\\n # Dictionary must be ordered, else hashes will be inconsistent\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def compute_hash(block):\\n block_string = json.dumps(self.__dict__, sort_keys= True)\\n return sha256(block_string.encode()).hexdigest()\",\n \"def hash(block):\\n\\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\n\\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\n\\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\n\\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def hash(block):\\n\\n # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes\\n block_string = json.dumps(block, sort_keys=True).encode()\\n return hashlib.sha256(block_string).hexdigest()\",\n \"def compute_hash(self) -> str:\\r\\n #block_dict = self.__dict__.pop('hash', None) # Remove hash field value before calculating hash\\r\\n block_dict = self.__dict__.copy()\\r\\n block_dict.pop('hash', None) # Remove hash field value before calculating hash\\r\\n block_string = json.dumps(block_dict, sort_keys=True).encode('utf-8')\\r\\n return sha256(block_string).hexdigest()\",\n \"def hash(self):\\n return self.block_header.hash\",\n \"def update_recovered_block(\\n self, block_hash: Sha256Hash, block_msg: TBlockMessage\\n ) -> None:\\n pass\",\n \"def _rehash(self, hashKey, integer):\\n return ( hashKey + integer * integer ) % self.size\",\n \"def hash_key(self, hash_key):\\n\\n self._hash_key = hash_key\",\n \"def hash(self) -> bytes:\\n block_string = json.dumps(self.serialize(), sort_keys=True).encode()\\n return bytes.fromhex(hashlib.sha256(block_string).hexdigest())\",\n \"def hash_string(self, hash_string):\\n\\n self._hash_string = hash_string\",\n \"def dense_hash(hash_, block_size=16):\\n results = list()\\n for index in range(0, len(hash_), block_size):\\n\\n block = hash_[index:index + block_size]\\n\\n total = 0\\n for i in block:\\n total ^= i\\n\\n results.append(total)\\n\\n return results\",\n \"def set_primary_object_hash(self, hsh):\\n self.hash = hsh\",\n \"def calculate_hash(self, hash_fn=Crypto.calculate_hash):\\n\\n self.hash = hash_fn(\\n self.index, self.previous_hash, self.timestamp, self.payload, self.nonce\\n )\",\n \"def set_hashes(self, url, hashes):\",\n \"def hash_block_header(self):\\r\\n # concatenate all the fields into string\\r\\n string = str(self.timestamp)\\r\\n string += self.hash_merkle_root\\r\\n string += str(self.bits)\\r\\n string += str(self.nonce)\\r\\n string += self.hash_prev_block_header\\r\\n hash_value = sha256(sha256(string.encode()).hexdigest().encode()).hexdigest()\\r\\n return hash_value\",\n \"def setHash(self):\\n chash_string = str(self.code) + str(\\\"CAMPAIGN\\\") + str(self.created_at)\\n chash = hashlib.sha1()\\n chash.update(chash_string)\\n \\n self.chash = chash.hexdigest()\\n self.save()\",\n \"def compute_hash(self):\\n '''\\n s = \\\"\\\"\\n s += str(self.index)\\n for i in range(len(self.transactions)):\\n s += self.transactions[i]\\n s += str(self.timestamp)\\n s += self.previous_hash\\n s += str(self.nonce)\\n\\n s_json = json.dumps(s)\\n x = sha256()\\n x.update(s_json.encode())\\n h = x.hexdigest()\\n return h\\n '''\\n\\n block_string = json.dumps(self.__dict__, sort_keys=True)\\n return sha256(block_string.encode()).hexdigest()\",\n \"def _hash(self, hashKey):\\n return hashKey % self.size\",\n \"def update_hash(cls, filelike, digest):\\r\\n block_size = digest.block_size * 1024\\r\\n for chunk in iter(lambda: filelike.read(block_size), b''):\\r\\n digest.update(chunk)\",\n \"def test_hash_sha256(self):\\n block = self.blockchain.new_block(self.proof, self.previous_hash)\\n hash_ = self.blockchain.hash(block)\\n\\n self.assertIsInstance(hash_, str)\\n self.assertEqual(hashlib.sha256(json.dumps(block, sort_keys=True).encode()).hexdigest(), hash_)\",\n \"def _hash(self, item):\\r\\n pass # TODO\\r\",\n \"def set_hash_digest(self, file_path, row):\\n hasher = hashlib.new(hash_algorithm)\\n with open(file_path, \\\"rb\\\") as f:\\n hasher.update(f.read())\\n row[_column_name] = hasher.hexdigest()\",\n \"def current_hash(self):\",\n \"def store(self, hash, original_url):\\n self.r.set(hash, original_url)\",\n \"def get_block_hash(index):\\n # TODO: Require implementation\\n pass\",\n \"def _hash(self, key):\\n # OPTIONAL STRETCH: You may replace the Python hash with DJB2 as a stretch goal\\n # return hash(key)\\n return self._hash_djb2(key)\",\n \"def compute_hash(self):\\n block_string = json.dumps(self.__dict__, sort_keys=True)\\n return sha256(block_string.encode()).hexdigest()\",\n \"def compute_hash(self):\\n block_string = json.dumps(self.__dict__, sort_keys=True)\\n return sha256(block_string.encode()).hexdigest()\",\n \"def regist_hash(cobj, hash, handler, dir):\\n pass\",\n \"def get_block_hash(header_bin):\\n _hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest()\\n return reverse_hash(_hash.hex())\",\n \"def extended_hash(self, extended_hash):\\n\\n self._extended_hash = extended_hash\",\n \"def build_block_hash(index, timestamp, data, previous_hash):\\n str_to_hash = str(index) + str(timestamp) + str(data) + str(previous_hash)\\n block_hash = sha256(\\n bytes(str_to_hash, encoding='utf-8')\\n ).hexdigest()\\n return block_hash\",\n \"def compute_payload_block_hash(this):\\n\\n return hmac.new(\\n hashlib.sha512(\\n struct.pack('<Q', this._index) +\\n hashlib.sha512(\\n this._.header.value.dynamic_header.master_seed.data +\\n this._.transformed_key + b'\\\\x01'\\n ).digest()\\n ).digest(),\\n struct.pack('<Q', this._index) +\\n struct.pack('<I', len(this.block_data)) +\\n this.block_data, hashlib.sha256\\n ).digest()\",\n \"def progression_hash(self, progression_hash):\\n\\n self._progression_hash = progression_hash\",\n \"def update_hashes(self, ret=False) -> None:\\n self.hash = self.calculate_hash()\\n self.stub_hash = self.calculate_hash(include_md=False)\",\n \"def rehash(self, new_len):\\n print(\\\"!!!!!!!!!Rehash\\\")\\n oldtable = self.table\\n self.table = [set() for x in range(new_len)]\\n for numberset in oldtable:\\n for number in numberset:\\n self.insert(number)\\n\\n print(\\\"Rehash-table-print\\\")\\n print(self.table)\",\n \"def calculate_hash(self, base_block_hash: bytes) -> bytes:\\n from hathor.merged_mining.bitcoin import build_merkle_root_from_path, sha256d_hash\\n coinbase_tx_hash = sha256d_hash(self.coinbase_head + base_block_hash + self.coinbase_tail)\\n merkle_root = bytes(reversed(build_merkle_root_from_path([coinbase_tx_hash] + self.merkle_path)))\\n return sha256d_hash(self.header_head + merkle_root + self.header_tail)\",\n \"def hash_method(self, hash_method):\\n\\n self._hash_method = hash_method\",\n \"def get_hash(self):\\r\\n block_data = self.prev_hash\\r\\n block_data += bytearray(struct.pack(\\\"f\\\", self.time))\\r\\n block_data += self.user_id.encode()\\r\\n block_data += self.public_key.public_bytes(serialization.Encoding.X962,\\r\\n serialization.PublicFormat.CompressedPoint)\\r\\n\\r\\n digest = hashes.Hash(hashes.SHA256())\\r\\n digest.update(block_data)\\r\\n return digest.finalize()\",\n \"def get_blockHash(self, data):\\n blockHash = data['blockHash']\\n return blockHash\",\n \"def hash_save(db: Redis[bytes], hash: hash_t) -> None:\\n db.zadd(HASH_INDEX, {str(hash): \\\"0\\\"})\",\n \"def set_hash_prime(self):\\n n = int(self.max_int+50)\\n prime = getPrimes(n)\\n self.hash_prime = prime\",\n \"def new_block(self, previous_hash):\\n\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'information': self.current_information,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n\\n # Reset the current list of transactions\\n self.current_information = []\\n\\n self.chain.append(block)\\n return block\",\n \"def init_hash_state(self) -> None:\\n self.hash_states = [hashlib.sha1()]\",\n \"def double_hashing(hash, hash2, A, x):\\n i = 0\\n s = len(A)\\n while A[getRemainder((hash(x) + i*hash2(x)), s)] is not None:\\n i = i + 1\\n index = getRemainder((hash(x) + i*hash2(x)), s)\\n print(f'Double Hashing index is: {index}')\\n A[index] = x\\n print(f'insertion of {x}: {A}')\",\n \"def hash(self, key):\\n key = str(key)\\n h = 0\\n a = self.hash_base\\n for i in range(len(str(key))):\\n h = (h * a + ord(key[i])) % self.table_capacity\\n return h\",\n \"def changed_block(self, old_block, new_block):\",\n \"def _update_block_in_structure(self, structure, block_key, content):\\n structure['blocks'][block_key] = content\",\n \"def hashFile(filename):\\n\\tblocks = []\\n\\twith open(filename, 'rb') as f:\\n\\t\\tblock = f.read(1024)\\n\\t\\twhile block:\\n\\t\\t\\tblocks.append(block)\\n\\t\\t\\tblock = f.read(1024)\\n\\t\\n\\tprevHash = b''\\n\\tfor block in reversed(blocks):\\n\\t\\thash = sha256(block + prevHash)\\n\\t\\tprevHash = hash\\n\\treturn prevHash\",\n \"def semhash(file):\\n _hash_helper(file)\",\n \"def semhash(file):\\n _hash_helper(file)\",\n \"def internal_hash(self): \\n return hash(tuple(sorted(self.hashtriples())))\",\n \"def hxlhash():\\n run_script(hxlhash_main)\",\n \"def getblockhash(self, blockheight):\\n for block in self.blocks:\\n if block[\\\"height\\\"] == int(blockheight):\\n return block[\\\"hash\\\"]\",\n \"def _update_block_in_structure(self, structure, block_id, content):\\r\\n structure['blocks'][LocMapperStore.encode_key_for_mongo(block_id)] = content\",\n \"def hash(self, key):\\n return self._hash_function(key) % self.size # Modular hashing\",\n \"def hash(self) -> bytes:\",\n \"def hash(self) -> str:\\r\\n ...\",\n \"def commit_hash(self, commit_hash):\\n\\n self._commit_hash = commit_hash\",\n \"def _basehash(self):\\n if self.baseseed is not None:\\n hashinput = (str(self.baseseed) + ',').encode()\\n self.basehash = hashlib.sha256(hashinput)\\n else:\\n self.basehash = None\",\n \"def get_hash(self):\\r\\n block_data = self.prev_hash\\r\\n block_data += bytearray(struct.pack(\\\"!f\\\", self.time))\\r\\n block_data += self.user_id.encode()\\r\\n block_data += self.signature.encode()\\r\\n block_data += self.choice.encode()\\r\\n\\r\\n digest = hashes.Hash(hashes.SHA256())\\r\\n digest.update(block_data)\\r\\n return digest.finalize()\",\n \"def _hash(self, string, hash_type):\\n hash_types = {\\n 'TABLE_OFFSET': 0,\\n 'HASH_A': 1,\\n 'HASH_B': 2,\\n 'TABLE': 3\\n }\\n seed1 = 0x7FED7FED\\n seed2 = 0xEEEEEEEE\\n\\n for ch in string.upper():\\n if not isinstance(ch, int): ch = ord(ch)\\n value = self.encryption_table[(hash_types[hash_type] << 8) + ch]\\n seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF\\n seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF\\n\\n return seed1\",\n \"def src_hash(self, src_hash):\\n\\n self._src_hash = src_hash\",\n \"def _calc_hash(self) -> None:\\n self.image = Image.open(self.path)\\n self.image = self.image.convert(\\\"L\\\")\\n self.image = self.image.resize((self.width, self.height), Image.ANTIALIAS)\\n lpixels = list(self.image.getdata())\\n self.hash = \\\"0b\\\"\\n for i, pixel in enumerate(lpixels):\\n if (i + 1) % self.width == 0 and i != 0:\\n continue\\n if pixel < lpixels[i + 1]:\\n self.hash += \\\"1\\\"\\n continue\\n self.hash += \\\"0\\\"\\n self.hash_hex = DHash.bin2hex(self.hash)\",\n \"def hash(x) -> int:\\n pass\",\n \"def calc_statistics_hash(self) -> bytes:\\n return b\\\"somehash\\\"\",\n \"def symlink_hash(path):\\n hasher = sha1()\\n data = path_to_bytes(os.readlink(path))\\n hasher.update(('blob %u\\\\0' % len(data)).encode('ascii'))\\n hasher.update(data)\\n return hasher\",\n \"def flow_graph_hash(graph):\\n assert isinstance(graph, BasicGraph)\\n sources = graph.nodes(in_degree=0)\\n\\n original_hash = 'original hash'\\n new_hash = 'new_hash'\\n cls = type(graph)\\n hash_graph = cls() # new graph with hashes.\\n visited = set()\\n\\n while sources:\\n source = sources[0]\\n sources = sources[1:]\\n\\n suppliers = graph.nodes(to_node=source)\\n\\n hash_func = hashlib.sha3_256()\\n hash_func.update(bytes(str(source), 'utf-8'))\\n for supplier in suppliers:\\n if graph.depth_first_search(start=source, end=supplier):\\n continue # it's a cycle.\\n d = hash_graph.node(supplier)\\n hash_func.update(bytes(d[new_hash], 'utf-8'))\\n source_hash = hash_func.hexdigest()\\n\\n if source not in hash_graph:\\n obj = {original_hash: source, new_hash: source_hash}\\n hash_graph.add_node(source, obj=obj)\\n else:\\n n = hash_graph.node(source)\\n n[new_hash] = source_hash\\n\\n receivers = graph.nodes(from_node=source)\\n for receiver in receivers:\\n if receiver in visited:\\n continue\\n visited.add(receiver)\\n\\n if receiver not in hash_graph:\\n obj = {original_hash: receiver, new_hash: None}\\n hash_graph.add_node(node_id=receiver, obj=obj)\\n hash_graph.add_edge(source, receiver)\\n if receiver not in sources:\\n sources.append(receiver)\\n\\n for sink in graph.nodes(out_degree=0):\\n n = hash_graph.node(sink)\\n assert n[new_hash] is not None, n\\n\\n return hash_graph\",\n \"def hash(self) -> str:\\n return pulumi.get(self, \\\"hash\\\")\",\n \"def get_num_slots(self):\\n Return the load factor for this hash table.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n return self.elements / self.capacity\\n\\n\\n def fnv1(self, key):\\n \\\"\\\"\\\"\\n FNV-1 Hash, 64-bit\\n\\n Implement this, and/or DJB2.pyy\\n \\\"\\\"\\\"\\n\\n # Your code here\\n\\n\\n def djb2(self, key):\\n \\\"\\\"\\\"\\n DJB2 hash, 32-bit\\n\\n Implement this, and/or FNV-1.\\n \\\"\\\"\\\"\\n # Your code here\\n\\n\\n def hash_index(self, key):\\n \\\"\\\"\\\"\\n Take an arbitrary key and return a valid integer index\\n between within the storage capacity of the hash table.\\n \\\"\\\"\\\"\\n #return self.fnv1(key) % self.capacity\\n<<<<<<< Updated upstream\\n return self.djb2(key) % self.capacity\\n=======\\n return self.djb2(key) % len(self.storage)\\n>>>>>>> Stashed changes\\n\\n def put(self, key, value):\\n \\\"\\\"\\\"\\n Store the value with the given key.\\n\\n Hash collisions should be handled with Linked List Chaining.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # need to account for if the key value is the same \\n\\n i = self.hash_index(key)\\n if not self.storage[i]:\\n hte = HashTableEntry(key, value)\\n self.storage[i] = hte\\n self.elements += 1\\n hte.head = HashTableEntry(key, value)\\n elif self.storage[i] and self.storage[i].key != key:\\n self.storage[i].insert_at_head(HashTableEntry(key, value))\\n>>>>>>> Stashed changes\\n\\n\\n def delete(self, key):\\n \\\"\\\"\\\"\\n Remove the value stored with the given key.\\n\\n Print a warning if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n i = self.hash_index(key)\\n node = self.storage[i]\\n prev = None\\n if node.key == key:\\n self.storage[i] = node.next\\n return\\n while node != None:\\n if node.key == key:\\n prev.next = node.next\\n self.storage[i].next = None\\n return\\n prev = node\\n node = node.next\\n self.elements -= 1\\n return\\n>>>>>>> Stashed changes\\n\\n\\n def get(self, key):\\n \\\"\\\"\\\"\\n Retrieve the value stored with the given key.\\n\\n Returns None if the key is not found.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n # - find the index in the hash table for the key\\n i = self.hash_index(key)\\n # - search the list for that key\\n if not self.storage[i]:\\n return None\\n else:\\n if self.storage[i].find_key(key) == key:\\n return self.storage[i].value\\n>>>>>>> Stashed changes\\n\\n\\n def resize(self, new_capacity):\\n \\\"\\\"\\\"\\n Changes the capacity of the hash table and\\n rehashes all key/value pairs.\\n\\n Implement this.\\n \\\"\\\"\\\"\\n<<<<<<< Updated upstream\\n # Your code here\\n=======\\n prev_storage = self.storage\\n self.capacity = new_cap\\n self.storage = [None] * new_cap\\n for i in range(len(prev_storage)):\\n prev = prev_storage[i]\\n if prev:\\n while prev:\\n if prev.key:\\n self.put(prev.key, prev.value)\\n prev = prev.next\\n\\n>>>>>>> Stashed changes\\n\\n\\n\\nif __name__ == \\\"__main__\\\":\\n ht = HashTable(8)\\n\\n ht.put(\\\"line_1\\\", \\\"'Twas brillig, and the slithy toves\\\")\\n ht.put(\\\"line_2\\\", \\\"Did gyre and gimble in the wabe:\\\")\\n ht.put(\\\"line_3\\\", \\\"All mimsy were the borogoves,\\\")\\n ht.put(\\\"line_4\\\", \\\"And the mome raths outgrabe.\\\")\\n ht.put(\\\"line_5\\\", '\\\"Beware the Jabberwock, my son!')\\n ht.put(\\\"line_6\\\", \\\"The jaws that bite, the claws that catch!\\\")\\n ht.put(\\\"line_7\\\", \\\"Beware the Jubjub bird, and shun\\\")\\n ht.put(\\\"line_8\\\", 'The frumious Bandersnatch!\\\"')\\n ht.put(\\\"line_9\\\", \\\"He took his vorpal sword in hand;\\\")\\n ht.put(\\\"line_10\\\", \\\"Long time the manxome foe he sought--\\\")\\n ht.put(\\\"line_11\\\", \\\"So rested he by the Tumtum tree\\\")\\n ht.put(\\\"line_12\\\", \\\"And stood awhile in thought.\\\")\\n\\n print(\\\"\\\")\\n\\n # Test storing beyond capacity\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n # Test resizing\\n old_capacity = ht.get_num_slots()\\n ht.resize(ht.capacity * 2)\\n new_capacity = ht.get_num_slots()\\n\\n print(f\\\"\\\\nResized from {old_capacity} to {new_capacity}.\\\\n\\\")\\n\\n # Test if data intact after resizing\\n for i in range(1, 13):\\n print(ht.get(f\\\"line_{i}\\\"))\\n\\n print(\\\"\\\")\",\n \"def generichash_blake2b_update(state: Blake2State, data: bytes) -> None:\\n\\n ensure(\\n isinstance(state, Blake2State),\\n \\\"State must be a Blake2State object\\\",\\n raising=exc.TypeError,\\n )\\n\\n ensure(\\n isinstance(data, bytes),\\n \\\"Input data must be a bytes sequence\\\",\\n raising=exc.TypeError,\\n )\\n\\n rc = lib.crypto_generichash_blake2b_update(\\n state._statebuf, data, len(data)\\n )\\n ensure(rc == 0, \\\"Unexpected failure\\\", raising=exc.RuntimeError)\",\n \"def block_num_from_id(block_hash: str) -> int:\\n return int(str(block_hash)[:8], base=16)\",\n \"def HashAlgorithm(self) -> _n_7_t_0:\",\n \"def rehash(self):\\n primes = [3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761,\\n 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,\\n 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,\\n 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,\\n 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369]\\n\\n temp_list = []\\n for i in self.array:\\n if i is not None:\\n temp_list.append(i)\\n\\n self.table_capacity = 2 * self.table_capacity\\n\\n\\n try:\\n for i in range(len(primes)):\\n if primes[i] > self.table_capacity:\\n self.table_capacity = primes[i]\\n break\\n elif i == (len(primes) -1) :\\n if not primes[i] > self.table_capacity:\\n raise ValueError(\\\"There is no prime in the list such that prime > \\\" + self.table_capacity)\\n except Exception as error:\\n print(error)\\n\\n self.array = [None] * self.table_capacity\\n self.count = 0\\n for element in temp_list:\\n self.insert(element[0], element[1])\\n\\n self.rehash_count += 1\",\n \"def hashing(file,pp):\\n\\n def myhash(instring):\\n # sdbm hash\\n res = 0\\n for t in instring:\\n res = (ord(t) + (res<<6) + (res<<16) - res) % 2**32\\n return res\\n\\n return hex(myhash(file.replace('\\\\\\\\','/')+\\\":\\\"+pp))\",\n \"def replace_block(proof, headers_map, interlink_map, block_index):\\n\\n prevous_block = proof[block_index - 1][0]\\n block_hash = prevous_block[36:68]\\n block = headers_map[block_hash]\\n interlink = list_flatten(interlink_map[block.GetHash()])\\n\\n block_2 = mine_block(\\n block.hashPrevBlock, block.nBits - 1, interlink, hashMerkleRoot=b\\\"\\\\x00\\\" * 32\\n )\\n return (\\n proof[0:block_index]\\n + [[block_2.serialize(), proof[block_index][1]]]\\n + proof[block_index + 1 :]\\n )\",\n \"def getblockhash(self, index):\\n return self.proxy.getblockhash(index)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6883189","0.67876226","0.67876226","0.67761916","0.67401713","0.65702283","0.65575254","0.64846873","0.6470802","0.64679575","0.6459402","0.64477664","0.6369744","0.6369744","0.6367037","0.6361284","0.6347822","0.6322299","0.6299315","0.6297634","0.6277471","0.6265814","0.6265814","0.6265814","0.6265814","0.6265814","0.6203319","0.6182764","0.6126588","0.6113627","0.6027859","0.6009788","0.6009022","0.6005189","0.600258","0.59705406","0.594597","0.5920693","0.5895601","0.58913004","0.5889936","0.5883472","0.5882998","0.5871659","0.58430624","0.579981","0.5795566","0.5788484","0.578598","0.57850724","0.57850724","0.57823217","0.5771251","0.5749758","0.57440174","0.57153726","0.5706262","0.56929296","0.56923026","0.5686317","0.5672228","0.5641094","0.5639617","0.5626356","0.5620603","0.5618869","0.56149095","0.5606273","0.55858785","0.55795187","0.55767876","0.5576512","0.5552366","0.5552366","0.55494475","0.55455","0.55408543","0.55365634","0.5535251","0.5532898","0.5520007","0.55198634","0.55139923","0.5509818","0.5495919","0.5486941","0.5469068","0.54418314","0.54193646","0.5416252","0.5414946","0.5409677","0.5407252","0.54007804","0.53941226","0.53930014","0.5388438","0.53834313","0.5369191","0.5355145"],"string":"[\n \"0.6883189\",\n \"0.67876226\",\n \"0.67876226\",\n \"0.67761916\",\n \"0.67401713\",\n \"0.65702283\",\n \"0.65575254\",\n \"0.64846873\",\n \"0.6470802\",\n \"0.64679575\",\n \"0.6459402\",\n \"0.64477664\",\n \"0.6369744\",\n \"0.6369744\",\n \"0.6367037\",\n \"0.6361284\",\n \"0.6347822\",\n \"0.6322299\",\n \"0.6299315\",\n \"0.6297634\",\n \"0.6277471\",\n \"0.6265814\",\n \"0.6265814\",\n \"0.6265814\",\n \"0.6265814\",\n \"0.6265814\",\n \"0.6203319\",\n \"0.6182764\",\n \"0.6126588\",\n \"0.6113627\",\n \"0.6027859\",\n \"0.6009788\",\n \"0.6009022\",\n \"0.6005189\",\n \"0.600258\",\n \"0.59705406\",\n \"0.594597\",\n \"0.5920693\",\n \"0.5895601\",\n \"0.58913004\",\n \"0.5889936\",\n \"0.5883472\",\n \"0.5882998\",\n \"0.5871659\",\n \"0.58430624\",\n \"0.579981\",\n \"0.5795566\",\n \"0.5788484\",\n \"0.578598\",\n \"0.57850724\",\n \"0.57850724\",\n \"0.57823217\",\n \"0.5771251\",\n \"0.5749758\",\n \"0.57440174\",\n \"0.57153726\",\n \"0.5706262\",\n \"0.56929296\",\n \"0.56923026\",\n \"0.5686317\",\n \"0.5672228\",\n \"0.5641094\",\n \"0.5639617\",\n \"0.5626356\",\n \"0.5620603\",\n \"0.5618869\",\n \"0.56149095\",\n \"0.5606273\",\n \"0.55858785\",\n \"0.55795187\",\n \"0.55767876\",\n \"0.5576512\",\n \"0.5552366\",\n \"0.5552366\",\n \"0.55494475\",\n \"0.55455\",\n \"0.55408543\",\n \"0.55365634\",\n \"0.5535251\",\n \"0.5532898\",\n \"0.5520007\",\n \"0.55198634\",\n \"0.55139923\",\n \"0.5509818\",\n \"0.5495919\",\n \"0.5486941\",\n \"0.5469068\",\n \"0.54418314\",\n \"0.54193646\",\n \"0.5416252\",\n \"0.5414946\",\n \"0.5409677\",\n \"0.5407252\",\n \"0.54007804\",\n \"0.53941226\",\n \"0.53930014\",\n \"0.5388438\",\n \"0.53834313\",\n \"0.5369191\",\n \"0.5355145\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6925265"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74279,"cells":{"query":{"kind":"string","value":"Deletes a number of blocks from the proof starting from block_index"},"document":{"kind":"string","value":"def skip_blocks(proof, block_index, skipped_blocks=1):\n\n if block_index >= len(proof):\n return proof\n\n for i in range(block_index, block_index + skipped_blocks):\n print(\"Deleting block\", i)\n del proof[i]\n\n return proof"},"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 __delitem__(self, index):\n def _removeBlock(blockIndex):\n block = self._doc.findBlockByNumber(blockIndex)\n if block.next().isValid(): # not the last\n cursor = QTextCursor(block)\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\n elif block.previous().isValid(): # the last, not the first\n cursor = QTextCursor(block.previous())\n cursor.movePosition(QTextCursor.EndOfBlock)\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\n else: # only one block\n cursor = QTextCursor(block)\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\n cursor.removeSelectedText()\n\n if isinstance(index, int):\n index = self._checkAndConvertIndex(index)\n _removeBlock(index)\n elif isinstance(index, slice):\n \"\"\"List of indexes is reversed for make sure \n not processed indexes are not shifted during document modification\n \"\"\"\n start, stop, step = index.indices(self._doc.blockCount())\n if step > 0:\n start, stop, step = stop - 1, start - 1, step * -1\n\n for blockIndex in range(start, stop, step):\n _removeBlock(blockIndex)","def example_deletion_with_block_lowering(self):\n i = 0\n while i < len(self.shrink_target.blocks):\n if not self.is_shrinking_block(i):\n i += 1\n continue\n\n u, v = self.blocks[i].bounds\n\n j = 0\n while j < len(self.shrink_target.examples):\n n = int_from_bytes(self.shrink_target.buffer[u:v])\n if n == 0:\n break\n ex = self.shrink_target.examples[j]\n if ex.start < v or ex.length == 0:\n j += 1\n continue\n\n buf = bytearray(self.shrink_target.buffer)\n buf[u:v] = int_to_bytes(n - 1, v - u)\n del buf[ex.start : ex.end]\n if not self.incorporate_new_buffer(buf):\n j += 1\n\n i += 1","def remove_blocks(self, *vertices):\n for vertex in vertices:\n try:\n self.world[vertex] = None\n self.shown.pop(vertex)\n for vtx in self._shown[vertex]:\n vtx.delete()\n except KeyError:\n pass\n except IndexError:\n pass","def delete_block(self, block):\n raise NotImplementedError('delete_block')","def remove_blocks(draft):\n for symbol in draft.Blocks:\n if symbol.Name in blocks_to_delete:\n print(\"[-] %s, \\tdeleted\" % symbol.Name)\n symbol.delete()\n\n # for ball in draft.ActiveSheet.Balloons:\n if draft.Balloons:\n for ball in draft.Balloons:\n if ball.BalloonType == 7: # type 7 filter the triangle balloons.\n print(\"[-] %s, \\tdeleted\" % ball.Name)\n ball.Delete()\n else:\n pass","def pop(self, index):\n self.dataBlocks.pop(index)\n self._n_data_blocks -= 1","def deleteAtIndex(self, index: int) -> None:\n if index < 0 or index > self.cnt-1:\n return \n tmp = self.dummy\n for _ in range(index):\n tmp = tmp.next\n if index == self.cnt - 1:\n tmp.next = None\n else:\n tmp.next = tmp.next.next\n if tmp.next:\n tmp.next.pre = tmp\n self.cnt -= 1","def remove_genesis(proof):\n\n old_size = len(proof)\n print(\"Removing genesis block from proof ...\")\n proof.pop(-1)\n print(\"OK\")\n print(\"old size:\", old_size, \"-> new size:\", len(proof))","def del_withdraws(self, index: hash) -> None:\n del self.withdraws[index]","def deleteAtIndex(self, index):\n if 0 <= index < len(self.nums):\n self.nums = self.nums[:index] + self.nums[index+1:]","def deleteAtIndex(self, index: int) -> None:\n node = self.get_node(index)\n\n if node:\n #print(\"called inside node to delete is \" + str(node) )\n prev_node = node.prev\n next_node = node.next\n\n if prev_node:\n prev_node.next = next_node\n else:\n self.head = next_node\n if next_node:\n next_node.prev = prev_node\n\n\n\n\n self.node_count -= 1","def __delitem__(self, index):\n # If input is a slice then delete all elements as determined\n # by the slice attributes, using an offset to account for the\n # changing size of the list.\n if isinstance(index, slice):\n offset = 0\n for i in xrange(*index.indices(len(self))):\n if i > -(len(self) + 1) or i < len(self):\n del self[i - offset]\n offset += 1\n return\n\n self.__verify_index(index)\n\n if index < 0:\n index += self.length\n\n index, prev_node, cur_node = self.__find_node_index(index)\n del cur_node.data_list[index]\n self.length -= 1\n\n self.__balance_node(prev_node, cur_node)","def erase(self, n=1):\n if len(self.x) < n:\n raise IndexError('Does not have enough data to erase!')\n for k in range(n):\n self.diff.pop()\n self.x.pop()","def remove_blocks(self, block_ids):\n self.smd3.remove_blocks(block_ids)\n self.logic.update(self.smd3)\n self.header.update(self.smd3)","def delete(self, index):\n try:\n self.shapes.pop(index)\n self.records.pop(index)\n except IndexError:\n print('No record found at index: {}'.format(index))","async def remove_block(\n self,\n position: typing.Union[\n typing.Tuple[int, int, int],\n typing.Any,\n ],\n immediate: bool = True,\n block_update: bool = True,\n block_update_self: bool = True,\n network_sync=True,\n reason=None,\n ):\n raise NotImplementedError","def delete_at_index(self, index: int) -> T:\n pass","def delete_at_index(self, index: int) -> T:\n pass","def delete(self, index):\n del self.data[index]","def deleteAtIndex(self, index: int) -> None:\n if index < 0 or index >= self.size:\n return\n\n curr = self.head\n for _ in range(index):\n curr = curr.next\n curr.next = curr.next.next\n self.size -= 1","def __delitem__(self, index):\n del self.chromosome_list[index]","def erase_block(self):\n self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]] = '0'","def remove_point(mutated_genome,index):\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n del mutated_genome[index][2][point_index]","def deleteAtIndex(self, index):\n if index >= self.len:\n return\n p = self.head\n while index > 0:\n index -= 1\n p = p.next\n if p.next is self.tail:\n self.tail = p\n p.next = p.next.next\n self.len -= 1","def delete_blockreplica(self, block_replica):\n raise NotImplementedError('delete_blockreplica')","def delete(self, block, name):\n self._kvs.delete(self._key(block, name))","def remove_block(self, block):\n raise NotImplementedError()","def delete(self, i):\n pq_idx = self.__qp[i]\n self.__swap(pq_idx, self.__n)\n self.__n -= 1\n self.__swim(pq_idx)\n self.__sink(pq_idx)\n self.__keys[i] = None\n self.__qp[i] = -1","def delete_segment(self, n):\n self.get_segment(n).delete()","def delete(self, flow):\n for parent in self.parents:\n parent.children.remove(self)\n for child in self.children:\n child.parents.remove(self)\n\n flow.blocks.remove(self)","def DeleteAtIndex(self, index: int = None):\n if index is None: index = self.Current_Index() # get selected line index\n if index is None: return\n self.delete(index)","def remove_from_drawn(section: str, index: int):\r\n del drawn[section][index]","def deleteAtIndex(self, index: int) -> None:\n if(index == 0):\n self.head = self.head.next\n else:\n prev = None \n cur = self.head \n cnt = 0 \n \n while cur != None:\n if(cnt == index):\n next_node = cur.next\n prev.next = next_node \n return\n else:\n prev = cur \n cur = cur.next\n cnt += 1","def delete_by_index(self, index):\n cur = self.head\n length=self.get_length()\n if type(index) is int:\n if self.is_empty():\n return\n else:\n if index > length:\n # The index value is out of range and prompts and exits\n print(\"Index is out of range.\")\n return\n else:\n if index == 0:\n if cur.next == None:\n self.head = None\n else:\n cur.next.prev = None\n self.head = cur.next\n return\n else:\n while (index) > 0:\n cur = cur.next\n index -= 1\n\n # Point the next node of cur to the next node of cur\n cur.prev.next = cur.next\n # Point the prev of the next node of cur to the previous node of cur\n cur.next.prev = cur.prev\n length -= 1\n return\n else:\n print(\"Index value is not int.\")\n return","def deleteAtIndex(self, index):\n cur = self.head\n if cur == None:\n return\n elif index == 0:\n self.head = cur.next\n\n cur, i = self.head, 1\n while cur and i != index:\n cur = cur.next\n i += 1\n if cur.next == None:\n cur = None\n else:\n cur.next = cur.next.next","def del_prefix(self, index):\n del self.bytes[:index]","def undelete(self,\r\n undeletelist=None,\r\n update_table=True):\r\n\r\n m_temp = iter([a_temp for a_temp\r\n in range(1,len(self.indexes()*2))\r\n if str(a_temp)\r\n not in self.indexes()])\r\n\r\n\r\n # iter function is used to find free spots for the notes to be undeleted\r\n\r\n if undeletelist is None:\r\n undeletelist = [Index(x_temp)\r\n for x_temp in\r\n self.find_within(indexfrom=None,\r\n indexto=0)]\r\n\r\n for u in undeletelist:\r\n print(PERIOD,end=EMPTYCHAR)\r\n\r\n self.move(u,\r\n Index(next(m_temp)),\r\n withchildren=True,\r\n update_table=update_table)\r\n print()","def delete(self, index):\n # check validity of index:\n if index < 0 or index > self.n:\n print(\"Index Error; please input valid index\")\n return\n # if head element is to be removed,\n if index == 0:\n _ = self.pop_front()\n return\n # else,\n temp_node = self.head\n for _ in range(index-1):\n temp_node = temp_node.next # traverse the list\n index_node = temp_node.next\n # unlink\n temp_node.next = temp_node.next.next\n index_node = None\n self.n -= 1","def test_answer_non_repeating_dependency_repeating_validate_all_of_block_and_group_removed(self):\n # Given\n schema = load_schema_from_params('test', 'titles_repeating_non_repeating_dependency')\n colour_answer_location = Location('colour-group', 0, 'favourite-colour')\n colour_answer = {'fav-colour-answer': 'blue'}\n\n # When\n with self._application.test_request_context():\n with patch('app.data_model.questionnaire_store.QuestionnaireStore.remove_completed_blocks') as patch_remove:\n update_questionnaire_store_with_form_data(self.question_store, colour_answer_location, colour_answer, schema)\n\n # Then\n patch_remove.assert_called_with(group_id='repeating-group', block_id='repeating-block-3')","def delete_index(self, index):\n delete = f\"(//*[name()='svg'][@class='chakra-icon css-onkibi'])[{index}]\"\n delete_sitem = self.locator_finder_by_xpath(delete)\n delete_sitem.click()\n time.sleep(1)\n delete_confirmation = \"//*[text()='Delete']\"\n delete_confirmation_stiem = self.locator_finder_by_xpath(delete_confirmation)\n delete_confirmation_stiem.click()\n time.sleep(1)","def drop_block2d(input, p=0.5, block_size=1, training=True, inplace=False):\n if not training or p <= 0:\n return input\n return FunctionLib.apply(\n 'DropBlock', input.device, [input],\n outputs=[input if inplace else None], block_size=block_size, ratio=p)","def delete_by_index(self, index):\n if index < 0 or index >= self.get_size():\n raise IndexError('Index out of bounds')\n if index == 0:\n self.head = self.head.next\n return\n i = 0\n temp = self.head\n while temp is not None:\n if i == index-1:\n temp.next = temp.next.next\n break\n temp = temp.next\n i += 1","def removeMemoryBlock(self, block: ghidra.program.model.mem.MemoryBlock) -> None:\n ...","def deleteAtIndex(self, index):\n cur = self.head\n prev = None\n# self.display(\"deleteAtIndex, deleting value at index \"+str(index))\n if not index:\n head = head.nxt\n if self.tail == cur:\n self.tail = None\n del cur\n return\n \n i = 0\n while i < index and cur:\n prev = cur\n cur = cur.nxt\n i+=1\n if prev:\n if cur:\n prev.nxt = cur.nxt\n if self.tail == cur:\n self.tail = prev\n del cur","def delete_packets(self, num):\n for i in range(num):\n del self._packets[0]","def delete(self, index):\n try:\n valid_index = (index < len(self)) and (index >= -len(self))\n if not valid_index:\n raise IndexError\n\n elif valid_index:\n if index < 0:\n index = index + len(self)\n # Move every item after the 'index' to left\n for i in range(index, self.count - 1):\n self.the_array[i] = self.the_array[i + 1]\n self.count -= 1\n\n if (self.capacity // 2 >= self.BASE_SIZE) and (self.count < self.capacity / 8):\n self._resize(self.capacity // 2)\n\n except IndexError:\n print(\"Index must be in between -len(self) to len(self).\")\n\n return valid_index","def _delete_command_idxs(indexes, from_cmake):\n for index in sorted(indexes, reverse=True):\n del from_cmake[index]","def destroy(self, coords):\n\n block = blocks[self.get_block(coords)]\n self.set_block(coords, block.replace)\n self.set_metadata(coords, 0)","def deleteAtIndex(self, index):\n if index < 0 or index >= self._size:\n return\n elif index == 0:\n self.deleteHead()\n return\n elif index == self._size - 1:\n self.deleteTail()\n return\n\n current = self._head\n for _ in range(index - 1):\n current = current.next\n current.next = current.next.next\n self._size -= 1","def DeleteIndex(self, arg0: 'unsigned long long') -> \"void\":\n return _itkQuadEdgeCellTraitsInfoPython.itkMapContainerULLQEMPF2GQEULLULLBBT_DeleteIndex(self, arg0)","def del_row(self, row_index):\n ...","def deleteAtIndex(self, index):\n\n if index < 0:\n return -1\n\n p = self.head\n while index and p: # 0-index before index-th\n p = p.next\n index -= 1\n\n if p == None or p.next == None:\n return\n if p.next.next:\n p.next.next.prev = p\n p.next = p.next.next\n if p.next == None:\n self.tail = p\n # self.printList()","def __delitem__(self, index: Any) -> None:\n del self.contents[index]\n return","def deleteAtIndex(self, index):\n if index >= 0 and index < self.length:\n prev = None\n curr = self.head\n _next = None\n if curr:\n _next = curr.next\n for i in range(1, index + 1):\n prev = curr\n curr = curr.next\n if curr:\n _next = curr.next\n if prev:\n prev.next = _next\n else:\n self.head = _next\n self.length -= 1","def removeBlock(self, block: ghidra.program.model.mem.MemoryBlock, monitor: ghidra.util.task.TaskMonitor) -> None:\n ...","def DeleteIndex(self, arg0: 'unsigned long long') -> \"void\":\n return _itkQuadEdgeCellTraitsInfoPython.itkMapContainerULLQEMPF3GQEULLULLBBT_DeleteIndex(self, arg0)","def removeRow(self, index: int) -> None:\n ...","def delete_bets(driver, indices):\n if isinstance(indices, int):\n indices = [indices]\n\n top_lines = driver.find_elements_by_class_name(TOP_LINE_CLASS)\n\n for i in indices:\n top_line = top_lines[i]\n delete_bet_button = top_line.find_element_by_tag_name(\"button\")\n delete_bet_button.send_keys(\"\\n\")\n time.sleep(1)\n print(f\"bet[{i}] deleted\")","def __delitem__(self, index: int) -> None:\n error = self._coreIndex.removeDescriptor(index)\n assertError(error)","def deleteAtIndex(self, index):\n if index < 0 or index >= self.size:\n return\n\n curr = self.head\n if index == 0:\n self.head = curr.next\n else:\n for i in range(index - 1):\n curr = curr.next\n curr.next = curr.next.next\n\n self.size -= 1","def removeNode(self, index):\n del self.nodes[index]","def EliminateSingleNodeSegments(self):\n sections_to_remove = [] # List of indices into self._section_list\n index = 0\n for each_section in self._section_list:\n if len(each_section.Nodes()) == 1:\n self.ReparentSectionChildren(each_section)\n sections_to_remove.append(index)\n index += 1\n sections_to_remove.reverse()\n for each_index in sections_to_remove:\n self._section_list.pop(each_index)\n self.RegenerateCaches()","def remove(self, block):\n try:\n self.blocks[block.height]\n except:\n raise ValueError(\"cant remove block: \" + str(block))\n\n removed = False\n for b in self.blocks[block.height]:\n # only delete the one with equal hash\n if b.hash() == block.hash():\n self.blocks[block.height].remove(b)\n removed = True\n if self.blocks[block.height] == []:\n self.blocks.pop(block.height)\n\n if not removed:\n raise ValueError(\"cant remove block: \" + str(block))","def removeBlock(self, aBlock: gp.Block):\n \n for y, row in iter(self.blocks):\n for x, block in iter(row):\n if block is aBlock:\n self.blocks[y][x] = None\n self.playerSprites.remove(aBlock.sprite)\n return","def deleteAtIndex(self, index: int) -> None:\n # if the index is invalid, do nothing\n if index < 0 or index >= self.size:\n return\n \n # find predecessor and successor of the node to be deleted\n if index < self.size - index:\n pred = self.head\n for _ in range(index):\n pred = pred.next\n succ = pred.next.next\n else:\n succ = self.tail\n for _ in range(self.size - index - 1):\n succ = succ.prev\n pred = succ.prev.prev\n \n # delete pred.next \n self.size -= 1\n pred.next = succ\n succ.prev = pred","def __delitem__(self, index: int) -> None:\n del self._rows[index]","def unblock_all(t):\n blocked_count = 0\n\n while True:\n blocked_user_ids = t.blocks.ids()[\"ids\"]\n if not blocked_user_ids:\n print(\"No more IDs to unblock\")\n break\n\n for user_id in blocked_user_ids:\n blocked_count = blocked_count + 1\n print(f\"{blocked_count}: {user_id}\")\n try:\n t.blocks.destroy(user_id=user_id, include_entities=False, skip_status=True)\n except:\n print(\"error\")","def remove_group(self, index):\n group = self.get(index).group\n for stone_index in group.members:\n self.board[stone_index] = None","def remove(self,index=0):\n if index>self.size-1: raise IndexError(\"Index out of range.\")\n elif self.size==1: self.reference=None\n else:\n pointer = self.reference\n for i in range(index): pointer = pointer.next\n pointer.previous.next, pointer.next.previous = pointer.next, pointer.previous\n if index==0: self.reference=self.reference.next\n self.size-=1","def test_remove_blocks(tmp_path):\n fn1 = tmp_path / \"test.asdf\"\n fn2 = tmp_path / \"test2.asdf\"\n\n tree = {\"a\": np.zeros(3), \"b\": np.ones(1)}\n af = asdf.AsdfFile(tree)\n af.write_to(fn1)\n\n with asdf.open(fn1, mode=\"rw\") as af:\n assert len(af._blocks._internal_blocks) == 2\n af[\"a\"] = None\n af.write_to(fn2)\n\n with asdf.open(fn1, mode=\"rw\") as af:\n assert len(af._blocks._internal_blocks) == 2\n af[\"a\"] = None\n af.update()\n\n for fn in (fn1, fn2):\n with asdf.open(fn) as af:\n assert len(af._blocks._internal_blocks) == 1","def purge(self,\r\n noterange=None):\r\n\r\n if noterange is None:\r\n noterange = [str(Index(a_temp))\r\n for a_temp\r\n in self.indexes()]\r\n for i_temp in [str(Index(n))\r\n for n in self.indexes()\r\n if Index(n) > Index(str(0))\r\n and str(Index(n)) in noterange]:\r\n if (len(str(self.get_keys_from_note(i_temp))) < 5\r\n and self.get_text_from_note(i_temp).replace(EOL,\r\n EMPTYCHAR).strip() == EMPTYCHAR):\r\n\r\n self.softdelete(i_temp)","def __delitem__(self, index):\n # delete the column\n del self._data[index]\n\n # adjust the number of columns\n self._nrows -= 1","def delete_node_at_index(self, index):\n if index < 0 or index >= self.size:\n return\n\n curr = self.head\n if index == 0:\n self.head = curr.next\n else:\n for i in range(index - 1):\n curr = curr.next\n curr.next = curr.next.next\n\n self.size -= 1","def delete_item(self, usage_locator, user_id, force=False): # lint-amnesty, pylint: disable=arguments-differ\n if not isinstance(usage_locator, BlockUsageLocator) or usage_locator.deprecated:\n # The supplied UsageKey is of the wrong type, so it can't possibly be stored in this modulestore.\n raise ItemNotFoundError(usage_locator)\n\n with self.bulk_operations(usage_locator.course_key):\n original_structure = self._lookup_course(usage_locator.course_key).structure\n block_key = BlockKey.from_usage_key(usage_locator)\n if original_structure['root'] == block_key:\n raise ValueError(\"Cannot delete the root of a course\")\n if block_key not in original_structure['blocks']:\n raise ValueError(\"Cannot delete block_key {} from course {}, because that block does not exist.\".format(\n block_key,\n usage_locator,\n ))\n index_entry = self._get_index_if_valid(usage_locator.course_key, force)\n new_structure = self.version_structure(usage_locator.course_key, original_structure, user_id)\n new_blocks = new_structure['blocks']\n new_id = new_structure['_id']\n parent_block_keys = self._get_parents_from_structure(block_key, original_structure)\n for parent_block_key in parent_block_keys:\n parent_block = new_blocks[parent_block_key]\n parent_block.fields['children'].remove(block_key)\n parent_block.edit_info.edited_on = datetime.datetime.now(UTC)\n parent_block.edit_info.edited_by = user_id\n parent_block.edit_info.previous_version = parent_block.edit_info.update_version\n parent_block.edit_info.update_version = new_id\n # remove the source_version reference\n parent_block.edit_info.source_version = None\n self.decache_block(usage_locator.course_key, new_id, parent_block_key)\n\n self._remove_subtree(BlockKey.from_usage_key(usage_locator), new_blocks)\n\n # update index if appropriate and structures\n self.update_structure(usage_locator.course_key, new_structure)\n\n if index_entry is not None:\n # update the index entry if appropriate\n self._update_head(usage_locator.course_key, index_entry, usage_locator.branch, new_id)\n result = usage_locator.course_key.for_version(new_id)\n else:\n result = CourseLocator(version_guid=new_id)\n\n if isinstance(usage_locator.course_key, LibraryLocator):\n self._flag_library_updated_event(usage_locator.course_key)\n\n self._emit_item_deleted_signal(usage_locator, user_id)\n\n return result","def test_delete_complex_tree_04(comp):\n comp.delete(13)\n assert tuple(comp.in_order()) == (4, 6, 7, 8, 9, 10, 11, 12, 14, 15)\n assert tuple(comp.breadth_first()) == (11, 8, 14, 6, 10, 12, 15, 4, 7, 9)","def delete_at_index(self, idx):\n del self.timeseries[idx]\n del self.freq[idx]\n del self.ch_name[idx]\n del self.units[idx]\n\n if self.trigger_idx == idx:\n LGR.warning(\"Removing trigger channel - are you sure you are doing\" \"the right thing?\")\n self.trigger_idx = 0","def delete_multiple(self, idxes, sort = True):\n if(sort): idxes.sort() # inplace\n # forced to loop but it's better than using np.remove which is not inplace.\n for idx in np.flip(idxes): # view = constant time \n self.arr[idx] = self.arr[self.current-1]\n self.current -= 1","def delete_note (self,\r\n index):\r\n\r\n if self.using_shelf:\r\n\r\n try:\r\n del self.note_dict[str(index)]\r\n except:\r\n display.noteprint((alerts.ATTENTION,alerts.DELETE+str(index)+alerts.FAILED))\r\n\r\n if self.using_database:\r\n aprint('DELETING NOTE')\r\n value_tuple = (notebookname,str(index),)\r\n db_cursor.execute(\"DELETE FROM \"\r\n +\"notes WHERE notebook=?\"\r\n +\" AND note_index=?;\",\r\n value_tuple)\r\n db_cursor.execute(\"DELETE FROM\"\r\n +\" all_note_keys\"\r\n +\" WHERE notebook=?\"\r\n +\" and note_index=?;\",\r\n value_tuple)\r\n db_cursor.execute(\"DELETE FROM\"\r\n +\" timestamps\"\r\n +\" WHERE notebook=?\"\r\n +\" and note_index=?;\",\r\n value_tuple)\r\n db_cursor.execute(\"SELECT note_index\"\r\n +\" FROM notes\"\r\n +\" WHERE notebook=?;\",\r\n (notebookname,))","def delete(self, index):\n if index == 0 and self.head is not None:\n self.head = self.head.next\n return\n\n current_index = 0\n current = self.head\n previous = None\n\n while current:\n if current_index == index:\n previous.next = current.next\n\n previous = current\n current = current.next\n current_index += 1","def remove(self, block_hash: Sha256Hash) -> int:\n\n self.connection.log_trace(\"Purging block {} from queuing service.\", block_hash)\n\n index = self.remove_from_queue(block_hash)\n if block_hash in self._blocks:\n self._blocks.remove(block_hash)\n return index","def remove(self, tile_index: int) -> None:\n octree_chunk = self._tiles[tile_index].octree_chunk\n self._chunks.remove(octree_chunk)\n del self._tiles[tile_index]","def delete_index(self):\n if self.index_module:\n self.index_module = None\n gc.collect()","def validate_blocks():\n # Validate the remesh blocks modifiers\n bpy.ops.object.apply_all_modifiers()\n \n date_1 = datetime.datetime.now()\n print(\"Start\")\n \n # Select the bottom faces\n Button_Operations.select_faces(radians(10))\n\n # Extrude the support\n bpy.ops.mesh.extrude_region_move(MESH_OT_extrude_region={\"use_normal_flip\":False, \"use_dissolve_ortho_edges\":False, \"mirror\":False}, TRANSFORM_OT_translate={\"value\":(0, 0, -20), \"orient_type\":'GLOBAL', \"orient_matrix\":((1, 0, 0), (0, 1, 0), (0, 0, 1)), \"orient_matrix_type\":'GLOBAL', \"constraint_axis\":(False, False, True), \"mirror\":False, \"use_proportional_edit\":False, \"proportional_edit_falloff\":'SMOOTH', \"proportional_size\":1, \"use_proportional_connected\":False, \"use_proportional_projected\":False, \"snap\":False, \"snap_target\":'CLOSEST', \"snap_point\":(0, 0, 0), \"snap_align\":False, \"snap_normal\":(0, 0, 0), \"gpencil_strokes\":False, \"cursor_transform\":False, \"texture_space\":False, \"remove_on_cancel\":False, \"release_confirm\":False, \"use_accurate\":False, \"use_automerge_and_split\":False})\n\n # Select all\n bpy.ops.mesh.select_all(action='SELECT')\n\n # Bissect and delete the element under the xy plane\n bpy.ops.mesh.bisect(plane_co=(0, 0, 0.01), plane_no=(0, 0, 1), use_fill=False, clear_inner=True, xstart=942, xend=1489, ystart=872, yend=874, flip=False) \n\n # Fill the hole and triangulate faces\n Button_Operations.manifold_and_triangulate()\n \n # Delete the copy\n object_to_delete = bpy.data.objects[\"temp_copy\"]\n bpy.data.objects.remove(object_to_delete, do_unlink=True) \n \n # Switch in object mode \n bpy.ops.object.mode_set(mode='OBJECT')","def removeRows(self, position, rows=1, index:QtCore.QModelIndex=QtCore.QModelIndex()):\n self.beginRemoveRows(QtCore.QModelIndex(), position, position + rows - 1)\n\n del self.__checknode.params[position:position + rows]\n self.__checknode._commit()\n\n self.endRemoveRows()\n return True","def removeRows(self, position, rows=1, index:QtCore.QModelIndex=QtCore.QModelIndex()):\n self.beginRemoveRows(QtCore.QModelIndex(), position, position + rows - 1)\n\n del self.__checknode.params[position:position + rows]\n self.__checknode._commit()\n\n self.endRemoveRows()\n return True","def test_delete_complex_tree_05(comp):\n comp.delete(8)\n assert tuple(comp.in_order()) == (4, 6, 7, 9, 10, 11, 12, 13, 14, 15)\n assert tuple(comp.breadth_first()) == (11, 9, 13, 6, 10, 12, 14, 4, 7, 15)","def remove_from_queue(self, block_hash: Sha256Hash) -> int:\n if block_hash not in self._blocks:\n return -1\n\n self.connection.log_trace(\"Removing block {} from queue.\", block_hash)\n\n for index in range(len(self._block_queue)):\n if self._block_queue[index][0] == block_hash:\n del self._block_queue[index]\n del self._blocks_waiting_for_recovery[block_hash]\n\n return index\n\n return -1","def delete_item(self, usage_locator, user_id, delete_all_versions=False, delete_children=False, force=False):\r\n assert isinstance(usage_locator, BlockUsageLocator)\r\n original_structure = self._lookup_course(usage_locator.course_key)['structure']\r\n if original_structure['root'] == usage_locator.block_id:\r\n raise ValueError(\"Cannot delete the root of a course\")\r\n index_entry = self._get_index_if_valid(usage_locator, force)\r\n new_structure = self._version_structure(original_structure, user_id)\r\n new_blocks = new_structure['blocks']\r\n new_id = new_structure['_id']\r\n parents = self.get_parent_locations(usage_locator)\r\n for parent in parents:\r\n encoded_block_id = LocMapperStore.encode_key_for_mongo(parent.block_id)\r\n parent_block = new_blocks[encoded_block_id]\r\n parent_block['fields']['children'].remove(usage_locator.block_id)\r\n parent_block['edit_info']['edited_on'] = datetime.datetime.now(UTC)\r\n parent_block['edit_info']['edited_by'] = user_id\r\n parent_block['edit_info']['previous_version'] = parent_block['edit_info']['update_version']\r\n parent_block['edit_info']['update_version'] = new_id\r\n\r\n def remove_subtree(block_id):\r\n \"\"\"\r\n Remove the subtree rooted at block_id\r\n \"\"\"\r\n encoded_block_id = LocMapperStore.encode_key_for_mongo(block_id)\r\n for child in new_blocks[encoded_block_id]['fields'].get('children', []):\r\n remove_subtree(child)\r\n del new_blocks[encoded_block_id]\r\n if delete_children:\r\n remove_subtree(usage_locator.block_id)\r\n else:\r\n del new_blocks[LocMapperStore.encode_key_for_mongo(usage_locator.block_id)]\r\n\r\n # update index if appropriate and structures\r\n self.db_connection.insert_structure(new_structure)\r\n\r\n if index_entry is not None:\r\n # update the index entry if appropriate\r\n self._update_head(index_entry, usage_locator.branch, new_id)\r\n result = usage_locator.course_key.for_version(new_id)\r\n else:\r\n result = CourseLocator(version_guid=new_id)\r\n\r\n return result","def clear_blockages(self):\n debug.info(3,\"Clearing all blockages\")\n self.rg.clear_blockages()","def delete_element(some_list, index):\n del some_list[index]\n return some_list","def delete(data, index):\n return data[:index] + data[index + 1:]","def clear_row_proportion(self, index):\n\n if index in self._proportions[1]:\n del self._proportions[1][index]","def delete_all(self, n):\n for i in range(n):\n try:\n del self.dictionary[i]\n except KeyError:\n continue","def test_removing_index(self):","def remove_card(self, card_idx: int) -> None:","def remove(self, index):\n raise NotImplementedError()","def building_remove(self, pos):\n x, y = pos\n step = self.bmap_step[y,x]\n\n if step == 0:\n return\n\n for x in range(0,AIV_SIZE):\n for y in range(0,AIV_SIZE):\n if (self.bmap_step[y,x] == step):\n self.bmap_step[y,x] = 0\n self.bmap_id[y,x] = 0\n self.bmap_size[y,x] = 0\n self.bmap_tile[y,x] = 0\n\n self.step_cur -= 1\n self.step_tot -= 1","def del_row(self, index):\n self.data.remove(self.data[index])","def remove_from_block(self):\n self.enclosing_block.remove_ops([self])","def test_delete_complex_tree_03(comp):\n comp.delete(15)\n assert tuple(comp.in_order()) == (4, 6, 7, 8, 9, 10, 11, 12, 13, 14)\n assert tuple(comp.breadth_first()) == (11, 8, 13, 6, 10, 12, 14, 4, 7, 9)"],"string":"[\n \"def __delitem__(self, index):\\n def _removeBlock(blockIndex):\\n block = self._doc.findBlockByNumber(blockIndex)\\n if block.next().isValid(): # not the last\\n cursor = QTextCursor(block)\\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\\n elif block.previous().isValid(): # the last, not the first\\n cursor = QTextCursor(block.previous())\\n cursor.movePosition(QTextCursor.EndOfBlock)\\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\\n else: # only one block\\n cursor = QTextCursor(block)\\n cursor.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)\\n cursor.removeSelectedText()\\n\\n if isinstance(index, int):\\n index = self._checkAndConvertIndex(index)\\n _removeBlock(index)\\n elif isinstance(index, slice):\\n \\\"\\\"\\\"List of indexes is reversed for make sure \\n not processed indexes are not shifted during document modification\\n \\\"\\\"\\\"\\n start, stop, step = index.indices(self._doc.blockCount())\\n if step > 0:\\n start, stop, step = stop - 1, start - 1, step * -1\\n\\n for blockIndex in range(start, stop, step):\\n _removeBlock(blockIndex)\",\n \"def example_deletion_with_block_lowering(self):\\n i = 0\\n while i < len(self.shrink_target.blocks):\\n if not self.is_shrinking_block(i):\\n i += 1\\n continue\\n\\n u, v = self.blocks[i].bounds\\n\\n j = 0\\n while j < len(self.shrink_target.examples):\\n n = int_from_bytes(self.shrink_target.buffer[u:v])\\n if n == 0:\\n break\\n ex = self.shrink_target.examples[j]\\n if ex.start < v or ex.length == 0:\\n j += 1\\n continue\\n\\n buf = bytearray(self.shrink_target.buffer)\\n buf[u:v] = int_to_bytes(n - 1, v - u)\\n del buf[ex.start : ex.end]\\n if not self.incorporate_new_buffer(buf):\\n j += 1\\n\\n i += 1\",\n \"def remove_blocks(self, *vertices):\\n for vertex in vertices:\\n try:\\n self.world[vertex] = None\\n self.shown.pop(vertex)\\n for vtx in self._shown[vertex]:\\n vtx.delete()\\n except KeyError:\\n pass\\n except IndexError:\\n pass\",\n \"def delete_block(self, block):\\n raise NotImplementedError('delete_block')\",\n \"def remove_blocks(draft):\\n for symbol in draft.Blocks:\\n if symbol.Name in blocks_to_delete:\\n print(\\\"[-] %s, \\\\tdeleted\\\" % symbol.Name)\\n symbol.delete()\\n\\n # for ball in draft.ActiveSheet.Balloons:\\n if draft.Balloons:\\n for ball in draft.Balloons:\\n if ball.BalloonType == 7: # type 7 filter the triangle balloons.\\n print(\\\"[-] %s, \\\\tdeleted\\\" % ball.Name)\\n ball.Delete()\\n else:\\n pass\",\n \"def pop(self, index):\\n self.dataBlocks.pop(index)\\n self._n_data_blocks -= 1\",\n \"def deleteAtIndex(self, index: int) -> None:\\n if index < 0 or index > self.cnt-1:\\n return \\n tmp = self.dummy\\n for _ in range(index):\\n tmp = tmp.next\\n if index == self.cnt - 1:\\n tmp.next = None\\n else:\\n tmp.next = tmp.next.next\\n if tmp.next:\\n tmp.next.pre = tmp\\n self.cnt -= 1\",\n \"def remove_genesis(proof):\\n\\n old_size = len(proof)\\n print(\\\"Removing genesis block from proof ...\\\")\\n proof.pop(-1)\\n print(\\\"OK\\\")\\n print(\\\"old size:\\\", old_size, \\\"-> new size:\\\", len(proof))\",\n \"def del_withdraws(self, index: hash) -> None:\\n del self.withdraws[index]\",\n \"def deleteAtIndex(self, index):\\n if 0 <= index < len(self.nums):\\n self.nums = self.nums[:index] + self.nums[index+1:]\",\n \"def deleteAtIndex(self, index: int) -> None:\\n node = self.get_node(index)\\n\\n if node:\\n #print(\\\"called inside node to delete is \\\" + str(node) )\\n prev_node = node.prev\\n next_node = node.next\\n\\n if prev_node:\\n prev_node.next = next_node\\n else:\\n self.head = next_node\\n if next_node:\\n next_node.prev = prev_node\\n\\n\\n\\n\\n self.node_count -= 1\",\n \"def __delitem__(self, index):\\n # If input is a slice then delete all elements as determined\\n # by the slice attributes, using an offset to account for the\\n # changing size of the list.\\n if isinstance(index, slice):\\n offset = 0\\n for i in xrange(*index.indices(len(self))):\\n if i > -(len(self) + 1) or i < len(self):\\n del self[i - offset]\\n offset += 1\\n return\\n\\n self.__verify_index(index)\\n\\n if index < 0:\\n index += self.length\\n\\n index, prev_node, cur_node = self.__find_node_index(index)\\n del cur_node.data_list[index]\\n self.length -= 1\\n\\n self.__balance_node(prev_node, cur_node)\",\n \"def erase(self, n=1):\\n if len(self.x) < n:\\n raise IndexError('Does not have enough data to erase!')\\n for k in range(n):\\n self.diff.pop()\\n self.x.pop()\",\n \"def remove_blocks(self, block_ids):\\n self.smd3.remove_blocks(block_ids)\\n self.logic.update(self.smd3)\\n self.header.update(self.smd3)\",\n \"def delete(self, index):\\n try:\\n self.shapes.pop(index)\\n self.records.pop(index)\\n except IndexError:\\n print('No record found at index: {}'.format(index))\",\n \"async def remove_block(\\n self,\\n position: typing.Union[\\n typing.Tuple[int, int, int],\\n typing.Any,\\n ],\\n immediate: bool = True,\\n block_update: bool = True,\\n block_update_self: bool = True,\\n network_sync=True,\\n reason=None,\\n ):\\n raise NotImplementedError\",\n \"def delete_at_index(self, index: int) -> T:\\n pass\",\n \"def delete_at_index(self, index: int) -> T:\\n pass\",\n \"def delete(self, index):\\n del self.data[index]\",\n \"def deleteAtIndex(self, index: int) -> None:\\n if index < 0 or index >= self.size:\\n return\\n\\n curr = self.head\\n for _ in range(index):\\n curr = curr.next\\n curr.next = curr.next.next\\n self.size -= 1\",\n \"def __delitem__(self, index):\\n del self.chromosome_list[index]\",\n \"def erase_block(self):\\n self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]] = '0'\",\n \"def remove_point(mutated_genome,index):\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n del mutated_genome[index][2][point_index]\",\n \"def deleteAtIndex(self, index):\\n if index >= self.len:\\n return\\n p = self.head\\n while index > 0:\\n index -= 1\\n p = p.next\\n if p.next is self.tail:\\n self.tail = p\\n p.next = p.next.next\\n self.len -= 1\",\n \"def delete_blockreplica(self, block_replica):\\n raise NotImplementedError('delete_blockreplica')\",\n \"def delete(self, block, name):\\n self._kvs.delete(self._key(block, name))\",\n \"def remove_block(self, block):\\n raise NotImplementedError()\",\n \"def delete(self, i):\\n pq_idx = self.__qp[i]\\n self.__swap(pq_idx, self.__n)\\n self.__n -= 1\\n self.__swim(pq_idx)\\n self.__sink(pq_idx)\\n self.__keys[i] = None\\n self.__qp[i] = -1\",\n \"def delete_segment(self, n):\\n self.get_segment(n).delete()\",\n \"def delete(self, flow):\\n for parent in self.parents:\\n parent.children.remove(self)\\n for child in self.children:\\n child.parents.remove(self)\\n\\n flow.blocks.remove(self)\",\n \"def DeleteAtIndex(self, index: int = None):\\n if index is None: index = self.Current_Index() # get selected line index\\n if index is None: return\\n self.delete(index)\",\n \"def remove_from_drawn(section: str, index: int):\\r\\n del drawn[section][index]\",\n \"def deleteAtIndex(self, index: int) -> None:\\n if(index == 0):\\n self.head = self.head.next\\n else:\\n prev = None \\n cur = self.head \\n cnt = 0 \\n \\n while cur != None:\\n if(cnt == index):\\n next_node = cur.next\\n prev.next = next_node \\n return\\n else:\\n prev = cur \\n cur = cur.next\\n cnt += 1\",\n \"def delete_by_index(self, index):\\n cur = self.head\\n length=self.get_length()\\n if type(index) is int:\\n if self.is_empty():\\n return\\n else:\\n if index > length:\\n # The index value is out of range and prompts and exits\\n print(\\\"Index is out of range.\\\")\\n return\\n else:\\n if index == 0:\\n if cur.next == None:\\n self.head = None\\n else:\\n cur.next.prev = None\\n self.head = cur.next\\n return\\n else:\\n while (index) > 0:\\n cur = cur.next\\n index -= 1\\n\\n # Point the next node of cur to the next node of cur\\n cur.prev.next = cur.next\\n # Point the prev of the next node of cur to the previous node of cur\\n cur.next.prev = cur.prev\\n length -= 1\\n return\\n else:\\n print(\\\"Index value is not int.\\\")\\n return\",\n \"def deleteAtIndex(self, index):\\n cur = self.head\\n if cur == None:\\n return\\n elif index == 0:\\n self.head = cur.next\\n\\n cur, i = self.head, 1\\n while cur and i != index:\\n cur = cur.next\\n i += 1\\n if cur.next == None:\\n cur = None\\n else:\\n cur.next = cur.next.next\",\n \"def del_prefix(self, index):\\n del self.bytes[:index]\",\n \"def undelete(self,\\r\\n undeletelist=None,\\r\\n update_table=True):\\r\\n\\r\\n m_temp = iter([a_temp for a_temp\\r\\n in range(1,len(self.indexes()*2))\\r\\n if str(a_temp)\\r\\n not in self.indexes()])\\r\\n\\r\\n\\r\\n # iter function is used to find free spots for the notes to be undeleted\\r\\n\\r\\n if undeletelist is None:\\r\\n undeletelist = [Index(x_temp)\\r\\n for x_temp in\\r\\n self.find_within(indexfrom=None,\\r\\n indexto=0)]\\r\\n\\r\\n for u in undeletelist:\\r\\n print(PERIOD,end=EMPTYCHAR)\\r\\n\\r\\n self.move(u,\\r\\n Index(next(m_temp)),\\r\\n withchildren=True,\\r\\n update_table=update_table)\\r\\n print()\",\n \"def delete(self, index):\\n # check validity of index:\\n if index < 0 or index > self.n:\\n print(\\\"Index Error; please input valid index\\\")\\n return\\n # if head element is to be removed,\\n if index == 0:\\n _ = self.pop_front()\\n return\\n # else,\\n temp_node = self.head\\n for _ in range(index-1):\\n temp_node = temp_node.next # traverse the list\\n index_node = temp_node.next\\n # unlink\\n temp_node.next = temp_node.next.next\\n index_node = None\\n self.n -= 1\",\n \"def test_answer_non_repeating_dependency_repeating_validate_all_of_block_and_group_removed(self):\\n # Given\\n schema = load_schema_from_params('test', 'titles_repeating_non_repeating_dependency')\\n colour_answer_location = Location('colour-group', 0, 'favourite-colour')\\n colour_answer = {'fav-colour-answer': 'blue'}\\n\\n # When\\n with self._application.test_request_context():\\n with patch('app.data_model.questionnaire_store.QuestionnaireStore.remove_completed_blocks') as patch_remove:\\n update_questionnaire_store_with_form_data(self.question_store, colour_answer_location, colour_answer, schema)\\n\\n # Then\\n patch_remove.assert_called_with(group_id='repeating-group', block_id='repeating-block-3')\",\n \"def delete_index(self, index):\\n delete = f\\\"(//*[name()='svg'][@class='chakra-icon css-onkibi'])[{index}]\\\"\\n delete_sitem = self.locator_finder_by_xpath(delete)\\n delete_sitem.click()\\n time.sleep(1)\\n delete_confirmation = \\\"//*[text()='Delete']\\\"\\n delete_confirmation_stiem = self.locator_finder_by_xpath(delete_confirmation)\\n delete_confirmation_stiem.click()\\n time.sleep(1)\",\n \"def drop_block2d(input, p=0.5, block_size=1, training=True, inplace=False):\\n if not training or p <= 0:\\n return input\\n return FunctionLib.apply(\\n 'DropBlock', input.device, [input],\\n outputs=[input if inplace else None], block_size=block_size, ratio=p)\",\n \"def delete_by_index(self, index):\\n if index < 0 or index >= self.get_size():\\n raise IndexError('Index out of bounds')\\n if index == 0:\\n self.head = self.head.next\\n return\\n i = 0\\n temp = self.head\\n while temp is not None:\\n if i == index-1:\\n temp.next = temp.next.next\\n break\\n temp = temp.next\\n i += 1\",\n \"def removeMemoryBlock(self, block: ghidra.program.model.mem.MemoryBlock) -> None:\\n ...\",\n \"def deleteAtIndex(self, index):\\n cur = self.head\\n prev = None\\n# self.display(\\\"deleteAtIndex, deleting value at index \\\"+str(index))\\n if not index:\\n head = head.nxt\\n if self.tail == cur:\\n self.tail = None\\n del cur\\n return\\n \\n i = 0\\n while i < index and cur:\\n prev = cur\\n cur = cur.nxt\\n i+=1\\n if prev:\\n if cur:\\n prev.nxt = cur.nxt\\n if self.tail == cur:\\n self.tail = prev\\n del cur\",\n \"def delete_packets(self, num):\\n for i in range(num):\\n del self._packets[0]\",\n \"def delete(self, index):\\n try:\\n valid_index = (index < len(self)) and (index >= -len(self))\\n if not valid_index:\\n raise IndexError\\n\\n elif valid_index:\\n if index < 0:\\n index = index + len(self)\\n # Move every item after the 'index' to left\\n for i in range(index, self.count - 1):\\n self.the_array[i] = self.the_array[i + 1]\\n self.count -= 1\\n\\n if (self.capacity // 2 >= self.BASE_SIZE) and (self.count < self.capacity / 8):\\n self._resize(self.capacity // 2)\\n\\n except IndexError:\\n print(\\\"Index must be in between -len(self) to len(self).\\\")\\n\\n return valid_index\",\n \"def _delete_command_idxs(indexes, from_cmake):\\n for index in sorted(indexes, reverse=True):\\n del from_cmake[index]\",\n \"def destroy(self, coords):\\n\\n block = blocks[self.get_block(coords)]\\n self.set_block(coords, block.replace)\\n self.set_metadata(coords, 0)\",\n \"def deleteAtIndex(self, index):\\n if index < 0 or index >= self._size:\\n return\\n elif index == 0:\\n self.deleteHead()\\n return\\n elif index == self._size - 1:\\n self.deleteTail()\\n return\\n\\n current = self._head\\n for _ in range(index - 1):\\n current = current.next\\n current.next = current.next.next\\n self._size -= 1\",\n \"def DeleteIndex(self, arg0: 'unsigned long long') -> \\\"void\\\":\\n return _itkQuadEdgeCellTraitsInfoPython.itkMapContainerULLQEMPF2GQEULLULLBBT_DeleteIndex(self, arg0)\",\n \"def del_row(self, row_index):\\n ...\",\n \"def deleteAtIndex(self, index):\\n\\n if index < 0:\\n return -1\\n\\n p = self.head\\n while index and p: # 0-index before index-th\\n p = p.next\\n index -= 1\\n\\n if p == None or p.next == None:\\n return\\n if p.next.next:\\n p.next.next.prev = p\\n p.next = p.next.next\\n if p.next == None:\\n self.tail = p\\n # self.printList()\",\n \"def __delitem__(self, index: Any) -> None:\\n del self.contents[index]\\n return\",\n \"def deleteAtIndex(self, index):\\n if index >= 0 and index < self.length:\\n prev = None\\n curr = self.head\\n _next = None\\n if curr:\\n _next = curr.next\\n for i in range(1, index + 1):\\n prev = curr\\n curr = curr.next\\n if curr:\\n _next = curr.next\\n if prev:\\n prev.next = _next\\n else:\\n self.head = _next\\n self.length -= 1\",\n \"def removeBlock(self, block: ghidra.program.model.mem.MemoryBlock, monitor: ghidra.util.task.TaskMonitor) -> None:\\n ...\",\n \"def DeleteIndex(self, arg0: 'unsigned long long') -> \\\"void\\\":\\n return _itkQuadEdgeCellTraitsInfoPython.itkMapContainerULLQEMPF3GQEULLULLBBT_DeleteIndex(self, arg0)\",\n \"def removeRow(self, index: int) -> None:\\n ...\",\n \"def delete_bets(driver, indices):\\n if isinstance(indices, int):\\n indices = [indices]\\n\\n top_lines = driver.find_elements_by_class_name(TOP_LINE_CLASS)\\n\\n for i in indices:\\n top_line = top_lines[i]\\n delete_bet_button = top_line.find_element_by_tag_name(\\\"button\\\")\\n delete_bet_button.send_keys(\\\"\\\\n\\\")\\n time.sleep(1)\\n print(f\\\"bet[{i}] deleted\\\")\",\n \"def __delitem__(self, index: int) -> None:\\n error = self._coreIndex.removeDescriptor(index)\\n assertError(error)\",\n \"def deleteAtIndex(self, index):\\n if index < 0 or index >= self.size:\\n return\\n\\n curr = self.head\\n if index == 0:\\n self.head = curr.next\\n else:\\n for i in range(index - 1):\\n curr = curr.next\\n curr.next = curr.next.next\\n\\n self.size -= 1\",\n \"def removeNode(self, index):\\n del self.nodes[index]\",\n \"def EliminateSingleNodeSegments(self):\\n sections_to_remove = [] # List of indices into self._section_list\\n index = 0\\n for each_section in self._section_list:\\n if len(each_section.Nodes()) == 1:\\n self.ReparentSectionChildren(each_section)\\n sections_to_remove.append(index)\\n index += 1\\n sections_to_remove.reverse()\\n for each_index in sections_to_remove:\\n self._section_list.pop(each_index)\\n self.RegenerateCaches()\",\n \"def remove(self, block):\\n try:\\n self.blocks[block.height]\\n except:\\n raise ValueError(\\\"cant remove block: \\\" + str(block))\\n\\n removed = False\\n for b in self.blocks[block.height]:\\n # only delete the one with equal hash\\n if b.hash() == block.hash():\\n self.blocks[block.height].remove(b)\\n removed = True\\n if self.blocks[block.height] == []:\\n self.blocks.pop(block.height)\\n\\n if not removed:\\n raise ValueError(\\\"cant remove block: \\\" + str(block))\",\n \"def removeBlock(self, aBlock: gp.Block):\\n \\n for y, row in iter(self.blocks):\\n for x, block in iter(row):\\n if block is aBlock:\\n self.blocks[y][x] = None\\n self.playerSprites.remove(aBlock.sprite)\\n return\",\n \"def deleteAtIndex(self, index: int) -> None:\\n # if the index is invalid, do nothing\\n if index < 0 or index >= self.size:\\n return\\n \\n # find predecessor and successor of the node to be deleted\\n if index < self.size - index:\\n pred = self.head\\n for _ in range(index):\\n pred = pred.next\\n succ = pred.next.next\\n else:\\n succ = self.tail\\n for _ in range(self.size - index - 1):\\n succ = succ.prev\\n pred = succ.prev.prev\\n \\n # delete pred.next \\n self.size -= 1\\n pred.next = succ\\n succ.prev = pred\",\n \"def __delitem__(self, index: int) -> None:\\n del self._rows[index]\",\n \"def unblock_all(t):\\n blocked_count = 0\\n\\n while True:\\n blocked_user_ids = t.blocks.ids()[\\\"ids\\\"]\\n if not blocked_user_ids:\\n print(\\\"No more IDs to unblock\\\")\\n break\\n\\n for user_id in blocked_user_ids:\\n blocked_count = blocked_count + 1\\n print(f\\\"{blocked_count}: {user_id}\\\")\\n try:\\n t.blocks.destroy(user_id=user_id, include_entities=False, skip_status=True)\\n except:\\n print(\\\"error\\\")\",\n \"def remove_group(self, index):\\n group = self.get(index).group\\n for stone_index in group.members:\\n self.board[stone_index] = None\",\n \"def remove(self,index=0):\\n if index>self.size-1: raise IndexError(\\\"Index out of range.\\\")\\n elif self.size==1: self.reference=None\\n else:\\n pointer = self.reference\\n for i in range(index): pointer = pointer.next\\n pointer.previous.next, pointer.next.previous = pointer.next, pointer.previous\\n if index==0: self.reference=self.reference.next\\n self.size-=1\",\n \"def test_remove_blocks(tmp_path):\\n fn1 = tmp_path / \\\"test.asdf\\\"\\n fn2 = tmp_path / \\\"test2.asdf\\\"\\n\\n tree = {\\\"a\\\": np.zeros(3), \\\"b\\\": np.ones(1)}\\n af = asdf.AsdfFile(tree)\\n af.write_to(fn1)\\n\\n with asdf.open(fn1, mode=\\\"rw\\\") as af:\\n assert len(af._blocks._internal_blocks) == 2\\n af[\\\"a\\\"] = None\\n af.write_to(fn2)\\n\\n with asdf.open(fn1, mode=\\\"rw\\\") as af:\\n assert len(af._blocks._internal_blocks) == 2\\n af[\\\"a\\\"] = None\\n af.update()\\n\\n for fn in (fn1, fn2):\\n with asdf.open(fn) as af:\\n assert len(af._blocks._internal_blocks) == 1\",\n \"def purge(self,\\r\\n noterange=None):\\r\\n\\r\\n if noterange is None:\\r\\n noterange = [str(Index(a_temp))\\r\\n for a_temp\\r\\n in self.indexes()]\\r\\n for i_temp in [str(Index(n))\\r\\n for n in self.indexes()\\r\\n if Index(n) > Index(str(0))\\r\\n and str(Index(n)) in noterange]:\\r\\n if (len(str(self.get_keys_from_note(i_temp))) < 5\\r\\n and self.get_text_from_note(i_temp).replace(EOL,\\r\\n EMPTYCHAR).strip() == EMPTYCHAR):\\r\\n\\r\\n self.softdelete(i_temp)\",\n \"def __delitem__(self, index):\\n # delete the column\\n del self._data[index]\\n\\n # adjust the number of columns\\n self._nrows -= 1\",\n \"def delete_node_at_index(self, index):\\n if index < 0 or index >= self.size:\\n return\\n\\n curr = self.head\\n if index == 0:\\n self.head = curr.next\\n else:\\n for i in range(index - 1):\\n curr = curr.next\\n curr.next = curr.next.next\\n\\n self.size -= 1\",\n \"def delete_item(self, usage_locator, user_id, force=False): # lint-amnesty, pylint: disable=arguments-differ\\n if not isinstance(usage_locator, BlockUsageLocator) or usage_locator.deprecated:\\n # The supplied UsageKey is of the wrong type, so it can't possibly be stored in this modulestore.\\n raise ItemNotFoundError(usage_locator)\\n\\n with self.bulk_operations(usage_locator.course_key):\\n original_structure = self._lookup_course(usage_locator.course_key).structure\\n block_key = BlockKey.from_usage_key(usage_locator)\\n if original_structure['root'] == block_key:\\n raise ValueError(\\\"Cannot delete the root of a course\\\")\\n if block_key not in original_structure['blocks']:\\n raise ValueError(\\\"Cannot delete block_key {} from course {}, because that block does not exist.\\\".format(\\n block_key,\\n usage_locator,\\n ))\\n index_entry = self._get_index_if_valid(usage_locator.course_key, force)\\n new_structure = self.version_structure(usage_locator.course_key, original_structure, user_id)\\n new_blocks = new_structure['blocks']\\n new_id = new_structure['_id']\\n parent_block_keys = self._get_parents_from_structure(block_key, original_structure)\\n for parent_block_key in parent_block_keys:\\n parent_block = new_blocks[parent_block_key]\\n parent_block.fields['children'].remove(block_key)\\n parent_block.edit_info.edited_on = datetime.datetime.now(UTC)\\n parent_block.edit_info.edited_by = user_id\\n parent_block.edit_info.previous_version = parent_block.edit_info.update_version\\n parent_block.edit_info.update_version = new_id\\n # remove the source_version reference\\n parent_block.edit_info.source_version = None\\n self.decache_block(usage_locator.course_key, new_id, parent_block_key)\\n\\n self._remove_subtree(BlockKey.from_usage_key(usage_locator), new_blocks)\\n\\n # update index if appropriate and structures\\n self.update_structure(usage_locator.course_key, new_structure)\\n\\n if index_entry is not None:\\n # update the index entry if appropriate\\n self._update_head(usage_locator.course_key, index_entry, usage_locator.branch, new_id)\\n result = usage_locator.course_key.for_version(new_id)\\n else:\\n result = CourseLocator(version_guid=new_id)\\n\\n if isinstance(usage_locator.course_key, LibraryLocator):\\n self._flag_library_updated_event(usage_locator.course_key)\\n\\n self._emit_item_deleted_signal(usage_locator, user_id)\\n\\n return result\",\n \"def test_delete_complex_tree_04(comp):\\n comp.delete(13)\\n assert tuple(comp.in_order()) == (4, 6, 7, 8, 9, 10, 11, 12, 14, 15)\\n assert tuple(comp.breadth_first()) == (11, 8, 14, 6, 10, 12, 15, 4, 7, 9)\",\n \"def delete_at_index(self, idx):\\n del self.timeseries[idx]\\n del self.freq[idx]\\n del self.ch_name[idx]\\n del self.units[idx]\\n\\n if self.trigger_idx == idx:\\n LGR.warning(\\\"Removing trigger channel - are you sure you are doing\\\" \\\"the right thing?\\\")\\n self.trigger_idx = 0\",\n \"def delete_multiple(self, idxes, sort = True):\\n if(sort): idxes.sort() # inplace\\n # forced to loop but it's better than using np.remove which is not inplace.\\n for idx in np.flip(idxes): # view = constant time \\n self.arr[idx] = self.arr[self.current-1]\\n self.current -= 1\",\n \"def delete_note (self,\\r\\n index):\\r\\n\\r\\n if self.using_shelf:\\r\\n\\r\\n try:\\r\\n del self.note_dict[str(index)]\\r\\n except:\\r\\n display.noteprint((alerts.ATTENTION,alerts.DELETE+str(index)+alerts.FAILED))\\r\\n\\r\\n if self.using_database:\\r\\n aprint('DELETING NOTE')\\r\\n value_tuple = (notebookname,str(index),)\\r\\n db_cursor.execute(\\\"DELETE FROM \\\"\\r\\n +\\\"notes WHERE notebook=?\\\"\\r\\n +\\\" AND note_index=?;\\\",\\r\\n value_tuple)\\r\\n db_cursor.execute(\\\"DELETE FROM\\\"\\r\\n +\\\" all_note_keys\\\"\\r\\n +\\\" WHERE notebook=?\\\"\\r\\n +\\\" and note_index=?;\\\",\\r\\n value_tuple)\\r\\n db_cursor.execute(\\\"DELETE FROM\\\"\\r\\n +\\\" timestamps\\\"\\r\\n +\\\" WHERE notebook=?\\\"\\r\\n +\\\" and note_index=?;\\\",\\r\\n value_tuple)\\r\\n db_cursor.execute(\\\"SELECT note_index\\\"\\r\\n +\\\" FROM notes\\\"\\r\\n +\\\" WHERE notebook=?;\\\",\\r\\n (notebookname,))\",\n \"def delete(self, index):\\n if index == 0 and self.head is not None:\\n self.head = self.head.next\\n return\\n\\n current_index = 0\\n current = self.head\\n previous = None\\n\\n while current:\\n if current_index == index:\\n previous.next = current.next\\n\\n previous = current\\n current = current.next\\n current_index += 1\",\n \"def remove(self, block_hash: Sha256Hash) -> int:\\n\\n self.connection.log_trace(\\\"Purging block {} from queuing service.\\\", block_hash)\\n\\n index = self.remove_from_queue(block_hash)\\n if block_hash in self._blocks:\\n self._blocks.remove(block_hash)\\n return index\",\n \"def remove(self, tile_index: int) -> None:\\n octree_chunk = self._tiles[tile_index].octree_chunk\\n self._chunks.remove(octree_chunk)\\n del self._tiles[tile_index]\",\n \"def delete_index(self):\\n if self.index_module:\\n self.index_module = None\\n gc.collect()\",\n \"def validate_blocks():\\n # Validate the remesh blocks modifiers\\n bpy.ops.object.apply_all_modifiers()\\n \\n date_1 = datetime.datetime.now()\\n print(\\\"Start\\\")\\n \\n # Select the bottom faces\\n Button_Operations.select_faces(radians(10))\\n\\n # Extrude the support\\n bpy.ops.mesh.extrude_region_move(MESH_OT_extrude_region={\\\"use_normal_flip\\\":False, \\\"use_dissolve_ortho_edges\\\":False, \\\"mirror\\\":False}, TRANSFORM_OT_translate={\\\"value\\\":(0, 0, -20), \\\"orient_type\\\":'GLOBAL', \\\"orient_matrix\\\":((1, 0, 0), (0, 1, 0), (0, 0, 1)), \\\"orient_matrix_type\\\":'GLOBAL', \\\"constraint_axis\\\":(False, False, True), \\\"mirror\\\":False, \\\"use_proportional_edit\\\":False, \\\"proportional_edit_falloff\\\":'SMOOTH', \\\"proportional_size\\\":1, \\\"use_proportional_connected\\\":False, \\\"use_proportional_projected\\\":False, \\\"snap\\\":False, \\\"snap_target\\\":'CLOSEST', \\\"snap_point\\\":(0, 0, 0), \\\"snap_align\\\":False, \\\"snap_normal\\\":(0, 0, 0), \\\"gpencil_strokes\\\":False, \\\"cursor_transform\\\":False, \\\"texture_space\\\":False, \\\"remove_on_cancel\\\":False, \\\"release_confirm\\\":False, \\\"use_accurate\\\":False, \\\"use_automerge_and_split\\\":False})\\n\\n # Select all\\n bpy.ops.mesh.select_all(action='SELECT')\\n\\n # Bissect and delete the element under the xy plane\\n bpy.ops.mesh.bisect(plane_co=(0, 0, 0.01), plane_no=(0, 0, 1), use_fill=False, clear_inner=True, xstart=942, xend=1489, ystart=872, yend=874, flip=False) \\n\\n # Fill the hole and triangulate faces\\n Button_Operations.manifold_and_triangulate()\\n \\n # Delete the copy\\n object_to_delete = bpy.data.objects[\\\"temp_copy\\\"]\\n bpy.data.objects.remove(object_to_delete, do_unlink=True) \\n \\n # Switch in object mode \\n bpy.ops.object.mode_set(mode='OBJECT')\",\n \"def removeRows(self, position, rows=1, index:QtCore.QModelIndex=QtCore.QModelIndex()):\\n self.beginRemoveRows(QtCore.QModelIndex(), position, position + rows - 1)\\n\\n del self.__checknode.params[position:position + rows]\\n self.__checknode._commit()\\n\\n self.endRemoveRows()\\n return True\",\n \"def removeRows(self, position, rows=1, index:QtCore.QModelIndex=QtCore.QModelIndex()):\\n self.beginRemoveRows(QtCore.QModelIndex(), position, position + rows - 1)\\n\\n del self.__checknode.params[position:position + rows]\\n self.__checknode._commit()\\n\\n self.endRemoveRows()\\n return True\",\n \"def test_delete_complex_tree_05(comp):\\n comp.delete(8)\\n assert tuple(comp.in_order()) == (4, 6, 7, 9, 10, 11, 12, 13, 14, 15)\\n assert tuple(comp.breadth_first()) == (11, 9, 13, 6, 10, 12, 14, 4, 7, 15)\",\n \"def remove_from_queue(self, block_hash: Sha256Hash) -> int:\\n if block_hash not in self._blocks:\\n return -1\\n\\n self.connection.log_trace(\\\"Removing block {} from queue.\\\", block_hash)\\n\\n for index in range(len(self._block_queue)):\\n if self._block_queue[index][0] == block_hash:\\n del self._block_queue[index]\\n del self._blocks_waiting_for_recovery[block_hash]\\n\\n return index\\n\\n return -1\",\n \"def delete_item(self, usage_locator, user_id, delete_all_versions=False, delete_children=False, force=False):\\r\\n assert isinstance(usage_locator, BlockUsageLocator)\\r\\n original_structure = self._lookup_course(usage_locator.course_key)['structure']\\r\\n if original_structure['root'] == usage_locator.block_id:\\r\\n raise ValueError(\\\"Cannot delete the root of a course\\\")\\r\\n index_entry = self._get_index_if_valid(usage_locator, force)\\r\\n new_structure = self._version_structure(original_structure, user_id)\\r\\n new_blocks = new_structure['blocks']\\r\\n new_id = new_structure['_id']\\r\\n parents = self.get_parent_locations(usage_locator)\\r\\n for parent in parents:\\r\\n encoded_block_id = LocMapperStore.encode_key_for_mongo(parent.block_id)\\r\\n parent_block = new_blocks[encoded_block_id]\\r\\n parent_block['fields']['children'].remove(usage_locator.block_id)\\r\\n parent_block['edit_info']['edited_on'] = datetime.datetime.now(UTC)\\r\\n parent_block['edit_info']['edited_by'] = user_id\\r\\n parent_block['edit_info']['previous_version'] = parent_block['edit_info']['update_version']\\r\\n parent_block['edit_info']['update_version'] = new_id\\r\\n\\r\\n def remove_subtree(block_id):\\r\\n \\\"\\\"\\\"\\r\\n Remove the subtree rooted at block_id\\r\\n \\\"\\\"\\\"\\r\\n encoded_block_id = LocMapperStore.encode_key_for_mongo(block_id)\\r\\n for child in new_blocks[encoded_block_id]['fields'].get('children', []):\\r\\n remove_subtree(child)\\r\\n del new_blocks[encoded_block_id]\\r\\n if delete_children:\\r\\n remove_subtree(usage_locator.block_id)\\r\\n else:\\r\\n del new_blocks[LocMapperStore.encode_key_for_mongo(usage_locator.block_id)]\\r\\n\\r\\n # update index if appropriate and structures\\r\\n self.db_connection.insert_structure(new_structure)\\r\\n\\r\\n if index_entry is not None:\\r\\n # update the index entry if appropriate\\r\\n self._update_head(index_entry, usage_locator.branch, new_id)\\r\\n result = usage_locator.course_key.for_version(new_id)\\r\\n else:\\r\\n result = CourseLocator(version_guid=new_id)\\r\\n\\r\\n return result\",\n \"def clear_blockages(self):\\n debug.info(3,\\\"Clearing all blockages\\\")\\n self.rg.clear_blockages()\",\n \"def delete_element(some_list, index):\\n del some_list[index]\\n return some_list\",\n \"def delete(data, index):\\n return data[:index] + data[index + 1:]\",\n \"def clear_row_proportion(self, index):\\n\\n if index in self._proportions[1]:\\n del self._proportions[1][index]\",\n \"def delete_all(self, n):\\n for i in range(n):\\n try:\\n del self.dictionary[i]\\n except KeyError:\\n continue\",\n \"def test_removing_index(self):\",\n \"def remove_card(self, card_idx: int) -> None:\",\n \"def remove(self, index):\\n raise NotImplementedError()\",\n \"def building_remove(self, pos):\\n x, y = pos\\n step = self.bmap_step[y,x]\\n\\n if step == 0:\\n return\\n\\n for x in range(0,AIV_SIZE):\\n for y in range(0,AIV_SIZE):\\n if (self.bmap_step[y,x] == step):\\n self.bmap_step[y,x] = 0\\n self.bmap_id[y,x] = 0\\n self.bmap_size[y,x] = 0\\n self.bmap_tile[y,x] = 0\\n\\n self.step_cur -= 1\\n self.step_tot -= 1\",\n \"def del_row(self, index):\\n self.data.remove(self.data[index])\",\n \"def remove_from_block(self):\\n self.enclosing_block.remove_ops([self])\",\n \"def test_delete_complex_tree_03(comp):\\n comp.delete(15)\\n assert tuple(comp.in_order()) == (4, 6, 7, 8, 9, 10, 11, 12, 13, 14)\\n assert tuple(comp.breadth_first()) == (11, 8, 13, 6, 10, 12, 14, 4, 7, 9)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71626973","0.68964684","0.62942344","0.625104","0.6132582","0.60548794","0.6051101","0.6042633","0.6016819","0.59291697","0.5908609","0.5838923","0.58307886","0.5816913","0.581112","0.5768777","0.5763255","0.5763255","0.5733283","0.5707062","0.5648815","0.56354","0.56125766","0.55805343","0.5572833","0.55726266","0.5569428","0.5552028","0.5534134","0.55320615","0.5512091","0.55040026","0.5491614","0.5490816","0.5488661","0.5484041","0.54775816","0.54753804","0.54690546","0.54689443","0.54640675","0.5454086","0.5453793","0.5449532","0.5445124","0.54373956","0.5406808","0.54033756","0.5395242","0.5391256","0.5384345","0.5380503","0.5374818","0.53693485","0.5368546","0.5368021","0.5356838","0.5346685","0.53244424","0.5323082","0.5313019","0.5308175","0.5304608","0.5289958","0.5287087","0.52815115","0.52760905","0.5272224","0.5270245","0.52652484","0.5248083","0.52365255","0.51967543","0.5193271","0.5184798","0.5175853","0.51728284","0.5162162","0.51592344","0.51553017","0.5151692","0.5146179","0.5145435","0.51450276","0.51450276","0.5142192","0.5137166","0.5134081","0.51295465","0.51291734","0.51278985","0.5126065","0.51240164","0.5115276","0.5110748","0.5108855","0.5104005","0.5101208","0.50921327","0.5082959"],"string":"[\n \"0.71626973\",\n \"0.68964684\",\n \"0.62942344\",\n \"0.625104\",\n \"0.6132582\",\n \"0.60548794\",\n \"0.6051101\",\n \"0.6042633\",\n \"0.6016819\",\n \"0.59291697\",\n \"0.5908609\",\n \"0.5838923\",\n \"0.58307886\",\n \"0.5816913\",\n \"0.581112\",\n \"0.5768777\",\n \"0.5763255\",\n \"0.5763255\",\n \"0.5733283\",\n \"0.5707062\",\n \"0.5648815\",\n \"0.56354\",\n \"0.56125766\",\n \"0.55805343\",\n \"0.5572833\",\n \"0.55726266\",\n \"0.5569428\",\n \"0.5552028\",\n \"0.5534134\",\n \"0.55320615\",\n \"0.5512091\",\n \"0.55040026\",\n \"0.5491614\",\n \"0.5490816\",\n \"0.5488661\",\n \"0.5484041\",\n \"0.54775816\",\n \"0.54753804\",\n \"0.54690546\",\n \"0.54689443\",\n \"0.54640675\",\n \"0.5454086\",\n \"0.5453793\",\n \"0.5449532\",\n \"0.5445124\",\n \"0.54373956\",\n \"0.5406808\",\n \"0.54033756\",\n \"0.5395242\",\n \"0.5391256\",\n \"0.5384345\",\n \"0.5380503\",\n \"0.5374818\",\n \"0.53693485\",\n \"0.5368546\",\n \"0.5368021\",\n \"0.5356838\",\n \"0.5346685\",\n \"0.53244424\",\n \"0.5323082\",\n \"0.5313019\",\n \"0.5308175\",\n \"0.5304608\",\n \"0.5289958\",\n \"0.5287087\",\n \"0.52815115\",\n \"0.52760905\",\n \"0.5272224\",\n \"0.5270245\",\n \"0.52652484\",\n \"0.5248083\",\n \"0.52365255\",\n \"0.51967543\",\n \"0.5193271\",\n \"0.5184798\",\n \"0.5175853\",\n \"0.51728284\",\n \"0.5162162\",\n \"0.51592344\",\n \"0.51553017\",\n \"0.5151692\",\n \"0.5146179\",\n \"0.5145435\",\n \"0.51450276\",\n \"0.51450276\",\n \"0.5142192\",\n \"0.5137166\",\n \"0.5134081\",\n \"0.51295465\",\n \"0.51291734\",\n \"0.51278985\",\n \"0.5126065\",\n \"0.51240164\",\n \"0.5115276\",\n \"0.5110748\",\n \"0.5108855\",\n \"0.5104005\",\n \"0.5101208\",\n \"0.50921327\",\n \"0.5082959\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8000275"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74280,"cells":{"query":{"kind":"string","value":"Replaces a block in the proof. The new block has the same interlink but different header hash"},"document":{"kind":"string","value":"def replace_block(proof, headers_map, interlink_map, block_index):\n\n prevous_block = proof[block_index - 1][0]\n block_hash = prevous_block[36:68]\n block = headers_map[block_hash]\n interlink = list_flatten(interlink_map[block.GetHash()])\n\n block_2 = mine_block(\n block.hashPrevBlock, block.nBits - 1, interlink, hashMerkleRoot=b\"\\x00\" * 32\n )\n return (\n proof[0:block_index]\n + [[block_2.serialize(), proof[block_index][1]]]\n + proof[block_index + 1 :]\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 change_interlink_hash(proof, block_index):\n\n block_of_interest = proof[block_index][0]\n changed_block = swap_byte(block_of_interest, 0)\n changed_proof = (\n proof[0:block_index]\n + [(changed_block, proof[block_index][1])]\n + proof[block_index + 1 :]\n )\n return changed_proof","def replace_blocks(self, block_id, replace_id):\n compatible = block_config[block_id].block_style == block_config[replace_id].block_style\n replace = Replace(self.smd3.get_block_list())\n replace.replace_blocks(block_id, replace_id, compatible)\n self.header.update(self.smd3)","def replace_blocks_hull(self, new_hull_type, hull_type=None):\n replace = Replace(self.smd3.get_block_list())\n replace.replace_hull(new_hull_type, hull_type)\n self.header.update(self.smd3)","def new_block(self, proof, previous_hash=None):\n\n # Create the block\n my_block = Block(proof=proof,\n previous_hash=previous_hash or self.hash(self.last_block))\n my_block.save()\n\n # Update current_transactions with this new block.\n my_block_trans = self.current_transactions_obj\n\n for trans in Transaction.objects.filter(block__isnull=True):\n trans.block = my_block\n trans.save()\n\n block = {\n 'index': my_block.id,\n 'timestamp': my_block.timestamp,\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\n 'proof': my_block.proof,\n 'previous_hash': my_block.previous_hash,\n }\n\n return block","def _adjustBlock(self, b):\n raise NotImplementedError","def new_block(self, proof, previous_hash=None):\n \n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n\n # Reset the current list of transactions\n self.current_transactions = []\n # Add block to existing chain\n self.chain.append(block)\n return block","def _update_block_in_structure(self, structure, block_key, content):\n structure['blocks'][block_key] = content","def new_block(self, proof, previous_hash=None):\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions':self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n self.current_transactions = []\n self.chain.append(block)\n return block","def update_recovered_block(\n self, block_hash: Sha256Hash, block_msg: TBlockMessage\n ) -> None:\n pass","def new_block(self, proof, previous_hash = None):\n #create a new Block & adds it to the chain.\n \n block = {\n 'index' : len(self.chain) + 1,\n 'timestamp' : time(),\n 'transactions' : self.pending_transactions,\n 'proof' : proof,\n 'previous_hash' : previous_hash or self.hash(self.chain[-1])\n }\n\n # Reset the current list of transactions\n self.pending_transactions = []\n\n self.chain.append(block)\n return block\n #pass","def _set_block(self, pos, block_):\n self._changes[deepcopy(pos)] = block","def changed_block(self, old_block, new_block):","def new_block(self, proof, previous_hash=None):\r\n block = {\r\n 'index': len(self.chain) + 1,\r\n 'timestamp': time(),\r\n 'transactions': self.current_transactions,\r\n 'proof': proof,\r\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\r\n }\r\n\r\n # reseta a atual lista de transacoes\r\n self.current_transactions = []\r\n\r\n self.chain.append(block)\r\n return block","def _set_block(self, pos, block_):\n raise NotImplementedError","def new_block(self, proof, previous_hash=None):\n\n\t\tblock = {\n\t\t\t'index': len(self.chain) + 1,\n\t\t\t'timestamp': time(),\n\t\t\t'transactions': self.current_transactions,\n\t\t\t'proof': proof,\n\t\t\t'previous_hash': previous_hash or self.hash(self.chain[-1]),\t\t\n\t\t}\n\n\t\t#Reset current list of transactions\n\t\tself.current_transactions = []\n\n\t\tself.chain.append(block)\n\t\treturn block","def reconsiderblock(self, block_hash: str) -> None:\n return self.rpc_call(\"reconsiderblock\", block_hash)","def _update_block_in_structure(self, structure, block_id, content):\r\n structure['blocks'][LocMapperStore.encode_key_for_mongo(block_id)] = content","def new_block(self, proof, previous_hash=None):\n servers = [\n \"1.us.pool.ntp.org\",\n \"2.us.pool.ntp.org\",\n \"3.us.pool.ntp.org\"\n ]\n\n response = {}\n\n try:\n response = self.c.request('0.us.pool.ntp.org')\n except Exception:\n for server in servers:\n try:\n response = self.c.request(server)\n\n if response:\n break\n\n except Exception:\n print('\\n //// alternate ntp server didnt work')\n\n block = {\n 'message': 'New Block Forged',\n 'index': len(self.chain) + 1,\n 'timestamp': response.tx_time or time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.chain[-1]['hash'],\n }\n\n # Calculate the hash of this new Block\n block['hash'] = self.hash(block)\n\n # Reset the current list of transactions\n self.current_transactions = []\n\n self.chain.append(block)\n return block","def new_block(self, proof, previous_hash=None):\n block = {\n 'index': len( self.chain ) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'merkle': self.hash(self.current_transactions),\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1])\n }\n\n # Reset the current list of transactions\n self.current_transactions = []\n\n # Add the block to the chain\n self.chain.append( block )\n self._write_chain()\n\n return block","def add_block(self, block, proof):\n # print(block.__dict__)\n try:\n previous_hash = self.last_block.hash\n except AttributeError:\n previous_hash = block.previous_hash\n\n if previous_hash != block.previous_hash:\n print(\"Hashes don't match\\n{}\\n{}\".format(previous_hash, block.previous_hash))\n return False\n\n if not self.is_valid_proof(block, proof):\n print(\"block is not valid\")\n return False\n\n block.hash = proof\n self.chain.append(block)\n return True","def add_block(self, block, proof):\n previous_hash = self.last_block.hash\n\n if previous_hash != block.previous_hash:\n print('Previous hash is not matched.')\n return False\n\n if not Blockchain.is_valid_proof(block, proof):\n print('Proof is not valid.')\n return False\n\n block.hash = proof\n self.chain.append(block)\n return True","def _initBlock(o,block):\n o.block = block.clone().shift(*o.board.startPosition)","def add_block(self, block, proof):\r\n previous_hash = self.last_block.hash\r\n if previous_hash != block.previous_hash:\r\n return False\r\n if not self.is_valid_proof(block, proof):\r\n return False\r\n block.hash = proof\r\n self.chain.append(block)\r\n return True","def add_new_block(self):\n old_block = self.curr_block\n self.curr_block = self.gen_new_block()\n add_edge(old_block, self.curr_block)","def add_block(self, block, proof):\n previous_hash = self.last_block.hash\n \n if previous_hash != block.previous: \n return False\n \n if not Blockchain.is_valid_proof(block, proof):\n return False\n \n block.hash = proof \n self.chain.append(block)\n return True","def sed(self, search, replace):\n\n for section in self.sections:\n for i, block in enumerate(section.blocks):\n if block == search:\n section.blocks[i] = replace\n self.all_damaged = True\n self.dirty = True","async def refresh(self):\n block = await self.blockchain.rpc.get_block_header(self.identifier)\n if not block:\n raise BlockDoesNotExistsException\n await super(BlockHeader, self).__init__(\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\n )","def mine(self):\n last_block = self.chain[-1]\n\n nonce = self.proof_of_work()\n previous_hash = self.hash(last_block)\n self.create_block(nonce, previous_hash)","def add_partial_decryption_block(self, block):\n\t\tself._blocks.append(block)","def update_pre_block(pre_block):\r\n updated_block=\"\";\r\n count=0;\r\n for line in pre_block.splitlines():\r\n count+=1;\r\n if count<len(pre_block.splitlines()):\r\n line=update_line(line)+\"\\n\";\r\n updated_block=updated_block+line;\r\n else:\r\n line=update_line(line);\r\n updated_block=updated_block+line;\r\n return updated_block","def replaceChain(self, newbc):\n if (Blockchain.validChain(newbc) == False):\n print(\"New Blockchain is invalid\")\n return\n elif (len(newbc.chain) < len(self.chain)):\n print(\"Not enough blocks on new Blockchain\")\n return\n \n print(\"Updating blockchain to newest version\")\n self.chain = newbc","def test_update_manifold(self):\r\n locator = BlockUsageLocator(\r\n CourseLocator('testx', 'GreekHero', branch='draft'),\r\n 'problem', block_id='problem1'\r\n )\r\n original = modulestore().get_item(locator)\r\n # first add 2 children to the course for the update to manipulate\r\n locator = BlockUsageLocator(\r\n CourseLocator('guestx', 'contender', branch='draft'),\r\n 'course', block_id=\"head345679\"\r\n )\r\n category = 'problem'\r\n new_payload = \"<problem>empty</problem>\"\r\n modulestore().create_item(\r\n locator, category, 'test_update_manifold',\r\n fields={'display_name': 'problem 1', 'data': new_payload},\r\n )\r\n another_payload = \"<problem>not empty</problem>\"\r\n modulestore().create_item(\r\n locator, category, 'test_update_manifold',\r\n fields={'display_name': 'problem 2', 'data': another_payload},\r\n definition_locator=original.definition_locator,\r\n )\r\n # pylint: disable=W0212\r\n modulestore()._clear_cache()\r\n\r\n # now begin the test\r\n block = modulestore().get_item(locator)\r\n pre_def_id = block.definition_locator.definition_id\r\n pre_version_guid = block.location.version_guid\r\n\r\n self.assertNotEqual(block.grading_policy['GRADER'][0]['min_count'], 13)\r\n block.grading_policy['GRADER'][0]['min_count'] = 13\r\n block.children = block.children[1:] + [block.children[0]]\r\n block.advertised_start = \"Soon\"\r\n\r\n block.save() # decache model changes\r\n updated_block = modulestore().update_item(block, \"**replace_user**\")\r\n self.assertNotEqual(updated_block.definition_locator.definition_id, pre_def_id)\r\n self.assertNotEqual(updated_block.location.version_guid, pre_version_guid)\r\n self.assertEqual(updated_block.grading_policy['GRADER'][0]['min_count'], 13)\r\n self.assertEqual(updated_block.children[0].version_agnostic(), block.children[0].version_agnostic())\r\n self.assertEqual(updated_block.advertised_start, \"Soon\")","def remove_block(self, block):\n raise NotImplementedError()","def updateBlock(self):\n self.blkno = self.blknoSpinBox.value() - 1\n self.initDataParms()\n self.updateCurveList()\n self.compute()","def _maskhg19(self):\n if len(self._current_block) > 2:\n self._current_block[0].text = self._current_block[1].text\n self._current_block[0].size = self._current_block[1].size\n self._current_block[0].setstring()\n self._current_block.remove(self._current_block[1])\n else:\n self._current_block = []","def addBlock(self, newBlock):\n newBlock.index = len(self.chain)\n newBlock.previousHash = self.chain[-1].hash\n newBlock.mineBlock(self.difficulty)\n self.chain.append(newBlock)\n self.writeBlocks()","def erase_block(self):\n self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]] = '0'","def test_replace_chain_keep_original(self):\n import copy\n miner_address = 'miner_address'\n\n blockchain1 = Blockchain()\n blockchain1.mine(miner_address)\n\n blockchain2 = copy.deepcopy(blockchain1)\n blockchain1.mine(miner_address)\n\n # Now let's make sure that each blockchain has its own number of blocks\n self.assertEqual(3, len(blockchain1.full_chain))\n self.assertEqual(2, len(blockchain2.full_chain))\n\n # Then let's replace blockchain1 with blockchain2\n blockchain1.replace_chain(blockchain2.full_chain)\n\n self.assertEqual(3, len(blockchain1.full_chain))\n self.assertEqual(2, len(blockchain2.full_chain))","def assert_block_does_not_change(\n block_type: str, middleware: Middleware, same_instance: Optional[bool]\n):\n block_type = block_type.lower()\n if block_type == \"preamble\":\n block = Preamble(\n start_line=5, raw=\"@Preamble{a_x + b_x^2}\", value=\"a_x + b_x^2\"\n )\n elif block_type == \"implicit_comment\":\n block = ImplicitComment(start_line=5, raw=\"# MyComment\", comment=\"MyComment\")\n elif block_type == \"explicit_comment\":\n block = ExplicitComment(\n start_line=5, raw=\"@Comment{MyComment}\", comment=\"MyComment\"\n )\n else:\n raise ValueError(\"block type not yet supported in test utility\")\n\n block_copy = deepcopy(block)\n\n transformed_library = middleware.transform(library=Library([block]))\n\n # Assert correct library state\n assert len(transformed_library.blocks) == 1\n assert transformed_library.blocks[0] == block_copy\n if same_instance:\n assert transformed_library.blocks[0] is block\n elif not same_instance:\n assert transformed_library.blocks[0] is not block","def test_replace_chain(self):\n import copy\n miner_address = 'miner_address'\n\n blockchain1 = Blockchain()\n blockchain1.mine(miner_address)\n\n blockchain2 = copy.deepcopy(blockchain1)\n blockchain2.mine(miner_address)\n\n # Now let's make sure that each blockchain has its own number of blocks\n self.assertEqual(2, len(blockchain1.full_chain))\n self.assertEqual(3, len(blockchain2.full_chain))\n\n # Then let's replace blockchain1 with blockchain2\n blockchain1.replace_chain(blockchain2.full_chain)\n\n self.assertEqual(3, len(blockchain1.full_chain))\n self.assertEqual(3, len(blockchain2.full_chain))\n self.assertEqual(blockchain1.last_block.hash, blockchain2.last_block.hash)","def newBlock(preBlock, remitter, number, payee):\r\n index = preBlock.index + 1\r\n timestamp = int(round(time.time() * 1000))\r\n data = (remitter, number, payee).__str__()\r\n previousHash = preBlock.hash\r\n nounce = 0\r\n return Blockchain(index, data, timestamp, nounce, previousHash)","def add_block(self, block, proof):\n previous_hash = self.last_block.hash\n\n if previous_hash != block.previous_hash:\n return False\n\n if not Blockchain.is_valid_proof(block, proof):\n return False\n\n block.hash = proof\n self.chain.append(block)\n return True","def new_block(self, previous_hash):\n\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'information': self.current_information,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n\n # Reset the current list of transactions\n self.current_information = []\n\n self.chain.append(block)\n return block","def refresh(self):\n block = self.graphene.rpc.get_block(self.block)\n if not block:\n raise BlockDoesNotExistsException\n super(Block, self).__init__(block)\n self.cached = True","def create_block(self, proof, previous_hash=None):\n\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash,\n }\n\n # Reset current list of transactions\n self.current_transactions = []\n\n self.chain.append(block)\n return block","def mine(self):\n new_block = Block(self.block['timestamp'], self.block['car'],\n self.block['id'])\n # link the block to the previous block\n new_block.previous_hash = self._get_previous_hash()\n while True:\n # get a hash\n new_hash = new_block.get_hash()\n # check hash rules, in our case check if the hash starts with\n # self.difficulty number of zeroes\n if new_hash[0] != self.difficulty * \"0\":\n if self.new_block[\"block\"] is None:\n # the hash hasn't been found yet by any other process,\n # therefore increase the nonce and continue\n # miners will use a different mining mechanism in order\n # to increase the probability of finding a hash by\n # a different miner\n new_block.increment_nonce(self.id + 1)\n continue\n break\n break\n\n # NOTE: May happen that two processes find the hash at the same time,\n # because there is not a big difficulty, however, it's not a problem,\n # for sake of the demo it's fine\n\n if self.new_block[\"block\"] is None:\n # this process has found the hash first\n print(self.id, \" - the winner hash\", new_hash)\n new_block.hash = new_hash\n self.new_block[\"block\"] = new_block\n print(self.id, \" - mined the block\")\n else:\n # validate the block found by other process (miner)\n if self.new_block[\"validated\"] is not False:\n print(self.id, \" - validating\")\n # check block's validity\n valid = False\n if self.new_block[\"block\"].is_block_valid():\n # check blockchain's validity when we apply the newly\n # mined block\n if self.is_blockchain_valid(self.new_block[\"block\"]):\n valid = True\n self.new_block[\"validated\"] = valid\n else:\n # NOTE: this demo doesn't take into account the number of\n # miners who approved the block, the block will be rejected\n # if any of them rejected it\n # but usually just more than 50% of miners must approve\n print(self.id, \" - the block has been rejected by other miner\")","def _patch_phis(self, ops, oldblock, newblock):\n for op in ops:\n for use in self.func.uses[op]:\n if use.opcode == 'phi':\n # Update predecessor blocks\n preds, vals = use.args\n preds = [newblock if pred == oldblock else pred\n for pred in preds]\n use.set_args([preds, vals])","def put_block(self):\n self.blocks[self.editor_cursor_position[1]][\n self.editor_cursor_position[0]] = self.available_block_types[self.current_block_type]","def rename_all_blocks(hpo_data, cyto_bed, block_prefix):\n\n for hpo, hdat in hpo_data.items():\n\n block_dict = {bid : bd['credset_bt'] for bid, bd in hdat['blocks'].items()}\n\n rename_dict = rename_blocks(block_dict, cyto_bed, '_'.join([hpo, block_prefix]))\n\n for old_id, new_id in rename_dict.items():\n hpo_data[hpo]['blocks'][new_id] = hpo_data[hpo]['blocks'][old_id]\n hpo_data[hpo]['blocks'].pop(old_id)\n \n return hpo_data","def _create_block(\n self,\n test_constants: Dict,\n challenge_hash: bytes32,\n height: uint32,\n prev_header_hash: bytes32,\n prev_iters: uint64,\n prev_weight: uint64,\n timestamp: uint64,\n difficulty: uint64,\n ips: uint64,\n seed: bytes,\n ) -> FullBlock:\n prover = None\n plot_pk = None\n plot_sk = None\n qualities: List[bytes] = []\n for pn in range(num_plots):\n # Allow passing in seed, to create reorgs and different chains\n seeded_pn = (pn + 17 * int.from_bytes(seed, \"big\")) % num_plots\n filename = self.filenames[seeded_pn]\n plot_pk = plot_pks[seeded_pn]\n plot_sk = plot_sks[seeded_pn]\n prover = DiskProver(os.path.join(self.plot_dir, filename))\n qualities = prover.get_qualities_for_challenge(challenge_hash)\n if len(qualities) > 0:\n break\n\n assert prover\n assert plot_pk\n assert plot_sk\n if len(qualities) == 0:\n raise NoProofsOfSpaceFound(\"No proofs for this challenge\")\n\n proof_xs: bytes = prover.get_full_proof(challenge_hash, 0)\n proof_of_space: ProofOfSpace = ProofOfSpace(\n challenge_hash, pool_pk, plot_pk, k, [uint8(b) for b in proof_xs]\n )\n number_iters: uint64 = pot_iterations.calculate_iterations(\n proof_of_space, difficulty, ips, test_constants[\"MIN_BLOCK_TIME\"]\n )\n\n disc: int = create_discriminant(\n challenge_hash, test_constants[\"DISCRIMINANT_SIZE_BITS\"]\n )\n start_x: ClassGroup = ClassGroup.from_ab_discriminant(2, 1, disc)\n y_cl, proof_bytes = create_proof_of_time_nwesolowski(\n disc, start_x, number_iters, disc, n_wesolowski\n )\n\n output = ClassgroupElement(y_cl[0], y_cl[1])\n\n proof_of_time = ProofOfTime(\n challenge_hash,\n number_iters,\n output,\n n_wesolowski,\n [uint8(b) for b in proof_bytes],\n )\n\n coinbase: CoinbaseInfo = CoinbaseInfo(\n height,\n block_rewards.calculate_block_reward(uint32(height)),\n coinbase_target,\n )\n coinbase_sig: PrependSignature = pool_sk.sign_prepend(bytes(coinbase))\n fees_target: FeesTarget = FeesTarget(fee_target, uint64(0))\n solutions_generator: bytes32 = sha256(seed).digest()\n cost = uint64(0)\n body: Body = Body(\n coinbase, coinbase_sig, fees_target, None, solutions_generator, cost\n )\n\n header_data: HeaderData = HeaderData(\n prev_header_hash,\n timestamp,\n bytes([0] * 32),\n proof_of_space.get_hash(),\n body.get_hash(),\n bytes([0] * 32),\n )\n\n header_hash_sig: PrependSignature = plot_sk.sign_prepend(header_data.get_hash())\n\n header: Header = Header(header_data, header_hash_sig)\n\n challenge = Challenge(\n challenge_hash,\n proof_of_space.get_hash(),\n proof_of_time.get_hash(),\n height,\n uint64(prev_weight + difficulty),\n uint64(prev_iters + number_iters),\n )\n header_block = HeaderBlock(proof_of_space, proof_of_time, challenge, header)\n\n full_block: FullBlock = FullBlock(header_block, body)\n\n return full_block","def delete_block(self, block):\n raise NotImplementedError('delete_block')","def block_seen(self):\n self.blocklist.update(self.mapping.values())\n self.mapping = dict()","def add_block(self, block):\n # Create a list of transaction objects\n transactions = [Transaction(\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']] \n chipsactions = [Chipsaction(\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']] \n messsactions = [Messsaction(\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']] \n # Validate the proof of work of the block and store the result (True or False) in a variable\n proof_is_valid = Verification.valid_proof(\n transactions[:-1], chipsactions, messsactions, block['previous_hash'], block['proof'])\n # Check if previous_hash stored in the block is equal to the local blockchain's last block's hash and store the result in a block\n hashes_match = hash_block(self.chain[-1]) == block['previous_hash']\n if not proof_is_valid or not hashes_match:\n return False\n # Create a Block object\n converted_block = Block(\n block['index'], block['previous_hash'], transactions, chipsactions, messsactions, block['proof'], block['timestamp'])\n self.__chain.append(converted_block)\n stored_transactions = self.__open_transactions[:]\n stored_chipsactions = self.__open_chipsactions[:]\n stored_messsactions = self.__open_messsactions[:]\n # Check which open transactions were included in the received block and remove them\n # This could be improved by giving each transaction an ID that would uniquely identify it\n for itx in block['transactions']:\n for opentx in stored_transactions:\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\n try:\n self.__open_transactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n\n for itx in block['chipsactions']:\n for opentx in stored_chipsactions:\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.sender == itx['follow'] and opentx.recipient == itx['message'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\n try:\n self.__open_chipsactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n for itx in block['messsactions']:\n for opentx in stored_messsactions:\n if opentx.sender == itx['sender'] and opentx.sender == itx['follower'] and opentx.recipient == itx['message'] and opentx.signature == itx['signature']:\n try:\n self.__open_messsactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n self.save_data()\n return True","def finalize_block_construction(self, pyomo_block):\n pass","def _new_block(self, user_id, category, block_fields, definition_id, new_id, raw=False):\r\n if not raw:\r\n block_fields = self._serialize_fields(category, block_fields)\r\n return {\r\n 'category': category,\r\n 'definition': definition_id,\r\n 'fields': block_fields,\r\n 'edit_info': {\r\n 'edited_on': datetime.datetime.now(UTC),\r\n 'edited_by': user_id,\r\n 'previous_version': None,\r\n 'update_version': new_id\r\n }\r\n }","def forge_block(offset, plaintext, oracle):\n b_size, _, _ = challenge_12.determine_block_stats(oracle)\n new_padding = b\"A\" * (b_size - offset)\n payload = new_padding + challenge_09.pkcs7(plaintext, b_size)\n ciphertext = oracle(payload)\n\n return challenge_07.as_blocks(ciphertext, b_size)[1]","def commit_block(self, block):\n raise NotImplementedError('commit_block: Implementation of this method is required.')","def _setBlock(o,block):\n o.board.add(block)\n o._cachedShadow = None\n clearedLines = o.board.clearLines()\n o.lines += clearedLines\n if clearedLines > 0 and o.onClearLines is not None:\n o.onClearLines(clearedLines)\n o.board.addRows(o.penalty)\n o.penalty = 0\n o._initBlock(o.queue.pop())\n if o.lines >= o.level*10: o.level+=1\n o.canHold = True\n isGameOver = all(sq.y >= o.board.height for sq in block) \\\n or any(o.board[sq.x,sq.y] != None for sq in o.block)\n if isGameOver and o.onGameOver: o.onGameOver(o)","def version_block(self, block_data, user_id, update_version):\n if block_data.edit_info.update_version == update_version:\n return\n\n original_usage = block_data.edit_info.original_usage\n original_usage_version = block_data.edit_info.original_usage_version\n block_data.edit_info.edited_on = datetime.datetime.now(UTC)\n block_data.edit_info.edited_by = user_id\n block_data.edit_info.previous_version = block_data.edit_info.update_version\n block_data.edit_info.update_version = update_version\n if original_usage:\n block_data.edit_info.original_usage = original_usage\n block_data.edit_info.original_usage_version = original_usage_version","async def refresh(self):\n block = await self.blockchain.rpc.get_block(self.identifier)\n if not block:\n raise BlockDoesNotExistsException\n await super(Block, self).__init__(\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\n )","def blockMirror_create(self, forceNew = False):\n try:\n _str_func = 'blockMirror_create'\n _side = get_sideMirror(self)\n _blockType = self.blockType\n if not _side:\n log.error(\"|{0}| >> Block is not sided. Can't create mirror\".format(_str_func, self.mNode)) \n return False\n \n if self.getMessage('blockMirror'):\n mMirror = self.blockMirror\n log.debug(\"|{0}| >> blockMirror found {1} \".format(_str_func, mMirror))\n if not forceNew:\n return mMirror\n log.debug(\"|{0}| >> focing new... \".format(_str_func, mMirror)) \n mMirror.delete()\n \n log.debug(\"|{0}| >> blockParent....\".format(_str_func))\n mBlockParent = self.p_blockParent\n if mBlockParent and mBlockParent.getMessage('blockMirror'):\n mBlockParent = mBlockParent.blockMirror\n log.debug(\"|{0}| >> blockParent has blockMirror: {1}\".format(_str_func,mBlockParent))\n \n log.debug(\"|{0}| >> Creating mirror block. {1} | {2}\".format(_str_func, _blockType, _side))\n \n _d = {'blockType':self.blockType, 'side':_side,\n 'autoForm':False,\n 'blockParent':mBlockParent,\n \n #'baseAim':[self.baseAimX,-self.baseAimY,self.baseAimZ],\n 'baseSize':baseSize_get(self)}\n \n for a in 'blockProfile','buildProfile','cgmName':\n if a in ['cgmName']:\n _d['name'] = self.getMayaAttr(a)\n else:\n _d[a] = self.getMayaAttr(a)\n\n \n log.debug(\"|{0}| >> Block settings...\".format(_str_func, self.mNode)) \n #pprint.pprint(_d)\n \n mMirror = cgmMeta.createMetaNode('cgmRigBlock',\n **_d)\n \n \n \n blockDat = self.getBlockDat()\n blockDat['ud']['side'] = _side\n for k in ['baseSize','baseAim']:\n if blockDat['ud'].has_key(k):\n blockDat['ud'].pop(k)\n for a in 'XYZ':\n if blockDat['ud'].has_key(k+a):\n blockDat['ud'].pop(k+a)\n mMirror.blockDat = blockDat\n \n blockMirror_settings(self,mMirror)\n mMirror.saveBlockDat()\n _d = mMirror.blockDat\n _d['blockState']=self.getEnumValueString('blockState')\n\n mMirror.blockDat = _d\n \n \"\"\"\n for k,dIter in BLOCKSHARE._d_mirrorAttrCheck.iteritems():\n _check = blockDat['ud'].get(k)\n if _check:\n log.debug(\"|{0}| >> mirror dat check {1} | {2}\".format(_str_func, k, dIter))\n blockDat['ud'][k] = dIter.get(blockDat['ud'][k])\"\"\"\n \n \"\"\"\n #Mirror some specfic dat\n if blockDat.get('form'):\n _subShapers = blockDat['form'].get('subShapers',{})\n log.debug(\"|{0}| >> subShaper dat mirror...\".format(_str_func, self.mNode)) \n \n for i,d_sub in _subShapers.iteritems():\n l_t = d_sub.get('t')\n l_r = d_sub.get('r')\n l_s = d_sub.get('s')\n \n for ii,d_list in enumerate(l_t):\n d_list[0] = d_list[0]*-1\n for ii,d_list in enumerate(l_r):\n d_list[0] = d_list[0]*-1 \n d_list[1] = d_list[1]*-1\n \n _subShapers[str(i)]['r'][ii] = l_r\n _subShapers[str(i)]['r'][ii] = l_t\"\"\"\n \n\n self.connectChildNode(mMirror,'blockMirror','blockMirror')#Connect\n mMirror.p_blockParent = mBlockParent\n \n blockDat_load(mMirror,useMirror=True,redefine=True)\n controls_mirror(self,mMirror)\n return mMirror\n except Exception,err:cgmGEN.cgmException(Exception,err)","def mine_block(last_block, data):\n timestamp = time.time_ns()\n last_hash = last_block.hash\n difficulty = Block.adjust_difficulty(last_block, timestamp)\n nonce = 0\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\n\n while hex_to_binary(hash)[0:difficulty] != '0'* difficulty:\n nonce += 1\n timestamp = time.time_ns()\n difficulty = Block.adjust_difficulty(last_block, timestamp)\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\n\n return Block(timestamp, last_hash, hash, data, difficulty, nonce)","def moveBlock(self, block: ghidra.program.model.mem.MemoryBlock, newStartAddr: ghidra.program.model.address.Address, monitor: ghidra.util.task.TaskMonitor) -> None:\n ...","def _create_utxo_block_unlocked(r,\n curr_block: Block,\n referenced_txos: Set[bytes],\n new_utxos: Mapping[bytes, bytes]) -> None:\n utxo_prev_block = r.dump(\"blockchain:utxo-block:\".encode() + curr_block.previous_hash)\n r.restore(name=\"blockchain:utxo-block:\".encode() + curr_block.current_hash,\n ttl=0,\n value=utxo_prev_block,\n replace=True)\n r.hdel(\"blockchain:utxo-block:\".encode() + curr_block.current_hash, *referenced_txos)\n r.hmset(\"blockchain:utxo-block:\".encode() + curr_block.current_hash, new_utxos)","def proof_of_work(self, block):\n block.nonce = 0 \n computed_hash = block.compute_hash()\n while not computed_hash.starswith('0' * Blockchain.difficulty):\n block.nonce += 1 \n computed_hash = block.compute_hash()","def penblock(self, block):\n self.block = block","def apply_block(self, block_id, func=..., edges=..., inplace=...): # -> None:\n ...","def remove_genesis(proof):\n\n old_size = len(proof)\n print(\"Removing genesis block from proof ...\")\n proof.pop(-1)\n print(\"OK\")\n print(\"old size:\", old_size, \"-> new size:\", len(proof))","def update(blockstring):\n with BLOCK_LOCK:\n for block in blockstring.split('|'):\n name, values = parse(block)\n BLOCKS[name] = values","def _set_block(self, pos, block_):\n _get_mc().setBlock(pos, block_)","def mine_block(): \n # Fetch the current last block of blockchain\n last_block = blockchain[-1]\n # Hash th elast block (=> to be able to compare it to stored hash value)\n hashed_block = hash_block(last_block)\n proof = proof_of_work()\n # Miners should be rewarded, so here is reward\n # reward_transaction = {\n # 'sender': 'MINING',\n # 'recipient': owner,\n # 'amount': MINING_REWARD\n # }\n reward_transaction = OrderedDict([('sender', 'MINING'), ('recipient', owner), ('amount', MINING_REWARD)])\n copied_transactions = open_transactions[:]\n copied_transactions.append(reward_transaction)\n\n block = {\n 'previous_hash': hashed_block,\n 'index': len(blockchain),\n 'transactions': copied_transactions,\n 'proof': proof\n }\n blockchain.append(block)\n return True","def fix_not_found(self, course_locator, user_id):\n original_structure = self._lookup_course(course_locator).structure\n index_entry = self._get_index_if_valid(course_locator)\n new_structure = self.version_structure(course_locator, original_structure, user_id)\n for block in new_structure['blocks'].values():\n if 'children' in block.fields:\n block.fields['children'] = [\n block_id for block_id in block.fields['children']\n if block_id in new_structure['blocks']\n ]\n self.update_structure(course_locator, new_structure)\n if index_entry is not None:\n # update the index entry if appropriate\n self._update_head(course_locator, index_entry, course_locator.branch, new_structure['_id'])","def _copy_from_template(\n self, source_structures, source_keys, dest_structure, new_parent_block_key, user_id, head_validation\n ):\n new_blocks = set()\n\n new_children = list() # ordered list of the new children of new_parent_block_key\n\n for usage_key in source_keys:\n src_course_key = usage_key.course_key\n hashable_source_id = src_course_key.for_version(None)\n block_key = BlockKey(usage_key.block_type, usage_key.block_id)\n source_structure = source_structures[src_course_key]\n\n if block_key not in source_structure['blocks']:\n raise ItemNotFoundError(usage_key)\n source_block_info = source_structure['blocks'][block_key]\n\n # Compute a new block ID. This new block ID must be consistent when this\n # method is called with the same (source_key, dest_structure) pair\n unique_data = \"{}:{}:{}\".format(\n str(hashable_source_id).encode(\"utf-8\"),\n block_key.id,\n new_parent_block_key.id,\n )\n new_block_id = hashlib.sha1(unique_data.encode('utf-8')).hexdigest()[:20]\n new_block_key = BlockKey(block_key.type, new_block_id)\n\n # Now clone block_key to new_block_key:\n new_block_info = copy.deepcopy(source_block_info)\n # Note that new_block_info now points to the same definition ID entry as source_block_info did\n existing_block_info = dest_structure['blocks'].get(new_block_key, BlockData())\n # Inherit the Scope.settings values from 'fields' to 'defaults'\n new_block_info.defaults = new_block_info.fields\n\n # <workaround>\n # CAPA modules store their 'markdown' value (an alternate representation of their content)\n # in Scope.settings rather than Scope.content :-/\n # markdown is a field that really should not be overridable - it fundamentally changes the content.\n # capa modules also use a custom editor that always saves their markdown field to the metadata,\n # even if it hasn't changed, which breaks our override system.\n # So until capa modules are fixed, we special-case them and remove their markdown fields,\n # forcing the inherited version to use XML only.\n if usage_key.block_type == 'problem' and 'markdown' in new_block_info.defaults:\n del new_block_info.defaults['markdown']\n # </workaround>\n\n # Preserve any existing overrides\n new_block_info.fields = existing_block_info.fields\n\n if 'children' in new_block_info.defaults:\n del new_block_info.defaults['children'] # Will be set later\n\n new_block_info.edit_info = existing_block_info.edit_info\n new_block_info.edit_info.previous_version = new_block_info.edit_info.update_version\n new_block_info.edit_info.update_version = dest_structure['_id']\n # Note we do not set 'source_version' - it's only used for copying identical blocks\n # from draft to published as part of publishing workflow.\n # Setting it to the source_block_info structure version here breaks split_draft's has_changes() method.\n new_block_info.edit_info.edited_by = user_id\n new_block_info.edit_info.edited_on = datetime.datetime.now(UTC)\n new_block_info.edit_info.original_usage = str(usage_key.replace(branch=None, version_guid=None))\n new_block_info.edit_info.original_usage_version = source_block_info.edit_info.update_version\n dest_structure['blocks'][new_block_key] = new_block_info\n\n children = source_block_info.fields.get('children')\n if children:\n children = [src_course_key.make_usage_key(child.type, child.id) for child in children]\n new_blocks |= self._copy_from_template(\n source_structures, children, dest_structure, new_block_key, user_id, head_validation\n )\n\n new_blocks.add(new_block_key)\n # And add new_block_key to the list of new_parent_block_key's new children:\n new_children.append(new_block_key)\n\n # Update the children of new_parent_block_key\n dest_structure['blocks'][new_parent_block_key].fields['children'] = new_children\n\n return new_blocks","def _merge_block(internal_transactions, transactions, whitelist):\n transactions_by_id = {\n (transaction[\"hash\"], transaction[\"blockHash\"]): transaction\n for transaction in transactions\n }\n for transaction in internal_transactions:\n hash = transaction[\"transactionHash\"]\n block = transaction[\"blockHash\"]\n if (hash, block) in transactions_by_id:\n whitelisted_fields = {\n key: value\n for key, value in transactions_by_id[(hash, block)].items()\n if key in whitelist\n }\n transaction.update(whitelisted_fields)\n del transactions_by_id[(hash, block)]\n return internal_transactions","def validate_and_add_block(self, block):\n\n # 1. Validate transaction(s) in block\n tx = block.transactions\n if not self.validate_transaction(tx):\n print(\"Block contains invalid transactions.\")\n return\n\n # 2. Hash transaction(s)\n tx_hash = HashAssist.hash_value(value=tx.to_string_for_hashing())\n\n # 3. Validate header\n header_string = block.prev_hash + tx_hash + block.nonce\n header_hash = HashAssist.hash_value(header_string)\n if not block.header_hash == header_hash:\n print(\"Block header invalid!\")\n return\n\n self.blocks.append(block)","def createNewBlock(self, nonce, previousBlockHash, hash):\n newBlock = Block(len(self.chain), self.pendingTransactions, nonce, hash, previousBlockHash)\n self.pendingTransactions = []\n self.chain.append(newBlock)\n return newBlock","def pre_process(writer, _):\n writer.disable_raw()\n writer.enable_wrap()\n writer.width = int(writer.defaults['width'])\n writer.pre_node = 0\n for name in writer.defaults['add_block'].split(','):\n if name and name not in MOD.BLOCK:\n MOD.BLOCK.append(name)\n for name in writer.defaults['del_block'].split(','):\n try:\n MOD.BLOCK.remove(name)\n except ValueError:\n pass","def transform_block(block, scale, translation):\n if block is None:\n return None\n if block.x is None:\n x = None\n else:\n x = (block.x * scale[0]) + translation[0]\n if block.y is None:\n y = None\n else:\n y = (block.y * scale[1]) + translation[1]\n width = block.width * scale[0]\n height = block.height * scale[1]\n\n return block._replace(x=x, y=y, width=width, height=height)","def test_update_metadata(self):\r\n locator = BlockUsageLocator(\r\n CourseLocator(org=\"testx\", offering=\"GreekHero\", branch='draft'),\r\n 'problem', block_id=\"problem3_2\"\r\n )\r\n problem = modulestore().get_item(locator)\r\n pre_def_id = problem.definition_locator.definition_id\r\n pre_version_guid = problem.location.version_guid\r\n self.assertIsNotNone(pre_def_id)\r\n self.assertIsNotNone(pre_version_guid)\r\n self.assertNotEqual(problem.max_attempts, 4, \"Invalidates rest of test\")\r\n\r\n problem.max_attempts = 4\r\n problem.save() # decache above setting into the kvs\r\n updated_problem = modulestore().update_item(problem, '**replace_user**')\r\n # check that course version changed and course's previous is the other one\r\n self.assertEqual(updated_problem.definition_locator.definition_id, pre_def_id)\r\n self.assertNotEqual(updated_problem.location.version_guid, pre_version_guid)\r\n self.assertEqual(updated_problem.max_attempts, 4)\r\n # refetch to ensure original didn't change\r\n original_location = problem.location.map_into_course(CourseLocator(version_guid=pre_version_guid))\r\n problem = modulestore().get_item(original_location)\r\n self.assertNotEqual(problem.max_attempts, 4, \"original changed\")\r\n\r\n current_course = modulestore().get_course(locator.course_key)\r\n self.assertEqual(updated_problem.location.version_guid, current_course.location.version_guid)\r\n\r\n history_info = modulestore().get_course_history_info(current_course.location)\r\n self.assertEqual(history_info['previous_version'], pre_version_guid)\r\n self.assertEqual(history_info['edited_by'], \"**replace_user**\")","def populate_block(self, block, additional_options=None):\n raise NotImplementedError(\n \"SurrogateModel class has not implemented populate_block method.\"\n )","def save_block(self, block):\n # Implementing this is optional.","def set_new_hash(court_id, new_hash):\n seals_data[court_id]['hash'] = new_hash","def pre_process(writer, _):\n writer.disable_raw()\n writer.enable_wrap()\n writer.header = writer.defaults['header']\n writer.width = int(writer.defaults['width'])\n writer.pre_node = 0\n writer.list_level = 0\n for name in writer.defaults['add_block'].split(','):\n if name and name not in MOD['nw'].BLOCK:\n MOD['nw'].BLOCK.append(name)\n for name in writer.defaults['del_block'].split(','):\n try:\n MOD['nw'].BLOCK.remove(name)\n except ValueError:\n pass","def test_block():\n b = common.Block(['1 1 1', '2 2 3 ', ''])\n expect = ['1 1 1', '2 2 3']\n c = b.compact()\n assert c == expect\n assert b != expect\n\n b.compact(inplace=True)\n assert b == expect","def new_block(self, body_blocks, snake_head):\n\t\tx = randint(0, 35)\n\t\ty = randint(1, 26)\n\t\tself.rect.x = (25 * x) + 1\n\t\tself.rect.bottom = 25 * y\n\t\t\n\t\t# If new block is on snake, get new block\n\t\tif self.rect.x == snake_head.rect.x and self.rect.bottom == snake_head.rect.bottom:\n\t\t\tself.new_block(body_blocks, snake_head)\n\t\t\n\t\t# If new block is on any body block, get new block\n\t\tif body_blocks:\n\t\t\tfor i in range(len(body_blocks)):\n\t\t\t\tif self.rect.x == body_blocks[i].rect.x and self.rect.bottom == body_blocks[i].rect.bottom:\n\t\t\t\t\tself.new_block(body_blocks, snake_head)","def add_block(self, block_pf):\n\n # test si il s'agit du bloc genesis\n if len(self.blocks) != 0:\n # check si previous H est coherent avant ajout a chaine\n if self.check_previousBlockH(block_pf.header['prevBlockH']):\n self.blocks.append(block_pf)\n else:\n print \"== Probleme de parent\"\n print \"= %s\" % block_pf.header['prevBlockH']\n print \"= %s\" % getHashBlock(self.get_topBlock())\n else:\n self.blocks.append(block_pf)","def invalidateblock(self, block_hash: str) -> None:\n return self.rpc_call(\"invalidateblock\", block_hash)","def replace_id(self, old_id, new_id):\n def replace(prf):\n for item in prf.items:\n item.prevs = [new_id if id == old_id else id for id in item.prevs]\n if item.subproof:\n replace(item.subproof)\n\n prf = self.prf.get_parent_proof(old_id)\n replace(prf)\n\n self.remove_line(old_id)","def block(self, block):\n\n self._block = block","def block(self, block):\n\n self._block = block","def seed(cls, block: Expr) -> Expr:\n return cls(BlockField.block_seed, block)","def replaceChain(self, newChain):\n\n if len(newChain) <= len(self.__chain):\n return False\n\n # Validate the new chain\n if not self.validateChain(newChain):\n return False\n\n newBlocks = newChain[len(self.__chain):]\n for block in newBlocks:\n self.addBlock(block)","def change_block(self, move):\n fpath = os.path.split(os.path.abspath(self.source_path))[0] # current directory\n fname = os.path.split(os.path.abspath(self.source_path))[1] # current file\n pre, _ = fname.split('_B')\n flist = glob.glob(fpath + '/' + pre + '_B*.nwb')\n curr_ind = flist.index(self.source_path)\n if curr_ind + move == len(flist):\n new_file = flist[0]\n else:\n new_file = flist[curr_ind + move]\n self.open_another_file(filename=new_file)","def remove(self, block):\n try:\n self.blocks[block.height]\n except:\n raise ValueError(\"cant remove block: \" + str(block))\n\n removed = False\n for b in self.blocks[block.height]:\n # only delete the one with equal hash\n if b.hash() == block.hash():\n self.blocks[block.height].remove(b)\n removed = True\n if self.blocks[block.height] == []:\n self.blocks.pop(block.height)\n\n if not removed:\n raise ValueError(\"cant remove block: \" + str(block))","def split(self, block: ghidra.program.model.mem.MemoryBlock, addr: ghidra.program.model.address.Address) -> None:\n ...","def add_block(self, env):\n block_size = (0.04, 0.04, 0.04)\n block_pose = self.random_pose(env, block_size)\n block_urdf = 'assets/stacking/block.urdf'\n block_id = env.add_object(block_urdf, block_pose)\n self.object_points[block_id] = np.float32((0, 0, 0)).reshape(3, 1)\n self._IDs[block_id] = 'block'\n return block_id","def removeMemoryBlock(self, block: ghidra.program.model.mem.MemoryBlock) -> None:\n ...","def CommitBlock(self, block):\n QUEUE.put(Block(block=block))","def makeBlock(tag):\n return {\"t\":\"RawBlock\",\"c\":[\"html\",tag]}","def MarkBlock(state, begin, end):\n # TODO: Make sure already existing blocks don't overlap\n if begin == end:\n return\n last_pos = 0\n for entry in state:\n pos = entry['pos']\n if begin >= last_pos and begin < pos:\n if end < pos:\n # block doesn't cross any line boundary\n entry['blocks'].append((begin, end))\n else:\n # block crosses the line boundary\n entry['blocks'].append((begin, pos))\n MarkBlock(state, pos, end)\n break\n last_pos = pos"],"string":"[\n \"def change_interlink_hash(proof, block_index):\\n\\n block_of_interest = proof[block_index][0]\\n changed_block = swap_byte(block_of_interest, 0)\\n changed_proof = (\\n proof[0:block_index]\\n + [(changed_block, proof[block_index][1])]\\n + proof[block_index + 1 :]\\n )\\n return changed_proof\",\n \"def replace_blocks(self, block_id, replace_id):\\n compatible = block_config[block_id].block_style == block_config[replace_id].block_style\\n replace = Replace(self.smd3.get_block_list())\\n replace.replace_blocks(block_id, replace_id, compatible)\\n self.header.update(self.smd3)\",\n \"def replace_blocks_hull(self, new_hull_type, hull_type=None):\\n replace = Replace(self.smd3.get_block_list())\\n replace.replace_hull(new_hull_type, hull_type)\\n self.header.update(self.smd3)\",\n \"def new_block(self, proof, previous_hash=None):\\n\\n # Create the block\\n my_block = Block(proof=proof,\\n previous_hash=previous_hash or self.hash(self.last_block))\\n my_block.save()\\n\\n # Update current_transactions with this new block.\\n my_block_trans = self.current_transactions_obj\\n\\n for trans in Transaction.objects.filter(block__isnull=True):\\n trans.block = my_block\\n trans.save()\\n\\n block = {\\n 'index': my_block.id,\\n 'timestamp': my_block.timestamp,\\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\\n 'proof': my_block.proof,\\n 'previous_hash': my_block.previous_hash,\\n }\\n\\n return block\",\n \"def _adjustBlock(self, b):\\n raise NotImplementedError\",\n \"def new_block(self, proof, previous_hash=None):\\n \\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n # Add block to existing chain\\n self.chain.append(block)\\n return block\",\n \"def _update_block_in_structure(self, structure, block_key, content):\\n structure['blocks'][block_key] = content\",\n \"def new_block(self, proof, previous_hash=None):\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions':self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n self.current_transactions = []\\n self.chain.append(block)\\n return block\",\n \"def update_recovered_block(\\n self, block_hash: Sha256Hash, block_msg: TBlockMessage\\n ) -> None:\\n pass\",\n \"def new_block(self, proof, previous_hash = None):\\n #create a new Block & adds it to the chain.\\n \\n block = {\\n 'index' : len(self.chain) + 1,\\n 'timestamp' : time(),\\n 'transactions' : self.pending_transactions,\\n 'proof' : proof,\\n 'previous_hash' : previous_hash or self.hash(self.chain[-1])\\n }\\n\\n # Reset the current list of transactions\\n self.pending_transactions = []\\n\\n self.chain.append(block)\\n return block\\n #pass\",\n \"def _set_block(self, pos, block_):\\n self._changes[deepcopy(pos)] = block\",\n \"def changed_block(self, old_block, new_block):\",\n \"def new_block(self, proof, previous_hash=None):\\r\\n block = {\\r\\n 'index': len(self.chain) + 1,\\r\\n 'timestamp': time(),\\r\\n 'transactions': self.current_transactions,\\r\\n 'proof': proof,\\r\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\r\\n }\\r\\n\\r\\n # reseta a atual lista de transacoes\\r\\n self.current_transactions = []\\r\\n\\r\\n self.chain.append(block)\\r\\n return block\",\n \"def _set_block(self, pos, block_):\\n raise NotImplementedError\",\n \"def new_block(self, proof, previous_hash=None):\\n\\n\\t\\tblock = {\\n\\t\\t\\t'index': len(self.chain) + 1,\\n\\t\\t\\t'timestamp': time(),\\n\\t\\t\\t'transactions': self.current_transactions,\\n\\t\\t\\t'proof': proof,\\n\\t\\t\\t'previous_hash': previous_hash or self.hash(self.chain[-1]),\\t\\t\\n\\t\\t}\\n\\n\\t\\t#Reset current list of transactions\\n\\t\\tself.current_transactions = []\\n\\n\\t\\tself.chain.append(block)\\n\\t\\treturn block\",\n \"def reconsiderblock(self, block_hash: str) -> None:\\n return self.rpc_call(\\\"reconsiderblock\\\", block_hash)\",\n \"def _update_block_in_structure(self, structure, block_id, content):\\r\\n structure['blocks'][LocMapperStore.encode_key_for_mongo(block_id)] = content\",\n \"def new_block(self, proof, previous_hash=None):\\n servers = [\\n \\\"1.us.pool.ntp.org\\\",\\n \\\"2.us.pool.ntp.org\\\",\\n \\\"3.us.pool.ntp.org\\\"\\n ]\\n\\n response = {}\\n\\n try:\\n response = self.c.request('0.us.pool.ntp.org')\\n except Exception:\\n for server in servers:\\n try:\\n response = self.c.request(server)\\n\\n if response:\\n break\\n\\n except Exception:\\n print('\\\\n //// alternate ntp server didnt work')\\n\\n block = {\\n 'message': 'New Block Forged',\\n 'index': len(self.chain) + 1,\\n 'timestamp': response.tx_time or time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.chain[-1]['hash'],\\n }\\n\\n # Calculate the hash of this new Block\\n block['hash'] = self.hash(block)\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n\\n self.chain.append(block)\\n return block\",\n \"def new_block(self, proof, previous_hash=None):\\n block = {\\n 'index': len( self.chain ) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'merkle': self.hash(self.current_transactions),\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1])\\n }\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n\\n # Add the block to the chain\\n self.chain.append( block )\\n self._write_chain()\\n\\n return block\",\n \"def add_block(self, block, proof):\\n # print(block.__dict__)\\n try:\\n previous_hash = self.last_block.hash\\n except AttributeError:\\n previous_hash = block.previous_hash\\n\\n if previous_hash != block.previous_hash:\\n print(\\\"Hashes don't match\\\\n{}\\\\n{}\\\".format(previous_hash, block.previous_hash))\\n return False\\n\\n if not self.is_valid_proof(block, proof):\\n print(\\\"block is not valid\\\")\\n return False\\n\\n block.hash = proof\\n self.chain.append(block)\\n return True\",\n \"def add_block(self, block, proof):\\n previous_hash = self.last_block.hash\\n\\n if previous_hash != block.previous_hash:\\n print('Previous hash is not matched.')\\n return False\\n\\n if not Blockchain.is_valid_proof(block, proof):\\n print('Proof is not valid.')\\n return False\\n\\n block.hash = proof\\n self.chain.append(block)\\n return True\",\n \"def _initBlock(o,block):\\n o.block = block.clone().shift(*o.board.startPosition)\",\n \"def add_block(self, block, proof):\\r\\n previous_hash = self.last_block.hash\\r\\n if previous_hash != block.previous_hash:\\r\\n return False\\r\\n if not self.is_valid_proof(block, proof):\\r\\n return False\\r\\n block.hash = proof\\r\\n self.chain.append(block)\\r\\n return True\",\n \"def add_new_block(self):\\n old_block = self.curr_block\\n self.curr_block = self.gen_new_block()\\n add_edge(old_block, self.curr_block)\",\n \"def add_block(self, block, proof):\\n previous_hash = self.last_block.hash\\n \\n if previous_hash != block.previous: \\n return False\\n \\n if not Blockchain.is_valid_proof(block, proof):\\n return False\\n \\n block.hash = proof \\n self.chain.append(block)\\n return True\",\n \"def sed(self, search, replace):\\n\\n for section in self.sections:\\n for i, block in enumerate(section.blocks):\\n if block == search:\\n section.blocks[i] = replace\\n self.all_damaged = True\\n self.dirty = True\",\n \"async def refresh(self):\\n block = await self.blockchain.rpc.get_block_header(self.identifier)\\n if not block:\\n raise BlockDoesNotExistsException\\n await super(BlockHeader, self).__init__(\\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\\n )\",\n \"def mine(self):\\n last_block = self.chain[-1]\\n\\n nonce = self.proof_of_work()\\n previous_hash = self.hash(last_block)\\n self.create_block(nonce, previous_hash)\",\n \"def add_partial_decryption_block(self, block):\\n\\t\\tself._blocks.append(block)\",\n \"def update_pre_block(pre_block):\\r\\n updated_block=\\\"\\\";\\r\\n count=0;\\r\\n for line in pre_block.splitlines():\\r\\n count+=1;\\r\\n if count<len(pre_block.splitlines()):\\r\\n line=update_line(line)+\\\"\\\\n\\\";\\r\\n updated_block=updated_block+line;\\r\\n else:\\r\\n line=update_line(line);\\r\\n updated_block=updated_block+line;\\r\\n return updated_block\",\n \"def replaceChain(self, newbc):\\n if (Blockchain.validChain(newbc) == False):\\n print(\\\"New Blockchain is invalid\\\")\\n return\\n elif (len(newbc.chain) < len(self.chain)):\\n print(\\\"Not enough blocks on new Blockchain\\\")\\n return\\n \\n print(\\\"Updating blockchain to newest version\\\")\\n self.chain = newbc\",\n \"def test_update_manifold(self):\\r\\n locator = BlockUsageLocator(\\r\\n CourseLocator('testx', 'GreekHero', branch='draft'),\\r\\n 'problem', block_id='problem1'\\r\\n )\\r\\n original = modulestore().get_item(locator)\\r\\n # first add 2 children to the course for the update to manipulate\\r\\n locator = BlockUsageLocator(\\r\\n CourseLocator('guestx', 'contender', branch='draft'),\\r\\n 'course', block_id=\\\"head345679\\\"\\r\\n )\\r\\n category = 'problem'\\r\\n new_payload = \\\"<problem>empty</problem>\\\"\\r\\n modulestore().create_item(\\r\\n locator, category, 'test_update_manifold',\\r\\n fields={'display_name': 'problem 1', 'data': new_payload},\\r\\n )\\r\\n another_payload = \\\"<problem>not empty</problem>\\\"\\r\\n modulestore().create_item(\\r\\n locator, category, 'test_update_manifold',\\r\\n fields={'display_name': 'problem 2', 'data': another_payload},\\r\\n definition_locator=original.definition_locator,\\r\\n )\\r\\n # pylint: disable=W0212\\r\\n modulestore()._clear_cache()\\r\\n\\r\\n # now begin the test\\r\\n block = modulestore().get_item(locator)\\r\\n pre_def_id = block.definition_locator.definition_id\\r\\n pre_version_guid = block.location.version_guid\\r\\n\\r\\n self.assertNotEqual(block.grading_policy['GRADER'][0]['min_count'], 13)\\r\\n block.grading_policy['GRADER'][0]['min_count'] = 13\\r\\n block.children = block.children[1:] + [block.children[0]]\\r\\n block.advertised_start = \\\"Soon\\\"\\r\\n\\r\\n block.save() # decache model changes\\r\\n updated_block = modulestore().update_item(block, \\\"**replace_user**\\\")\\r\\n self.assertNotEqual(updated_block.definition_locator.definition_id, pre_def_id)\\r\\n self.assertNotEqual(updated_block.location.version_guid, pre_version_guid)\\r\\n self.assertEqual(updated_block.grading_policy['GRADER'][0]['min_count'], 13)\\r\\n self.assertEqual(updated_block.children[0].version_agnostic(), block.children[0].version_agnostic())\\r\\n self.assertEqual(updated_block.advertised_start, \\\"Soon\\\")\",\n \"def remove_block(self, block):\\n raise NotImplementedError()\",\n \"def updateBlock(self):\\n self.blkno = self.blknoSpinBox.value() - 1\\n self.initDataParms()\\n self.updateCurveList()\\n self.compute()\",\n \"def _maskhg19(self):\\n if len(self._current_block) > 2:\\n self._current_block[0].text = self._current_block[1].text\\n self._current_block[0].size = self._current_block[1].size\\n self._current_block[0].setstring()\\n self._current_block.remove(self._current_block[1])\\n else:\\n self._current_block = []\",\n \"def addBlock(self, newBlock):\\n newBlock.index = len(self.chain)\\n newBlock.previousHash = self.chain[-1].hash\\n newBlock.mineBlock(self.difficulty)\\n self.chain.append(newBlock)\\n self.writeBlocks()\",\n \"def erase_block(self):\\n self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]] = '0'\",\n \"def test_replace_chain_keep_original(self):\\n import copy\\n miner_address = 'miner_address'\\n\\n blockchain1 = Blockchain()\\n blockchain1.mine(miner_address)\\n\\n blockchain2 = copy.deepcopy(blockchain1)\\n blockchain1.mine(miner_address)\\n\\n # Now let's make sure that each blockchain has its own number of blocks\\n self.assertEqual(3, len(blockchain1.full_chain))\\n self.assertEqual(2, len(blockchain2.full_chain))\\n\\n # Then let's replace blockchain1 with blockchain2\\n blockchain1.replace_chain(blockchain2.full_chain)\\n\\n self.assertEqual(3, len(blockchain1.full_chain))\\n self.assertEqual(2, len(blockchain2.full_chain))\",\n \"def assert_block_does_not_change(\\n block_type: str, middleware: Middleware, same_instance: Optional[bool]\\n):\\n block_type = block_type.lower()\\n if block_type == \\\"preamble\\\":\\n block = Preamble(\\n start_line=5, raw=\\\"@Preamble{a_x + b_x^2}\\\", value=\\\"a_x + b_x^2\\\"\\n )\\n elif block_type == \\\"implicit_comment\\\":\\n block = ImplicitComment(start_line=5, raw=\\\"# MyComment\\\", comment=\\\"MyComment\\\")\\n elif block_type == \\\"explicit_comment\\\":\\n block = ExplicitComment(\\n start_line=5, raw=\\\"@Comment{MyComment}\\\", comment=\\\"MyComment\\\"\\n )\\n else:\\n raise ValueError(\\\"block type not yet supported in test utility\\\")\\n\\n block_copy = deepcopy(block)\\n\\n transformed_library = middleware.transform(library=Library([block]))\\n\\n # Assert correct library state\\n assert len(transformed_library.blocks) == 1\\n assert transformed_library.blocks[0] == block_copy\\n if same_instance:\\n assert transformed_library.blocks[0] is block\\n elif not same_instance:\\n assert transformed_library.blocks[0] is not block\",\n \"def test_replace_chain(self):\\n import copy\\n miner_address = 'miner_address'\\n\\n blockchain1 = Blockchain()\\n blockchain1.mine(miner_address)\\n\\n blockchain2 = copy.deepcopy(blockchain1)\\n blockchain2.mine(miner_address)\\n\\n # Now let's make sure that each blockchain has its own number of blocks\\n self.assertEqual(2, len(blockchain1.full_chain))\\n self.assertEqual(3, len(blockchain2.full_chain))\\n\\n # Then let's replace blockchain1 with blockchain2\\n blockchain1.replace_chain(blockchain2.full_chain)\\n\\n self.assertEqual(3, len(blockchain1.full_chain))\\n self.assertEqual(3, len(blockchain2.full_chain))\\n self.assertEqual(blockchain1.last_block.hash, blockchain2.last_block.hash)\",\n \"def newBlock(preBlock, remitter, number, payee):\\r\\n index = preBlock.index + 1\\r\\n timestamp = int(round(time.time() * 1000))\\r\\n data = (remitter, number, payee).__str__()\\r\\n previousHash = preBlock.hash\\r\\n nounce = 0\\r\\n return Blockchain(index, data, timestamp, nounce, previousHash)\",\n \"def add_block(self, block, proof):\\n previous_hash = self.last_block.hash\\n\\n if previous_hash != block.previous_hash:\\n return False\\n\\n if not Blockchain.is_valid_proof(block, proof):\\n return False\\n\\n block.hash = proof\\n self.chain.append(block)\\n return True\",\n \"def new_block(self, previous_hash):\\n\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'information': self.current_information,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n\\n # Reset the current list of transactions\\n self.current_information = []\\n\\n self.chain.append(block)\\n return block\",\n \"def refresh(self):\\n block = self.graphene.rpc.get_block(self.block)\\n if not block:\\n raise BlockDoesNotExistsException\\n super(Block, self).__init__(block)\\n self.cached = True\",\n \"def create_block(self, proof, previous_hash=None):\\n\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash,\\n }\\n\\n # Reset current list of transactions\\n self.current_transactions = []\\n\\n self.chain.append(block)\\n return block\",\n \"def mine(self):\\n new_block = Block(self.block['timestamp'], self.block['car'],\\n self.block['id'])\\n # link the block to the previous block\\n new_block.previous_hash = self._get_previous_hash()\\n while True:\\n # get a hash\\n new_hash = new_block.get_hash()\\n # check hash rules, in our case check if the hash starts with\\n # self.difficulty number of zeroes\\n if new_hash[0] != self.difficulty * \\\"0\\\":\\n if self.new_block[\\\"block\\\"] is None:\\n # the hash hasn't been found yet by any other process,\\n # therefore increase the nonce and continue\\n # miners will use a different mining mechanism in order\\n # to increase the probability of finding a hash by\\n # a different miner\\n new_block.increment_nonce(self.id + 1)\\n continue\\n break\\n break\\n\\n # NOTE: May happen that two processes find the hash at the same time,\\n # because there is not a big difficulty, however, it's not a problem,\\n # for sake of the demo it's fine\\n\\n if self.new_block[\\\"block\\\"] is None:\\n # this process has found the hash first\\n print(self.id, \\\" - the winner hash\\\", new_hash)\\n new_block.hash = new_hash\\n self.new_block[\\\"block\\\"] = new_block\\n print(self.id, \\\" - mined the block\\\")\\n else:\\n # validate the block found by other process (miner)\\n if self.new_block[\\\"validated\\\"] is not False:\\n print(self.id, \\\" - validating\\\")\\n # check block's validity\\n valid = False\\n if self.new_block[\\\"block\\\"].is_block_valid():\\n # check blockchain's validity when we apply the newly\\n # mined block\\n if self.is_blockchain_valid(self.new_block[\\\"block\\\"]):\\n valid = True\\n self.new_block[\\\"validated\\\"] = valid\\n else:\\n # NOTE: this demo doesn't take into account the number of\\n # miners who approved the block, the block will be rejected\\n # if any of them rejected it\\n # but usually just more than 50% of miners must approve\\n print(self.id, \\\" - the block has been rejected by other miner\\\")\",\n \"def _patch_phis(self, ops, oldblock, newblock):\\n for op in ops:\\n for use in self.func.uses[op]:\\n if use.opcode == 'phi':\\n # Update predecessor blocks\\n preds, vals = use.args\\n preds = [newblock if pred == oldblock else pred\\n for pred in preds]\\n use.set_args([preds, vals])\",\n \"def put_block(self):\\n self.blocks[self.editor_cursor_position[1]][\\n self.editor_cursor_position[0]] = self.available_block_types[self.current_block_type]\",\n \"def rename_all_blocks(hpo_data, cyto_bed, block_prefix):\\n\\n for hpo, hdat in hpo_data.items():\\n\\n block_dict = {bid : bd['credset_bt'] for bid, bd in hdat['blocks'].items()}\\n\\n rename_dict = rename_blocks(block_dict, cyto_bed, '_'.join([hpo, block_prefix]))\\n\\n for old_id, new_id in rename_dict.items():\\n hpo_data[hpo]['blocks'][new_id] = hpo_data[hpo]['blocks'][old_id]\\n hpo_data[hpo]['blocks'].pop(old_id)\\n \\n return hpo_data\",\n \"def _create_block(\\n self,\\n test_constants: Dict,\\n challenge_hash: bytes32,\\n height: uint32,\\n prev_header_hash: bytes32,\\n prev_iters: uint64,\\n prev_weight: uint64,\\n timestamp: uint64,\\n difficulty: uint64,\\n ips: uint64,\\n seed: bytes,\\n ) -> FullBlock:\\n prover = None\\n plot_pk = None\\n plot_sk = None\\n qualities: List[bytes] = []\\n for pn in range(num_plots):\\n # Allow passing in seed, to create reorgs and different chains\\n seeded_pn = (pn + 17 * int.from_bytes(seed, \\\"big\\\")) % num_plots\\n filename = self.filenames[seeded_pn]\\n plot_pk = plot_pks[seeded_pn]\\n plot_sk = plot_sks[seeded_pn]\\n prover = DiskProver(os.path.join(self.plot_dir, filename))\\n qualities = prover.get_qualities_for_challenge(challenge_hash)\\n if len(qualities) > 0:\\n break\\n\\n assert prover\\n assert plot_pk\\n assert plot_sk\\n if len(qualities) == 0:\\n raise NoProofsOfSpaceFound(\\\"No proofs for this challenge\\\")\\n\\n proof_xs: bytes = prover.get_full_proof(challenge_hash, 0)\\n proof_of_space: ProofOfSpace = ProofOfSpace(\\n challenge_hash, pool_pk, plot_pk, k, [uint8(b) for b in proof_xs]\\n )\\n number_iters: uint64 = pot_iterations.calculate_iterations(\\n proof_of_space, difficulty, ips, test_constants[\\\"MIN_BLOCK_TIME\\\"]\\n )\\n\\n disc: int = create_discriminant(\\n challenge_hash, test_constants[\\\"DISCRIMINANT_SIZE_BITS\\\"]\\n )\\n start_x: ClassGroup = ClassGroup.from_ab_discriminant(2, 1, disc)\\n y_cl, proof_bytes = create_proof_of_time_nwesolowski(\\n disc, start_x, number_iters, disc, n_wesolowski\\n )\\n\\n output = ClassgroupElement(y_cl[0], y_cl[1])\\n\\n proof_of_time = ProofOfTime(\\n challenge_hash,\\n number_iters,\\n output,\\n n_wesolowski,\\n [uint8(b) for b in proof_bytes],\\n )\\n\\n coinbase: CoinbaseInfo = CoinbaseInfo(\\n height,\\n block_rewards.calculate_block_reward(uint32(height)),\\n coinbase_target,\\n )\\n coinbase_sig: PrependSignature = pool_sk.sign_prepend(bytes(coinbase))\\n fees_target: FeesTarget = FeesTarget(fee_target, uint64(0))\\n solutions_generator: bytes32 = sha256(seed).digest()\\n cost = uint64(0)\\n body: Body = Body(\\n coinbase, coinbase_sig, fees_target, None, solutions_generator, cost\\n )\\n\\n header_data: HeaderData = HeaderData(\\n prev_header_hash,\\n timestamp,\\n bytes([0] * 32),\\n proof_of_space.get_hash(),\\n body.get_hash(),\\n bytes([0] * 32),\\n )\\n\\n header_hash_sig: PrependSignature = plot_sk.sign_prepend(header_data.get_hash())\\n\\n header: Header = Header(header_data, header_hash_sig)\\n\\n challenge = Challenge(\\n challenge_hash,\\n proof_of_space.get_hash(),\\n proof_of_time.get_hash(),\\n height,\\n uint64(prev_weight + difficulty),\\n uint64(prev_iters + number_iters),\\n )\\n header_block = HeaderBlock(proof_of_space, proof_of_time, challenge, header)\\n\\n full_block: FullBlock = FullBlock(header_block, body)\\n\\n return full_block\",\n \"def delete_block(self, block):\\n raise NotImplementedError('delete_block')\",\n \"def block_seen(self):\\n self.blocklist.update(self.mapping.values())\\n self.mapping = dict()\",\n \"def add_block(self, block):\\n # Create a list of transaction objects\\n transactions = [Transaction(\\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']] \\n chipsactions = [Chipsaction(\\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']] \\n messsactions = [Messsaction(\\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']] \\n # Validate the proof of work of the block and store the result (True or False) in a variable\\n proof_is_valid = Verification.valid_proof(\\n transactions[:-1], chipsactions, messsactions, block['previous_hash'], block['proof'])\\n # Check if previous_hash stored in the block is equal to the local blockchain's last block's hash and store the result in a block\\n hashes_match = hash_block(self.chain[-1]) == block['previous_hash']\\n if not proof_is_valid or not hashes_match:\\n return False\\n # Create a Block object\\n converted_block = Block(\\n block['index'], block['previous_hash'], transactions, chipsactions, messsactions, block['proof'], block['timestamp'])\\n self.__chain.append(converted_block)\\n stored_transactions = self.__open_transactions[:]\\n stored_chipsactions = self.__open_chipsactions[:]\\n stored_messsactions = self.__open_messsactions[:]\\n # Check which open transactions were included in the received block and remove them\\n # This could be improved by giving each transaction an ID that would uniquely identify it\\n for itx in block['transactions']:\\n for opentx in stored_transactions:\\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_transactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n\\n for itx in block['chipsactions']:\\n for opentx in stored_chipsactions:\\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.sender == itx['follow'] and opentx.recipient == itx['message'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_chipsactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n for itx in block['messsactions']:\\n for opentx in stored_messsactions:\\n if opentx.sender == itx['sender'] and opentx.sender == itx['follower'] and opentx.recipient == itx['message'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_messsactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n self.save_data()\\n return True\",\n \"def finalize_block_construction(self, pyomo_block):\\n pass\",\n \"def _new_block(self, user_id, category, block_fields, definition_id, new_id, raw=False):\\r\\n if not raw:\\r\\n block_fields = self._serialize_fields(category, block_fields)\\r\\n return {\\r\\n 'category': category,\\r\\n 'definition': definition_id,\\r\\n 'fields': block_fields,\\r\\n 'edit_info': {\\r\\n 'edited_on': datetime.datetime.now(UTC),\\r\\n 'edited_by': user_id,\\r\\n 'previous_version': None,\\r\\n 'update_version': new_id\\r\\n }\\r\\n }\",\n \"def forge_block(offset, plaintext, oracle):\\n b_size, _, _ = challenge_12.determine_block_stats(oracle)\\n new_padding = b\\\"A\\\" * (b_size - offset)\\n payload = new_padding + challenge_09.pkcs7(plaintext, b_size)\\n ciphertext = oracle(payload)\\n\\n return challenge_07.as_blocks(ciphertext, b_size)[1]\",\n \"def commit_block(self, block):\\n raise NotImplementedError('commit_block: Implementation of this method is required.')\",\n \"def _setBlock(o,block):\\n o.board.add(block)\\n o._cachedShadow = None\\n clearedLines = o.board.clearLines()\\n o.lines += clearedLines\\n if clearedLines > 0 and o.onClearLines is not None:\\n o.onClearLines(clearedLines)\\n o.board.addRows(o.penalty)\\n o.penalty = 0\\n o._initBlock(o.queue.pop())\\n if o.lines >= o.level*10: o.level+=1\\n o.canHold = True\\n isGameOver = all(sq.y >= o.board.height for sq in block) \\\\\\n or any(o.board[sq.x,sq.y] != None for sq in o.block)\\n if isGameOver and o.onGameOver: o.onGameOver(o)\",\n \"def version_block(self, block_data, user_id, update_version):\\n if block_data.edit_info.update_version == update_version:\\n return\\n\\n original_usage = block_data.edit_info.original_usage\\n original_usage_version = block_data.edit_info.original_usage_version\\n block_data.edit_info.edited_on = datetime.datetime.now(UTC)\\n block_data.edit_info.edited_by = user_id\\n block_data.edit_info.previous_version = block_data.edit_info.update_version\\n block_data.edit_info.update_version = update_version\\n if original_usage:\\n block_data.edit_info.original_usage = original_usage\\n block_data.edit_info.original_usage_version = original_usage_version\",\n \"async def refresh(self):\\n block = await self.blockchain.rpc.get_block(self.identifier)\\n if not block:\\n raise BlockDoesNotExistsException\\n await super(Block, self).__init__(\\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\\n )\",\n \"def blockMirror_create(self, forceNew = False):\\n try:\\n _str_func = 'blockMirror_create'\\n _side = get_sideMirror(self)\\n _blockType = self.blockType\\n if not _side:\\n log.error(\\\"|{0}| >> Block is not sided. Can't create mirror\\\".format(_str_func, self.mNode)) \\n return False\\n \\n if self.getMessage('blockMirror'):\\n mMirror = self.blockMirror\\n log.debug(\\\"|{0}| >> blockMirror found {1} \\\".format(_str_func, mMirror))\\n if not forceNew:\\n return mMirror\\n log.debug(\\\"|{0}| >> focing new... \\\".format(_str_func, mMirror)) \\n mMirror.delete()\\n \\n log.debug(\\\"|{0}| >> blockParent....\\\".format(_str_func))\\n mBlockParent = self.p_blockParent\\n if mBlockParent and mBlockParent.getMessage('blockMirror'):\\n mBlockParent = mBlockParent.blockMirror\\n log.debug(\\\"|{0}| >> blockParent has blockMirror: {1}\\\".format(_str_func,mBlockParent))\\n \\n log.debug(\\\"|{0}| >> Creating mirror block. {1} | {2}\\\".format(_str_func, _blockType, _side))\\n \\n _d = {'blockType':self.blockType, 'side':_side,\\n 'autoForm':False,\\n 'blockParent':mBlockParent,\\n \\n #'baseAim':[self.baseAimX,-self.baseAimY,self.baseAimZ],\\n 'baseSize':baseSize_get(self)}\\n \\n for a in 'blockProfile','buildProfile','cgmName':\\n if a in ['cgmName']:\\n _d['name'] = self.getMayaAttr(a)\\n else:\\n _d[a] = self.getMayaAttr(a)\\n\\n \\n log.debug(\\\"|{0}| >> Block settings...\\\".format(_str_func, self.mNode)) \\n #pprint.pprint(_d)\\n \\n mMirror = cgmMeta.createMetaNode('cgmRigBlock',\\n **_d)\\n \\n \\n \\n blockDat = self.getBlockDat()\\n blockDat['ud']['side'] = _side\\n for k in ['baseSize','baseAim']:\\n if blockDat['ud'].has_key(k):\\n blockDat['ud'].pop(k)\\n for a in 'XYZ':\\n if blockDat['ud'].has_key(k+a):\\n blockDat['ud'].pop(k+a)\\n mMirror.blockDat = blockDat\\n \\n blockMirror_settings(self,mMirror)\\n mMirror.saveBlockDat()\\n _d = mMirror.blockDat\\n _d['blockState']=self.getEnumValueString('blockState')\\n\\n mMirror.blockDat = _d\\n \\n \\\"\\\"\\\"\\n for k,dIter in BLOCKSHARE._d_mirrorAttrCheck.iteritems():\\n _check = blockDat['ud'].get(k)\\n if _check:\\n log.debug(\\\"|{0}| >> mirror dat check {1} | {2}\\\".format(_str_func, k, dIter))\\n blockDat['ud'][k] = dIter.get(blockDat['ud'][k])\\\"\\\"\\\"\\n \\n \\\"\\\"\\\"\\n #Mirror some specfic dat\\n if blockDat.get('form'):\\n _subShapers = blockDat['form'].get('subShapers',{})\\n log.debug(\\\"|{0}| >> subShaper dat mirror...\\\".format(_str_func, self.mNode)) \\n \\n for i,d_sub in _subShapers.iteritems():\\n l_t = d_sub.get('t')\\n l_r = d_sub.get('r')\\n l_s = d_sub.get('s')\\n \\n for ii,d_list in enumerate(l_t):\\n d_list[0] = d_list[0]*-1\\n for ii,d_list in enumerate(l_r):\\n d_list[0] = d_list[0]*-1 \\n d_list[1] = d_list[1]*-1\\n \\n _subShapers[str(i)]['r'][ii] = l_r\\n _subShapers[str(i)]['r'][ii] = l_t\\\"\\\"\\\"\\n \\n\\n self.connectChildNode(mMirror,'blockMirror','blockMirror')#Connect\\n mMirror.p_blockParent = mBlockParent\\n \\n blockDat_load(mMirror,useMirror=True,redefine=True)\\n controls_mirror(self,mMirror)\\n return mMirror\\n except Exception,err:cgmGEN.cgmException(Exception,err)\",\n \"def mine_block(last_block, data):\\n timestamp = time.time_ns()\\n last_hash = last_block.hash\\n difficulty = Block.adjust_difficulty(last_block, timestamp)\\n nonce = 0\\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\\n\\n while hex_to_binary(hash)[0:difficulty] != '0'* difficulty:\\n nonce += 1\\n timestamp = time.time_ns()\\n difficulty = Block.adjust_difficulty(last_block, timestamp)\\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\\n\\n return Block(timestamp, last_hash, hash, data, difficulty, nonce)\",\n \"def moveBlock(self, block: ghidra.program.model.mem.MemoryBlock, newStartAddr: ghidra.program.model.address.Address, monitor: ghidra.util.task.TaskMonitor) -> None:\\n ...\",\n \"def _create_utxo_block_unlocked(r,\\n curr_block: Block,\\n referenced_txos: Set[bytes],\\n new_utxos: Mapping[bytes, bytes]) -> None:\\n utxo_prev_block = r.dump(\\\"blockchain:utxo-block:\\\".encode() + curr_block.previous_hash)\\n r.restore(name=\\\"blockchain:utxo-block:\\\".encode() + curr_block.current_hash,\\n ttl=0,\\n value=utxo_prev_block,\\n replace=True)\\n r.hdel(\\\"blockchain:utxo-block:\\\".encode() + curr_block.current_hash, *referenced_txos)\\n r.hmset(\\\"blockchain:utxo-block:\\\".encode() + curr_block.current_hash, new_utxos)\",\n \"def proof_of_work(self, block):\\n block.nonce = 0 \\n computed_hash = block.compute_hash()\\n while not computed_hash.starswith('0' * Blockchain.difficulty):\\n block.nonce += 1 \\n computed_hash = block.compute_hash()\",\n \"def penblock(self, block):\\n self.block = block\",\n \"def apply_block(self, block_id, func=..., edges=..., inplace=...): # -> None:\\n ...\",\n \"def remove_genesis(proof):\\n\\n old_size = len(proof)\\n print(\\\"Removing genesis block from proof ...\\\")\\n proof.pop(-1)\\n print(\\\"OK\\\")\\n print(\\\"old size:\\\", old_size, \\\"-> new size:\\\", len(proof))\",\n \"def update(blockstring):\\n with BLOCK_LOCK:\\n for block in blockstring.split('|'):\\n name, values = parse(block)\\n BLOCKS[name] = values\",\n \"def _set_block(self, pos, block_):\\n _get_mc().setBlock(pos, block_)\",\n \"def mine_block(): \\n # Fetch the current last block of blockchain\\n last_block = blockchain[-1]\\n # Hash th elast block (=> to be able to compare it to stored hash value)\\n hashed_block = hash_block(last_block)\\n proof = proof_of_work()\\n # Miners should be rewarded, so here is reward\\n # reward_transaction = {\\n # 'sender': 'MINING',\\n # 'recipient': owner,\\n # 'amount': MINING_REWARD\\n # }\\n reward_transaction = OrderedDict([('sender', 'MINING'), ('recipient', owner), ('amount', MINING_REWARD)])\\n copied_transactions = open_transactions[:]\\n copied_transactions.append(reward_transaction)\\n\\n block = {\\n 'previous_hash': hashed_block,\\n 'index': len(blockchain),\\n 'transactions': copied_transactions,\\n 'proof': proof\\n }\\n blockchain.append(block)\\n return True\",\n \"def fix_not_found(self, course_locator, user_id):\\n original_structure = self._lookup_course(course_locator).structure\\n index_entry = self._get_index_if_valid(course_locator)\\n new_structure = self.version_structure(course_locator, original_structure, user_id)\\n for block in new_structure['blocks'].values():\\n if 'children' in block.fields:\\n block.fields['children'] = [\\n block_id for block_id in block.fields['children']\\n if block_id in new_structure['blocks']\\n ]\\n self.update_structure(course_locator, new_structure)\\n if index_entry is not None:\\n # update the index entry if appropriate\\n self._update_head(course_locator, index_entry, course_locator.branch, new_structure['_id'])\",\n \"def _copy_from_template(\\n self, source_structures, source_keys, dest_structure, new_parent_block_key, user_id, head_validation\\n ):\\n new_blocks = set()\\n\\n new_children = list() # ordered list of the new children of new_parent_block_key\\n\\n for usage_key in source_keys:\\n src_course_key = usage_key.course_key\\n hashable_source_id = src_course_key.for_version(None)\\n block_key = BlockKey(usage_key.block_type, usage_key.block_id)\\n source_structure = source_structures[src_course_key]\\n\\n if block_key not in source_structure['blocks']:\\n raise ItemNotFoundError(usage_key)\\n source_block_info = source_structure['blocks'][block_key]\\n\\n # Compute a new block ID. This new block ID must be consistent when this\\n # method is called with the same (source_key, dest_structure) pair\\n unique_data = \\\"{}:{}:{}\\\".format(\\n str(hashable_source_id).encode(\\\"utf-8\\\"),\\n block_key.id,\\n new_parent_block_key.id,\\n )\\n new_block_id = hashlib.sha1(unique_data.encode('utf-8')).hexdigest()[:20]\\n new_block_key = BlockKey(block_key.type, new_block_id)\\n\\n # Now clone block_key to new_block_key:\\n new_block_info = copy.deepcopy(source_block_info)\\n # Note that new_block_info now points to the same definition ID entry as source_block_info did\\n existing_block_info = dest_structure['blocks'].get(new_block_key, BlockData())\\n # Inherit the Scope.settings values from 'fields' to 'defaults'\\n new_block_info.defaults = new_block_info.fields\\n\\n # <workaround>\\n # CAPA modules store their 'markdown' value (an alternate representation of their content)\\n # in Scope.settings rather than Scope.content :-/\\n # markdown is a field that really should not be overridable - it fundamentally changes the content.\\n # capa modules also use a custom editor that always saves their markdown field to the metadata,\\n # even if it hasn't changed, which breaks our override system.\\n # So until capa modules are fixed, we special-case them and remove their markdown fields,\\n # forcing the inherited version to use XML only.\\n if usage_key.block_type == 'problem' and 'markdown' in new_block_info.defaults:\\n del new_block_info.defaults['markdown']\\n # </workaround>\\n\\n # Preserve any existing overrides\\n new_block_info.fields = existing_block_info.fields\\n\\n if 'children' in new_block_info.defaults:\\n del new_block_info.defaults['children'] # Will be set later\\n\\n new_block_info.edit_info = existing_block_info.edit_info\\n new_block_info.edit_info.previous_version = new_block_info.edit_info.update_version\\n new_block_info.edit_info.update_version = dest_structure['_id']\\n # Note we do not set 'source_version' - it's only used for copying identical blocks\\n # from draft to published as part of publishing workflow.\\n # Setting it to the source_block_info structure version here breaks split_draft's has_changes() method.\\n new_block_info.edit_info.edited_by = user_id\\n new_block_info.edit_info.edited_on = datetime.datetime.now(UTC)\\n new_block_info.edit_info.original_usage = str(usage_key.replace(branch=None, version_guid=None))\\n new_block_info.edit_info.original_usage_version = source_block_info.edit_info.update_version\\n dest_structure['blocks'][new_block_key] = new_block_info\\n\\n children = source_block_info.fields.get('children')\\n if children:\\n children = [src_course_key.make_usage_key(child.type, child.id) for child in children]\\n new_blocks |= self._copy_from_template(\\n source_structures, children, dest_structure, new_block_key, user_id, head_validation\\n )\\n\\n new_blocks.add(new_block_key)\\n # And add new_block_key to the list of new_parent_block_key's new children:\\n new_children.append(new_block_key)\\n\\n # Update the children of new_parent_block_key\\n dest_structure['blocks'][new_parent_block_key].fields['children'] = new_children\\n\\n return new_blocks\",\n \"def _merge_block(internal_transactions, transactions, whitelist):\\n transactions_by_id = {\\n (transaction[\\\"hash\\\"], transaction[\\\"blockHash\\\"]): transaction\\n for transaction in transactions\\n }\\n for transaction in internal_transactions:\\n hash = transaction[\\\"transactionHash\\\"]\\n block = transaction[\\\"blockHash\\\"]\\n if (hash, block) in transactions_by_id:\\n whitelisted_fields = {\\n key: value\\n for key, value in transactions_by_id[(hash, block)].items()\\n if key in whitelist\\n }\\n transaction.update(whitelisted_fields)\\n del transactions_by_id[(hash, block)]\\n return internal_transactions\",\n \"def validate_and_add_block(self, block):\\n\\n # 1. Validate transaction(s) in block\\n tx = block.transactions\\n if not self.validate_transaction(tx):\\n print(\\\"Block contains invalid transactions.\\\")\\n return\\n\\n # 2. Hash transaction(s)\\n tx_hash = HashAssist.hash_value(value=tx.to_string_for_hashing())\\n\\n # 3. Validate header\\n header_string = block.prev_hash + tx_hash + block.nonce\\n header_hash = HashAssist.hash_value(header_string)\\n if not block.header_hash == header_hash:\\n print(\\\"Block header invalid!\\\")\\n return\\n\\n self.blocks.append(block)\",\n \"def createNewBlock(self, nonce, previousBlockHash, hash):\\n newBlock = Block(len(self.chain), self.pendingTransactions, nonce, hash, previousBlockHash)\\n self.pendingTransactions = []\\n self.chain.append(newBlock)\\n return newBlock\",\n \"def pre_process(writer, _):\\n writer.disable_raw()\\n writer.enable_wrap()\\n writer.width = int(writer.defaults['width'])\\n writer.pre_node = 0\\n for name in writer.defaults['add_block'].split(','):\\n if name and name not in MOD.BLOCK:\\n MOD.BLOCK.append(name)\\n for name in writer.defaults['del_block'].split(','):\\n try:\\n MOD.BLOCK.remove(name)\\n except ValueError:\\n pass\",\n \"def transform_block(block, scale, translation):\\n if block is None:\\n return None\\n if block.x is None:\\n x = None\\n else:\\n x = (block.x * scale[0]) + translation[0]\\n if block.y is None:\\n y = None\\n else:\\n y = (block.y * scale[1]) + translation[1]\\n width = block.width * scale[0]\\n height = block.height * scale[1]\\n\\n return block._replace(x=x, y=y, width=width, height=height)\",\n \"def test_update_metadata(self):\\r\\n locator = BlockUsageLocator(\\r\\n CourseLocator(org=\\\"testx\\\", offering=\\\"GreekHero\\\", branch='draft'),\\r\\n 'problem', block_id=\\\"problem3_2\\\"\\r\\n )\\r\\n problem = modulestore().get_item(locator)\\r\\n pre_def_id = problem.definition_locator.definition_id\\r\\n pre_version_guid = problem.location.version_guid\\r\\n self.assertIsNotNone(pre_def_id)\\r\\n self.assertIsNotNone(pre_version_guid)\\r\\n self.assertNotEqual(problem.max_attempts, 4, \\\"Invalidates rest of test\\\")\\r\\n\\r\\n problem.max_attempts = 4\\r\\n problem.save() # decache above setting into the kvs\\r\\n updated_problem = modulestore().update_item(problem, '**replace_user**')\\r\\n # check that course version changed and course's previous is the other one\\r\\n self.assertEqual(updated_problem.definition_locator.definition_id, pre_def_id)\\r\\n self.assertNotEqual(updated_problem.location.version_guid, pre_version_guid)\\r\\n self.assertEqual(updated_problem.max_attempts, 4)\\r\\n # refetch to ensure original didn't change\\r\\n original_location = problem.location.map_into_course(CourseLocator(version_guid=pre_version_guid))\\r\\n problem = modulestore().get_item(original_location)\\r\\n self.assertNotEqual(problem.max_attempts, 4, \\\"original changed\\\")\\r\\n\\r\\n current_course = modulestore().get_course(locator.course_key)\\r\\n self.assertEqual(updated_problem.location.version_guid, current_course.location.version_guid)\\r\\n\\r\\n history_info = modulestore().get_course_history_info(current_course.location)\\r\\n self.assertEqual(history_info['previous_version'], pre_version_guid)\\r\\n self.assertEqual(history_info['edited_by'], \\\"**replace_user**\\\")\",\n \"def populate_block(self, block, additional_options=None):\\n raise NotImplementedError(\\n \\\"SurrogateModel class has not implemented populate_block method.\\\"\\n )\",\n \"def save_block(self, block):\\n # Implementing this is optional.\",\n \"def set_new_hash(court_id, new_hash):\\n seals_data[court_id]['hash'] = new_hash\",\n \"def pre_process(writer, _):\\n writer.disable_raw()\\n writer.enable_wrap()\\n writer.header = writer.defaults['header']\\n writer.width = int(writer.defaults['width'])\\n writer.pre_node = 0\\n writer.list_level = 0\\n for name in writer.defaults['add_block'].split(','):\\n if name and name not in MOD['nw'].BLOCK:\\n MOD['nw'].BLOCK.append(name)\\n for name in writer.defaults['del_block'].split(','):\\n try:\\n MOD['nw'].BLOCK.remove(name)\\n except ValueError:\\n pass\",\n \"def test_block():\\n b = common.Block(['1 1 1', '2 2 3 ', ''])\\n expect = ['1 1 1', '2 2 3']\\n c = b.compact()\\n assert c == expect\\n assert b != expect\\n\\n b.compact(inplace=True)\\n assert b == expect\",\n \"def new_block(self, body_blocks, snake_head):\\n\\t\\tx = randint(0, 35)\\n\\t\\ty = randint(1, 26)\\n\\t\\tself.rect.x = (25 * x) + 1\\n\\t\\tself.rect.bottom = 25 * y\\n\\t\\t\\n\\t\\t# If new block is on snake, get new block\\n\\t\\tif self.rect.x == snake_head.rect.x and self.rect.bottom == snake_head.rect.bottom:\\n\\t\\t\\tself.new_block(body_blocks, snake_head)\\n\\t\\t\\n\\t\\t# If new block is on any body block, get new block\\n\\t\\tif body_blocks:\\n\\t\\t\\tfor i in range(len(body_blocks)):\\n\\t\\t\\t\\tif self.rect.x == body_blocks[i].rect.x and self.rect.bottom == body_blocks[i].rect.bottom:\\n\\t\\t\\t\\t\\tself.new_block(body_blocks, snake_head)\",\n \"def add_block(self, block_pf):\\n\\n # test si il s'agit du bloc genesis\\n if len(self.blocks) != 0:\\n # check si previous H est coherent avant ajout a chaine\\n if self.check_previousBlockH(block_pf.header['prevBlockH']):\\n self.blocks.append(block_pf)\\n else:\\n print \\\"== Probleme de parent\\\"\\n print \\\"= %s\\\" % block_pf.header['prevBlockH']\\n print \\\"= %s\\\" % getHashBlock(self.get_topBlock())\\n else:\\n self.blocks.append(block_pf)\",\n \"def invalidateblock(self, block_hash: str) -> None:\\n return self.rpc_call(\\\"invalidateblock\\\", block_hash)\",\n \"def replace_id(self, old_id, new_id):\\n def replace(prf):\\n for item in prf.items:\\n item.prevs = [new_id if id == old_id else id for id in item.prevs]\\n if item.subproof:\\n replace(item.subproof)\\n\\n prf = self.prf.get_parent_proof(old_id)\\n replace(prf)\\n\\n self.remove_line(old_id)\",\n \"def block(self, block):\\n\\n self._block = block\",\n \"def block(self, block):\\n\\n self._block = block\",\n \"def seed(cls, block: Expr) -> Expr:\\n return cls(BlockField.block_seed, block)\",\n \"def replaceChain(self, newChain):\\n\\n if len(newChain) <= len(self.__chain):\\n return False\\n\\n # Validate the new chain\\n if not self.validateChain(newChain):\\n return False\\n\\n newBlocks = newChain[len(self.__chain):]\\n for block in newBlocks:\\n self.addBlock(block)\",\n \"def change_block(self, move):\\n fpath = os.path.split(os.path.abspath(self.source_path))[0] # current directory\\n fname = os.path.split(os.path.abspath(self.source_path))[1] # current file\\n pre, _ = fname.split('_B')\\n flist = glob.glob(fpath + '/' + pre + '_B*.nwb')\\n curr_ind = flist.index(self.source_path)\\n if curr_ind + move == len(flist):\\n new_file = flist[0]\\n else:\\n new_file = flist[curr_ind + move]\\n self.open_another_file(filename=new_file)\",\n \"def remove(self, block):\\n try:\\n self.blocks[block.height]\\n except:\\n raise ValueError(\\\"cant remove block: \\\" + str(block))\\n\\n removed = False\\n for b in self.blocks[block.height]:\\n # only delete the one with equal hash\\n if b.hash() == block.hash():\\n self.blocks[block.height].remove(b)\\n removed = True\\n if self.blocks[block.height] == []:\\n self.blocks.pop(block.height)\\n\\n if not removed:\\n raise ValueError(\\\"cant remove block: \\\" + str(block))\",\n \"def split(self, block: ghidra.program.model.mem.MemoryBlock, addr: ghidra.program.model.address.Address) -> None:\\n ...\",\n \"def add_block(self, env):\\n block_size = (0.04, 0.04, 0.04)\\n block_pose = self.random_pose(env, block_size)\\n block_urdf = 'assets/stacking/block.urdf'\\n block_id = env.add_object(block_urdf, block_pose)\\n self.object_points[block_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n self._IDs[block_id] = 'block'\\n return block_id\",\n \"def removeMemoryBlock(self, block: ghidra.program.model.mem.MemoryBlock) -> None:\\n ...\",\n \"def CommitBlock(self, block):\\n QUEUE.put(Block(block=block))\",\n \"def makeBlock(tag):\\n return {\\\"t\\\":\\\"RawBlock\\\",\\\"c\\\":[\\\"html\\\",tag]}\",\n \"def MarkBlock(state, begin, end):\\n # TODO: Make sure already existing blocks don't overlap\\n if begin == end:\\n return\\n last_pos = 0\\n for entry in state:\\n pos = entry['pos']\\n if begin >= last_pos and begin < pos:\\n if end < pos:\\n # block doesn't cross any line boundary\\n entry['blocks'].append((begin, end))\\n else:\\n # block crosses the line boundary\\n entry['blocks'].append((begin, pos))\\n MarkBlock(state, pos, end)\\n break\\n last_pos = pos\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6696862","0.6492034","0.62668824","0.62506884","0.62480694","0.6142988","0.61030936","0.6102814","0.6081092","0.6058437","0.6036382","0.6030431","0.60070413","0.5958737","0.5852314","0.58496255","0.5832161","0.5744932","0.57379293","0.5737272","0.5722827","0.5722498","0.5706847","0.57065016","0.568726","0.56568944","0.5648556","0.56285864","0.559861","0.5563516","0.5548452","0.5523684","0.552134","0.5513415","0.551311","0.54941195","0.54875916","0.5485968","0.54612005","0.5458781","0.5448669","0.5435308","0.54307705","0.54161876","0.53706646","0.5361761","0.5331015","0.5321637","0.5297056","0.52929634","0.5292174","0.5291908","0.5288679","0.5286698","0.52667814","0.5257211","0.5250791","0.52446884","0.5239018","0.521737","0.52095145","0.52079123","0.5184243","0.5135404","0.5125718","0.5124084","0.51229924","0.51197743","0.5106089","0.50958383","0.5094121","0.5084571","0.50816995","0.50582856","0.5058278","0.50545883","0.5053815","0.50535285","0.5044193","0.50432795","0.5042776","0.5036819","0.5032222","0.50303566","0.5025617","0.50075036","0.5000669","0.4996435","0.49926394","0.49926394","0.4990653","0.49899185","0.49837762","0.49800897","0.49726802","0.49451876","0.49332714","0.4929146","0.49256873","0.49211076"],"string":"[\n \"0.6696862\",\n \"0.6492034\",\n \"0.62668824\",\n \"0.62506884\",\n \"0.62480694\",\n \"0.6142988\",\n \"0.61030936\",\n \"0.6102814\",\n \"0.6081092\",\n \"0.6058437\",\n \"0.6036382\",\n \"0.6030431\",\n \"0.60070413\",\n \"0.5958737\",\n \"0.5852314\",\n \"0.58496255\",\n \"0.5832161\",\n \"0.5744932\",\n \"0.57379293\",\n \"0.5737272\",\n \"0.5722827\",\n \"0.5722498\",\n \"0.5706847\",\n \"0.57065016\",\n \"0.568726\",\n \"0.56568944\",\n \"0.5648556\",\n \"0.56285864\",\n \"0.559861\",\n \"0.5563516\",\n \"0.5548452\",\n \"0.5523684\",\n \"0.552134\",\n \"0.5513415\",\n \"0.551311\",\n \"0.54941195\",\n \"0.54875916\",\n \"0.5485968\",\n \"0.54612005\",\n \"0.5458781\",\n \"0.5448669\",\n \"0.5435308\",\n \"0.54307705\",\n \"0.54161876\",\n \"0.53706646\",\n \"0.5361761\",\n \"0.5331015\",\n \"0.5321637\",\n \"0.5297056\",\n \"0.52929634\",\n \"0.5292174\",\n \"0.5291908\",\n \"0.5288679\",\n \"0.5286698\",\n \"0.52667814\",\n \"0.5257211\",\n \"0.5250791\",\n \"0.52446884\",\n \"0.5239018\",\n \"0.521737\",\n \"0.52095145\",\n \"0.52079123\",\n \"0.5184243\",\n \"0.5135404\",\n \"0.5125718\",\n \"0.5124084\",\n \"0.51229924\",\n \"0.51197743\",\n \"0.5106089\",\n \"0.50958383\",\n \"0.5094121\",\n \"0.5084571\",\n \"0.50816995\",\n \"0.50582856\",\n \"0.5058278\",\n \"0.50545883\",\n \"0.5053815\",\n \"0.50535285\",\n \"0.5044193\",\n \"0.50432795\",\n \"0.5042776\",\n \"0.5036819\",\n \"0.5032222\",\n \"0.50303566\",\n \"0.5025617\",\n \"0.50075036\",\n \"0.5000669\",\n \"0.4996435\",\n \"0.49926394\",\n \"0.49926394\",\n \"0.4990653\",\n \"0.49899185\",\n \"0.49837762\",\n \"0.49800897\",\n \"0.49726802\",\n \"0.49451876\",\n \"0.49332714\",\n \"0.4929146\",\n \"0.49256873\",\n \"0.49211076\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8152844"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74281,"cells":{"query":{"kind":"string","value":"Create, edit and print chains and proofs"},"document":{"kind":"string","value":"def main():\n\n parser = argparse.ArgumentParser(description=\"Prints the contents of a NiPoPoW\")\n parser.add_argument(\"--blocks\", required=True, type=int, help=\"Number of blocks\")\n parser.add_argument(\n \"--output\", default=\"proof.pkl\", type=str, help=\"Name of exported proof\"\n )\n args = parser.parse_args()\n blocks = args.blocks\n output = args.output\n if output.find(\".pkl\") == -1:\n output += \".pkl\"\n\n # Create blockchain\n header, headers_map, interlink_map = create_blockchain(blocks=blocks)\n print_headers(headers_map)\n print_interlinks(headers_map, interlink_map)\n\n # Create proof\n proof = make_proof(header, headers_map, interlink_map)\n print_proof(proof, headers_map)\n\n ### Start spoiling proof\n\n # remove_genesis(proof)\n # proof = change_interlink_hash(proof, 0)\n # proof = skip_blocks(proof, -2)\n # proof = replace_block(proof, headers_map, interlink_map, int(len(proof)/2))\n # print_proof(proof, headers_map)\n # verify_proof(Hash(proof[0][0]), proof)\n\n ### Stop spoiling proof\n\n proof_tool = ProofTool(\"../../data/proofs/\")\n p, f, lca = proof_tool.create_proof_and_forkproof(blocks, forkindex, forkblocks)\n print(p, f, lca)\n\n fixed_fork_proof = proof_tool.fetch_proof(f)\n verify_proof(Hash(fixed_fork_proof[0][0]), fixed_fork_proof)\n\n # proof_tool = ProofTool(\"../../data/proofs/\")\n # proof_tool.export_proof(fixed_fork_proof, f)"},"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 main():\n\n parser = argparse.ArgumentParser(\n description=\"Create and store proof from create_blockchain_new.py\"\n )\n group = parser.add_mutually_exclusive_group()\n group.add_argument(\"--blocks\", type=int, help=\"Number of blocks\")\n group.add_argument(\"--proof\", type=str, help=\"Name of proof\")\n args = parser.parse_args()\n blocks = args.blocks\n proof_name = args.proof\n\n proof_tool = ProofTool(\"../../data/proofs/\")\n\n proof = []\n if blocks is not None:\n # proof = proof_tool.fetch_proof(blocks)\n proof = proof_tool.create_proof(blocks)\n elif proof_name is not None:\n proof = proof_tool.fetch_proof(proof_name)\n else:\n print(\"Provide --blocks or --proof argument\")\n sys.exit()\n\n print(\"Proof size:\", len(proof))","def demo():\n # Create some nonterminals\n S, NP, VP, PP = nonterminals('S, NP, VP, PP')\n N, V, P, Det = nonterminals('N, V, P, Det')\n VP_slash_NP = VP/NP\n\n print 'Some nonterminals:', [S, NP, VP, PP, N, V, P, Det, VP/NP]\n print ' S.symbol() =>', `S.symbol()`\n print\n\n # Create some CFG Productions\n prods = [CFGProduction(S, [NP, VP]), CFGProduction(PP, [P, NP]),\n CFGProduction(NP, [Det, N]), CFGProduction(NP, [NP, PP]),\n CFGProduction(VP, [V, NP]), CFGProduction(VP, [VP, PP]),\n CFGProduction(Det, ['a']), CFGProduction(Det, ['the']),\n CFGProduction(N, ['dog']), CFGProduction(N, ['cat']), \n CFGProduction(V, ['chased']), CFGProduction(V, ['sat']),\n CFGProduction(P, ['on']), CFGProduction(P, ['in'])]\n\n prod = prods[2]\n print 'A CFG production:', `prod`\n print ' prod.lhs() =>', `prod.lhs()`\n print ' prod.rhs() =>', `prod.rhs()`\n print\n\n # Create and print a CFG\n cfg = CFG(S, prods)\n print 'A CFG grammar:', `cfg`\n print ' cfg.start() =>', `cfg.start()`\n print ' cfg.productions() =>',\n # Use string.replace(...) is to line-wrap the output.\n print `cfg.productions()`.replace(',', ',\\n'+' '*25)\n print\n\n # Create some probabilistic CFG Productions\n A, B, C = nonterminals('A, B, C')\n pcfg_prods = [PCFGProduction(A, [B, B], prob=0.3),\n PCFGProduction(A, [C, B, C], prob=0.7),\n PCFGProduction(B, [B, 'b'], prob=0.5),\n PCFGProduction(B, [C], prob=0.5),\n PCFGProduction(C, ['a'], prob=0.1),\n PCFGProduction(C, ['b'], prob=0.9)] \n \n pcfg_prod = pcfg_prods[2]\n print 'A PCFG production:', `pcfg_prod`\n print ' pcfg_prod.lhs() =>', `pcfg_prod.lhs()`\n print ' pcfg_prod.rhs() =>', `pcfg_prod.rhs()`\n print ' pcfg_prod.prob() =>', `pcfg_prod.prob()`\n print\n\n # Create and print a PCFG\n pcfg = PCFG(S, pcfg_prods)\n print 'A PCFG grammar:', `pcfg`\n print ' pcfg.start() =>', `pcfg.start()`\n print ' pcfg.productions() =>',\n # Use string.replace(...) is to line-wrap the output.\n print `pcfg.productions()`.replace(',', ',\\n'+' '*26)\n print","def m_dump_tf():\n\n # Info about ENS and Resolver Smart Contracts\n #print(f\"ENS address: {ens.address()}\")\n print(f\"ENS address (contract address): {ENS.address}\")\n print(f\"Resolver address (contract address): {resolver.address()}\")\n print(f\"Resolver address from ENS(root): {ens.resolver('root')}\")\n print(\"\\n\")\n\n print(f\"Owner of ROOT record: {ens.owner('root')}\")\n ROOT_address, ROOT_key = wallet.account_from_name(\"ROOT\", \"ThePassword\")\n print(f\"ROOT address from wallet: {ROOT_address}\")\n\n n_subnodes = ens.numberSubnodes(0)\n print(f\"Number of subnodes of root: {n_subnodes}\")\n for i in range(n_subnodes):\n hash = ens.subnode(index=i).hex()\n print(f\" Subnode hash {i}: {ens.subnode(i).hex()}\")\n name = resolver.name(node_hash=hash)\n print(f\" Name: {name}\")\n resolver_address = ENS.functions.resolver(hash).call()\n print(f\" Resolver: {resolver_address}\")\n ala_address = ens.resolver(name)\n print(f\" Resolver by name: {ala_address}\")\n owner = owner = ENS.functions.owner(hash).call()\n print(f\" Owner: {owner}\")\n ROOT_address, ROOT_key = wallet.account_from_name(\"Alastria\", \"ThePassword\")\n print(f\" Address from wallet: {ROOT_address}\")\n\n n_subnodes = ens.numberSubnodes(\"ala\")\n print(f\"Number of subnodes of {name}: {n_subnodes}\")\n for i in range(n_subnodes):\n hash = ens.subnode(node_name=\"ala\", index=i).hex()\n print(f\" Subnode hash {i}: {hash}\")\n name = resolver.name(node_hash=hash)\n print(f\" Name: {name}\")\n resolver_address = ENS.functions.resolver(hash).call()\n print(f\" Resolver: {resolver_address}\")\n ala_address = ens.resolver(name)\n print(f\" Resolver by name: {ala_address}\")\n owner = owner = ENS.functions.owner(hash).call()\n print(f\" Owner: {owner}\")","def test_conjecture():\n print(\"Executing test_conjecture:\")\n\n theory=[]\n\n print(language.program_string(theory))\n for i in range(10):\n theory=conjecture.vary([theory], 0, [], steps=1)\n print(f\"Theory after {i+1} stages of variation:\")\n print(language.program_string(theory))","def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_failed = []\n output_ordering_map = {k: v for v, k in enumerate(sol)}\n for c in constraints:\n\n m = output_ordering_map # Creating an alias for easy reference\n\n wiz_a = m[c[0]]\n wiz_b = m[c[1]]\n wiz_mid = m[c[2]]\n\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\n constraints_failed.append(c)\n else:\n constraints_satisfied += 1\n return num_constraints - constraints_satisfied\n\n def neighbors(sol):\n wiz1 = random.randint(0,num_wizards-1)\n wiz2 = random.randint(0,num_wizards-1)\n\n new_sol = copy.copy(sol)\n temp = new_sol[wiz1]\n new_sol[wiz1] = new_sol[wiz2]\n new_sol[wiz2] = temp\n \n return new_sol\n\n def acceptance_probability(old_cost,new_cost,T):\n exponent = (old_cost - new_cost) / T\n \n try:\n ans = math.exp(exponent)\n except OverflowError:\n ans = float('inf')\n return ans\n\n\n def anneal(solution, num_constraints, constraints):\n old_cost = 0\n new_cost = 0\n old_cost = cost(solution,num_constraints,constraints)\n T = 1.0\n T_min = 0.000001\n alpha = 0.98\n while T > T_min:\n i = 1\n while i <= 1000:\n new_solution = neighbors(solution)\n new_cost = cost(new_solution,num_constraints,constraints)\n if new_cost == 0:\n return new_solution,new_cost\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T*alpha\n return solution, old_cost\n\n s = copy.copy(wizards)\n random.shuffle(s)\n ret = anneal(s,num_constraints,constraints)\n \n for i in range(10):\n if ret[1] == 0:\n break\n random.shuffle(s)\n new_ret = anneal(s,num_constraints,constraints)\n print(i)\n if new_ret[1] < ret[1]:\n ret = new_ret\n print(\"constraints failed: {0}\".format(ret[1]))\n return ret[0]","def makeBinaryChains():\n\t\n\t# retrieve the binding partner specifications\n\t(maxsize,types) = getTypes()\n\t\n\t# Do some basic argument checking for this model\n\tif (len(types) < 2):\n\t\tprint \"Number of defined types must equal two for binary chain calculations.\"\n\t\treturn\n\tif (maxsize == 0):\n\t\tprint \"Must specify a valid maximum number for one or more components.\"\n\t\treturn\n\n\tallChains = []\n\tnewChainsA = [[]]\n\tnewChainsB = []\n\t\n\ttypeA = types[0]\n\ttypeB = types[1]\n\t\n\t# start the chain with a single type A component\n\taddComponent(newChainsA[0],typeA,0,0)\n\n\tdepth = 0\n\tfor n in range(maxsize):\n\t\tdepth+=1\n\t\t\n\t\t# go through all the chains created last iteration and append B components\n\t\tnewChainsB = []\n\t\tfor thisChain in newChainsA:\n\n\t\t\t# get a list of new available sites in the provided chain\n\t\t\t# by setting depth -1, we will only add to components added last round\n\t\t\topenSites = makeSiteList(thisChain,typeB,depth-1)\n\t\t\t\n\t\t\t# make all the descendants from the current chain and append them to the pool\n\t\t\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\n\t\t\telse:\n\t\t\t\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\n\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsB\n\t\t\n\t\tdepth+=1\n\t\t\n\t\t# add an additional component to all the previously modified chains\n\t\tnewChainsA = []\n\t\tfor thisChain in newChainsB:\n\n\t\t\topenSites = makeSiteList(thisChain,typeA,depth-1)\n\t\t\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\n\t\t\t\n\t\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\n\t\t\n\t\tallChains = allChains + newChainsA\n\n\treturn allChains","def genChains(self):\n self.numMonomer = 0\n self.numBonds = 0\n self.numMols = 0\n self.numCations = 0\n self.numAnions = 0\n\n self.atomsCoords = []\n self.atomsType = []\n self.atomsCharge = []\n self.molId = []\n self.bondList = []\n \n for i in range(self.numPa + self.numPc):\n\n if i < self.numPc:\n # polycation chains, charge in LJ units of LAMMPS\n # electron charge would be 10.54 using bare LAMMPS LJ units\n # the dielectric constans of solvent is effectively taken as 111 when assign 1 to +e\n # just need to set dielectric as 0.72 in LAMMPS ot mimic water with dielectric constant 80\n self.beadCharge = 1\n self.beadType = 1 # atomic type for neutral beads in polycation chains\n self.chain = self.lenPc\n else:\n self.beadCharge = -1 # polyanion chains\n self.beadType = 3 # atomic type for neutral beads in polyanion chains\n self.chain = self.lenPa\n\n self.numMols += 1\n\n # generate the first bead of each chain randomly\n self.numMonomer += 1\n self.cxyz = np.random.rand(3) * self.box + self.lxyz\n\n self.atomsCoords.append(self.cxyz)\n #self.atomsType.append(self.beadType)\n\n # decide if the first bead is charged or not\n if self.chargeRepeat == 1:\n self.atomsCharge.append(self.beadCharge)\n self.atomsType.append(self.beadType + 1)\n if i < self.numPc:\n self.numCations += 1\n else:\n self.numAnions += 1\n else:\n self.atomsType.append(self.beadType)\n self.atomsCharge.append(0)\n\n self.molId.append(self.numMols)\n\n self.currpxyz = self.cxyz\n\n # follow random walk to generate the chain\n # generate the seconb bead of the chain\n self.theta, self.phi = np.random.rand(2) * np.array([np.pi, 2 * np.pi])\n self.ds = np.array([np.cos(self.theta), np.sin(self.theta) * np.cos(self.phi),\\\n np.sin(self.theta) * np.sin(self.phi)]) * self.segment\n\n self.cxyz = self.currpxyz + self.ds\n\n self.numMonomer += 1\n self.atomsCoords.append(self.cxyz)\n\n # decide if the second bead is charged or not\n if 2%self.chargeRepeat == 0:\n self.atomsCharge.append(self.beadCharge)\n self.atomsType.append(self.beadType + 1)\n if i < self.numPc:\n self.numCations += 1\n else:\n self.numAnions += 1\n else:\n self.atomsCharge.append(0)\n self.atomsType.append(self.beadType)\n\n self.molId.append(self.numMols)\n \n self.numBonds += 1\n self.bondList.append([self.numMonomer - 1, self.numMonomer])\n\n self.currpxyz = self.cxyz\n\n self.currtheta = self.theta\n self.currphi = self.phi\n\n self.dstot += self.ds\n\n # generating the rest beads of the chain\n\n for k in range(3, self.chain+1):\n # only accept atoms that are beyong certain distance\n # from the atom precding the current atom in the chain\n self.theta, self.phi = np.random.rand() * np.array([np.pi - self.stiffangle, \\\n 2 * np.pi])\n self.ds1 = np.array([np.cos(self.theta), np.sin(self.theta) * np.cos(self.phi),\\\n np.sin(self.theta) * np.sin(self.phi)]) * self.segment\n\n self.reverseXZrotation()\n self.cxyz = self.currpxyz + self.ds\n\n self.numMonomer += 1\n self.atomsCoords.append(self.cxyz)\n\n if k % self.chargeRepeat == 0:\n self.atomsCharge.append(self.beadCharge)\n self.atomsType.append(self.beadType + 1)\n if i < self.numPc:\n self.numCations += 1\n else:\n self.numAnions += 1\n else:\n self.atomsCharge.append(0)\n self.atomsType.append(self.beadType)\n\n self.molId.append(self.numMols)\n self.numBonds += 1\n self.bondList.append([self.numMonomer - 1, self.numMonomer])\n\n self.currpxyz = self.cxyz\n\n self.currtheta = np.arccos(self.ds[0]/self.segment)\n if self.ds[2] > 0:\n self.currphi = np.arccos(self.ds[1]/self.segment/np.sin(self.currtheta))\n else:\n self.currphi = 2*np.pi - np.arccos(self.ds[1]/self.segment/np.sin(self.currtheta))\n\n self.dstot += self.ds\n\n print \"%d beads are generated.\\n\" % self.numMonomer \n assert self.numMonomer == self.numPc * self.lenPc + self.numPa * self.lenPa, \\\n \"The number of monomers in chains is wrong!\\n\"\n assert self.numCations == int(np.floor(self.lenPc * self.chargeFraction)*self.numPc), \\\n \"The number of positively charged beads is wrong!\\n\"\n assert self.numAnions == int(np.floor(self.lenPa * self.chargeFraction)*self.numPa), \\\n \"The number of negatively charged beads is wrong!\\n\"","def main():\n\n # Define the names of required input files, and other main configuration variables\n protein_w_underscores = os.getcwd().split('/')[-1]\n protein = protein_w_underscores.replace('_', ' ')\n pdbfile = 'pdb_structure.pdb' # the name of the PDB file\n pdbchain = None # chain in pdbfile -- there is only one chain, so not relevant here\n seqfile = 'protseq.txt' # file containing the protein sequence\n ddgdatafile = 'ddG_data.txt' # file containing the literature-culled ddG values\n ddgdatafile_warning = False # warn if ddgdatafile has conflicting ddG values for a mutation\n alignment_file = \"uniref_alignment-gaps_lt_0.1-identities_gt_0.5.fasta\" # file with aligned sequences\n phylip_path = '/Users/bloom/phylip-3.67/exe/' # path to phylip phylogeny program\n\n # Define the names of files that will be created by the script if they do not already exist\n cupsatfile = 'CUPSAT_ddGs.txt' # contains the ddG values from CUPSAT\n treefile = \"tree.newick\" # phylogenetic tree created by phylip\n phylipsequencefile = \"phylip_sequence_file\" # phylip input sequence file\n phylipdistancefile = \"phylip_distance_file\" # phylip distance matrix\n pipsddgsfile = \"pips_ddgs.txt\" # pips ddgs file\n regularizingpriorpipsddgsfile = 'pips_ddgs_with_regularizing_priors.txt' # pips ddgs file calculated with regularizing priors\n hydrophobicitypriorpipsddgsfile = 'pips_ddgs_with_hydrophobicity_priors.txt' # pips ddgs file calculated with hydrophobicity priors\n\n # Begin execution of the program\n seq = open(seqfile).read().strip() # read in protein sequence\n\n # Get the ddG values from CUPSAT and store in the dictionary cupsat_ddgs. Note that\n # in this and all subsequent ddG dictionaries, the first residue is numbered as 0.\n print \"\\nObtaining CUPSAT ddG values...\"\n sys.stdout.flush()\n if os.path.isfile(cupsatfile): # ddG values already obtained, just read from file\n (datetime, cupsat_ddgs) = pips.ddg_inference.ReadDDGs(cupsatfile)\n print \"Read the stored CUPSAT values from %s from the file %s.\" % (datetime, cupsatfile)\n else: # we need to obtain the ddG values from the CUPSAT webserver\n datetime = time.asctime()\n print \"Beginning to calculate and download CUPSAT ddGs at %s...\" % datetime\n sys.stdout.flush()\n cupsat_ddgs = pips.cupsat.RunCUPSAT(pdbfile, seq, pdbchain)\n pips.ddg_inference.WriteDDGs(cupsat_ddgs, cupsatfile, datetime)\n print \"Completed download of CUPSAT ddG values, stored in the file %s.\" % cupsatfile\n rescaled_cupsat_ddgs = pips.ddg_inference.RescaleDDGs(cupsat_ddgs, 10.0, '10TH_TO_90TH', recenter=5.0, min_max=(-3.0, 13.0)) \n\n # Read the literature-culled ddG data from ddgdatafile and store in the dictionary ddg_data\n print \"\\nReading the literature-culled ddG data from %s...\" % ddgdatafile\n sys.stdout.flush()\n ddgmatch = re.compile(\"^(?P<wt>[A-Y])(?P<r>\\d+)(?P<mut>[A-Y])\\s+(?P<ddg>\\-{0,1}\\d+\\.\\d+)$\")\n ddg_data = {}\n for r in range(len(seq)):\n rdict = {}\n wt = seq[r]\n for aa in pips.ddg_inference.AminoAcids():\n if aa != wt:\n rdict[aa] = []\n ddg_data[r] = (wt, rdict)\n for line in open(ddgdatafile).readlines(): # loop over all lines in ddgdatafile\n if line[0] == '#':\n continue # line is a comment\n m = ddgmatch.search(line.strip()) # match the ddG value\n if not m:\n raise ValueError, \"Cannot read ddG value of %s\" % line\n (wt, r, mut, ddg) = (m.group('wt'), int(m.group('r')), m.group('mut'), float(m.group('ddg')))\n r -= 1 # we decrement r because we are calling the first residue 0\n if seq[r] != wt:\n raise ValueError, \"Wildtype residue does not match protein sequence in %s\" % line\n ddg_data[r][1][mut].append(ddg) \n nddgs = 0\n ddgslist = []\n for (r, (wt, rddgs)) in ddg_data.iteritems():\n for mut in rddgs.iterkeys():\n if not rddgs[mut]:\n rddgs[mut] = None # no ddG value\n else:\n nddgs += 1\n ddg0 = rddgs[mut][0]\n allthesame = True\n for ddgi in rddgs[mut][1 : ]: # see if all ddG values are the same for mutation\n if ddgi != ddg0:\n allthesame = False\n if allthesame: # all of the ddG values are the same, take this value\n rddgs[mut] = ddg0\n ddgslist.append(ddg0)\n else: # ddG values differ, print warning and take the average value\n ddg = pips.stats.Mean(rddgs[mut])\n if ddgdatafile_warning:\n print \"WARNING: Mutation %s%d%s has multiple ddG values of\" % (wt, r + 1, mut),\n for ddgi in rddgs[mut]:\n print \"%.2f\" % ddgi,\n print \"--- taking the average value of %.2f.\" % ddg\n sys.stdout.flush()\n rddgs[mut] = ddg\n ddgslist.append(ddg)\n print \"Read a total of %d different ddG values from %s. The mean value is %.2f, the maximum value is %.2f, and the minimum value is %.2f.\" % (nddgs, ddgdatafile, pips.stats.Mean(ddgslist), max(ddgslist), min(ddgslist))\n\n # Read the aligned sequences (into sequences), give short names for phylip\n sequences = pips.fasta.Read(alignment_file)\n nsequences = len(sequences)\n sequences = [(\"SEQ%d\" % (i + 1), sequences[i][1]) for i in range(nsequences)] # rename \n pips.fasta.Write(sequences, 'renamed_alignment.fasta')\n sequences = pips.align.StripGapsToFirstSequence(sequences) \n print \"\\nThere are %d sequences in the alignment.\" % nsequences\n\n # Construct the phylogenetic tree\n if os.path.isfile(treefile):\n print \"A phylogenetic tree has already been constructed for these sequences, and is being read from %s.\" % treefile\n newick_tree = open(treefile).read()\n else:\n print \"Constructing a phylogenetic tree for these sequences...\"\n sys.stdout.flush()\n pips.phylip.WritePhylipSequenceFile(sequences, phylipsequencefile)\n open(phylipdistancefile, 'w').write(pips.phylip.Protdist(phylipsequencefile, phylip_path))\n newick_tree = pips.phylip.DistanceTree(phylipdistancefile, phylip_path, molecular_clock=True, neighbor_joining=True)\n print \"Finished constructing the phylogenetic tree, writing it to %s.\" % treefile\n sys.stdout.flush()\n open(treefile, 'w').write(newick_tree)\n\n # Perform the pips analysis\n sequences = pips.fasta.UnknownsToGaps(sequences) # replace unknown amino acids with gaps\n random.seed(1) # seed the random number generator to make output predictable\n (datetime, pips_ddgs) = pips.ddg_inference.ReadDDGs(pipsddgsfile)\n\n # Read things in with the new pips\n tree = pips.tree.Tree(newick_tree, tipnames_sequences=sequences) # phylogenetic tree data\n ddgset = pips.ddg_inference.DDGSet(seq, tree, ('TRANSITION_TRANSVERSION_RATIO', 0.5), ('SPECIFIED', pips_ddgs, 0, 0), ('BETA', 3, ('KYTE_DOOLITTLE_HYDROPHOBICITY', 1, 0)), 5.0, underflow=5, runtestcode=False)\n ddgset.MaximizePosterior(nrandomstarts=1, printprogress=True)\n new_pips_ddgs = ddgset.DDGDict()\n pips.ddg_inference.WriteDDGs(new_pips_ddgs, 'new_pips_ddgs.txt', time.asctime())\n\n # Get the consensus ddG\n consensus_ddgs = pips.ddg_inference.ConsensusDDGs(seq, sequences, pseudocounts=1)\n\n sys.exit()\n\n # Perform analysis of correlations, and make pylab plots\n print \"\\nAnalysis of correlations to experimental ddG values...\"\n ddgtypes = ['actual', 'CUPSAT', 'consensus', '\\\\begin{tabular}{c} PIPS with \\\\\\\\ informative prior \\end{tabular}', '\\\\begin{tabular}{c} PIPS with \\\\\\\\ regularizing prior \\end{tabular}', '\\\\begin{tabular}{c} PIPS with \\\\\\\\ hydrophobicity prior \\end{tabular}']\n zippedlists = pips.ddg_inference.ZippedDDGLists(ddg_data, cupsat_ddgs, consensus_ddgs, pips_ddgs, pips_ddgs_regularizing, pips_ddgs_hydrophobicity)\n mutations = zippedlists[0]\n nmutations = len(mutations)\n ddgs = dict([(ddgtypes[i], zippedlists[i + 1]) for i in range(len(ddgtypes))])\n pylab.rc('text', usetex=True)\n nplots = len(ddgtypes) - 1 # number of different plots\n invnplots = 1.0 / nplots\n (xscale, yscale) = (2.8, 2.5) # each plot covers a rectangle of this size, in inches\n bottom = 1.06\n (tmargin, bmargin, lmargin, rmargin) = (0.03, 0, 0.22, 0.03)\n fig = pylab.figure(figsize=(xscale * (1 + lmargin + rmargin), 3 * yscale * (1 + tmargin + bmargin) * bottom))\n figaxes = pylab.axes([0, 0, 1, 1])\n figaxes.axison = False\n iplot = 0\n maxticks = 5\n (xmin, xmax) = (int(round(min(ddgs['actual'])) - 1), int(round(max(ddgs['actual'])) + 1))\n xtick = 1\n while (xmax - xmin) / float(xtick) > maxticks:\n xtick += 1\n nxticks = int(math.ceil((xmax - xmin) / float(xtick)))\n xticks = [x for x in range(xmin, xmin + nxticks * xtick + 1, xtick)]\n xticklocator = matplotlib.ticker.FixedLocator(xticks)\n xtickformatter = matplotlib.ticker.FixedFormatter([\"%d\" % x for x in xticks])\n for ddgtype in ddgtypes[1 : ]:\n if ddgtype == ddgtypes[-1]:\n xlabel = 'experimental $\\Delta\\Delta G$ values'\n else:\n xlabel = ''\n (r, p, npoints) = pips.stats.PearsonCorrelation(ddgs['actual'], ddgs[ddgtype])\n axes = pylab.axes([lmargin, 1.0 - invnplots * (1 + iplot + bmargin) / bottom, 1.0 - rmargin - lmargin, invnplots * (1.0 - tmargin - bmargin) / bottom], xlabel=xlabel, ylabel=ddgtype)\n nolabels = matplotlib.ticker.NullFormatter()\n (ymin, ymax) = (int(round(min(ddgs[ddgtype])) - 1), int(round(max(ddgs[ddgtype])) + 1))\n ytick = 1\n while (ymax - ymin) / float(ytick) > maxticks:\n ytick += 1\n nyticks = int(math.ceil((ymax - ymin) / float(ytick)))\n yticks = [y for y in range(ymin, ymin + nyticks * ytick + 1, ytick)]\n yticklocator = matplotlib.ticker.FixedLocator(yticks)\n ytickformatter = matplotlib.ticker.FixedFormatter([\"%d\" % y for y in yticks])\n axes.xaxis.set_major_locator(xticklocator)\n axes.yaxis.set_major_locator(yticklocator)\n axes.yaxis.set_major_formatter(ytickformatter)\n if ddgtype != ddgtypes[-1]:\n axes.xaxis.set_major_formatter(nolabels)\n else:\n axes.xaxis.set_major_formatter(xtickformatter)\n iplot += 1\n pylab.text(0.64, 0.14, '$R^2 = %.2f$' % r**2, transform=axes.transAxes, ha='left', va='top', size=14)\n pylab.scatter(ddgs['actual'], ddgs[ddgtype], figure=fig, axes=axes)\n pylab.savefig(\"%s_vertical_plot.eps\" % protein_w_underscores)\n\n pylab.show()","def generate_schemas(structure, n_paths, draw_chains=False):\n base_state_chain, max_id_in_chain = extract_nodes_from_structure(structure)\n num_edges_in_chain = max_id_in_chain\n num_nodes_in_chain = num_edges_in_chain + 1\n node_list = list(itertools.chain(*base_state_chain))\n node_list = list(more_itertools.unique_everseen(node_list))\n base_node_id_list = list(range(max_id_in_chain + 1))\n\n # num_nodes = n_paths * (n_nodes_in_structure - 1) + 1\n num_nodes_needed = n_paths * max_id_in_chain + 1\n num_schemas_possibe = pow(2, num_nodes_needed - max_id_in_chain)\n\n # add to our node list\n for i in range(max_id_in_chain + 1, num_nodes_needed):\n node_list.append(\"state\" + str(i))\n # node_list.append(\"action\" + str(i))\n node_to_id_bidir_dict = create_birdirectional_dict(node_list, SchemaNodeID)\n\n # generate all possible chains from nodes\n node_id_list = [node_to_id_bidir_dict[x] for x in node_list]\n base_state_chain_id = [\n (node_to_id_bidir_dict[x], node_to_id_bidir_dict[y])\n for x, y in base_state_chain\n ]\n\n possible_edges = set(itertools.permutations(node_id_list, r=2))\n\n possible_chains = set(itertools.permutations(possible_edges, r=num_edges_in_chain))\n\n # remove base base chain (having the base chain produces duplicates)\n possible_chains.remove(tuple(base_state_chain_id))\n\n # check that each chain forms a valid chain (each child of an edge has a matching parent of the next edge\n possible_chains = [chain for chain in possible_chains if valid_chain(chain)]\n\n possible_chains_with_npaths = []\n for nchains in range(1, n_paths):\n possible_chains_with_npaths.extend(\n list(itertools.combinations(possible_chains, r=nchains))\n )\n\n counter = 0\n print_update_rate = 10000\n\n schema_chains = []\n schema_graphs = []\n chains_producing_schemas = []\n for chains in possible_chains_with_npaths:\n counter += 1\n if counter % print_update_rate == 0:\n print(\n \"Generated {}/{} schema_chains with {} chains and {} nodes\".format(\n counter,\n len(possible_chains_with_npaths),\n n_paths,\n num_nodes_in_chain,\n )\n )\n\n # create new chain from chain\n chains = list(chains)\n new_edges = set(itertools.chain(*chains))\n chains.append(tuple(base_state_chain_id))\n\n # add in base chain (required for all schema_chains\n new_edges.update(base_state_chain_id)\n new_edges = list(new_edges)\n\n # is_target_chain, target_chain_name = check_target(new_edges)\n # if is_target_chain:\n # print(\"target schema: {}\".format(target_chain_name))\n\n new_node_list = list(itertools.chain(*new_edges))\n new_node_list = set(new_node_list)\n\n # checks if this schema has a valid node list\n if not valid_node_ids(new_node_list):\n # if is_target_chain:\n # print(\"removing target chain {}\".format(target_chain_name))\n continue\n\n root_nodes = find_root_nodes(new_edges, new_node_list)\n leaf_nodes = find_leaf_nodes(new_edges, new_node_list)\n\n new_graph = nx.DiGraph(new_edges)\n\n # verify there are no disjoint subchains\n if disjoint_subchains_present(new_graph):\n # if is_target_chain:\n # print(\"removing target chain {}\".format(target_chain_name))\n continue\n\n # verify this chain has no cycles\n if len(list(nx.simple_cycles(new_graph))) != 0:\n # if is_target_chain:\n # print(\"removing target chain {}\".format(target_chain_name))\n continue\n\n # verify this chain has valid depths (specifically, every path from root to leaf\n # should have length num_nodes_in_chain)\n if not schema_depths_valid(\n new_edges, new_graph, root_nodes, leaf_nodes, num_nodes_in_chain, n_paths\n ):\n # if is_target_chain:\n # print(\"removing target chain {}\".format(target_chain_name))\n # schema_depths_valid(\n # new_edges, new_graph, root_nodes, leaf_nodes, num_nodes_in_chain, n_paths\n # )\n continue\n\n # store schema as list of edges\n # schema_chains.append(new_edges)\n # store schema as list of chains\n schema_chains.append(chains)\n schema_graphs.append(new_graph)\n chains_producing_schemas.append(chains)\n\n # get set of schema edges of unique chains - by checking if each chain is isomporphic\n final_schema_chains = set()\n final_schema_graphs = set()\n for i in range(len(schema_graphs)):\n graph = schema_graphs[i]\n chain = tuple(schema_chains[i])\n # if chain1 is not in out schema set and it is not isomorphic to any chain in our schema set, add the chain to our schema set\n if chain not in final_schema_chains and all(\n [not nx.is_isomorphic(graph, final_graph) for final_graph in final_schema_graphs]\n ):\n final_schema_chains.add(chain)\n final_schema_graphs.add(graph)\n schema_chains = list(final_schema_chains)\n\n if draw_chains:\n save_chains_to_files(\n schema_chains,\n os.path.expanduser(\"~/Desktop/schema_chains/\"),\n num_nodes_in_chain,\n n_paths,\n )\n\n print(\n \"Generated {}/{} schema_chains with {} chains and {} nodes\".format(\n len(possible_chains_with_npaths),\n len(possible_chains_with_npaths),\n n_paths,\n num_nodes_in_chain,\n )\n )\n return schema_chains","def main():\n\t# GET THE DIALOG CONTENT\n\tpolicyFlag = int(sys.argv[3])\n\tif policyFlag == 0:\n\t\texistedIterNum = 15000\n\t\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05'\n\telif policyFlag == 1:\n\t\texistedIterNum = 10000\n\t\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05Retroflex'\n\n\tqLearnOpts = {'gamma': 1.0, \n\t\t\t\t 'alpha': 0.0, \n\t\t\t\t 'epsilon': 0.0}\n\tnumOfTurn = util.returnConvertedIndexListCount('b','cycle_tree')\n\tnumofgauss = 5\n\tvar = 0.0625\n\tlamda = 0.05\n\tunitNum = 101\n\ta = qlearningAgents.FittedQLearningAgent(numOfTurn,numofgauss,var,lamda,unitNum, **qLearnOpts)\t\t\n\ta.openThetaFile(existedThetaFileName,existedIterNum)\n\n\tturnNum = int(sys.argv[1])\n\tuserUnitScore = []\n\tuserUnitScoreVector = sys.argv[2].split(',')\n\tfor i in userUnitScoreVector:\n\t\t\tuserUnitScore.append(float(i)/100.0)\n\n\tstate = State.State(turnNum, userUnitScore)\n\tprint a.getAction(state)","def SolveAndPrint(self, model, decisions, constraints):\n\t\tself.root = Toplevel()\n\t\tmenubar = Menu(self.root)\n\t\ttext=Text(self.root)\n\t\t\n\t\tfilemenu=Menu(menubar, tearoff=0)\n\t\tfilemenu.add_command(label=\"Save As...\", \n\t\t\t\t\tcommand=(lambda text=text: file_save(text)), \n\t\t\t\t\taccelerator=\"Ctrl+Shift+S\")\n\n\t\tfilemenu.add_command(label=\"Reload Module\", command=(lambda: reload(simplex_class)), accelerator=\"Ctrl+T\")\n\n\t\tfilemenu.add_command(label=\"Close\", \n\t\t\t\t\tcommand=donothing, \n\t\t\t\t\taccelerator=\"Ctrl+w\") #come back to this\n\t\tfilemenu.add_separator()\n\t\tfilemenu.add_command(label=\"Exit\", command=self.root.quit)\n\n\t\tmenubar.add_cascade(label=\"File\", menu=filemenu)\n\n\t\thelpmenu = Menu(menubar, tearoff=0)\n\t\thelpmenu.add_command(label=\"Help\", command=donothing) #come back to this\n\t\ttext.insert(END, \n\t\t\t\t\"\\nNumber of variables = %d\\n\"%(model.NumVariables()))\n\n\t\tprint (\"Number of variables = %d\"%(model.NumVariables()))\n\t\tprint (\"Number of constraints = %d\"%(model.NumConstraints()))\n\n\t\ttext.insert(END, \"\\nNumber of constraints = %d\\n\"%(model.NumConstraints()))\n\t\t\n\t\tresult_status = model.Solve()\n\n\t\ttext.insert(END, \"\\nsolve output = %s\"%(result_status))\n\n\t\tassert model.VerifySolution(1e-7, True), \"model is not verifiable\" # % equivalent to infeasibility\n\n\t\tassert result_status == pywraplp.Solver.OPTIMAL, \"not an optimal solution present\" #The problem has an optimal solution\n\n\t\ttext.insert(END, \"\\nProblem solved in %f ms \\n\"%(model.wall_time()))\n\n\t\tprint (\"\\nProblem solved in %f milliseconds \\n\" %(model.wall_time()))\n\n\t\ttext.insert(END, \"\\nOptimal objective value = %f \\n\" %(model.Objective().Value())) #The objective value of the solution `no reduced costs`\n\t\tprint (\"\\nOptimal objective value = %f\\n\" %(model.Objective().Value()))\n\n\t\tfor variable in decisions:\n\t\t\ttext.insert(END, \"\\n%s = %f\\n\"%(variable.name(), variable.solution_value()))\n\t\t\tprint (\"%s = %f\" %(variable.name(), variable.solution_value()))\n\n\t\ttext.insert(END, \"\\n \\nAdvanced Usage: \\n\")\n\t\tprint (\"\\n \\nAdvanced Stats: \\n\")\n\t\ttext.insert(END, \"\\n \\nProblem Solved in %d iterations\"%model.iterations())\n\t\tprint (\"\\n \\n Problem solved in %d iterations\" %model.iterations())\n\n\t\tfor variable in decisions:\n\t\t\ttext.insert(END, \"\\n \\n%s: reduced cost = %f\" %(variable.name(), \n\t\t\t\t\t\t\t\t\tvariable.reduced_cost()))\n\t\t\tprint (\"%s: reduced cost = %f\" %(variable.name(), variable.reduced_cost()))\n\n\t\tactivities = model.ComputeConstraintActivities() #printout of RHS = `b` in AX = b\n\n\t\tfor i, constraint in enumerate(constraints):\n\t\n\t\t\tprint(dir(constraint))\n\t\t\ttext.insert(END, \n\t\t\t\t\"\\n\\n constraint %s: dual value = %f\\n activity=%f\" %(constraint.name(), \n\t\t\t\t\t\t\t\t\t\t\tconstraint.dual_value(), \n\t\t\t\t\t\t\t\t\t\t\tactivities[constraint.index()]))\n\n\t\t\tprint (\"constraint %s: dual value = %f\\nactivity=%f\" %(constraint.name(), \n\t\t\t\t\t\t\t\t\t\tconstraint.dual_value(),\n\t\t\t\t\t\t\t\t\t\tactivities[constraint.index()]))\n\t\t\ttext.insert(END, \n\t\t\t\t\t\"\\n \\n constraint %s Lower to Upper Boundary:\\n \\t %f < %.2d < %f\" %(constraint.name(),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tconstraint.Lb(),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tactivities[constraint.index()],\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tconstraint.Ub()))\n\n\t\t\tprint (\"constraint %s Lower.....to.....Upper Boundary: %f < %.2d < %f\" %(constraint.name(), \n\t\t\t\t\t\t\t\t\t\t\t\tconstraint.Lb(),\n\t\t\t\t\t\t\t\t\t\t\t\tactivities[constraint.index()],\n\t\t\t\t\t\t\t\t\t\t\t\tconstraint.Ub()))\n\t\ttext.config(state=DISABLED)\n\t\ttext.pack()\n\t\tself.root.config(menu=menubar)","def toCNF (N, instance, outputfile):\r\n \"\"\" OUTPUT: Write Dimacs CNF to output_file \"\"\"\r\n import itertools\r\n n = N\r\n output_file = open(outputfile, \"w\")\r\n \"*** YOUR CODE HERE ***\"\r\n constraint = []\r\n constraint_2 = []\r\n constraint_3 = []\r\n counter = 0\r\n count = 0\r\n for i in range(N):\r\n for j in range(N):\r\n if instance [i][j] != 0:\r\n counter = counter + 1\r\n\r\n #Write the first line p cnf NNN and Line\r\n count = (N*N) + (N-1)*(N*N*N)*3 + counter + 1\r\n output_file.write(\"p cnf \" + str(str(N)+str(N)+str(N)))\r\n output_file.write(\" \" + str(count))\r\n output_file.write(\"\\n\")\r\n\r\n\r\n #First Constraint\r\n for i in range(N):\r\n for j in range(N):\r\n for k in range(N):\r\n output_file.write(str(i+1)+str(j+1)+str(k+1)+ \" \")\r\n output_file.write(str(0))\r\n output_file.write(\"\\n\")\r\n\r\n \r\n #Second Constraint\r\n for i in range(N):\r\n for j in range(N):\r\n for k in range(N):\r\n for l in range(N):\r\n if k != l:\r\n output_file.write(\"-\"+str(i+1)+str(j+1)+str(k+1)+ \" \")\r\n output_file.write(\"-\"+str(i+1)+str(j+1)+str(l+1)+ \" \")\r\n output_file.write(str(0))\r\n output_file.write(\" \")\r\n output_file.write(\"\\n\")\r\n\r\n\r\n #Third Constraint\r\n for i in range(N):\r\n for k in range(N):\r\n for j1 in range(N):\r\n for j2 in range(N):\r\n if j1 != j2:\r\n output_file.write(\"-\"+str(i+1)+str(j1+1)+str(k+1)+ \" \")\r\n output_file.write(\"-\"+str(i+1)+str(j2+1)+str(k+1)+ \" \")\r\n output_file.write(str(0))\r\n output_file.write(\" \")\r\n output_file.write(\"\\n\")\r\n \r\n\r\n #Fourth Constraint\r\n for j in range(N):\r\n for k in range(N):\r\n for i1 in range(N):\r\n for i2 in range(N):\r\n if i1 != i2:\r\n output_file.write(\"-\"+str(i1+1)+str(j+1)+str(k+1)+ \" \")\r\n output_file.write(\"-\"+str(i2+1)+str(j+1)+str(k+1)+ \" \")\r\n output_file.write(str(0))\r\n output_file.write(\" \")\r\n output_file.write(\"\\n\") \r\n\r\n\r\n #Fifth Constraint\r\n for i in range(N):\r\n for j in range(N):\r\n if instance [i][j] != 0 :\r\n output_file.write(str(i+1)+str(j+1))\r\n output_file.write(str(instance[i][j]))\r\n output_file.write(\" \")\r\n output_file.write(str(0))\r\n output_file.write(\"\\n\") \r\n \"*** YOUR CODE ENDS HERE ***\"\r\n output_file.close()","def print_solution():\n pass","def __init__(self):\n\n # names of atoms that make up relevant segements of each chain\n self.chains = {'a': {'C': 'C1', 'C1': 'C2', 'C2': 'C3', 'C3': 'C4', 'C4': 'C5', 'H': 'H1', 'H1': 'H2',\n 'H2': 'H3', 'H3': 'H4', 'H4': 'H5'},\n 'b': {'C45': 'C1', 'C44': 'C2', 'C43': 'C3', 'C42': 'C4', 'C41': 'C5', 'H81': 'H1', 'H80': 'H2',\n 'H79': 'H3', 'H78': 'H4', 'H77': 'H5'}\n }\n\n self.nchains = len(list(self.chains.keys()))\n\n self.chain_numbers = {'a': 0, 'b': 1} # used to number chains\n\n # self.initial_types = {'C1': 'c2', 'C2': 'ce', 'C3': 'ce', 'C4': 'c2', 'H1': 'ha', 'H2': 'ha', 'H3': 'ha',\n # 'H4': 'ha', 'H5': 'ha'}\n\n # all indices numbered from 0. D1, D2, ... correspond to dummies attached to C1, C2, ... respectively\n self.indices = {'a': {'C1': 0, 'C2': 1, 'C3': 2, 'C4': 3, 'C5': 4, 'H1': 52, 'H2': 53, 'H3': 54, 'H4': 55,\n 'H5': 56, 'D1': 136, 'D2': 137, 'D3': 138, 'D4': 139},\n 'b': {'C1': 49, 'C2': 48, 'C3': 47, 'C4': 46, 'C5': 45, 'H1': 133, 'H2': 132, 'H3': 131,\n 'H4': 130, 'H5': 129, 'D1': 140, 'D2': 141, 'D3': 142, 'D4': 143}\n }\n\n self.dummy_connectivity = {'a': {'C': 'D1', 'C1': 'D2', 'C2': 'D3', 'C3': 'D4'},\n 'b': {'C45': 'D1', 'C44': 'D2', 'C43': 'D3', 'C42': 'D4'}}\n\n self.hydrogen_connectivity = {'C': ['H1', 'H2'], 'C1': ['H3'], 'C2': ['H4'], 'C3': ['H5'],\n 'C45': ['H1', 'H2'], 'C44': ['H3'], 'C43': ['H4'], 'C42': ['H5']}\n\n self.dummy_mass = 1.008 # mass of hydrogen\n\n # write these in order of priority\n # for efficiency, don't repeat things. For example self.carbons['C1']: self.carbons['C2'] is the same as\n # self.carbons['C2']: self.carbons['C1']. Otherwise, computational expense goes up and a new reaction has\n # to be defined below.\n self.carbons = {'C1': ['C', 'C45'], 'C2': ['C1', 'C44'], 'C3': ['C2', 'C43'], 'C4': ['C3', 'C42']}\n self.bonds_with = [[self.carbons['C1'], self.carbons['C2']]]\n\n # define which improper dihedrals to remove -- written in same order as .itp file!!!\n # note that the order of the atoms may be different for each chain\n # NOTE: C3 not tested\n self.impropers = {'a': {'C1': ['H2', 'C1', 'H1', 'C2'], 'C2': ['C1', 'C3', 'C2', 'H3'],\n 'C3': ['C4', 'C2', 'C3', 'H4'], 'C4': ['C5', 'C3', 'C4', 'H5']},\n 'b': {'C1': ['C2', 'H2', 'C1', 'H1'], 'C2': ['C1', 'C3', 'C2', 'H3'],\n 'C3': ['C4', 'C2', 'C3', 'H4'], 'C4': ['C5', 'C3', 'C4', 'H5']}}","def constraint_test():\n import itertools, sys\n\n show_analysis = False\n #Generated via grammar\n gr = grammar.Grammar('grammars/test_constraints.bnf')\n inputs = ([1 for _ in range(100)], [ i%3 for i in range(100)])\n for _input in inputs: \n output = gr.generate(_input)\n azr = analyser.Analyser('test',output['phenotype'],True)\n try:\n azr.create_graph()\n except ValueError as e:\n print(__name__, \"ERROR\", _input, e)\n continue\n azr.parse_graph()\n azr.apply_stresses()\n azr.create_slf_file()\n azr.test_slf_file()\n azr.parse_results()\n azr.print_stresses()\n if show_analysis:\n azr.show_analysis()\n \n #Fixed generated\n lengths = (1000, 10000)\n levels = (5, 10)\n for length_idx, level_idx in itertools.permutations([0,1]):\n try:\n GRAPH = constrained_offset_graph(lengths[length_idx],\n levels[length_idx])\n except ValueError as e:\n print(__name__, \"ERROR\", lengths[length_idx], levels[length_idx], e)\n continue\n GRAPH.save_graph(\"pylon\")\n print \"nodes:\", GRAPH.number_of_nodes()\n print \"edges\", GRAPH.number_of_edges()\n #will it blend?\n azr = analyser.Analyser('test',\"moo\",True)\n azr.my_graph = GRAPH\n azr.parse_graph()\n azr.apply_stresses()\n azr.create_slf_file()\n azr.test_slf_file()\n azr.parse_results()\n azr.print_stresses()\n if show_analysis:\n azr.show_analysis()","def main():\n\n config = read_json_file(CONFIG_FILE)\n posititve_path = (\n config[\"main\"][\"DATASET_BASE_PATH_DIR\"]\n + config[\"main\"][\"POSITIVE_FILENAME\"]\n )\n negative_path = (\n config[\"main\"][\"DATASET_BASE_PATH_DIR\"]\n + config[\"main\"][\"NEGATIVE_FILENAME\"]\n )\n complexity_factor = config[\"main\"][\"COMPLEXITY_FACTOR\"]\n max_sequences_to_fit_pos = config[\"main\"][\"MAX_SEQUENCES_TO_FIT_POS\"]\n max_sequences_to_fit_neg = config[\"main\"][\"MAX_SEQUENCES_TO_FIT_NEG\"]\n\n input_organisms_path = config[\"main\"][\"INPUT_FILENAME\"]\n mean_nodes = 3.0\n mean_fitness = 150\n positive_dataset = read_fasta_file(posititve_path)\n positive_dataset.sort()\n negative_dataset = read_fasta_file(negative_path)\n print(\"{} {}\".format(len(positive_dataset), len(negative_dataset)))\n\n organism_factory = OrganismFactory(\n config[\"organism\"],\n config[\"organismFactory\"],\n config[\"connector\"],\n config[\"pssm\"],\n )\n\n a_organisms = organism_factory.import_organisms(input_organisms_path)\n # random.shuffle(negativeDataset)\n\n for org in a_organisms:\n\n # org.print()\n nodes = org.count_nodes()\n\n p_1 = org.get_seq_set_fitness(\n positive_dataset[:max_sequences_to_fit_pos]\n )\n n_1 = org.get_seq_set_fitness(\n negative_dataset[:max_sequences_to_fit_neg]\n )\n # p1 = 20\n # n1 = org.getSeqSetFitness(negativeDataset[31:32])\n c_1 = org.get_complexity(mean_nodes, mean_fitness)\n\n # Score\n fitness = p_1 - n_1\n effective_fitness = fitness - complexity_factor * c_1\n print(\n (\n \"ORG {} N: {:.2f} P: {:.2f} N: {:.2f} C: {:.2f} F: {:.2f}\"\n + \" EF: {:.2f}\\n\"\n ).format(org._id, nodes, p_1, n_1, c_1, fitness, effective_fitness)\n )\n\n export_organism(\n org,\n positive_dataset,\n \"{}positive_{}\".format(\n config[\"main\"][\"RESULT_TEST_BASE_PATH_DIR\"], org._id\n ),\n organism_factory,\n )\n # exportOrganism(\n # org,\n # negativeDataset[31:32],\n # \"{}negative_{}\".format(config[\"main\"][\"RESULT_TEST_BASE_PATH_DIR\"], org.ID),\n # organismFactory,\n # )\n\n export_organism(\n org,\n negative_dataset[:50],\n \"{}negative_{}\".format(\n config[\"main\"][\"RESULT_TEST_BASE_PATH_DIR\"], org._id\n ),\n organism_factory,\n )","def main():\n\n rules, evolutions = [int(i) for i in input().strip().split()]\n\n rule = {}\n for _ in range(rules):\n start, finish = input().strip().split(' -> ')\n rule[start] = finish\n\n print(lindenmayor(rule, evolutions, input().strip()))","def main():\n \n # 1. Learn a decision tree from the data in training.txt\n print \"--Building trees--\"\n train_examples = read_file('training.txt')\n print(train_examples)\n attrs = range(len(train_examples[0])-1)\n rand_tree = decision_tree_learning(train_examples, attrs, use_gain=False)\n gain_tree = decision_tree_learning(train_examples, attrs, use_gain=True)\n print \"--Done building--\"\n print\n\n # 2. Document the tree you got\n print \"--Random tree--\"\n print_tree(rand_tree)\n print\n print \"--Learn tree--\"\n print_tree(gain_tree)\n print\n\n # 3. Classify all examples in the test-set\n test_examples = read_file('test.txt')\n print \"--Testing random tree--\"\n test(rand_tree, test_examples, attrs)\n print\n print \"--Testing information gain tree--\"\n test(gain_tree, test_examples, attrs)\n print \"--Done testings--\"","def main():\n # create a list of test employees and managers\n testList = [\n {'type': 'employee', 'firstName': 'Mickey', 'lastName': 'Mouse', 'SSN': '100-12-3456', 'salary': 1500.00},\n {'type': 'manager', 'firstName': 'Walt', 'lastName': 'Disney', 'SSN': '100-00-0000', 'salary': 5000.00,\n 'title': 'Head Of Disneyland', 'yearBonus': 1000.00},\n {'type': 'employee', 'firstName': 'Donald', 'lastName': 'Duck', 'SSN': '100-65-4321', 'salary': 1000.00},\n {'type': 'manager', 'firstName': 'Minnie', 'lastName': 'Mouse', 'SSN': '999-99-999', 'salary': 10000.00,\n 'title': 'Head Of Mouse HouseHold', 'yearBonus': 15000.00},\n {'type': 'manager', 'firstName': 'Daisy', 'lastName': 'Duck', 'SSN': '100-65-4321', 'salary': 12000.00,\n 'title': 'Head Of Duck HouseHold', 'yearBonus': 10000.00}]\n\n # Define percentRaise (0.1 == 10%)\n percentRaise = 0.1\n\n # Create Employees and Managers Object using the Test data\n employeeList = loadEmployees(testList)\n\n # Sort employee List, which will ustilize Employee's __lt__ and __eq__ methods\n employeeList.sort()\n\n # Loop over Employee and Manager Objects\n print(\"Employees and Manager should be sorted by last name, then first\\n\")\n for employee in employeeList:\n if type(employee) == Manager:\n print(\"Manager:\")\n else:\n print(\"Employee:\")\n # Print Employee or Manager\n print(employee)\n # Give Raise to Employee or Manager\n employee.giveRaise(percentRaise)\n # Print New Salary\n print(\"With %.2f%% Raise, Salary: $%.2f\\n\" % (percentRaise * 100, employee.salary))\n\n # Employee docStrings\n print(\"\\nEmployee docstring for each method\")\n print(\"Employee.__doc__=\" + Employee.__doc__)\n print(\"Employee.__init__.__doc__=\" + Employee.__init__.__doc__)\n print(\"Employee.giveRaise.__doc__=\" + Employee.giveRaise.__doc__)\n print(\"Employee.__str__.__doc__=\" + Employee.__str__.__doc__)\n print(\"Employee.__eq__.__doc__=\" + Employee.__eq__.__doc__)\n print(\"Employee.__lt__.__doc__=\" + Employee.__lt__.__doc__)\n\n print(\"\\nManger docstring for each method\")\n print(\n \"Since Manager inherits from Employee, several of the methods ('giveRaise', '__eq__' and '__lt__') and the corresponding docstring will originate from the Employee class\\n\")\n print(\"Manager.__doc__=\" + Manager.__doc__)\n print(\"Manager.__init__.__doc__=\" + Manager.__init__.__doc__)\n print(\"Manager.giveRaise.__doc__=\" + Manager.giveRaise.__doc__)\n print(\"Manager.__str__.__doc__=\" + Manager.__str__.__doc__)\n print(\"Manager.__eq__.__doc__=\" + Manager.__eq__.__doc__)\n print(\"Manager.__lt__.__doc__=\" + Manager.__lt__.__doc__)","def chainsetup(filename, cation, facets, operation, end_radii, nradii,\n adensity):\n\n # Load the Cage from the file\n try:\n # If that fails, try other file formats supported by pymatgen\n anion = Cage.from_file(filename)\n except ValueError:\n # If that fails, try the VASP POSCAR format\n anion = Cage.from_poscar(filename)\n\n # Center the anion around the origin\n anion.center()\n\n # Find the chain edges, i.e. the paths between the edge sharing facets of\n # the chain of non-equivalent facets.\n anion.find_surface_facets(ignore=IGNORE)\n\n if not facets == tuple:\n chosen_facets = [anion.facets[index] for index in facets]\n edges = anion.find_noneq_chain_links(chosen_facets)\n else:\n edges = anion.find_noneq_chain_links()\n\n total_mol = anion.copy()\n\n chain_dir = 'chain_' + operation\n try:\n os.mkdir(chain_dir)\n except FileExistsError:\n pass\n\n # For each edge, set up the calculation input files\n edge_number = 1\n\n for edge in edges:\n\n # Set up the edge directory\n edge_dir = os.path.join(chain_dir, \"edge\" + str(edge_number))\n\n while os.path.exists(edge_dir):\n edge_number += 1\n edge_dir = os.path.join(chain_dir, \"edge\" + str(edge_number))\n\n os.mkdir(edge_dir)\n\n # Write out the molecule and path facets to the edge directory\n anion.to(fmt=\"json\", filename=os.path.join(edge_dir, \"molecule.json\"))\n edge[0].to(fmt=\"json\", filename=os.path.join(edge_dir,\n \"init_facet.json\"))\n edge[1].to(fmt=\"json\", filename=os.path.join(edge_dir,\n \"final_facet.json\"))\n\n # Get copies so the originals aren't mutated\n edge_mol = anion.copy()\n facet1 = edge[0].copy()\n facet2 = edge[1].copy()\n\n if edge == edges[-1]:\n remove_endline = False\n else:\n remove_endline = True\n\n # Set up the landscape\n landscape = set_up_edge_landscape(facet1, facet2,\n endpoint_radii=end_radii,\n number_of_radii=nradii,\n angle_density=adensity,\n remove_endline=remove_endline)\n\n # Get the molecule for each landscape point\n molecules = set_up_molecules(edge_mol, landscape, cation)\n\n # Set up an xyz file to visualize the edge and total landscape\n for point in landscape.points:\n try:\n total_mol.append(pmg.Specie(cation, 1), point,\n validate_proximity=False)\n edge_mol.append(pmg.Specie(cation, 1), point,\n validate_proximity=False)\n except ValueError:\n pass\n\n edge_mol.to(fmt=\"xyz\", filename=os.path.join(edge_dir, \"edge.xyz\"))\n\n # In case the molecules must be optimized, add the constraints and\n # optimization setup (DRIVER)\n if operation == \"optimize\":\n far_facet = anion.find_farthest_facet(landscape.center)\n constraints = find_constraints(anion, far_facet.sites)\n constraints['fix atom'] += ' ' + str(len(anion.sites) + 1)\n ALT_SETUP['constraints'] = constraints\n ALT_SETUP[\"driver\"] = DRIVER_SETUP\n\n # Set up the task for the calculations\n tasks = [nwchem.NwTask(molecules[0].charge, None, BASIS,\n theory=\"dft\",\n operation=operation,\n theory_directives=THEORY_SETUP,\n alternate_directives=ALT_SETUP)]\n\n # Set up the input files\n study = Study(molecules, tasks)\n study.set_up_input(edge_dir, sort_comp=False,\n geometry_options=GEO_SETUP)\n\n edge_number += 1\n\n # Set up an xyz file with all the paths\n total_mol.to(fmt=\"xyz\", filename=os.path.join(chain_dir, \"total_mol.xyz\"))","def main():\n ref_seq = {}\n ent_spe_sero = {}\n tag_dict = {\"Contigs_with_VP1\":\"contigs\", \"P1_sequences\":\"p1\",\n \"VP1_sequences\":\"vp1\", \"5UTR_sequences\":\"5utr\", \"3D_sequences\":\"3d\"}\n args = get_arguments()\n # Load query elements\n print(\"Load resume file\")\n (query_dict, classify_list,\n classify_specie_list, serotype_list) = get_query(args.resume_file,\n args.tag,\n args.incomplete)\n print(\"{} descriptions loaded\".format(len(query_dict)))\n # Load specie association\n if args.ent_serotype_file and args.template_seq_file:\n # Load enterovirus serotype\n print(\"Load enterovirus serotype association\")\n ent_spe_sero = load_spe_sero(args.ent_serotype_file)\n # Load template sequence\n print(\"Load template sequence\")\n ref_seq = get_template_sequence(args.template_seq_file, ent_spe_sero)\n # Grab query sequence in the database\n print(\"Load database sequence\")\n sequence_data = get_sequence(query_dict, args.fasta_file)\n print(\"{} sequences loaded\".format(len(sequence_data)))\n # Write the new fasta file\n print(\"Write the new fasta\")\n write_sequence(args.results, sequence_data, query_dict, classify_list,\n tag_dict[args.tag], ref_seq, ent_spe_sero)\n #print(save_association)\n print(\"Write the itol label\")\n write_itol_label(args.itol_dir, sequence_data, query_dict, classify_list,\n tag_dict[args.tag])\n print(\"Write the itol tree color\")\n write_itol_tree_color(args.itol_dir, sequence_data, query_dict, classify_specie_list, serotype_list,\n tag_dict[args.tag])\n print(\"Done\")","def check_proof(self):\n for gene in self.population:\n if gene.is_proof:\n print(gene.chromosome)\n for state in gene.coq_states:\n print(state)\n self.proofs.append(Gene(chromosome=gene.valid_tactics))","def test_markov_to_chain():\n chain = {\n 'PIKARD': [('Q', 2.0 / 3), ('DORF', 1.0 / 3)],\n 'Q': [('PIKARD', 2.0 / 3), ('ROKER', 1.0 / 3)],\n 'DORF': [('PIKARD', 1.0)],\n 'ROKER': [('Q', 1.0)],\n }\n with markov.DialogChainDatastore() as store:\n store.reinitialize()\n store.store_chain('speakers', chain)\n new_chain = store.to_chain('speakers')\n assert set(chain.keys()) == set(new_chain.keys())\n for speaker, probabilities in six.iteritems(chain):\n assert sort_probs(probabilities) == sort_probs(new_chain[speaker])","def InfoPrint(currentFile):\n Chains = ReturnChain(currentFile)\n chainlist = ReturnChain(currentFile)\n if len(chainlist) > 1:\n chainlist.insert(len(chainlist)-1,'and')\n print('CHAINS:',' '.join(chainlist))\n else:\n print('CHAIN: %s'%''.join(chainlist))\n x= ' '\n for chain in Chains:\n with open(currentFile) as fileIn:\n sequence=[]\n helix_count = 0\n sheet_count = 0\n line = fileIn.readline()\n while line:\n if line.startswith('SEQRES'):\n words = line.split()\n chaintype = words[2]\n if chaintype == chain:\n for word in words:\n if word in aminoacidsCode.values():\n sequence.append(word)\n\n else:\n pass\n\n\n if line.startswith('HELIX'):\n helixInfo = line.split()\n chaintype = helixInfo[4]\n if chaintype == chain:\n helix_count = helix_count + 1\n\n else:\n pass\n\n if line.startswith('SHEET'):\n sheetInfo = line.split()\n chaintype = sheetInfo[5]\n if chaintype == chain:\n sheet_count = sheet_count + 1\n\n else:\n pass\n\n line = fileIn.readline()\n\n print('- Chain %s'%chain)\n print('Number of amino acids: %s'%len(sequence))\n print('Number of helix:%s %s'%(x*7,helix_count))\n print('Number of sheet:%s %s'%(x*7,sheet_count))\n print('Sequence:'),seqprint(sequence)","def test_claim_generation():\n print(\"Executing test_claim_generation:\")\n append_9_theory=[\n (13,9),\n (30,)\n ]\n set_false_and_append_9_theory=[\n (13,0),\n (28,),\n (13,9),\n (30,)\n ]\n\n print(\"append_9_theory:\")\n print(language.program_string(append_9_theory))\n print(\"set_false_and_append_9_theory:\")\n print(language.program_string(set_false_and_append_9_theory))\n\n mind=minds.new_mind(theories=[append_9_theory,set_false_and_append_9_theory],claims=[(True,[])])\n\n for i in range(10):\n minds.generate_claims(mind)\n\n print(minds.mind_string(mind))","def __repr__(self):\n st = '\\nProof(syntax=\\\"' + self.syntax + '\\\", formula_list=[\\n'\n for l in self.proof[:-1]:\n st += str(l) + ',\\n'\n return st + str(self.proof[-1]) + '])'","def tree_produce(self, n, verbose=True):\n # only for finite axioms\n root = dict()\n ref = root\n for a in self.axioms:\n assert not a.is_axiom_schema\n a = a.axiom\n ref[a] = dict()\n ref = ref[a]\n self._tree_produce(a, 0, n, ref, verbose)\n return root","def __init__(self,\n point_size: int,\n max_levels=6,\n min_levels=3,\n mutation_prob=0.5\n ) -> None:\n self.rec_refs = {}\n self.mutation_prob = mutation_prob\n\n vars1 = []\n vars2 = []\n for i in range(point_size):\n vars1 += [f\"X1[{i}]\"]\n\n for i in range(point_size):\n vars2 += [f\"X2[{i}]\"]\n\n self.grammar = {\n **{f\"<expr_{i}>\": [f\"<expr_{i+1}> <op> <expr_{i+1}>\", f\"<func> ( <expr_{i+1}> <op> <expr_{i+1}> )\"] for i in range(min_levels)},\n **{f\"<expr_{min_levels + i}>\": [f\"<expr_{min_levels + i+1}> <op> <expr_{min_levels + i+1}>\", f\"<func> ( <expr_{min_levels + i + 1}> <op> <expr_{min_levels + i + 1}> )\", \"<term>\"] for i in range(max_levels - min_levels)},\n f\"<expr_{max_levels}>\": [\"<term_1> <op> <term_2>\", \"<term_2> <op> <term_1>\"],\n \"<term>\": [\n \"<term_1>\", \"<term_2>\"\n ],\n \"<term_1>\": [\n \"<var_1>\",\n \"<pre-op> ( <var_1> )\",\n ],\n \"<term_2>\": [\n \"<var_2>\",\n \"<pre-op> ( <var_2> )\",\n ],\n \"<pre-op>\": [\n \"1/\",\n \"-\",\n \"+\",\n \"abs\",\n \"numpy.math.sqrt\"\n ],\n \"<func>\": [\n \"abs\",\n \"\"\n ],\n \"<op>\": [\n \"+\",\n \"*\",\n \"-\",\n \"/\",\n ],\n \"<var_1>\": vars1,\n \"<var_2>\": vars2,\n }\n\n self.non_terminals = sorted(self.grammar.keys())\n\n # these two lines are described in the pseudocode of the reference paper\n rec_refs = self.countRecursiveReferences()\n self.ref_count = {\n key: self.findReferences(key, *rec_refs) for key in self.grammar.keys()\n }","def produce(self, n, verbose=True):\n gen = self._produce(verbose)\n for _ in range(n):\n new_theorem = next(gen)\n self.theorems.update({new_theorem.theorem: new_theorem})\n if verbose:\n print(new_theorem)","def make_control_knowledge(self, horizon):\n\n \"\"\" *** YOUR CODE HERE *** \"\"\"\n\n # ADD_RULE1_COUNT = 0\n # ADD_RULE2_COUNT = 0\n # ADD_RULE3_COUNT = 0\n\n close = list()\n far = list()\n\n for g in self.problem.goal:\n for p in self.problem.propositions:\n if re.match(r'at\\spackage\\d+\\scity\\d+-\\d+', str(p)):\n p_split = str(p).split()\n g_split = str(g).split()\n\n # if \"at\" and \"package[oo]\" match\n if p_split[0] == g_split[0] and p_split[1] == g_split[1]:\n # also \"city[oo]-[xx]\" match\n if p_split[2][:-2] == g_split[2][:-2]:\n close.append(p)\n else:\n far.append(p)\n\n # Rule 1:\n # ===============================\n # If a package is at its goal location, then it must remain there.\n # p@t and goal@t) -> p@t+1), where p is at(package, location)\n # cnf: not p@t or not goal@t or p@t+1\n\n for g in self.problem.goal:\n for t in range(0, horizon):\n clause = list()\n clause.append(-self.proposition_fluent_codes[(g, t)])\n clause.append(self.proposition_fluent_codes[(g, t + 1)])\n self.add_clause(clause, \"control\")\n # ADD_RULE1_COUNT += 1\n\n for t in range(0, horizon):\n for a in self.problem.actions:\n\n # Rule 2\n # ===============================\n\n # RULE\n # close -> do not load airplane\n # p1: close@t\n # p2: at the location of an airport @t\n # p3: airplane at this location @t\n # p4: plane is not loaded\n # a: load this airplane\n #\n # p1@t and p2@t and p3@t and p4@t => a@t\n # not p1@t or not p2@t or not p3@t or not p4@t or a@t\n # cnf: not p@t or not a@t\n if str(a).startswith('load-airplane'):\n for i in close:\n package = str(i).split()[1]\n if str(a).split()[1] == package:\n clause = list()\n clause.append(\n -self.proposition_fluent_codes[(i, t)])\n clause.append(-self.action_fluent_codes[(a, t)])\n self.add_clause(clause, \"control\")\n # ADD_RULE2_COUNT += 1\n\n # Rule 3\n # ===============================\n\n # RULE\n # far -> do not unload airplane\n # p@t -> not a@t, where p is far, a is unload-airplane\n # cnf: not p@t or not a@t\n if str(a).startswith('unload-airplane'):\n for j in far:\n package = str(j).split()[1]\n if str(a).split()[1] == package:\n clause = list()\n clause.append(\n -self.proposition_fluent_codes[(j, t)])\n clause.append(-self.action_fluent_codes[(a, t)])\n self.add_clause(clause, \"control\")\n # ADD_RULE3_COUNT += 1\n\n # # RULE\n # # if an airplane has a package on it and the package's\n # # destination is close do not fly this airplane.\n # # in fact, if the destination of package is far,\n # # fly this plane to it.\n # #\n # # p1: package on airplane @ t\n # # p2: package at a place @ t\n # # p3: the place and the goal are in the same city\n # # rule: p1@t and p2@t and p@3 => not fly plane@t\n # # and unload the plane@t\n #\n # # not p1@t or not p2@t or not fly@t\n # # not p1@t or not p2@t or unload\n #\n # # rule: p1@t and p2@t and not p3@t => fly plane@t and not\n # # unload the plane@t\n #\n # if str(a).startswith('fly-airplane'):\n # plane = str(a).split()[1]\n # # loc_from = str(a).split()[2]\n # for p1 in self.problem.propositions:\n # if str(p1).startswith('in package') and str(p1).split()[2] == plane: # in package plane\n # package = str(p1).split()[1]\n # for p2 in self.problem.propositions:\n # if p2 in close and str(p2).split()[1] == package: # at package location\n # clause = list()\n # clause.append(-self.proposition_fluent_codes[p1, t])\n # clause.append(-self.proposition_fluent_codes[p2, t])\n # clause.append(-self.action_fluent_codes[a, t])\n # self.add_clause(clause, 'control')\n # ADD_RULE2_COUNT += 1\n #\n #\n # for g in self.problem.goal:\n # if str(g).split()[1] == package:\n # destination = str(g).split()[2]\n # for do in self.problem.actions:\n # # unload-airplane package00 plane00 city00-00\n # if str(do).startswith('unload') and str(do).split()[1] == package and str(do).split()[2] == plane and str(do).split()[3] == destination:\n # clause2 = list()\n # clause2.append(-\n # self.proposition_fluent_codes[\n # p1, t])\n # clause2.append(-\n # self.proposition_fluent_codes[\n # p2, t])\n # clause2.append(\n # self.action_fluent_codes[\n # do, t])\n # self.add_clause(clause2,\n # 'control')\n #\n # ADD_RULE3_COUNT += 1\n\n # RULE\n # if there is no package needs to be transferred at a location,\n # and the location has a truck\n # drive the truck to its airport\n\n # p1: (at package__ city__-__ /\\ (it is a goal)@t\n # p2: (at truck__ city__-__)@t\n # p3: (city__-__ is not airport)\n # not p1/\\p2/\\p3 => drive_truck_to_its_airport@t\n #\n #\n # CNF: p1 V not p2 V not p3 V drive_truck_to_its_airport@t\n # if str(a).startswith('DRIVE-TRUCK'):\n # for p1 in self.problem.goal:\n # city = str(p1).split()[2]\n # for p2 in self.problem.propositions:\n # if str(p2).startswith('at truck') and str(p2).split()[2] == city:\n # for p3 in self.problem.propositions:\n # if str(p3).startswith('airport') and str(p3).split()[1] == city:\n # clause = list()\n # clause.append(self.proposition_fluent_codes[(p1, t)])\n # clause.append(-self.proposition_fluent_codes[(p2, t)])\n # clause.append(-self.proposition_fluent_codes[(p3, t)])\n # clause.append(self.action_fluent_codes[(a, t)])\n # self.add_clause(clause, \"control\")\n\n # RULE\n # if there is an airplane is loaded with a package need\n # transfer (to another city), fly airplane to the corresponding\n # city.\n\n # p1: (at airplane__ city__-__)@t\n # p2: (in package__ airplane__)@t\n # p3: ( p2 is in far)\n # p1/\\p2/\\p3 => fly_airplane_to_its_airport@t\n #\n #\n # CNF: not p1@t V not p2@t V not p3@t V fly_plane_to_airport@t\n\n # print(\"ADDED RULE 1:\")\n # print(ADD_RULE1_COUNT)\n #\n # print(\"ADDED RULE 2:\")\n # print(ADD_RULE2_COUNT)\n #\n # print(\"ADDED RULE 3:\")\n # print(ADD_RULE3_COUNT)","def sat_all(props, f):\n solver = Solver()\n solver.add(f)\n result = []\n while solver.check() == sat:\n m = solver.model()\n result.append(m)\n block = []\n for prop in props:\n prop_is_true = m.eval(prop, model_completion=True)\n\n if prop_is_true:\n new_prop = prop\n else:\n new_prop = Not(prop)\n\n block.append(new_prop)\n \n # Exercise 1-6 begin\n f = And(f, Not(And(*block)))\n solver.add(f)\n # Exercise 1-6 end\n\n print(\"the given proposition: \", f)\n print(\"the number of solutions: \", len(result))\n\n def print_model(m):\n print(sorted([(d, m[d]) for d in m], key=lambda x: str(x[0])))\n\n for m in result:\n print_model(m)","def main(supply):\n\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\n # between each pair. For instance, the arc from node 0 to node 1 has a\n # capacity of 15 and a unit cost of 4.\n\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\n\n # Define an array of supplies at each node.\n supplies = supply\n\n\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n\n # Add each arc.\n for i in range(0, len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\n capacities[i], unit_costs[i])\n\n # Add node supplies.\n\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n\n\n # Find the minimum cost flow between node 0 and node 4.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n flag = 1\n optimal_flows = np.zeros(36)\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # save answer to the variable\n optimal_flows[i] = min_cost_flow.Flow(i)\n return flag, optimal_flows\n else:\n print('There was an issue with the min cost flow input.')\n flag = 0\n return flag, 0","def prove_and_commutativity() -> Proof:\n all_lines = []\n all_lines.append(Proof.Line(Formula.parse('(p&q)')))\n all_lines.append(Proof.Line(Formula.parse('q'), AE1_RULE, [0]))\n all_lines.append(Proof.Line(Formula.parse('p'), AE2_RULE, [0]))\n all_lines.append(Proof.Line(Formula.parse('(q&p)'), A_RULE, [1, 2]))\n statement = InferenceRule([Formula.parse('(p&q)')], Formula.parse('(q&p)'))\n all_rules = {A_RULE, AE1_RULE, AE2_RULE}\n return Proof(statement, all_rules, all_lines)","def proposed_order_print(proposed_order_list):\n for item_details in proposed_order_list:\n proposed_order_item_print(item_details)","def run(self):\n import standard\n \n # runs the checkpoints\n def checkpoints():\n result = True\n for chk in self.checkpoints:\n if chk(self) == False: result = False\n return result\n\n\n # Checks that self is complete and fills in where possible\n if hasattr(self, \"fill_attributes\"): self.fill_attributes()\n else: self = standard.fill_attributes(self)\n assert hasattr(self, \"Individual\"), \"No Individual type.\\n\"\n assert hasattr(self, \"taboo\"), \"No taboo operation.\\n\"\n assert hasattr(self, \"population\"), \"No population attribute.\\n\"\n assert hasattr(self, \"popsize\"), \"No popsize attribute.\\n\"\n assert hasattr(self, \"current_gen\"), \"No current_gen attribute.\\n\"\n assert hasattr(self, \"evaluation\"), \"No evaluation operation.\\n\"\n assert hasattr(self, \"rate\"), \"No rate attribute.\\n\"\n assert hasattr(self, \"mating\"), \"No mating functor.\\n\"\n assert hasattr(self, \"offspring\"), \"No offspring attribute.\\n\"\n assert hasattr(self, \"comparison\"), \"No comparison operation.\\n\"\n\n # creates population if it does not exist.\n if self.comm.is_root: \n while len(self.population) < self.popsize:\n j = 0\n loop = True\n while loop:\n indiv = self.Individual()\n loop = self.taboo(indiv)\n j += 1\n assert j < max(50*self.popsize, 100), \"Could not create offspring.\\n\"\n indiv.birth = self.current_gen\n self.population.append(indiv)\n self.population = self.comm.broadcast(self.population)\n \n # evaluates population if need be.\n self.evaluation() \n # now makes sure evaluation did not create twins.\n dummy, self.population = self.population, []\n for indiv in dummy:\n if any(indiv == u for u in self.population): continue\n self.population.append(indiv)\n\n # Number of offspring per generation.\n nboffspring = max(int(float(self.popsize)*self.rate), 1)\n\n # generational loop\n while checkpoints(): \n if self.comm.do_print:\n print \"\\nStarting generation \", self.current_gen\n\n # tries and creates offspring.\n if self.comm.rank == 0:\n while len(self.offspring) < nboffspring:\n j = 0\n loop = True\n while loop:\n indiv = self.mating()\n loop = self.taboo(indiv)\n j += 1\n assert j < max(10*self.popsize, 100), \"Could not create offspring.\\n\"\n indiv.birth = self.current_gen\n self.offspring.append(indiv)\n self.comm.broadcast(self.offspring)\n else: self.offspring = self.comm.broadcast(self.offspring)\n\n\n # now evaluates population.\n self.evaluation()\n\n # finally, sort and replace.\n if self.comm.rank == 0:\n # deal with differences in function sorted between python versions.\n from platform import python_version_tuple\n if python_version_tuple()[0] > 2:\n from functools import cmp_to_key\n self.population = sorted(self.population, key=cmp_to_key(self.comparison))\n else: \n self.population = sorted(self.population, cmp=self.comparison)\n # Inserts individual one by one ensuring they do not yet exist in the\n # population. This ensures that duplicates are not allowed.\n for indiv in self.offspring:\n if any(indiv == u for u in self.population): continue\n self.population.insert(0, indiv)\n # In case population smaller than expected, use conditional.\n if len(self.population) > self.popsize: self.population.pop(-1)\n self.population = self.comm.broadcast(self.population)\n \n self.offspring = []\n self.current_gen += 1 \n\n # final stuff before exiting.\n if hasattr(self, \"final\"): self.final()\n elif self.comm.do_print: print \"done\"","def run(args):\n # Load the pedigree file\n print('Parsing pedigree...', file=sys.stderr)\n pedigree = Pedigree.parse(args.input_ped)\n for member in pedigree.members:\n print(member, file=sys.stderr)\n # load the HLA calls for each donor\n print('Loading HLA calls...', file=sys.stderr)\n all_calls = {}\n calls = {}\n for donor, fcalls in zip(args.donor_name, args.donor_calls):\n print(donor, fcalls.name, file=sys.stderr)\n all_calls[donor] = []\n calls[donor] = {'A': [], 'B': [], 'C': []}\n for hla_type in sorted(HLAType.parse(line.strip())\n for line in fcalls):\n calls[donor][hla_type.gene_name].append(hla_type)\n all_calls[donor].append(hla_type)\n print('Checking for consistency...', file=sys.stderr)\n # get IDs of parents\n index_member = pedigree.by_name[args.index_donor]\n father = index_member.father\n mother = index_member.mother\n # check for 4 digit consistency\n mm4 = check_consistency(4, calls[args.index_donor], calls.get(father),\n calls.get(mother))\n # check for 2 digit consistency\n mm2 = check_consistency(2, calls[args.index_donor], calls.get(father),\n calls.get(mother))\n num_parents = len({father, mother} - {'0'})\n # print result line\n print('\\t'.join(map(str, [\n args.index_donor, num_parents, mm2 or 'OK', mm4 or 'OK'\n ])))","def proof_by_way_of_contradiction(proof: Proof, assumption: Formula,\r\n print_as_proof_forms: bool = False) -> Proof:\r\n assert proof.is_valid()\r\n assert Schema(assumption) in proof.assumptions\r\n assert proof.assumptions.issuperset(Prover.AXIOMS)\r\n for line in proof.lines:\r\n if isinstance(line, Proof.UGLine):\r\n assert line.formula.variable not in assumption.free_variables()\r\n\r\n # Remove the proof assumption while basing a fully-fledged proof on it\r\n proof = remove_assumption(proof, assumption)\r\n\r\n # Create a prover out of this proof assumptions\r\n prover = Prover(proof.assumptions)\r\n\r\n # Append\r\n step = prover.add_proof(proof.conclusion, proof)\r\n\r\n # Conclude\r\n prover.add_tautological_implication(assumption.inverse(), {step})\r\n return prover.qed()","def generate(self, analysis):\n\n #analysis = ['p','a','n','i','c','+past form']\n # Let's define our first FST\n\n f1 = FST('morphology-generate')\n \n f1.add_state('1')\n f1.add_state('2')\n f1.add_state('3')\n f1.add_state('4')\n f1.add_state('5') \n f1.add_state('6') #non-c state\n f1.add_state('7') #c state\n f1.add_state('8') #add k\n f1.add_state('9') #+present \n f1.add_state('10') #+past\n \n f1.initial_state = '1'\n #f1.set_final('8')\n f1.set_final('9')\n f1.set_final('10')\n \n #state 1 to 2, and 2 to 3. we don't care about vowel or consonant here\n for letter in list(string.ascii_letters):\n f1.add_arc('1', '2', letter, letter)\n f1.add_arc('2', '3', letter, letter)\n \n #3 to 5 input/output consonants\n vowels = ['a','e','i','o','u','A','E','I','O','U']\n consonants = [c for c in list(string.ascii_letters) if c not in vowels]\n non_c_con = [c for c in consonants if c not in ['c', 'C']]\n for letter in consonants:\n f1.add_arc('3', '5', letter, letter)\n f1.add_arc('5', '5', letter, letter)\n \n #the third and fourth input should be a vowel\n for letter in vowels:\n f1.add_arc('3', '4', letter, letter)\n f1.add_arc('4', '4', letter, letter)\n \n #if the fourth input is a non c consonant, go to 5\n for letter in non_c_con:\n f1.add_arc('4', '5', letter, letter)\n \n #if the input at state 5 is a vowel, go back to 4 \n for letter in vowels:\n f1.add_arc('5', '4', letter, letter)\n \n #if the second last letter is a c, go to 7\n f1.add_arc('4', '7', 'c', 'c')\n \n #add k after 7\n f1.add_arc('7', '8', '', 'k')\n #output nothing from 5 to 8\n f1.add_arc('5', '8', '', '')\n \n f1.add_arc('8','9','+present participle form','ing')\n f1.add_arc('8','10','+past form','ed')\n \n output = f1.transduce(analysis)[0]\n return ''.join(output)","def main():\n\trelations = [json.loads(x) for x in open('tutorial/pdtb_trial_data.json')]\n\toutput_relations = [convert_to_output(x) for x in relations]\n\toutput_relations[1]['Connective']['TokenList'] = [0]\n\toutput_relations[3]['Arg1']['TokenList'].pop(4)\n\toutput_relations[4]['Arg2']['TokenList'].pop(4)\n\toutput_relations[5]['Arg2']['TokenList'].pop(4)\n\toutput_relations[6]['Sense'] = [u'Contingency.Condition'] # This will hurt sense recall\n\toutput_relations.pop(0) # This will hurt all precision\n\tscorer.evaluate(relations, output_relations)\n\treturn output_relations","def sample_chains():\n c = chain(add.s(1, 1), add.s(1), add.s(1))\n res = c()\n print(res.get())\n print(res.parent.get())\n print(res.parent.parent.get())","def process_tree(tree):\n c = circuit()\n l = line()\n names = {}\n procedures = []\n for lst in tree.children:\n print(lst)\n if type(lst[0]) is str:\n names[lst[0]] = lst[1]\n else:\n procedures.append(lst)\n print(names)\n #print(procedures)\n\n for proc in procedures:\n\n proc_elements_names = proc[0]\n proc_name = proc[1]\n\n #print(proc_elements_names)\n #print(proc_name)\n\n if proc_name == \"set_mode\":\n mode_name = proc_elements_names[0]\n if mode_name != \"draw-mode\": \n c.set_mode(mode_name)\n elif mode_name == \"draw-mode\":\n l1 = line()\n # draw mode is different from other modes\n for element in names:\n e = CompleteElement(element)\n e.set_other_attrs(names[element])\n e.process_other_attrs()\n l1.addElement(e)\n c.connectInSeries(l1)\n c.set_mode(\"draw-mode\")\n \n \n if proc_name == \"series\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n l = l1\n c.connectInSeries(l)\n #raise SyntaxError(\"Alias {0} referrenced before assignment\".format(item[0]))\n\n elif proc_name == \"parallel\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n c.connectInParallel(l1)\n l1 = line()\n\n\n elif proc_name == \"add_parallel\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n l1 = line()\n l1.addElement(names[new_element])\n c.connection.append(l1)\n\n\n elif proc_name == \"add_series\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n for ln in c.connection:\n for e in ln.elements:\n if names[old_element] == e:\n ln.addElement(names[new_element])\n\n\n c.evaluate(\"output.png\")\n #print(c)","def load_model_and_test_composition(alg_name, tester, curriculum, num_times, new_task, show_print):\n for n in range(num_times):\n random.seed(n)\n sess = tf.Session()\n\n curriculum.restart()\n\n # Initialize a policy_bank graph to be loaded with saved model\n task_aux = Game(tester.get_task_params(curriculum.get_current_task()))\n num_features = len(task_aux.get_features())\n num_actions = len(task_aux.get_actions())\n policy_bank = PolicyBankDQN(sess, num_actions, num_features,\n tester.learning_params, tester.get_reward_machines())\n\n # Load the model\n saver = tf.train.Saver()\n\n # Get path\n if task_aux.params.game_type == \"craftworld\":\n save_model_path = '../model/' + str(task_aux.params.game_type) + '/' + task_aux.game.get_map_id()\n else:\n save_model_path = '../model/' + str(task_aux.params.game_type)\n\n saver.restore(sess, tf.train.latest_checkpoint(save_model_path))\n\n reward_machines = tester.get_reward_machines()\n print(\"Loaded {} policies (RMs)\".format(len(reward_machines)))\n\n # partial-ordered RM of new task\n new_task_rm = RewardMachine(new_task.rm_file)\n linearized_plans = new_task.get_linearized_plan()\n print(\"There are {} possible linearized plans: {}\".format(len(linearized_plans), linearized_plans))\n least_cost = float('inf')\n best_policy = [] # list of (rm_id, state_id) corresponding to each action\n\n for i, curr_plan in enumerate(linearized_plans):\n # Get the least cost path for the current linearized plan\n # cost, switching_seq = search_policy(curr_plan, tester, curriculum, new_task_rm, reward_machines,\n # policy_bank, bound=least_cost)\n cost, switching_seq = dfs_search_policy(curr_plan, tester, curriculum, new_task_rm, reward_machines,\n policy_bank, bound=least_cost)\n if cost < least_cost:\n print(cost, switching_seq)\n least_cost = cost\n best_policy = switching_seq\n\n # Execute the best policy\n print(\"Executing Best Policy...{} ({} steps)\".format(best_policy, least_cost))\n task = Game(tester.get_task_params(curriculum.get_current_task()))\n new_task_u1 = new_task_rm.get_initial_state()\n s1, s1_features = task.get_state_and_features()\n r_total = 0\n curr_policy = None\n for t in range(int(least_cost)):\n if show_print:\n task.render()\n if curr_policy is None:\n curr_policy = best_policy.pop(0)\n curr_policy_rm = reward_machines[curr_policy[0]]\n\n a = policy_bank.get_best_action(curr_policy[0], curr_policy[1],\n s1_features.reshape((1, num_features)),\n add_noise=False)\n if show_print: print(\"Action:\", Actions(a))\n task.execute_action(a)\n\n s2, s2_features = task.get_state_and_features()\n new_task_u2 = new_task_rm.get_next_state(new_task_u1, task.get_true_propositions())\n\n curr_policy_u2 = curr_policy_rm.get_next_state(curr_policy[1], task.get_true_propositions())\n desired_next_state = curr_policy_rm.get_next_state(curr_policy[1], curr_policy[2])\n if curr_policy_u2 == desired_next_state:\n logger.info(\"EXECUTED ACTION {}, SWITCHING POLICIES\".format(curr_policy[2]))\n curr_policy = None\n\n r = new_task_rm.get_reward(new_task_u1, new_task_u2, s1, a, s2)\n r_total += r * tester.learning_params.gamma ** t\n\n s1, s1_features = s2, s2_features\n new_task_u1 = new_task_u2\n if show_print:\n task.render()\n print(\"Rewards:\", r_total)\n\n return r_total","def test_theories():\n print(\"Executing test_theories:\")\n increment_theory=[\n (26,-1),\n (13,1),\n (14,),\n (31,-1),\n (30,),\n (8,0),\n (8,0),\n (8,0)\n ]\n\n repeat_increment_theory=[\n (3,),\n (33,0),\n (4,)\n ]\n\n repeat_increment_10_times_theory=[\n (13,10),\n (33,1)\n ]\n\n sum_theory=[\n (13,0),\n (13,1),\n (2,),\n (8,0),\n\n (26,-1),\n (31,-1),\n (14,),\n (8,1),\n (8,1),\n\n (24,),\n (4,),\n \n (8,0),\n (30,)\n ]\n\n print(\"increment_theory:\")\n print(language.program_string(increment_theory))\n\n print(\"Running increment_theory on (True, [0, 0])\")\n print(language.run_theory(0, [increment_theory], [], [(True, [0, 0])]))\n print(\"\\n\")\n\n print(\"repeat_increment_theory:\")\n print(language.program_string(repeat_increment_theory))\n\n print(\"repeat_increment_10_times_theory:\")\n print(language.program_string(repeat_increment_10_times_theory))\n\n print(\"Running repeat_increment_10_times_theory on (True, [0, 0])\")\n print(language.run_theory(0, [repeat_increment_10_times_theory], [increment_theory, repeat_increment_theory], [(True, [0, 0])]))","def printGraph(self):\n print \"-----\"\n for feature in self.features:\n feature.printFeature()\n for constraint in self.constraints:\n constraint.printConstraint()\n print \"-----\"","def main(test=False):\n vocabulary = chainer.datasets.get_ptb_words_vocabulary()\n freq_thresh = 0 ## ARBITRARY\n word_freqs = FreqDist(ptb.words())\n\n if not os.path.isfile('parsers/grammar.pkl'):\n\n productions = []\n add_dict = {}\n\n # use the entire treebank's parsed sentences to generate the CFG\n for i, tree in enumerate(ptb.parsed_sents()):\n\n # is it a good idea to combine this with my preprocessing?\n tree.collapse_unary(collapsePOS=False)\n tree.chomsky_normal_form(horzMarkov=2)\n\n # preprocess all productions by removing all tags\n these_productions = tree.productions()\n for production in these_productions:\n\n # remove all tags from the LHS (only keep primary tag)\n production._lhs = preprocess_nt(production._lhs)\n\n rhs = []\n for item in production._rhs:\n\n # remove all tags from the Nonterminals on the RHS\n if type(item) == nltk.grammar.Nonterminal:\n rhs.append(preprocess_nt(item))\n\n # replace numbers with N\n elif is_number(item):\n rhs.append('N')\n\n # items not in dictionary replaced with <unk>\n # dictionary requires lower\n elif not is_key(vocabulary, item.lower()):\n rhs.append('<unk>')\n\n # replace infrequent words with <unk>\n elif word_freqs[item] < freq_thresh:\n rhs.append('<unk>')\n\n # lowercase all entries in the grammar\n else:\n rhs.append(item.lower())\n\n production._rhs = tuple(rhs)\n\n if not is_key(add_dict, production.unicode_repr()):\n add_dict[production.unicode_repr()] = True\n productions.append(production)\n\n print('** {} productions found! **'.format(len(productions)))\n grammar = induce_pcfg(Nonterminal('S'), productions)\n\n with open('parsers/grammar.pkl', 'wb') as f:\n f.write(pickle.dumps(grammar))\n\n if not os.path.isfile('parsers/viterbi_parser.pkl'):\n filename = open('parsers/grammar.pkl', 'rb')\n grammar = pickle.load(filename)\n viterbi_parser = ViterbiParser(grammar, trace=0) # cubic time\n\n with open('parsers/viterbi_parser.pkl', 'wb') as f:\n f.write(pickle.dumps(viterbi_parser))\n\n if not os.path.isfile('parsers/shift_reduce_parser.pkl'):\n filename = open('parsers/grammar.pkl', 'rb')\n grammar = pickle.load(filename)\n shift_reduce_parser = ShiftReduceParser(grammar, trace=0) # linear time\n\n with open('parsers/shift_reduce_parser.pkl', 'wb') as f:\n f.write(pickle.dumps(shift_reduce_parser))\n\n with open('data/ptb.train.txt', 'r') as f:\n data = f.readlines()\n\n if test:\n for sample in [1, 23, 20330, 20332, 443]:\n\n t1 = time.time()\n viterbi_parser.parse_one(data[sample].split())\n t2 = time.time()\n print('viterbi = {:.2f} sec for {} words'.format(\n t2-t1, len(data[sample].split())))\n\n t1 = time.time()\n shift_reduce_parser.parse_one(data[sample].split())\n t2 = time.time()\n print('shift reduce = {:.2f} sec for {} words'.format(\n t2-t1, len(data[sample].split())))","def regenerateTable():\n deleteAll()\n\n # Start generating records from start nodes, and continue generating\n # records for their children until either the bottom of the ANAD_PART_OF\n # tree is reached, or stop nodes are reached.\n\n for perspective in Perspectives.Iterator():\n perspectiveName = perspective.getName()\n starts = PerspectiveAmbits.getStartAmbitForPerspective(perspectiveName)\n stops = PerspectiveAmbits.getStopAmbitForPerspective(perspectiveName)\n startNodeOids = sets.Set(starts.keys())\n stopNodeOids = sets.Set(stops.keys())\n \n #print perspectiveName\n #print startNodeOids\n #print stopNodeOids\n \n startApos = [PartOfs.getPrimaryPathApoForNodeOid(nodeOid)\n for nodeOid in startNodeOids]\n apoList = startApos[:]\n\n while len(apoList) > 0:\n partOf = apoList.pop()\n\n # create POP record for this part of.\n \n pop = AnadPartOfPerspectiveDb.AnadPartOfPerspectiveDbRecord()\n pop.setPerspectiveName(perspectiveName)\n pop.setApoOid(partOf.getOid())\n pop.setIsAncestor(False)\n pop.setNodeOid(partOf.getNodeOid())\n pop.insert()\n \n #if partOf.getOid() == 68470:\n # print \n # print pop.getPerspectiveName()\n # print pop.getApoOid()\n # print pop.isAncestor()\n # print pop.getNodeOid()\n # print\n # print partOf.getOid()\n # print partOf.getSpecies()\n # print partOf.getNodeStartStageOid()\n # print partOf.getNodeEndStageOid()\n # print partOf.getPathStartStageOid()\n # print partOf.getPathEndStageOid()\n # print partOf.getNodeOid()\n # print partOf.getSequence()\n # print partOf.getDepth()\n # print partOf.getFullPathEmapas()\n # print partOf.getFullPath()\n # print partOf.isPrimaryPath()\n # print partOf.getParentApoOid()\n\n _addToKnowledge(pop)\n\n # if this is not a stop node, then add all its part-of kids\n # to the list of APOs to generate POP records for.\n if partOf.getNodeOid() not in stopNodeOids:\n apoList.extend(PartOfs.getByParentOid(partOf.getOid()))\n\n # for each start node, add any ancestor APOs that were not added\n # by the above process.\n ancesApos = sets.Set()\n for apo in startApos:\n parentApoOid = apo.getParentApoOid()\n if parentApoOid != None:\n parentApo = PartOfs.getByOid(parentApoOid)\n if (_byApoOid.get(parentApoOid) == None or\n _byApoOid[parentApoOid].get(perspectiveName) == None):\n ancesApos.add(parentApo)\n\n while len(ancesApos) > 0:\n ancesApo = ancesApos.pop()\n # create POP record for this ancestor\n pop = AnadPartOfPerspectiveDb.AnadPartOfPerspectiveDbRecord()\n pop.setPerspectiveName(perspectiveName)\n pop.setApoOid(ancesApo.getOid())\n pop.setIsAncestor(True)\n pop.setNodeOid(ancesApo.getNodeOid())\n pop.insert()\n _addToKnowledge(pop)\n\n # if this APO has a parent that hasn't yet been processed then\n # add it to list of ancestor APOs to generate records for.\n parentApoOid = ancesApo.getParentApoOid()\n if (parentApoOid != None and\n (_byApoOid.get(parentApoOid) == None or\n _byApoOid[parentApoOid].get(perspectiveName) == None)):\n parentApo = PartOfs.getByOid(parentApoOid)\n ancesApos.add(parentApo)\n \n \n \n return","def execute_print_chain(arg):\n blockchain = Blockchain()\n blockchain.read_blockchain()\n blockchain.print_blocks()","def main_loop(num_models, output, interaction_dict, verbose=False, max_chains=100, dirty=False,\n stech_dict=False):\n out_models = []\n for i in range(1, num_models + 1):\n print(\"Macrocomplex \" + str(i) + \" ...\")\n macrocomplex = get_starting_model(interaction_dict, verbose).copy() # Selects a starting model\n model_stech = generate_model_profile(macrocomplex) # Generates the stechometry of the first two chains\n macrocomplex.id = \"Model_\" + str(i)\n run = True # WHile this variable is true, the program will keep trying to add chains to the macrocomplex\n num_of_chains = 2 # The model starts with 2 chains already\n num_empty_chains = 0 # NUmber of chains that have all their interactions depleted\n while run:\n for chain in macrocomplex: # Iterates the macrocomplex chains\n if num_of_chains < max_chains: # If the number of chains still hasn't reached the maximum allowed\n if chain.interactions: # If this chain still has pending interactions\n random.shuffle(chain.interactions) # Shuffle the interactions list (to avoid\n # repetitive behaviour)\n for inter_tple in chain.interactions:\n if stech_dict: # If there is stechometry input (either as stirng or template pdb)\n target_chain_id = interaction_dict[chain.id][inter_tple][1].id # chain to be added\n model_stech.setdefault(target_chain_id, 0)\n model_number_chain = model_stech[target_chain_id] # Get the number of repetitions\n stech_dict.setdefault(target_chain_id, 0)\n if stech_dict[target_chain_id] <= model_number_chain: # If the number of this target\n # chain would surpass the stechemestry given, don't add the chain and\n if verbose:\n print(\"(S) Chain NOT added: interaction \" + chain.id + \": \" +\n str(inter_tple[:1]) + \" ... \" + str(inter_tple[-1]) + \" to \" + target_chain_id)\n continue # jump to the next interaction tuple\n fix, to_move = interaction_dict[chain.id][inter_tple] # Get the interaction chain instances\n sup = Bio.PDB.Superimposer() # Generates a superimposer instance\n chain_atoms, fix_atoms = chain.get_common_atoms(fix) # Get common atoms between the\n # macrocomplex chain and the one in the interaction dictionary\n sup.set_atoms(chain_atoms, fix_atoms) # Generate the superposition\n move = to_move.copy() # Make a copy of the chain to move\n sup.apply(move) # Apply superposition matrix\n move_atoms = sorted(move.get_atoms())\n # Now it checks if the target chain has clashes with the model\n if not has_clashes(move_atoms, macrocomplex): # If it hasn't\n if verbose:\n print(\"Chain \" + str(num_of_chains) + \" added: interaction \" + chain.id + \": \" +\n str(inter_tple[0]) + \" ... \" + str(inter_tple[-1]) + \" to \" + move.id)\n move.parent = None # Sets the parent to none to evade biopython's strict id policy\n macrocomplex.add(move) # Adds the target chain to the model\n model_stech.setdefault(move.id, 0) # Updates stech dict\n model_stech[move.id] += 1\n num_of_chains += 1\n if dirty: # Generates a cif file for each step in the building of the model\n macrocomplex.save_to_mmCIF(output + str(i) + \"_tmp_\" + str(num_of_chains))\n elif verbose: # If it has don't add the target chain\n print(\"Chain NOT added: interaction \" + chain.id + \": \" +\n str(inter_tple[:1]) + \" ... \" + str(inter_tple[-1]) + \" to \" + move.id)\n chain.interactions = False # Set the interaction attribute to 0, this chain now will be ignored\n else:\n if verbose:\n print(\"Chain \" + chain.id + \" empty\")\n num_empty_chains += 1\n else:\n run = False # When the maximum chain treshold is reached stop running\n break\n if num_empty_chains >= len(macrocomplex): # If all chains are empty of interactions stop running\n run = False\n if verbose:\n stechometry_string = \"\" # Print the model's stechometry\n for key in sorted(model_stech.keys()):\n stechometry_string += key + \":\" + str(model_stech[key]) + \",\"\n stechometry_string = stechometry_string[:-1]\n print(\"Macrocomplex's\"+str(i)+\" Stoichiometry is: \"+stechometry_string)\n print(\"Macrocomplex \" + str(i) + \" finished\")\n out_models.append(macrocomplex) # Add model to the models list\n return out_models","def main():\n data = read_data()\n print('Part one solution: {}'.format(part_one(data)))\n print('Part two solution: {}'.format(part_two(data)))","def init_sequential_planning_program() -> str:\n # We reason about the state of the world at particular time steps: [0, t_max]\n seq_encoding = 'time(0..horizon).\\n'\n\n # Predicates evaluate to True or False\n seq_encoding += 'boolean(true).\\n'\n seq_encoding += 'boolean(false).\\n'\n # The contains/2 atom captures this relationship\n seq_encoding += 'contains(X, value(X, B)) :- predicate(X), boolean(B).\\n'\n\n # The initial state is at time t=0\n # The holds/3 atom captures the value of a predicate at a particular timestep t >= 0\n seq_encoding += 'holds(Predicate, Value, 0) :- initialState(Predicate, Value).\\n'\n\n # Closed World Assumption (CWA): Any ground atoms in the initial state which are not explicitly declared True\n # are set to False\n seq_encoding += 'initialState(X, value(X, false)) :- predicate(X), not initialState(X, value(X, true)).\\n'\n\n # The solution to the planning problem is extracted from occurs/2 atoms\n # This is a sequential encoding: only one action may occur at a particular timestep\n # Also, actions may only occur AFTER the initial state.\n seq_encoding += '1 {occurs(Action, T) : action(Action)} 1 :- time(T), T > 0.\\n'\n\n # An action may not occur unless its preconditions are met (i.e., for an action to occur at time t,\n # all applicable predicates must hold the values specified in the precondition at time t-1)\n seq_encoding += (\n ':- occurs(Action, T), precondition(Action, Predicate, Value), '\n 'not holds(Predicate, Value, T - 1).\\n'\n )\n\n # Capture the effects of an action: at time t, the value of a predicate is changed to the one specified in the\n # action's effect as long as the action was valid (see previous statement).\n seq_encoding += (\n 'caused(Predicate, Value, T) :- '\n 'occurs(Action, T), '\n 'effect(Action, Predicate, Value), '\n 'holds(PredicatePre, ValuePre, T - 1) : precondition(Action, PredicatePre, ValuePre).\\n'\n )\n\n # A predicate is considered modified if its value was changed by an action\n seq_encoding += 'modified(Predicate, T) :- caused(Predicate, Value, T).\\n'\n\n # The so-called 'inertia' statements. At a particular timestep, the value of a predicate was either:\n # 1) Modified and therefore holds a new value\n seq_encoding += 'holds(Predicate, Value, T) :- caused(Predicate, Value, T).\\n'\n # 2) Was not modified and therefore continues to hold its previous value\n seq_encoding += (\n 'holds(predicate(V), Value, T) :- holds(predicate(V), Value, T - 1), '\n 'not modified(predicate(V), T), time(T).\\n'\n )\n\n # The goal is not met unless the appropriate predicates hold their goal values at the final timestep\n seq_encoding += ':- goal(Predicate, Value), not holds(Predicate, Value, horizon).\\n'\n\n return seq_encoding","def shannon_parry_markov_chain(self):\n from sage.modules.free_module_element import vector\n if not self.is_deterministic():\n raise NotImplementedError(\"Automaton must be deterministic.\")\n if not self.digraph().is_aperiodic():\n raise NotImplementedError(\"Automaton must be aperiodic.\")\n if not self.digraph().is_strongly_connected():\n raise NotImplementedError(\"Automaton must be strongly connected.\")\n if not all(s.is_final for s in self.iter_states()):\n raise NotImplementedError(\"All states must be final.\")\n from sage.rings.integer_ring import ZZ\n M = self.adjacency_matrix().change_ring(ZZ)\n states = {state: i for i, state in enumerate(self.iter_states())}\n w_all = sorted(M.eigenvectors_right(),\n key=lambda x: abs(x[0]),\n reverse=True)\n w = w_all[0][1][0]\n mu = w_all[0][0]\n u_all = sorted(M.eigenvectors_left(),\n key=lambda x: abs(x[0]),\n reverse=True)\n u = u_all[0][1][0]\n u = 1/(u*w) * u\n final = vector(int(s.is_final) for s in self.iter_states())\n ff = u*final\n\n assert u*w == 1\n P = Transducer(initial_states=[s.label() for s in self.iter_initial_states()],\n final_states=[s.label() for s in self.iter_final_states()],\n on_duplicate_transition=duplicate_transition_add_input)\n for t in self.iter_transitions():\n P.add_transition(t.from_state.label(),\n t.to_state.label(),\n w[states[t.to_state]]/w[states[t.from_state]]/mu,\n t.word_in)\n for s in self.iter_states():\n P.state(s.label()).color = 1/(w[states[s]] * ff)\n P.state(s.label()).initial_probability = w[states[s]] * u[states[s]]\n return P","def prove_or_disprove(prop):\n #create sequent\n sequent = Sequent([],[prop])\n #create proof tree\n tree = ProofTree(sequent)\n tree.build_proof()\n #check leaves\n found = True\n seq_leaves = tree.get_leaves()\n for s in seq_leaves:\n if s.is_id() == False:\n assign(prop, s)\n found = False\n break\n if found == True:\n print tree","def generate_demonstration(start, policy, mdp):\n demonstration = []\n curr_state = start\n #print('start',curr_state)\n \n while curr_state not in mdp.terminals:\n #print('action',policy[curr_state])\n demonstration.append((curr_state, policy[curr_state]))\n curr_state = mdp.go(curr_state, policy[curr_state])\n #print('next state', curr_state)\n #append the terminal state\n demonstration.append((curr_state, None))\n return demonstration","def exercise():\n pi_good = get_pdb_inputs(pdb_str=pdb_str_answer, restraints=False)\n map_data = get_map(xrs=pi_good.xrs)\n xrs_good = pi_good.xrs.deep_copy_scatterers()\n pi_good.ph.write_pdb_file(file_name=\"answer.pdb\",\n crystal_symmetry=xrs_good.crystal_symmetry())\n #\n pi_poor = get_pdb_inputs(pdb_str=pdb_str_poor, restraints=True)\n pi_poor.ph.write_pdb_file(file_name=\"poor.pdb\")\n xrs_poor = pi_poor.xrs.deep_copy_scatterers()\n #\n d = xrs_good.distances(other=xrs_poor)\n print(d.min_max_mean().as_tuple())\n assert flex.max(d)>2\n assert flex.mean(d)>0.7\n #\n xrs_refined = xrs_poor\n for i in range(3):\n ero = individual_sites.easy(\n map_data = map_data,\n xray_structure = xrs_refined,\n pdb_hierarchy = pi_poor.ph,\n geometry_restraints_manager = pi_poor.grm)\n xrs_refined = ero.xray_structure\n # comapre\n d = xrs_good.distances(other=xrs_refined)\n print(d.min_max_mean().as_tuple())\n assert flex.max(d)<0.15\n assert flex.mean(d)<0.03\n ero.pdb_hierarchy.write_pdb_file(file_name=\"refined.pdb\",\n crystal_symmetry=xrs_good.crystal_symmetry())","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--file', '-f', type=str, help='path to corpus file', default='./train')\n args = parser.parse_args()\n\n corpus_reader = CorpusReader(args.file)\n model = BigramModel(corpus_reader.sents())\n\n test_sentences = ['Suggestive, Watson, is it not?',\n 'It is amazing that a family can be torn apart by something as simple as a pack of wild dogs!',\n 'So spoke Sherlock Holmes and turned back to the great scrapbook in which he was arranging and indexing some of his recent material.',\n 'What I like best about my friends is that they are few.',\n 'Friends what is like are they about I best few my that.']\n\n # prints two paragraphs with each five sentences\n for _ in range(2):\n print(generate(model, 5) + '\\n')\n\n # for each sentence in the test_sentences print the perplexity\n for sentence in test_sentences:\n print(model.perplexity(nltk.word_tokenize(sentence)))","def evaljointbayes(fname):\n #read file and save lines to contents\n contents = []\n f = open(fname)\n for line in f:\n randomVar = line.rstrip().split()\n if randomVar[0] != 'END':\n contents.append(randomVar)\n print \"1. Read file\", fname, \"successfully.\"\n f.close()\n \n #count numbers of nodes and probabilities in each line\n length = len(contents)\n nodes, prob = [0] * length, [0] * length\n table = [] #save all probabilities for each node \n for num in range(0, length):\n tableline = []\n for i in contents[num]:\n try:\n j = float(i)\n prob[num] += 1\n tableline.append(j) \n except ValueError:\n if i != 'NONE':\n nodes[num] += 1 \n table.append(tableline) \n \n #print out the joint distribution formular\n print \"2. The joint distribution using this network is:\"\n nodelist = []\n for line in contents:\n nodelist.append(line[0])\n print \"P(\", printElement(nodelist), \") = \"\n for num in range(0, length):\n line = contents[num]\n if nodes[num] == 1:\n print \"P(\", line[0], \")\", \n else: \n print \"P(\", line[0], '|', printElement(line[1:nodes[num]]),\\\n \")\", \n if num == length - 1:\n print ' '\n else: \n print ' * ', \n \n #print out the full joint distribution table \n###This is the revised version using recursive calls and###\n###print out the cpt table to a .txt file###\n #further revision includes deleting depth by pop() table, contents and nodes\n #also, I can extract the parents in the previous step, then contents will not be used here\n fo=open(fname+'.zz.txt','w')\n result = 1.0\n depth = 0\n global additions, multiplications\n additions, multiplications = 0, 0\n fullCPT(nodelist, [], result, depth, fo, contents, table, nodes)\n fo.close()\n\n #print out result of step 3 \n print \"3. Additions and multiplications needed to calculate\",\\\n \"the joint distribution is:\", additions, \"and\", multiplications\n print \"The number of nodes in the network is: \", length\n\n #print out reselt of step 4\n spaceFull = int(math.pow(2,length)) - 1\n spaceBN = sum(prob)\n print \"4. Space this network saved is (Compactness): \", spaceBN, \"/\", \\\n spaceFull, \"=\", float(spaceBN) / float(spaceFull), '\\n'\n return","def main():\n\n # Generate the network from the given file, and get its original weight\n matrix = generate_matrix('network.txt')\n old_weight = total_weight(matrix)\n\n # Generate a network graph from the input network to be used in Prim's\n # algorithm\n graph = generate_network_graph(matrix)\n\n # Generate a minimum spanning tree from the network graph using Prim's\n # algorithm\n mst = prim(graph)\n\n print(f\"Old network weight: {old_weight}\")\n print(f\"New network weight: {old_weight - sum(mst.values())}\")","def proof_by_way_of_contradiction(proof: Proof, assumption: Formula,\n print_as_proof_forms: bool = False) -> Proof:\n assert proof.is_valid()\n assert Schema(assumption) in proof.assumptions\n assert proof.assumptions.issuperset(Prover.AXIOMS)\n for line in proof.lines:\n if isinstance(line, Proof.UGLine):\n assert line.formula.variable not in assumption.free_variables()\n # Task 11.2","def main():\r\n\timport sys\r\n\r\n\tlistofSequences = FastAreader(sys.stdin).readFasta() \r\n\tPAMSequences = PAMfinder(listofSequences).classController() # Calls on controller class to return desired models.\r\n\tf = open('Guide Sequences.txt','w') \r\n\tfor i in range(len(PAMSequences[0])):\r\n\t\tf.write(PAMSequences[0][i]) # Prints the header sequence into the file.\r\n\t\tf.write('\\n') \r\n\t\tprint(PAMSequences[0][i]) \r\n\t\tfor j in range(len(PAMSequences[1][i])): \r\n\t\t\tif j == 0: \r\n\t\t\t\tf.write(\"Forward Strand PAM Sites:\") \r\n\t\t\t\tf.write('\\n')\r\n\t\t\t\tprint(\"Forward Strand PAM Sites:\") \r\n\t\t\tprint(PAMSequences[1][i][j]) # Prints the forward sequences\r\n\t\t\ty = str(PAMSequences[1][i][j]) # Changes from int to string characters.\r\n\t\t\tx = ''.join(y) # Joining all the string values so we can print to file.\r\n\t\t\tf.write(x) # Write the joined forward sequences to the file.\r\n\t\t\tf.write('\\n')\r\n\t\tfor k in range(len(PAMSequences[2][i])): # For reverse sequences, and follows same logic as forward. \r\n\t\t\tif k == 0:\r\n\t\t\t\tf.write(\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\")\r\n\t\t\t\tf.write('\\n')\r\n\t\t\t\tprint(\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\")\r\n\t\t\tprint(PAMSequences[2][i][k]) # Prints the reverse sequences with the corresponding positions. \r\n\t\t\ta = str(PAMSequences[2][i][k]) # Changes the integer to string characters, allowing for the values to join.\r\n\t\t\tb = ''.join(a)\r\n\t\t\tf.write(b) # Write all of the reverse sequences onto the text file with their positions. \r\n\t\t\tf.write('\\n')\r\n\tf.close() # Close the file.\r","def main():\n # Read input from file, returns all objects\n objects = read_input()\n for obj in objects:\n try:\n # Generate the objects answer, yields new object\n obj = generate_answer(obj)\n except Exception:\n # If an error might occur that is not covered, catch it here! Continue where left off\n print('ERROR: An unrecoverable error occured during the processing of ' + obj.get(\n 'operation') + '. Continuing...')\n obj['answer'] = 'ERROR'\n\n print(obj) # TODO: Remove before production\n # Generate an output file\n print_output(objects)","def CreateDecisionMdp(self):\n print(\"Creating MDP\")\n self.states = {}\n self.actions = {}\n self.rewards = []\n stateNodes = map(lambda x:x.name,\\\n filter(lambda x: x.type not in [\"ActionNode\",\"MotorNode\"],self.nodes.values()) )\n actionNodes = map(lambda x:x.name,\\\n filter(lambda x: x.type is \"ActionNode\",self.nodes.values()))\n self.states = sorted(list(stateNodes))\n self.actions = sorted(list(actionNodes))\n if(len(self.states) < 2 or len(self.actions) < 1):\n print(\"Error: States and actions must be non-empty\")\n\n # Transition probabilities\n self.P = []\n self.hasPredictions = False\n for n in range(0,len(self.actions)):\n actionNode = self.nodes[self.actions[n]]\n b = []\n for state1 in range(0,len(self.states)):\n a = []\n for state2 in range(0,len(self.states)):\n if(actionNode.predictions.has_key(self.states[state2])):\n a.append(actionNode.predictions[self.states[state2]])\n hasPredictions = True\n else: a.append(0.0)\n b.append(a)\n self.P.append(b)\n # Rewards matrix\n self.R = []\n for i in (range(0,len(self.actions))):\n b = []\n for j in (range(0,len(self.states))):\n a = []\n for k in (range(0,len(self.states))):\n key = (self.states[j],self.actions[i],self.states[k])\n if self.expectedRewards.has_key(key):\n a.append(self.expectedRewards[key])\n else: a.append(0.0)\n b.append(a)\n self.R.append(b)\n\n if self.hasPredictions:\n print(\"Number of states: \" + str(len(self.states)))\n print(\"Number of actions: \" + str(len(self.actions)))\n print(np.array(self.R))\n self.vi = mdptoolbox.mdp.QLearning(np.array(self.P), np.array(self.R), self.discountFactor)\n self.vi.run()\n else:\n print(\"MDP not created. No prediction values available.\")","def create_proof_and_forkproof(self, mainblocks, fork_index, forkblocks):\n\n # Initial blockchain\n header = None\n header_map = None\n interlink_map = None\n blockchain_name = self.proof_dir() + \"blockchain_\" + str(mainblocks) + \".pkl\"\n try:\n open(blockchain_name)\n header, header_map, interlink_map = blockchain_utils.load_blockchain(\n blockchain_name\n )\n except Exception:\n (header, header_map, interlink_map) = blockchain_utils.create_blockchain(\n blocks=mainblocks\n )\n blockchain_utils.save_blockchain(\n blockchain_name, header, header_map, interlink_map\n )\n # Initial proof\n proof = []\n proof_name = self.make_proof_filename(mainblocks)\n proof = blockchain_utils.make_proof(header, header_map, interlink_map)\n\n # Fork blockchain\n fork_header = None\n fork_header_map = None\n fork_interlink_map = None\n f_header = header\n fork_blockchain_name = (\n self.proof_dir()\n + \"blockchain_\"\n + str(mainblocks)\n + \"-\"\n + str(fork_index)\n + \"+\"\n + str(forkblocks)\n + \".pkl\"\n )\n\n # TODO: Chech if the fork blockchain can be exported as well\n (\n fork_header,\n fork_header_map,\n fork_interlink_map,\n ) = blockchain_utils.create_fork(\n f_header,\n header_map.copy(),\n interlink_map.copy(),\n fork=fork_index,\n blocks=forkblocks,\n )\n blockchain_utils.save_blockchain(\n fork_blockchain_name, fork_header, fork_header_map, fork_interlink_map\n )\n\n # Fork proof\n fork_proof = []\n fork_proof_name = self.make_fork_proof_filename(\n mainblocks, fork_index, forkblocks\n )\n fork_proof = blockchain_utils.make_proof(\n fork_header, fork_header_map, fork_interlink_map\n )\n\n fixed_fork_proof, lca = self.truncate_fork_proof(proof, fork_proof)\n self.export_proof(fixed_fork_proof, fork_proof_name)\n\n return (\n proof_name,\n fork_proof_name,\n lca,\n fork_header,\n fork_header_map,\n fork_interlink_map,\n )","def make_chains(input_text, n):\n\n # contents = open_and_read_file(sys.argv[1])\n\n chains = {}\n\n words = input_text.split()\n\n for i in range(len(words) - 2):\n a, b = words[i], words[i+1]\n pair = (a, b,)\n\n if pair in chains:\n chains[pair] += [words[i+2]]\n else:\n chains[pair] = [words[i+2]]\n # if chains.get(pair, False):\n # c = words[i + 2]\n # chains[pair].append(c)\n # # how can we have an empty list as a value and not reset?\n # else:\n # c = words[i + 2]\n # chains[pair] = []\n # chains[pair].append(c)\n\n # print \"C equals: \", c\n # chains[pair].append(c)\n # else add \"\" to dictionary\n return chains","def simplex(params, out_prefix = None, yule=True, n_model = 5, n_seqgen=5,\n JC=False, alphabet='nuc_nogap', alpha=1.0, rate_alpha=1.5, W_dirichlet_alpha=2.0):\n from Bio import AlignIO\n # generate a model\n T = betatree(params['n'], alpha=2.0)\n T.yule=yule\n T.coalesce()\n # ladderize the tree and name internal nodes via loading into TreeAnc\n T.BioTree.ladderize()\n tt = TreeAnc(tree=T.BioTree)\n if out_prefix:\n Phylo.write(tt.tree, tree_name(out_prefix, params), 'newick')\n\n for mi in range(n_model):\n params['model']=mi\n if JC:\n myGTR = GTR_site_specific.random(L=params['L'], alphabet=alphabet,\n pi_dirichlet_alpha=False, W_dirichlet_alpha=False, mu_gamma_alpha=rate_alpha)\n else:\n myGTR = GTR_site_specific.random(L=params['L'], alphabet=alphabet, pi_dirichlet_alpha = alpha,\n mu_gamma_alpha=rate_alpha, W_dirichlet_alpha=W_dirichlet_alpha)\n\n myGTR.mu*=params['m']\n\n if out_prefix:\n save_model(myGTR, model_name(out_prefix, params))\n\n for si in range(n_seqgen):\n params['seqgen']=si\n # generate sequences\n mySeq = SeqGen(params['L'], gtr=myGTR, tree=T.BioTree)\n mySeq.evolve()\n\n if out_prefix:\n save_mutation_count(mySeq, mutation_count_name(out_prefix, params))\n with open(alignment_name_raw(out_prefix, params), 'wt') as fh:\n AlignIO.write(mySeq.get_aln(), fh, 'fasta')\n reconstruct_tree(out_prefix, params, aa='aa' in alphabet)\n os.system('gzip '+alignment_name_raw(out_prefix, params))","def main():\n parser = create_argument_parser(\n \"generate a wheel spinning loose on an axle\",\n default_gravity=[0, -9.81, 0])\n parser.add_argument(\"--num-links\",\n type=int,\n default=11,\n help=\"number of links in the chain\")\n args = parser.parse_args()\n\n if args.out_path is None:\n directory = pathlib.Path(__file__).resolve().parents[1] / \"fixtures\"\n args.out_path = directory / \"chain-cross-section.json\"\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\n\n print_args(args)\n\n fixture = generate_fixture(args)\n\n save_fixture(fixture, args.out_path)","def print_seq(self):\n names, values = [], []\n for each in self.minions:\n names.append(each.name)\n values.append(f'{each.atk}/{each.dfs}')\n t = PrettyTable()\n t.add_row(names)\n t.add_row(values)\n print(t)","def makeTrainingExamples(trace):\n current = SimpleBrep()\n spec = trace[-1][1]\n examples = []\n for command, new_state in trace + [(\"RETURN\",spec)]:\n state = Object.extract(current, False) + Object.extract(spec, True)\n def horizontalPointer(x):\n try:\n x = float(x)\n pi = None\n for objectIndex, o in enumerate(state):\n if o.isVertex and o.p[0] == x or \\\n o.isLine and o.isVertical and o.p1[0] == x:\n pi = objectIndex\n break\n if pi is None:\n print(\"FATAL\")\n print(x)\n print(state)\n assert pi is not None\n return Pointer(pi)\n except (ValueError, TypeError): return x\n def verticalPointer(y):\n try:\n y = float(y)\n pi = None\n for objectIndex, o in enumerate(state):\n if o.isVertex and o.p[1] == y or \\\n o.isLine and o.isHorizontal and o.p1[1] == y:\n pi = objectIndex\n break\n if pi is None:\n print(\"FATAL\")\n print(y)\n print(state)\n assert pi is not None\n return Pointer(pi)\n except (ValueError, TypeError): return y\n\n tokens = command.split(\" \")\n if tokens[0] == \"RETURN\":\n command = [\"RETURN\"]\n elif tokens[0] == \"translation\":\n command = tokens[1:]\n command = [ token if token[0] not in ['n','l'] else \\\n Pointer([pi for pi,obj in enumerate(state) \\\n if obj.name == token and not obj.spec][0]) \n for token in command ]\n command = [\"translation\"] + command\n else:\n command = tokens[1:]\n # convert the command into a list of symbols and pointers\n # First convert pointers\n command = [ token if token[0] not in ['n','l'] else \\\n Pointer([pi for pi,obj in enumerate(state) if obj.name == token][0]) \n for token in command ]\n if tokens[0][0] == 'n': # vertex\n command[0] = horizontalPointer(command[0])\n command[1] = verticalPointer(command[1])\n elif tokens[0][0] == 'l':\n pass # lines never use absolute coordinates\n else:\n assert False\n command = [tokens[0][0]] + command\n\n examples.append((state, command))\n current = new_state\n if False:\n print(trace)\n print(\"EXAMPLES\")\n for state, command in examples:\n print(\"in the state\",state)\n print(\"execute\",command)\n \n return examples","def build_proof(self):\n if not self.root.is_atomic():\n l = apply_rule(self.root)\n self.left_subtree = ProofTree(l[0])\n if l[1] != None:\n self.right_subtree = ProofTree(l[1]) \n if self.left_subtree is not None:\n self.rule = l[2]\n left_tree= ProofTree(self.left_subtree.build_proof())\n if self.right_subtree is not None:\n self.rule = l[2]\n right_tree = ProofTree(self.right_subtree.build_proof())","def SolveAndPrint(self, model, decisions, constraints, solver_type):\n\t\ttry:\n\t\t\tresult_status = model.Solve()\n\t\t\tassert result_status == pywraplp.Solver.OPTIMAL #The problem has an optimal solution\n\t\t\tassert model.VerifySolution(1e-7, True)\n\t\t\tprint (\"Success\")\n\n\t\texcept AssertionError:\n\t\t\tresult_status = 3\n\t\t\tprint('linear problem is not sovable/infeasible for %s method'%(solver_type))\n\t\t\ttkMessageBox.showerror('infeasible', message='Problem is infeasible, no x* node for %s'%(solver_type))\n\t\t\tif solver_type == 'clp':\n\t\t\t\treturn self.optimization_problem(2,\n\t\t\t\t\t\t\t\t self.variables,\n\t\t\t\t\t\t\t\t self.constraints,\n\t\t\t\t\t\t\t\t self.type,\n\t\t\t\t\t\t\t\t self.objective,\n\t\t\t\t\t\t\t\t 'glop')\n\t\t\telse:\n\n\t\t\t\tprint('an error has occured, please review data')\n\t\t\t\ttkMessageBox.showerror('an error has occured, please review data')\n\t\t\t\treturn\t\n\n\t\tfinally:\n\t\t\tpass\n\n\t\t######## SOLUTION IS OPTIMAL ######\n\t\tself.root = Toplevel()\n\t\tmenubar = Menu(self.root)\n\t\ttext=Text(self.root)\n\t\n\t\tfilemenu=Menu(menubar, tearoff=0)\n\t\tfilemenu.add_command(label=\"Save As...\", \n\t\t\t\t\tcommand=(lambda text=text: file_save(text)), \n\t\t\t\t\taccelerator=\"Ctrl+Shift+S\")\n\n\t\tfilemenu.add_command(label=\"Reload Module\", \n\t\t\t\t\tcommand=(lambda: reload(simplex_class)), \n\t\t\t\t\taccelerator=\"Ctrl+T\")\n\n\t\tfilemenu.add_command(label=\"Close\", \n\t\t\t\t\tcommand=(lambda: checkwork(self.root, text)), \n\t\t\t\t\taccelerator=\"Ctrl+w\") #come back to this\n\t\tfilemenu.add_separator()\n\t\tfilemenu.add_command(label=\"Exit\", command=(lambda: checkwork(self.root, text)))\n\n\t\tmenubar.add_cascade(label=\"File\", menu=filemenu)\n\n\t\thelpmenu = Menu(menubar, tearoff=0)\n\t\thelpmenu.add_command(label=\"Help\", command=donothing) #come back to this\n\n\n\t\t################### STATS ########################\n\t\ttext.insert(END, \"\\n ___%s___ \\n\" %(self.title.upper()))\n\n\t\ttext.insert(END, \"\\nsolve output = %s\"%(result_status))\n\t\tprint(\"\\n\\nsolve output = %d\"%(result_status))\n\n\t\ttext.insert(END, \n\t\t\t\t\"\\nNumber of variables = %d\\n\"%(model.NumVariables()))\n\n\t\tprint (\"Number of variables = %d\"%(model.NumVariables()))\n\t\tprint (\"Number of constraints = %d\"%(model.NumConstraints()))\n\n\t\ttext.insert(END, \"\\nNumber of constraints = %d\\n\"%(model.NumConstraints()))\n\t\t\n\n\t\ttext.insert(END, \"\\nProblem solved in %f ms \\n\"%(model.wall_time()))\n\n\t\tprint (\"\\nProblem solved in %f milliseconds \\n\" %(model.wall_time()))\n\n\t\ttext.insert(END, \"\\nOptimal objective value = %f \\n\" %(model.Objective().Value())) #The objective value of the solution `no reduced costs`\n\t\tprint (\"\\nOptimal objective value = %f\\n\" %(model.Objective().Value()))\n\n\t\tfor variable in decisions:\n\t\t\ttext.insert(END, \"\\n%s = %f\\n\"%(variable.name(), variable.solution_value()))\n\t\t\tprint (\"%s = %f\" %(variable.name(), variable.solution_value()))\n\n\t\ttext.insert(END, \"\\n \\nAdvanced Stats: \\n\")\n\t\tprint (\"\\n \\nAdvanced Stats: \\n\")\n\t\ttext.insert(END, \"\\n \\nProblem Solved in %d iterations\"%model.iterations())\n\t\tprint (\"\\n \\n Problem solved in %d iterations\" %model.iterations())\n\n\t\tfor variable in decisions:\n\t\t\ttext.insert(END, \"\\n \\n%s: reduced cost = %f\" %(variable.name(), \n\t\t\t\t\t\t\t\t\tvariable.reduced_cost()))\n\t\t\tprint (\"%s: reduced cost = %f\" %(variable.name(), variable.reduced_cost()))\n\n\t\tactivities = model.ComputeConstraintActivities() #printout of RHS = `b` in AX = b\n\n\t\tfor i, constraint in enumerate(constraints):\n\t\t\ttext.insert(END, \n\t\t\t\t\"\\n\\nconstraint %s: \\ndual value = %f\\n activity=%f\" %(constraint.name(), \n\t\t\t\t\t\t\t\t\t\t\tconstraint.dual_value(), \n\t\t\t\t\t\t\t\t\t\t\tactivities[constraint.index()]))\n\n\t\t\tprint (\"constraint %s: dual value = %f\\nactivity=%f\" %(constraint.name(), \n\t\t\t\t\t\t\t\t\t\tconstraint.dual_value(),\n\t\t\t\t\t\t\t\t\t\tactivities[constraint.index()]))\n\t\t\ttext.insert(END, \n\t\t\t\t\t\"\\nLower to Upper Boundary:\\n \\t %f < %.2d < %f\" %(constraint.Lb(),\n\t\t\t\t\t\t\t\t\t\t\t activities[constraint.index()],\n\t\t\t\t\t\t\t\t\t\t\t constraint.Ub()))\n\n\t\t\tprint (\"\\nLower.....to.....Upper Boundary:\\n\\t %f < %.2d < %f\" %(constraint.Lb(),\n\t\t\t\t\t\t\t\t\t\t activities[constraint.index()],\n\t\t\t\t\t\t\t\t\t\t constraint.Ub()))\n\n\t\t\tprint(\"\\nSLACK/SURPLUS status:\\n\\t %s\"%(constraint.basis_status()))\n\n\t\t\ttext.insert(END,\n\t\t\t\t\t\"\\nSLACK/SURPLUS status:\\n\\t %s\"%(constraint.basis_status()))\n\t\ttext.config(state=DISABLED)\n\t\ttext.pack()\n\t\tself.root.config(menu=menubar)","def test_4():\n h = iotbx.pdb.input(source_info=None, lines=test_pdb_4).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 main (cmd):\n#################################################################\n#step 1: generate common block list report from block list folder\n#################################################################\n#step 2: folder read learning list\n\trecord_sequences = sequence_pattern_mining.multi_file_folder_sequence_learning_list_read(cmd)\n\tresult = sequence_pattern_mining.multi_file_sequence_prior_matrix_gen (record_sequences)\n\tprior_matrix = result[0]\n\tdone_block_name_list = result[1]\n\tprint \"block total number\"\n\tprint len (done_block_name_list)\n\n\t#done block name list contains all block names we need to ananlyze\n\t#left_candidate_list = sequence_pattern_mining.generate_critical_path(done_block_name_list, prior_matrix)\n\ttotal_result = sequence_pattern_mining.topology_path_find(done_block_name_list, prior_matrix)\n\tprint record_sequences[3]\n\tsequence_pattern_mining.sub_path_list_verify_2 (total_result , record_sequences[3])\n\t\t\n\n\t\"\"\"\n\tfor sub_list in total_result:\n\t\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[0])\n\t\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[1])\n\t\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[2])\n\t\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[3])\n\t\"\"\"\n\n\t\n\t\"\"\"\n\tstatus_matrix = sequence_pattern_mining.gen_status_matrix_based_on_prior_matrix(done_block_name_list, prior_matrix)\n\t\n\tdone_block_name_list = ['block_106','block_75', 'block_22', 'block_72', 'block_73' ]\n\tsub_path_list = sequence_pattern_mining.find_sub_path (done_block_name_list, status_matrix, prior_matrix)\n\tprint sub_path_list\n\t\n\tdone_block_name_list = ['block_106','block_75', 'block_22', 'block_73', 'block_72' ]\n\tsub_path_list = sequence_pattern_mining.find_sub_path (done_block_name_list, status_matrix, prior_matrix)\n\tprint sub_path_list\n\t\n\tgrowing_pattern = [ 'block_22', 'block_73', 'block_75','block_106']\n\tinsert_pos = sequence_pattern_mining.search_sub_block_insert_into_growing_pattern_position_1 (growing_pattern, \"block_72\", status_matrix)\n\tprint insert_pos\n\tnew_list = list(growing_pattern)\n\tnew_list.insert(insert_pos, \"block_72\")\n\tprint new_list\n\t\n\tgrowing_pattern = [ 'block_22', 'block_72', 'block_75','block_106']\t\n\tinsert_pos = sequence_pattern_mining.search_sub_block_insert_into_growing_pattern_position_1 (growing_pattern, \"block_73\", status_matrix)\n\tprint insert_pos\n\tnew_list = list(growing_pattern)\n\tnew_list.insert(insert_pos, \"block_73\")\n\tprint new_list\n\t\"\"\"","def logic_program_form(self):\r\n s = ''\r\n for x in self.new_sorts:\r\n s = s + 'dom(' + x + ').\\nis_a(' + x + ', nodes).\\n' \r\n for y in self.supersorts:\r\n s = s + 'link(' + x + ', ' + y + ').\\n'\r\n return s","def test_BuildModel3(self):\n print(\"\\nTest 7: Building a more complicated Model\")\n builder = StaticBuilder(\"BreakIt\")\n in1 = builder.addInput(10)\n in2 = builder.addInput(20)\n enc1 = builder.addInner(3)\n enc2 = builder.addInner(5, num_islots=2)\n out1 = builder.addOutput()\n out2 = builder.addOutput()\n \n builder.addDirectedLink(in1, enc1)\n builder.addDirectedLink(in2, enc2, islot=0)\n builder.addDirectedLink(enc1, enc2, islot=1)\n builder.addDirectedLink(enc1, out1)\n builder.addDirectedLink(enc2, out2)\n \n builder.build()","def test_markov_word_chain_builder():\n input_sequence = (\n 'PIKARD', 'Q', 'PIKARD', 'DORF', 'PIKARD', 'Q', 'ROKER', 'Q', 'PIKARD'\n )\n expected_probabilities = {\n 'PIKARD': [('Q', 2.0 / 3), ('DORF', 1.0 / 3)],\n 'Q': [('PIKARD', 2.0 / 3), ('ROKER', 1.0 / 3)],\n 'DORF': [('PIKARD', 1.0)],\n 'ROKER': [('Q', 1.0)],\n }\n builder = markov.WordChainBuilder()\n for word in input_sequence:\n builder.add_next(word)\n chain = builder.normalize()\n\n for leader, probs in expected_probabilities.items():\n assert leader in chain\n assert sort_probs(probs) == sort_probs(chain[leader])","def generate_problems(ctx):\n\timport random\n\timport subprocess\n\toutput_folder = \"problems\"\n\tproblem_type = 'octdiff'\n\tcommand = \"./plas.py\"\n\tnvals = 10\n\tmin_val = 1\n\tmax_val = 100\n\tmut_chance = 1/8\n\tinc_chance = 0.9\n\tnvars_list = [2, 3, 5, 10, 15, 20]\n\toutput_format = \"{}-problem-@n-@s.@t.plas\"\n\ttotals_per_mode = [(25, 0, 0), (25, inc_chance, 0), (25, 0, mut_chance), (25, inc_chance, mut_chance)] # No mutation, only removal, only mutation, removal + mutation\n\tabs_totals = 0\n\t\n\tfor x in totals_per_mode:\n\t\tabs_totals += x[0]\n\tproblems_node = ctx.path.make_node(output_folder)\n\tproblems_node.delete()\n\tproblems_node.mkdir()\n\n\tfor nvars in nvars_list:\n\t\tnvars_name = \"%dv\" % nvars\n\t\tnvars_node = problems_node.make_node(nvars_name)\n\t\tnvars_node.mkdir()\n\t\tnumber_seed = int(random.uniform(1, 2**32 - 1)) # int(random.uniform(1, 2 ** (2 ** 6) + 1) % sys.maxsize)\n\t\tremove_seed = int(random.uniform(1, 2**32 - 1)) # int(random.uniform(1, 2 ** (2 ** 6) + 1) % sys.maxsize)\n\t\tmutate_seed = int(random.uniform(1, 2**32 - 1)) # int(random.uniform(1, 2 ** (2 ** 6) + 1) % sys.maxsize)\n\t\tcount = 1\n\t\tfor totals_idx in range(len(totals_per_mode)):\n\t\t\ttotals = totals_per_mode[totals_idx][0]\n\t\t\ttotals_inc_chance = totals_per_mode[totals_idx][1]\n\t\t\ttotals_mut_chance = totals_per_mode[totals_idx][2]\n\t\t\tcmdline = [command,\n\t\t\t\t\"gen\",\n\t\t\t\t\"--problem-type=%s\" % problem_type,\n\t\t\t\t\"--nvars=%d\" % nvars,\n\t\t\t\t\"--nvals=%d\" % nvals,\n\t\t\t\t\"--min=%g\" % min_val,\n\t\t\t\t\"--max=%g\" % max_val,\n\t\t\t\t\"--nproblems=%d\" % totals,\n\t\t\t\t\"--nproblems-startnum=%d\" % count,\n\t\t\t\t\"--nproblems-total=%d\" % abs_totals,\n\t\t\t\t\"--output=%s\" % (nvars_node.abspath() + \"/\" + output_format.format(nvars_name)),\n\t\t\t\t\"--seed=%d\" % number_seed,\n\t\t\t\t\"--mutation-seed=%d\" % mutate_seed,\n\t\t\t\t\"--inclusion-seed=%d\" % remove_seed,\n\t\t\t\t\"--mutation-chance=%g\" % totals_mut_chance,\n\t\t\t\t\"--inclusion-chance=%g\" % totals_inc_chance,\n\t\t\t]\n\t\t\tprint(\"Generating problems: \\\"%s\\\"\" % (\" \".join(cmdline)) )\n\t\t\tresult = subprocess.call(cmdline)\n\t\t\tif result:\n\t\t\t\tprint(\"ERROR while generating previous command! Exit code: %d\" % result)\n\t\t\tcount += totals","def asp_problem(choices: TextIO, rules: TextIO = None, positives: TextIO = None, main: Union[str, TextIO] = '', outf: TextIO = None):\n if outf is None:\n outf = sys.stdout\n\n def asp_section(name):\n print('\\n' + ('%' * 30) + '\\n%%%% ' + name + '\\n', file=outf)\n\n def asp_comment(txt: str):\n print(ASPenc.comment(txt), file=outf)\n\n actions = set()\n asp_section('Choices')\n asp_comment('constraints in choices are in all possible constraints')\n print(ASPenc.rule(ASPenc.all_constraintsp('C'), [ASPenc.choicep('_', 'C')]), file=outf)\n outf.write('\\n')\n choices2asp(choices, actions, out=outf)\n\n if positives is not None:\n asp_section('Positive')\n asp_comment('positive constraints holds by assumption')\n print(ASPenc.rule(ASPenc.holdsp('C'), [ASPenc.fixedp('C')]), file=outf)\n outf.write('\\n')\n asp_comment('positive constraints constraints in choices are in all possible constraints')\n print(ASPenc.rule(ASPenc.all_constraintsp('C'), [ASPenc.fixedp('C')]), file=outf)\n constraints2asp(positives, actions, outf=outf)\n outf.write('\\n')\n\n asp_section('Actions')\n for a in actions:\n print(ASPenc.all_actionsp(ASPenc.const(a)) + '.', file=outf)\n\n asp_section('Declare rules')\n asp_comment(f'selected constraints holds')\n print(ASPenc.rule(ASPenc.holdsp('C'), [ASPenc.selectedp('C')]), file=outf)\n outf.write('\\n')\n if rules is not None:\n rules2asp(rules, outf=outf)\n\n asp_section('Constraints structure')\n max_arity = 3\n for i in range(1, max_arity+1):\n asp_comment(f'Constraints of arity {i}')\n avars = [f'A{j}' for j in range(1, i+1)]\n rhead = ASPenc.constraint_namep('C', 'P', i)\n rbody = [\n ASPenc.all_constraintsp('C'),\n 'C = ' + ASPenc.constraint('P', avars, quote=False),\n ]\n print(ASPenc.rule(rhead, rbody), file=outf)\n for j in range(i):\n rhead = ASPenc.constraint_actionp('C', avars[j])\n print(ASPenc.rule(rhead, rbody), file=outf)\n\n asp_section('Main')\n if isinstance(main, str):\n outf.write(main)\n else:\n outf.write(main.read())\n\n asp_comment('print selected constraints')\n print(r'#show ${predicate_selected}/1.', file=outf)","def prover9(assume_list, goal_list, mace_seconds=2, prover_seconds=60,\n domain_cardinality=None, one=False, options=[], noniso=True, hints_list=None, keep_list=None, \n delete_list=None):\n fh = open('tmp.in','w')\n for st in options:\n fh.write(st+'.\\n')\n fh.write('formulas(assumptions).\\n')\n for st in assume_list:\n fh.write(st+'.\\n')\n fh.write('end_of_list.\\nformulas(goals).\\n')\n for st in goal_list:\n fh.write(st+'.\\n')\n fh.write('end_of_list.\\n')\n fh.close()\n\n if mace_seconds!=0:\n mace_params = ''\n if domain_cardinality != None:\n st = str(domain_cardinality)\n mace_params = ' -n '+st+' -N '+st+('' if one else ' -m -1')+' -S 1' #set skolem_last\n res = os.system(uapth+'mace4 -t '+str(mace_seconds)+mace_params+' -f tmp.in >tmp.out 2>tmpe')\n fh = open('tmp.out')\n out_str = fh.read()\n fh.close()\n ind = out_str.find(\"%%ERROR\")\n if ind != -1: \n print out_str[ind+2:]\n return\n if out_str.find('Exiting with failure') == -1:\n if domain_cardinality != None and not one and noniso:\n os.system(uapth+'interpformat standard -f tmp.out | '+uapth+'isofilter '+\n 'check \\\"+ * v ^ \\' - ~ \\\\ / -> B C D E F G H I J K P Q R S T U V W b c d e f g h i j k p q r s t 0 1 <= -<\\\" '+\n 'output \\\"+ * v ^ \\' - ~ \\\\ / -> B C D E F G H I J K P Q R S T U V W b c d e f g h i j k p q r s t 0 1 <= -<\\\" | '+\n uapth+'interpformat portable >tmpe')\n else:\n os.system(uapth+'interpformat portable -f tmp.out >tmpe')\n fh = open('tmpe')\n out_str = fh.read()\n fh.close()\n if out_str!=\"\":\n li = eval(out_str.replace(\"\\\\\",\"\\\\\\\\\"))\n else:\n print \"No models found (so far)\"\n return\n models = []\n for m in li:\n models += [Model(m[0],len(models),getops(m[2],'function'),getops(m[2],'relation'))]\n if domain_cardinality != None and not one:\n print \"Number of \"+(\"nonisomorphic \" if noniso else \"\")+ \"models of cardinality\", domain_cardinality, \" is \", len(models)\n #else: print \"(Counter)example of minimal cardinality:\"\n return models\n elif domain_cardinality != None and out_str.find('exit (exhausted)') != -1:\n if not one: print 'No model of cardinality '+str(domain_cardinality)\n return []\n\n res = os.system(uapth+'prover9 -t '+str(prover_seconds)+' -f tmp.in >tmp.out 2>tmpe')\n fh = open('tmp.out')\n out_str = fh.read()\n fh.close()\n ind = out_str.find(\"%%ERROR\")\n if ind != -1: \n print out_str[ind+2:]\n return\n if True:#res==0 or res==1 or res==256: \n os.system(uapth+'prooftrans expand renumber parents_only -f tmp.out >tmpe')\n fh = open('tmpe')\n out_str = fh.read()\n fh.close()\n lst = []\n ind1 = out_str.find(\"PROOF ===\")\n ind2 = out_str.find(\"end of proof ===\")\n while ind1 != -1:\n lst.append([proofstep2list(x) for x in out_str[ind1:ind2].split('\\n')[10:-2]])\n ind1 = out_str.find(\"PROOF ===\",ind2)\n ind2 = out_str.find(\"end of proof ===\",ind2+1)\n return [Proof(li) for li in lst]\n print 'No conclusion (timeout)'\n return 'No conclusion (timeout)'","def print_generations(start, n):\n pb(start)\n for c in range(n):\n print(\"---\")\n start = life_generation(start)\n pb(start)\n return start","def alg(self):\n\n # Find freq ordering of vars and initialize lowest level mdps\n self.mdps[0] = set()\n self.freq, self.state_dim = self.find_freq()\n\n # Build the task hierarchy\n for level in range(self.state_dim):\n # Randomly execute actions from level and fill MDP properties (trans prob, adj, etc)\n self.explore(level=level, exploration_iterations=self.args.exploration_iterations)\n # Using MDP properties, find exits, MERs, and form MDPs at level+1\n self.create_sub_mdps(level+1)\n # Train a policy to reach every exit in the MDPs at level+1\n self.train_sub_mdps(self.mdps[level+1])\n\n # Serialize the MDPs\n with open(self.args.binary_file, 'wb') as handle:\n pickle.dump(self.mdps, handle, protocol=pickle.HIGHEST_PROTOCOL)\n handle.close()\n\n self.log[self.args.log_name].info(\"Finished pickling MDPs, saved at {}!\\n\".format(self.args.binary_file))","def pre_flight(self):\n\n def check_already_chain():\n \"\"\"In case a user runs the command twice on the same input\"\"\"\n all_are_already_rigids = True\n for transform, _ in self._pairs:\n if not transform.shape(type=\"rdRigid\"):\n all_are_already_rigids = False\n break\n\n assert not all_are_already_rigids, (\n \"Every transform is already dynamic\"\n )\n\n def check_hierarchy():\n \"\"\"Ensure incoming chain reflects a physical hierarchy\n\n For example, this is what a valid selection looks like,\n including a non-selected offset group that is still part\n of the hierarchy.\n\n o- clavicle\n |-o upperArm\n |-o lowerArm\n |-o ( offsetGroup )\n |-o hand\n\n \"\"\"\n\n pairs = self._pairs[:]\n while pairs:\n transform, _ = pairs.pop()\n expected_parent, _ = pairs[-1] if pairs else (None, None)\n\n if not expected_parent:\n break\n\n # Walk up the hierarchy until you find what\n # is supposed to be the parent.\n #\n # .\n # |--o a /|\\\n # |--o B |\n # |--o c |\n # |--o d |\n # |\n #\n valid = False\n for parent in transform.lineage():\n if parent == expected_parent:\n valid = True\n break\n\n problem = (\n \"%s was not a parent of %s\" % (\n expected_parent, transform)\n )\n\n # Ok, so the prior link isn't a parent, but we\n # also must make it isn't a child of the subsequent\n # link, as that would mean a cycle\n #\n # |\n # |--o a |\n # |--o B |\n # |--o c |\n # |--o d |\n # \\ /\n # `\n if not valid:\n is_child = False\n for child in transform.descendents():\n if child == expected_parent:\n is_child = True\n break\n\n # It's valid if the Maya parent isn't a Ragdoll child\n valid = not is_child\n\n # This flips the problem on its head\n problem = (\n \"%s cannot be a child of %s, that's a cycle\" % (\n expected_parent, transform)\n )\n\n assert valid, problem\n\n def pre_cache():\n \"\"\"Pre-cache attributes to avoid needless evaluation\"\"\"\n for transform, _ in self._pairs:\n world_matrix = transform[\"worldMatrix\"][0].asMatrix()\n parent_matrix = transform[\"parentMatrix\"][0].asMatrix()\n matrix = transform[\"matrix\"].asMatrix()\n translate = transform[\"translate\"].as_vector()\n rotate = transform[\"rotate\"].as_euler()\n\n if \"jointOrient\" in transform:\n joint_orient = transform[\"jointOrient\"].as_quaternion()\n else:\n # Only joints have these\n joint_orient = cmdx.Quaternion()\n\n self._cache[(transform, \"worldMatrix\")] = world_matrix\n self._cache[(transform, \"parentMatrix\")] = parent_matrix\n self._cache[(transform, \"matrix\")] = matrix\n self._cache[(transform, \"translate\")] = translate\n self._cache[(transform, \"rotate\")] = rotate\n self._cache[(transform, \"jointOrient\")] = joint_orient\n\n def remember_existing_inputs():\n # Remember existing animation\n for transform, _ in self._pairs:\n transform.data[\"priorConnections\"] = {}\n for channel in (\"translate\", \"rotate\"):\n for axis in \"XYZ\":\n src = transform[channel + axis]\n src = src.connection(plug=True, destination=False)\n\n if src is not None:\n anim = transform.data[\"priorConnections\"]\n dst = \"in%s%s1\" % (channel.title(), axis)\n anim[src] = dst\n\n check_already_chain()\n check_hierarchy()\n remember_existing_inputs()\n pre_cache()\n\n return True","def main():\n n, m = map(int, raw_input().split(' '))\n knowledge = []\n for i in xrange(n):\n knowledge.append(raw_input())\n print '\\n'.join(map(str, acm_icpc_team(knowledge)))","def main():\n\n N, k = map(int, sys.stdin.readline().split())\n initial_state = tuple( map(int, sys.stdin.readline().split()) )\n final_state = tuple( map(int, sys.stdin.readline().split()) )\n\n init_path = [initial_state]\n all_paths = [init_path]\n\n visited_states = set()\n visited_states.add(initial_state)\n\n while all_paths:\n popped_path = all_paths.pop(0)\n current_state = popped_path[-1]\n\n if current_state == final_state:\n solution = popped_path\n break\n\n for state, action in generate_moves(current_state, N, k).items():\n if state not in visited_states:\n visited_states.add(state)\n new_path = popped_path + [action,state]\n all_paths.append(new_path)\n\n display_solution(solution)","def main():\n target = 'Coding:Level1'\n output_root = f'problem_5_output/{target.replace(\":\", \"_\")}'\n if not os.path.exists(output_root):\n os.makedirs(output_root, exist_ok=True)\n\n # dictionary of parameter grids, one for each process\n param_grids = {\n 'early_stopping': ParameterGrid([\n {\n 'patience': [15], # , 20, 40]\n },\n ]),\n 'fit': ParameterGrid([\n {\n 'batch_size': [128], # , 64, 128, 256],\n 'epochs': [16], # 20, 50],\n },\n ]),\n 'model_preprocessor': ParameterGrid([\n {\n 'num_unique_words': [5000], # 4000, 1000, 6000, 10000],\n 'max_sequence_length': [150], # 50, 75, 100, 125, 150, 200],\n },\n ]),\n 'model': ParameterGrid([\n # {\n # Dense single hidden layer model hyperparameters:\n # 'name': ['dense_h1'],\n # 'embedded_dims': [8], # , 16, 32, 64, 128, 256],\n # 'num_units_h1': [8], # , 16, 32, 64, 128, 256],\n # 'drop_h1': [None], # , 0.1, 0.2, 0.25, 0.5, 0.75],\n # 'optimizer': ['nadam', 'adam'],\n # 'learning_rate': [None], # , 0.01, 0.001],\n # 'activation': ['relu', 'tanh'],\n # },\n # {\n # Dense double hidden layer model hyperparameters:\n # 'name': ['dense_h2'],\n # 'embedded_dims': [64],\n # 'num_units_h1': [128],\n # 'num_units_h2': [128],\n # 'drop_h1': [None],\n # 'drop_h2': [0.5],\n # 'optimizer': ['nadam'],\n # 'activation': ['relu'],\n # 'learning_rate': [0.01],\n # },\n # {\n # CNN single hidden layer model hyperparameters\n # 'name': ['conv_h1'],\n # 'embedded_dims': [64],\n # 'num_units_h1': [32], # , 64, 256],\n # 'k_conv_h1': [2], # , 3, 4],\n # 'drop_embed': [0.2], # , 0.5],\n # 'activation': ['relu', 'tanh'],\n # 'optimizer': ['adam', 'nadam']\n # },\n # {\n # CNN double hidden layer model hyperparameters\n # 'name': ['conv_h2'],\n # 'embedded_dims': [128], # , 64, 32, 16, 8],\n # 'num_units_h1': [32], # , 64, 128],\n # 'drop_h2': [0.5], # , 0.75, 0.25, 0.1],\n # 'k_conv_h1': [2], # , 3, 4],\n # 'num_units_h2': [128], # , 64, 32, 16, 8],\n # 'drop_embed': [0.2], # , 0.50],\n # 'activation': ['relu'],\n # 'optimizer': ['adam'], # , 'nadam'],\n # },\n # {\n # CNN double hidden layer model hyperparameters\n # 'name': ['conv_h2.1'],\n # 'embedded_dims': [64],\n # 'num_units_h1': [32], # , 64, 128],\n # 'k_conv_h1': [2], # , 3, 4],\n # 'drop_embed': [0.2], # , 0.5],\n # 'activation': ['relu'],\n # 'optimizer': ['adam'], # , 'nadam']\n # },\n # {\n # RNN single hidden layer model hyperparameters\n # 'name': ['rnn_h1'],\n # 'embedded_dims': [64],\n # 'drop_embed': [0.2],\n # 'num_units_h1': [128],\n # 'optimizer': ['nadam'],\n # 'learning_rate': [0.01]\n # },\n # {\n # # LSTM double hidden layer (second layer dense FC) model hyperparameters\n # 'name': ['lstm_h1'],\n # 'embedded_dims': [64],\n # 'drop_embed': [0.2],\n # 'drop_h1': [0.5],\n # 'num_units_h1': [128],\n # 'optimizer': ['nadam'],\n # },\n # {\n # LSTM double hidden layer (second layer dense FC) model hyperparameters\n # 'name': ['lstm_h2'],\n # 'embedded_dims': [64],\n # 'drop_embed': [0.2],\n # 'num_units_h1': [128],\n # 'drop_h1': [0.5],\n # 'num_units_h2': [128],\n # 'optimizer': ['nadam'],\n # 'activation': ['relu']\n # },\n # {\n # # Bi-directional LSTM single hidden layer model hyperparameters\n # 'name': ['bi_lstm_h1'],\n # 'embedded_dims': [32], # , 64, 128],\n # 'drop_embed': [0.2], # , 0.25, 0.5],\n # 'num_units_h1': [32], # , 64, 128],\n # 'drop_h1': [0.2], # , 0.25, 0.5],\n # 'optimizer': ['nadam', 'adam']\n # },\n # {\n # Bi-directional LSTM double hidden layer (second layer Bi-LSTM) model hyperparameters\n # 'name': ['bi_lstm_h2'],\n # 'embedded_dims': [32], # , 64, 128],\n # 'num_units_h1': [32], # , 64, 128],\n # 'num_units_h2': [32], # , 64, 128],\n # 'drop_h1': [0.25, 0.5],\n # 'drop_h2': [0.25, 0.5],\n # 'optimizer': ['nadam', 'adam']\n # },\n {\n # Multi Convolutional model hyperparameters\n 'name': ['multi_conv_h3_s2'],\n 'drop_embed': [0.5], # , 0.3],\n 'embedded_dims': [128], # , 64, 128, 256],\n 'num_units_h1': [128], # , 64, 128, 256],\n 'num_units_h2': [128], # , 64, 128, 256],\n 'num_units_h3': [128], # , 64, 128, 256],\n 'num_units_h4': [128], # , 64, 128, 256],\n 'k_conv_h1': [3],\n 'k_conv_h2': [2],\n 'activation': ['relu'], # , 'tanh'],\n 'drop_h3': [0.2], # , 0.2, 0.25, 0.5, 0.75],\n 'optimizer': ['adam'], # 'nadam']\n },\n # {\n # # Multi Convolutional model hyperparameters\n # 'name': ['multi_conv_h3_s3'],\n # 'drop_embed': [0.5], # , 0.3],\n # 'embedded_dims': [32], # , 64, 128, 256],\n # 'num_units_h1': [32], # , 64, 128, 256],\n # 'num_units_h2': [32], # , 64, 128, 256],\n # 'num_units_h3': [32], # , 64, 128, 256],\n # 'num_units_h4': [32], # , 64, 128, 256],\n # 'k_conv_h1': [3],\n # 'k_conv_h2': [2],\n # 'k_conv_h3': [4],\n # 'k_conv_h4': [4],\n # 'activation': ['relu', 'tanh'],\n # 'drop_h4': [0.1], # , 0.2, 0.25, 0.5, 0.75],\n # 'optimizer': ['adam', 'nadam']\n # },\n ]),\n 'preprocessor': ParameterGrid([\n # {\n # 'do_clean': [False],\n # 'pad_type': ['pre', 'post'],\n # 'trunc_type': ['pre', 'post'],\n # },\n {\n 'do_clean': [True],\n 'pad_type': ['post'], # , 'post'],\n 'trunc_type': ['post'], # 'post'],\n 'omit_stopwords': [False],\n 'ignore_urls': [False],\n 'fix_contractions': [True],\n 'stem': [True],\n 'remove_foreign_characters': [False], # , False],\n 'lower': [True], # , False],\n 'remove_punctuation': [True], # , False],\n 'bigrams': [True], # , False]\n },\n ])\n }\n\n def prod(a):\n if len(a) == 0:\n return 1\n return a[0] * prod(a[1:])\n\n num_models = prod([len(pg) for pg in param_grids.values()])\n\n param_grid_names = sorted(list(param_grids.keys()))\n param_grid_list = [param_grids[k] for k in param_grid_names]\n\n all_params, best_params = assemble_results(output_root)\n\n if CHECK_ONLY:\n for i, params in enumerate(itertools.product(*param_grid_list[3:5])):\n params = {k: v for k, v in zip(param_grid_names[3:5], params)}\n print(i, params)\n Preprocessor(**params['preprocessor'], **params['model_preprocessor'])\n\n for i, params in enumerate(itertools.product(*param_grid_list[2:4])):\n params = {k: v for k, v in zip(param_grid_names[2:4], params)}\n print(i, params)\n build_fn(num_classes=3, **params['model'], **params['model_preprocessor'])\n return\n\n for i, params in enumerate(itertools.product(*param_grid_list)):\n mem = psutil.virtual_memory()\n percent_used = 1 - mem.available / mem.total\n print(f'{percent_used:.2%} memory used')\n if percent_used > 0.80:\n # exit failure\n print('Exiting (-1)')\n exit(-1)\n\n params = {k: v for k, v in zip(param_grid_names, params)}\n print(f'\\n{i + 1}/{num_models}: {params}\\n')\n\n if params in all_params:\n # skip this one because we already ran it.\n continue\n\n if best_params is not None:\n # print best performance so far\n print(f'best params: {best_params}')\n print(f'best val loss: {best_params[\"results\"][\"valid\"][\"loss\"]:.6f}')\n print(f'best val acc: {best_params[\"results\"][\"valid\"][\"accuracy\"]:.4%}')\n\n # create a new output directory with path to model file.\n date = datetime.datetime.utcnow().strftime(\"%Y-%m-%d-%H.%M.%S.%f\")\n output_dir = os.path.join(output_root, date)\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n model_file = os.path.join(output_dir, 'model.h5')\n\n # get the preprocessed training and validation data\n preprocess_time = time.time()\n classes, data_sets, set_names = get_xy(Preprocessor(**params['preprocessor'], **params['model_preprocessor']),\n target=target)\n ((x_train, y_train), (x_valid, y_valid)) = data_sets\n preprocess_time -= time.time()\n\n # build and compile model\n model = build_fn(num_classes=len(classes), **params['model'], **params['model_preprocessor'])\n\n # setup callbacks\n early_stopping = EarlyStopping(monitor='val_loss', verbose=1, **params['early_stopping'])\n model_checkpoint = ModelCheckpoint(\n filepath=model_file,\n save_weights_only=False, save_freq='epoch',\n save_best_only=True, monitor='val_loss', verbose=1)\n callbacks = [early_stopping, model_checkpoint]\n\n # Use sample weights to treat classes equally in loss and accuracy.\n sample_weight = get_sample_weight(y_train)\n sample_weight_valid = get_sample_weight(y_valid)\n\n # fit the model\n train_time = time.time()\n model.fit(x=x_train, y=y_train, sample_weight=sample_weight, verbose=1,\n validation_data=(x_valid, y_valid, sample_weight_valid), callbacks=callbacks, **params['fit'])\n train_time -= time.time()\n\n # load the best model (last one saved)\n model = load_model(model_file, compile=True)\n\n # compute results\n results = get_performance(model, data_sets, set_names)\n results['time'] = {'train': train_time, 'preprocess': preprocess_time}\n\n print(pd.DataFrame(data=results).T)\n params['results'] = results\n\n # save params and results\n with open(os.path.join(output_dir, 'params.json'), 'w') as fp:\n json.dump(params, fp)\n\n # save a copy of *this* Python file.\n shutil.copyfile(__file__, os.path.join(output_dir, 'roatan.py'))\n\n # for convenience, show the validation loss and accuracy in a file name in the same directory.\n result_file_name = f'{params[\"results\"][\"valid\"][\"loss\"]:.6f}_{params[\"results\"][\"valid\"][\"accuracy\"]:.4f}.out'\n with open(os.path.join(output_dir, result_file_name), 'w'):\n pass\n\n # check_model(output_dir)\n\n if best_params is None or (params['results']['valid']['loss'] < best_params['results']['valid']['loss']):\n best_params = params\n\n # assemble results from all runs into one CSV file in output root.\n assemble_results(output_root)","def reveal(self):\n if not all([self.u, self.P, self.P2, self.s, self.e]):\n raise PoDLEError(\"Cannot generate proof, data is missing\")\n if not self.commitment:\n self.get_commitment()\n Phex, P2hex, shex, ehex, commit = [\n safe_hexlify(x) for x in [self.P.serialize(),\n self.P2.serialize(),\n self.s, self.e, self.commitment]]\n return {'used': str(self.used), 'utxo': self.u, 'P': Phex, 'P2': P2hex,\n 'commit': commit, 'sig': shex, 'e': ehex}","def make_text(chains):\n key = choice(list(chains.keys()))\n\n words = []\n\n while key in chains:\n word = get_new_word(key, chains)\n words.append(word)\n key = get_new_key(key, word)\n\n return \" \".join(words)","def __init__(self, lines=[], people=[], name=''):\n\n self.name=repr(name)\n self.relable=defaultdict(str)\n self.people=set(people + self.keys())\n self.new_names=list(set(people)-set(self.keys())) #New People being added.\n self.process_lines(lines)\n self.concepts=set(self.relable.keys())\n# have to store all concepts and then check for each concept (before adding it to a causal graph) if it already exists in the set or not; if it exists, I find the representative label with which it is labelled in the first causal graph to which it was added. Also, this set of concepts is the raw material of the data set of concepts wherein 3000 or so concepts that are identical in meaning are paired by hand and then a machiene learning algorithm will be trained on the training set (the first x paired concepts) to learn which concepts are in meaning identical. Later, the causal-belief-graphs will be simplified, using this tool. The concepts are also stored in each node, under the key \"concept\". The greatest advantage of using networkx is that all kinds of information, including affective information, can be stored in each link and each concept, making these cognitive maps greatly extendable beyond the causal!\n\n for name in self.new_names:\n self[name]=CausalGraph()","def print_details():\n\n print('\\n'\n 'SCORE: {0}\\n'\n 'COMPLEXITY: {1}\\n'\n .format(pwd_score, pwd_complex))\n\n print('Password as list: {0}\\n'.format(pwd_list))\n print('ns calculations: {0}\\n'.format(ns))\n print('Scores calculations: {0}\\n'.format(scores))\n print('Entropy: {0}\\n'.format(entropy))\n\n # store string lengths for table\n plength = {\n 'counts': 0,\n 'scores': 0,\n 'heading': 0\n }\n # loop value dicts to get lengths for table\n for k, v in ns.items():\n if len(str(v)) > plength['counts']:\n plength['counts'] = len(str(v))\n for k, v in scores.items():\n if len(str(v)) > plength['scores']:\n plength['scores'] = len(str(v))\n for k, v in stext.items():\n if len(v) > plength['heading']:\n plength['heading'] = len(v)\n\n # print table heading\n # t00, t11, t22 calculate indentation\n t00 = int(((plength['heading'] + 2 - 6) / 2)) * ' '\n t11 = int(((plength['counts'] + 1) / 2)) * ' '\n t22 = int(((plength['scores'] + 1) / 2)) * ' '\n print('{0}Metric{0}{1}Count{1}{2}Bonus'.format(t00, t11, t22))\n\n # print table content\n for k, v in stext.items():\n # get description\n t0 = stext[k]\n # indent count\n t1 = (plength['heading'] + plength['counts'] - len(stext[k]) - len(\n str(ns[k])) + 5) * ' '\n # get count\n t2 = ns[k]\n # indent score\n t3 = (plength['scores'] - len(str(scores[k])) + 5) * ' '\n # get score\n t4 = scores[k]\n print('{0}{1}{2}{3}{4}'.format(t0, t1, t2, t3, t4))","def proofs(df):\n proofs_df = df.dropna()\n proofs_ids = proofs_df['proof_id'].unique()\n\n for proof_id in proofs_ids:\n ctx = proofs_df[proofs_df['proof_id'] == proof_id]\n proof = df[df['proof_id'] == proof_id]\n\n start_token, proof_token, end_token = \\\n (ctx[ctx['proof_context'] == x].iloc[0] for x in (\n 'goal',\n 'enter',\n 'leave'\n ))\n\n ids = [int(x['token_id']) for x in (\n start_token,\n proof_token,\n end_token\n )]\n\n definition = proof[\n [x >= ids[0] and x < ids[1] for x in proof['token_id']]\n ]\n demonstration = proof[\n [x >= ids[1] and x < ids[2] for x in proof['token_id']]\n ]\n yield proof_id, definition, demonstration","def main():\n with open(sys.argv[1], 'r') as test_cases:\n\n # Initialize possible pairs, pairs, and social graph Graph\n possible_pairs = set()\n pairs = set()\n social_graph = Graph()\n\n # Find true pairs of sender, recipient and vice versa for graph\n for test in test_cases:\n # Parse line into sender, recipient\n parsed_line = test.rstrip().split('\\t')\n sender, recipient = parsed_line[1], parsed_line[2]\n\n # Determine which sender, recipient reciprocal pairs exist\n # Candidates are tested against possible pairs\n # True pairs are stored in pairs\n if (recipient, sender) in possible_pairs:\n pairs.add(frozenset({x for x in (sender, recipient)}))\n else:\n possible_pairs.add((sender, recipient))\n\n # From pairs, add to social graph\n for pair in pairs:\n u, v = pair\n social_graph.add_pair(u, v)\n\n # Compute maximal cliques of size >= 3 only\n max_cliques_gt_3 = [\n clique\n for clique in social_graph.max_cliques()\n if len(clique) >= 3]\n\n # Sort maximal cliques, ascending, and pretty print\n for cluster in sorted(map(\n lambda x: \", \".join(sorted(x)),\n max_cliques_gt_3)):\n print cluster","def main() -> None:\n with open(f'{os.path.dirname(__file__)}/input.txt', 'r') as input_file:\n for solution in solve(input_file):\n print(solution)","def main() -> None:\n with open(f'{os.path.dirname(__file__)}/input.txt', 'r') as input_file:\n for solution in solve(input_file):\n print(solution)","def main() -> None:\n with open(f'{os.path.dirname(__file__)}/input.txt', 'r') as input_file:\n for solution in solve(input_file):\n print(solution)","def generate_trajectories():\n\n setup_timestamp_logging()\n\n logger = logging.getLogger()\n\n substance = Substance.from_components('C(C(C(C(C(F)(F)Br)(F)F)(F)F)(F)F)(C(C(C(F)(F)F)(F)F)(F)F)(F)F')\n\n logger.info('Building system.')\n\n build_system = BuildSmirnoffSystem('build_system')\n build_system.coordinate_file_path = 'coords.pdb'\n build_system.substance = substance\n build_system.force_field_path = 'smirnoff99Frosst-1.1.0.offxml'\n build_system.execute('', None)\n\n logger.info('System built.')\n\n production_simulation = RunOpenMMSimulation(f'production_simulation')\n production_simulation.steps_per_iteration = 500\n production_simulation.output_frequency = 1\n production_simulation.timestep = 2.0 * unit.femtosecond\n production_simulation.thermodynamic_state = ThermodynamicState(temperature=298.15*unit.kelvin,\n pressure=1.0*unit.atmosphere)\n production_simulation.input_coordinate_file = 'coords.pdb'\n production_simulation.system_path = 'system.xml'\n\n compute_resources = ComputeResources(number_of_threads=4)\n\n logger.info(f'Simulation started.')\n production_simulation_schema = production_simulation.schema\n production_simulation.execute('', compute_resources)\n production_simulation.schema = production_simulation_schema\n logger.info(f'Simulation finished.')","def launch(self):\n out_log, err_log = fu.get_logs(path=self.path, mutation=self.mut, step=self.step)\n if self.mutation is not None:\n # Read structure with Biopython\n parser = PDBParser(PERMISSIVE=1)\n st = parser.get_structure('s', self.input_pdb_path) # s random id never used\n\n # Remove the side chain of the AA to be mutated\n if self.mutation['chain']!='*':\n chains = [self.mutation['chain']]\n else:\n chains = [chain.id for chain in st[0]]\n\n resnum = int(self.mutation['resnum'])\n\n for chain in chains:\n residue = st[0][chain][(' ', resnum, ' ')]\n backbone_atoms = ['N', 'CA', 'C', 'O', 'CB']\n not_backbone_atoms = []\n\n # The following formula does not work. Biopython bug?\n # for atom in residue:\n # if atom.id not in backbone_atoms:\n # residue.detach_child(atom.id)\n\n for atom in residue:\n if atom.id not in backbone_atoms:\n not_backbone_atoms.append(atom)\n for atom in not_backbone_atoms:\n residue.detach_child(atom.id)\n\n # Change residue name\n residue.resname = self.mutation['mt'].upper()\n\n # Write resultant structure\n w = PDBIO()\n w.set_structure(st)\n prepared_file_path = self.mut+self.step+'prepared.pdb'\n w.save(prepared_file_path)\n else:\n prepared_file_path = self.input_pdb_path\n\n scrwl = 'Scwrl4' if self.scwrl4_path is None else self.scwrl4_path\n cmd = [scrwl, '-i', prepared_file_path, '-o', self.output_pdb_path]\n\n command = cmd_wrapper.CmdWrapper(cmd, out_log, err_log)\n return command.launch()","def logic_program_form(self):\r\n return '% -------------------------------------\\n' +\\\r\n '% Theory ' + self.name + '\\n' +\\\r\n '% -------------------------------------\\n\\n' +\\\r\n GENERAL_AXIOMS","def test_3():\n h = iotbx.pdb.input(source_info=None, lines=test_pdb_3).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 generate_tree(tree, out_file='tree'):\n activities = [\n 'Working at Computer',\n 'Standing Up, Walking and Going up/down stairs',\n 'Standing',\n 'Walking',\n 'Going Up/Down Stairs',\n 'Walking and Talking with Someone',\n 'Talking while Standing',\n ]\n file_name = path.join('..', 'proposal', out_file)\n export_graphviz(tree, out_file=\"{}.dot\".format(file_name), class_names=activities, rounded=True)\n # system(\"dot -Tpng {0}.dot -o {0}.png\".format(out_file))","def main():\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('rest_conn', type=__validate_conn_pattern, default='127.0.0.1:2049', help='REST connection information')\n parser.add_argument('ledger_conn', type=__validate_conn_pattern, default='127.0.0.1:2048', help='TCP master information')\n parser.add_argument('-a', '--auth', type=str, default=None, help='REST authentication information')\n parser.add_argument('-t', '--timeout', type=int, default=30, help='REST timeout period')\n args = parser.parse_args()\n\n # connect to AnyLog\n auth = ()\n if args.auth is not None: \n auth = tuple(args.auth.split(','))\n\n # personalized hierarchy\n policy = {'panel': {\n 'name': None,\n 'city': None,\n 'loc': None,\n 'owner': 'AFG'\n }}\n\n for location in LOCATIONS:\n policy['panel']['name'] = f'Panel {str(int(list(LOCATIONS).index(location)) + 1)}'\n policy['panel']['city'] = location\n policy['panel']['loc'] = LOCATIONS[location]\n status = __publish_policy(conn=args.rest_conn, ledger_conn=args.ledger_conn, policy=policy, auth=auth,\n timeout=args.timeout)\n\n if status is True:\n print('Policy for %s added to blockchain' % policy['panel']['city'])\n else:\n print('Failed to add policy to blockchain')","def gen_option_trajectories(O_a, skills, beta, g, theta=[], vals=-1*np.ones(4604), Zs=None, povs=None):\n adj = adjusted_adj_list_4\n T_o = [[[]] for i in range(len(O_a))] #Generate empty list-of-lists-of-lists\n Ps = [[] for i in range(len(O_a))]\n Ps[0] = [1]\n for i in range(len(O_a)):\n if T_o[i] != [] or i == 0:\n for k in range(1, len(O_a) - i):\n Os = adj[O_a[i]] + skills if skills != [] else adj[O_a[i]]\n for o in Os:\n # print o, k\n # print prob_consistent(O_a[i:i+k+1], o) != 0\n p = prob_consistent(O_a[i:i+k+1], o, beta, g, theta, vals, Zs)\n if p != 0:\n to_add = [[]]\n for index, t in enumerate(T_o[i]):\n if to_add == [[]]:\n to_add = [t + [o]]\n p_add = [Ps[i][index] * p]\n else:\n to_add.append(t + [o])\n p_add.append(p * Ps[i][index])\n for index, t1 in enumerate(to_add):\n if T_o[i+k] == [[]]:\n T_o[i+k] = [t1]\n Ps[i+k] = [p_add[0]]\n else:\n T_o[i+k].append(t1)\n Ps[i+k].append(p_add[index])\n for index, o in enumerate(skills):\n p = prob_consistent(O_a[i:i+k+1], o, beta, g, theta,\n povs[3][:, index], povs[4][:, index], option_flag=True)\n if p != 0:\n to_add = [[]]\n for index, t in enumerate(T_o[i]):\n if to_add == [[]]:\n to_add = [t + [o]]\n p_add = [Ps[i][index] * p]\n else:\n to_add.append(t + [o])\n p_add.append(p * Ps[i][index])\n for index, t1 in enumerate(to_add):\n if T_o[i+k] == [[]]:\n T_o[i+k] = [t1]\n Ps[i+k] = [p_add[0]]\n else:\n T_o[i+k].append(t1)\n Ps[i+k].append(p_add[index]) \n # T_o[i+k].extend(to_add) #Add to trajectories getting to i+k\n return T_o[-1], Ps[-1] #Return all trajectories that get to the final state.","def initialization():\r\n\r\n # # Transition function P(s'|s,a)\r\n p_tran = {}\r\n # s' is \"save\" and a is not \"ask\"\r\n p_tran[\"000\"] = p_tran[\"001\"] = p_tran[\"010\"] = p_tran[\"011\"] = 0.65\r\n # s' is \"delete\" and a is not \"ask\"\r\n p_tran[\"100\"] = p_tran[\"101\"] = p_tran[\"110\"] = p_tran[\"111\"] = 0.35\r\n # a is \"ask\"\r\n p_tran[\"002\"] = p_tran[\"112\"] = 1.0\r\n p_tran[\"102\"] = p_tran[\"012\"] = 0.0\r\n\r\n # # Observation function P(o'|s', a)\r\n p_obsv = {}\r\n # a is \"ask\"\r\n p_obsv[\"002\"] = 0.8 ; p_obsv[\"102\"] = 0.2\r\n p_obsv[\"012\"] = 0.3 ; p_obsv[\"112\"] = 0.7\r\n # a is not \"ask\", observation gives no useful information\r\n for i in [1,0]:\r\n for j in [1,0]:\r\n for k in [1,0]:\r\n p_obsv[str(i)+str(j)+str(k)] = 0.5\r\n\r\n # # reward function r(s, a)\r\n reward = {}\r\n # case of \"asking\"\r\n reward[\"02\"] = -1\r\n reward[\"12\"] = -1\r\n # case of correct action\r\n reward[\"00\"] = 5\r\n reward[\"11\"] = 5\r\n # case of wrong action\r\n reward[\"01\"] = -20\r\n reward[\"10\"] = -10\r\n \r\n gama = 0.95\r\n action_set = (\"0\", \"1\", \"2\")\r\n # (\"0\", \"1\", \"2\") correspondingly refers to (\"dosave\", \"dodelete\", \"ask\")\r\n state_set = (\"0\", \"1\")\r\n # (\"0\", \"1\") correspondingly refers to (\"save\", \"delete\")\r\n obsv_set = (\"0\", \"1\")\r\n # (\"0\", \"1\") correspondingly refers to (\"save\", \"delete\")\r\n \r\n return state_set, action_set, p_tran, reward, obsv_set, p_obsv, gama"],"string":"[\n \"def main():\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"Create and store proof from create_blockchain_new.py\\\"\\n )\\n group = parser.add_mutually_exclusive_group()\\n group.add_argument(\\\"--blocks\\\", type=int, help=\\\"Number of blocks\\\")\\n group.add_argument(\\\"--proof\\\", type=str, help=\\\"Name of proof\\\")\\n args = parser.parse_args()\\n blocks = args.blocks\\n proof_name = args.proof\\n\\n proof_tool = ProofTool(\\\"../../data/proofs/\\\")\\n\\n proof = []\\n if blocks is not None:\\n # proof = proof_tool.fetch_proof(blocks)\\n proof = proof_tool.create_proof(blocks)\\n elif proof_name is not None:\\n proof = proof_tool.fetch_proof(proof_name)\\n else:\\n print(\\\"Provide --blocks or --proof argument\\\")\\n sys.exit()\\n\\n print(\\\"Proof size:\\\", len(proof))\",\n \"def demo():\\n # Create some nonterminals\\n S, NP, VP, PP = nonterminals('S, NP, VP, PP')\\n N, V, P, Det = nonterminals('N, V, P, Det')\\n VP_slash_NP = VP/NP\\n\\n print 'Some nonterminals:', [S, NP, VP, PP, N, V, P, Det, VP/NP]\\n print ' S.symbol() =>', `S.symbol()`\\n print\\n\\n # Create some CFG Productions\\n prods = [CFGProduction(S, [NP, VP]), CFGProduction(PP, [P, NP]),\\n CFGProduction(NP, [Det, N]), CFGProduction(NP, [NP, PP]),\\n CFGProduction(VP, [V, NP]), CFGProduction(VP, [VP, PP]),\\n CFGProduction(Det, ['a']), CFGProduction(Det, ['the']),\\n CFGProduction(N, ['dog']), CFGProduction(N, ['cat']), \\n CFGProduction(V, ['chased']), CFGProduction(V, ['sat']),\\n CFGProduction(P, ['on']), CFGProduction(P, ['in'])]\\n\\n prod = prods[2]\\n print 'A CFG production:', `prod`\\n print ' prod.lhs() =>', `prod.lhs()`\\n print ' prod.rhs() =>', `prod.rhs()`\\n print\\n\\n # Create and print a CFG\\n cfg = CFG(S, prods)\\n print 'A CFG grammar:', `cfg`\\n print ' cfg.start() =>', `cfg.start()`\\n print ' cfg.productions() =>',\\n # Use string.replace(...) is to line-wrap the output.\\n print `cfg.productions()`.replace(',', ',\\\\n'+' '*25)\\n print\\n\\n # Create some probabilistic CFG Productions\\n A, B, C = nonterminals('A, B, C')\\n pcfg_prods = [PCFGProduction(A, [B, B], prob=0.3),\\n PCFGProduction(A, [C, B, C], prob=0.7),\\n PCFGProduction(B, [B, 'b'], prob=0.5),\\n PCFGProduction(B, [C], prob=0.5),\\n PCFGProduction(C, ['a'], prob=0.1),\\n PCFGProduction(C, ['b'], prob=0.9)] \\n \\n pcfg_prod = pcfg_prods[2]\\n print 'A PCFG production:', `pcfg_prod`\\n print ' pcfg_prod.lhs() =>', `pcfg_prod.lhs()`\\n print ' pcfg_prod.rhs() =>', `pcfg_prod.rhs()`\\n print ' pcfg_prod.prob() =>', `pcfg_prod.prob()`\\n print\\n\\n # Create and print a PCFG\\n pcfg = PCFG(S, pcfg_prods)\\n print 'A PCFG grammar:', `pcfg`\\n print ' pcfg.start() =>', `pcfg.start()`\\n print ' pcfg.productions() =>',\\n # Use string.replace(...) is to line-wrap the output.\\n print `pcfg.productions()`.replace(',', ',\\\\n'+' '*26)\\n print\",\n \"def m_dump_tf():\\n\\n # Info about ENS and Resolver Smart Contracts\\n #print(f\\\"ENS address: {ens.address()}\\\")\\n print(f\\\"ENS address (contract address): {ENS.address}\\\")\\n print(f\\\"Resolver address (contract address): {resolver.address()}\\\")\\n print(f\\\"Resolver address from ENS(root): {ens.resolver('root')}\\\")\\n print(\\\"\\\\n\\\")\\n\\n print(f\\\"Owner of ROOT record: {ens.owner('root')}\\\")\\n ROOT_address, ROOT_key = wallet.account_from_name(\\\"ROOT\\\", \\\"ThePassword\\\")\\n print(f\\\"ROOT address from wallet: {ROOT_address}\\\")\\n\\n n_subnodes = ens.numberSubnodes(0)\\n print(f\\\"Number of subnodes of root: {n_subnodes}\\\")\\n for i in range(n_subnodes):\\n hash = ens.subnode(index=i).hex()\\n print(f\\\" Subnode hash {i}: {ens.subnode(i).hex()}\\\")\\n name = resolver.name(node_hash=hash)\\n print(f\\\" Name: {name}\\\")\\n resolver_address = ENS.functions.resolver(hash).call()\\n print(f\\\" Resolver: {resolver_address}\\\")\\n ala_address = ens.resolver(name)\\n print(f\\\" Resolver by name: {ala_address}\\\")\\n owner = owner = ENS.functions.owner(hash).call()\\n print(f\\\" Owner: {owner}\\\")\\n ROOT_address, ROOT_key = wallet.account_from_name(\\\"Alastria\\\", \\\"ThePassword\\\")\\n print(f\\\" Address from wallet: {ROOT_address}\\\")\\n\\n n_subnodes = ens.numberSubnodes(\\\"ala\\\")\\n print(f\\\"Number of subnodes of {name}: {n_subnodes}\\\")\\n for i in range(n_subnodes):\\n hash = ens.subnode(node_name=\\\"ala\\\", index=i).hex()\\n print(f\\\" Subnode hash {i}: {hash}\\\")\\n name = resolver.name(node_hash=hash)\\n print(f\\\" Name: {name}\\\")\\n resolver_address = ENS.functions.resolver(hash).call()\\n print(f\\\" Resolver: {resolver_address}\\\")\\n ala_address = ens.resolver(name)\\n print(f\\\" Resolver by name: {ala_address}\\\")\\n owner = owner = ENS.functions.owner(hash).call()\\n print(f\\\" Owner: {owner}\\\")\",\n \"def test_conjecture():\\n print(\\\"Executing test_conjecture:\\\")\\n\\n theory=[]\\n\\n print(language.program_string(theory))\\n for i in range(10):\\n theory=conjecture.vary([theory], 0, [], steps=1)\\n print(f\\\"Theory after {i+1} stages of variation:\\\")\\n print(language.program_string(theory))\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n\\n # print(num_wizards)\\n # print(num_constraints)\\n # print(wizards)\\n # print(constraints)\\n # node_set = set(wizards)\\n \\n\\n\\n def cost(sol,num_constraints,constraints):\\n constraints_satisfied = 0\\n constraints_failed = []\\n output_ordering_map = {k: v for v, k in enumerate(sol)}\\n for c in constraints:\\n\\n m = output_ordering_map # Creating an alias for easy reference\\n\\n wiz_a = m[c[0]]\\n wiz_b = m[c[1]]\\n wiz_mid = m[c[2]]\\n\\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\\n constraints_failed.append(c)\\n else:\\n constraints_satisfied += 1\\n return num_constraints - constraints_satisfied\\n\\n def neighbors(sol):\\n wiz1 = random.randint(0,num_wizards-1)\\n wiz2 = random.randint(0,num_wizards-1)\\n\\n new_sol = copy.copy(sol)\\n temp = new_sol[wiz1]\\n new_sol[wiz1] = new_sol[wiz2]\\n new_sol[wiz2] = temp\\n \\n return new_sol\\n\\n def acceptance_probability(old_cost,new_cost,T):\\n exponent = (old_cost - new_cost) / T\\n \\n try:\\n ans = math.exp(exponent)\\n except OverflowError:\\n ans = float('inf')\\n return ans\\n\\n\\n def anneal(solution, num_constraints, constraints):\\n old_cost = 0\\n new_cost = 0\\n old_cost = cost(solution,num_constraints,constraints)\\n T = 1.0\\n T_min = 0.000001\\n alpha = 0.98\\n while T > T_min:\\n i = 1\\n while i <= 1000:\\n new_solution = neighbors(solution)\\n new_cost = cost(new_solution,num_constraints,constraints)\\n if new_cost == 0:\\n return new_solution,new_cost\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T*alpha\\n return solution, old_cost\\n\\n s = copy.copy(wizards)\\n random.shuffle(s)\\n ret = anneal(s,num_constraints,constraints)\\n \\n for i in range(10):\\n if ret[1] == 0:\\n break\\n random.shuffle(s)\\n new_ret = anneal(s,num_constraints,constraints)\\n print(i)\\n if new_ret[1] < ret[1]:\\n ret = new_ret\\n print(\\\"constraints failed: {0}\\\".format(ret[1]))\\n return ret[0]\",\n \"def makeBinaryChains():\\n\\t\\n\\t# retrieve the binding partner specifications\\n\\t(maxsize,types) = getTypes()\\n\\t\\n\\t# Do some basic argument checking for this model\\n\\tif (len(types) < 2):\\n\\t\\tprint \\\"Number of defined types must equal two for binary chain calculations.\\\"\\n\\t\\treturn\\n\\tif (maxsize == 0):\\n\\t\\tprint \\\"Must specify a valid maximum number for one or more components.\\\"\\n\\t\\treturn\\n\\n\\tallChains = []\\n\\tnewChainsA = [[]]\\n\\tnewChainsB = []\\n\\t\\n\\ttypeA = types[0]\\n\\ttypeB = types[1]\\n\\t\\n\\t# start the chain with a single type A component\\n\\taddComponent(newChainsA[0],typeA,0,0)\\n\\n\\tdepth = 0\\n\\tfor n in range(maxsize):\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# go through all the chains created last iteration and append B components\\n\\t\\tnewChainsB = []\\n\\t\\tfor thisChain in newChainsA:\\n\\n\\t\\t\\t# get a list of new available sites in the provided chain\\n\\t\\t\\t# by setting depth -1, we will only add to components added last round\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeB,depth-1)\\n\\t\\t\\t\\n\\t\\t\\t# make all the descendants from the current chain and append them to the pool\\n\\t\\t\\tif (n == 0) and (typeA['sym']): #if the starting binder is symmetric, no need to start chains at all its sites\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,-1)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tnewChainsB = newChainsB + fillSites(openSites,thisChain,typeB,depth)\\n\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsB))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsB\\n\\t\\t\\n\\t\\tdepth+=1\\n\\t\\t\\n\\t\\t# add an additional component to all the previously modified chains\\n\\t\\tnewChainsA = []\\n\\t\\tfor thisChain in newChainsB:\\n\\n\\t\\t\\topenSites = makeSiteList(thisChain,typeA,depth-1)\\n\\t\\t\\tnewChainsA = newChainsA + fillSites(openSites,thisChain,typeA,depth)\\n\\t\\t\\t\\n\\t\\tprint('n:'+str(n)+', '+str(len(newChainsA))+ ' chains created at depth '+str(depth))\\n\\t\\t\\n\\t\\tallChains = allChains + newChainsA\\n\\n\\treturn allChains\",\n \"def genChains(self):\\n self.numMonomer = 0\\n self.numBonds = 0\\n self.numMols = 0\\n self.numCations = 0\\n self.numAnions = 0\\n\\n self.atomsCoords = []\\n self.atomsType = []\\n self.atomsCharge = []\\n self.molId = []\\n self.bondList = []\\n \\n for i in range(self.numPa + self.numPc):\\n\\n if i < self.numPc:\\n # polycation chains, charge in LJ units of LAMMPS\\n # electron charge would be 10.54 using bare LAMMPS LJ units\\n # the dielectric constans of solvent is effectively taken as 111 when assign 1 to +e\\n # just need to set dielectric as 0.72 in LAMMPS ot mimic water with dielectric constant 80\\n self.beadCharge = 1\\n self.beadType = 1 # atomic type for neutral beads in polycation chains\\n self.chain = self.lenPc\\n else:\\n self.beadCharge = -1 # polyanion chains\\n self.beadType = 3 # atomic type for neutral beads in polyanion chains\\n self.chain = self.lenPa\\n\\n self.numMols += 1\\n\\n # generate the first bead of each chain randomly\\n self.numMonomer += 1\\n self.cxyz = np.random.rand(3) * self.box + self.lxyz\\n\\n self.atomsCoords.append(self.cxyz)\\n #self.atomsType.append(self.beadType)\\n\\n # decide if the first bead is charged or not\\n if self.chargeRepeat == 1:\\n self.atomsCharge.append(self.beadCharge)\\n self.atomsType.append(self.beadType + 1)\\n if i < self.numPc:\\n self.numCations += 1\\n else:\\n self.numAnions += 1\\n else:\\n self.atomsType.append(self.beadType)\\n self.atomsCharge.append(0)\\n\\n self.molId.append(self.numMols)\\n\\n self.currpxyz = self.cxyz\\n\\n # follow random walk to generate the chain\\n # generate the seconb bead of the chain\\n self.theta, self.phi = np.random.rand(2) * np.array([np.pi, 2 * np.pi])\\n self.ds = np.array([np.cos(self.theta), np.sin(self.theta) * np.cos(self.phi),\\\\\\n np.sin(self.theta) * np.sin(self.phi)]) * self.segment\\n\\n self.cxyz = self.currpxyz + self.ds\\n\\n self.numMonomer += 1\\n self.atomsCoords.append(self.cxyz)\\n\\n # decide if the second bead is charged or not\\n if 2%self.chargeRepeat == 0:\\n self.atomsCharge.append(self.beadCharge)\\n self.atomsType.append(self.beadType + 1)\\n if i < self.numPc:\\n self.numCations += 1\\n else:\\n self.numAnions += 1\\n else:\\n self.atomsCharge.append(0)\\n self.atomsType.append(self.beadType)\\n\\n self.molId.append(self.numMols)\\n \\n self.numBonds += 1\\n self.bondList.append([self.numMonomer - 1, self.numMonomer])\\n\\n self.currpxyz = self.cxyz\\n\\n self.currtheta = self.theta\\n self.currphi = self.phi\\n\\n self.dstot += self.ds\\n\\n # generating the rest beads of the chain\\n\\n for k in range(3, self.chain+1):\\n # only accept atoms that are beyong certain distance\\n # from the atom precding the current atom in the chain\\n self.theta, self.phi = np.random.rand() * np.array([np.pi - self.stiffangle, \\\\\\n 2 * np.pi])\\n self.ds1 = np.array([np.cos(self.theta), np.sin(self.theta) * np.cos(self.phi),\\\\\\n np.sin(self.theta) * np.sin(self.phi)]) * self.segment\\n\\n self.reverseXZrotation()\\n self.cxyz = self.currpxyz + self.ds\\n\\n self.numMonomer += 1\\n self.atomsCoords.append(self.cxyz)\\n\\n if k % self.chargeRepeat == 0:\\n self.atomsCharge.append(self.beadCharge)\\n self.atomsType.append(self.beadType + 1)\\n if i < self.numPc:\\n self.numCations += 1\\n else:\\n self.numAnions += 1\\n else:\\n self.atomsCharge.append(0)\\n self.atomsType.append(self.beadType)\\n\\n self.molId.append(self.numMols)\\n self.numBonds += 1\\n self.bondList.append([self.numMonomer - 1, self.numMonomer])\\n\\n self.currpxyz = self.cxyz\\n\\n self.currtheta = np.arccos(self.ds[0]/self.segment)\\n if self.ds[2] > 0:\\n self.currphi = np.arccos(self.ds[1]/self.segment/np.sin(self.currtheta))\\n else:\\n self.currphi = 2*np.pi - np.arccos(self.ds[1]/self.segment/np.sin(self.currtheta))\\n\\n self.dstot += self.ds\\n\\n print \\\"%d beads are generated.\\\\n\\\" % self.numMonomer \\n assert self.numMonomer == self.numPc * self.lenPc + self.numPa * self.lenPa, \\\\\\n \\\"The number of monomers in chains is wrong!\\\\n\\\"\\n assert self.numCations == int(np.floor(self.lenPc * self.chargeFraction)*self.numPc), \\\\\\n \\\"The number of positively charged beads is wrong!\\\\n\\\"\\n assert self.numAnions == int(np.floor(self.lenPa * self.chargeFraction)*self.numPa), \\\\\\n \\\"The number of negatively charged beads is wrong!\\\\n\\\"\",\n \"def main():\\n\\n # Define the names of required input files, and other main configuration variables\\n protein_w_underscores = os.getcwd().split('/')[-1]\\n protein = protein_w_underscores.replace('_', ' ')\\n pdbfile = 'pdb_structure.pdb' # the name of the PDB file\\n pdbchain = None # chain in pdbfile -- there is only one chain, so not relevant here\\n seqfile = 'protseq.txt' # file containing the protein sequence\\n ddgdatafile = 'ddG_data.txt' # file containing the literature-culled ddG values\\n ddgdatafile_warning = False # warn if ddgdatafile has conflicting ddG values for a mutation\\n alignment_file = \\\"uniref_alignment-gaps_lt_0.1-identities_gt_0.5.fasta\\\" # file with aligned sequences\\n phylip_path = '/Users/bloom/phylip-3.67/exe/' # path to phylip phylogeny program\\n\\n # Define the names of files that will be created by the script if they do not already exist\\n cupsatfile = 'CUPSAT_ddGs.txt' # contains the ddG values from CUPSAT\\n treefile = \\\"tree.newick\\\" # phylogenetic tree created by phylip\\n phylipsequencefile = \\\"phylip_sequence_file\\\" # phylip input sequence file\\n phylipdistancefile = \\\"phylip_distance_file\\\" # phylip distance matrix\\n pipsddgsfile = \\\"pips_ddgs.txt\\\" # pips ddgs file\\n regularizingpriorpipsddgsfile = 'pips_ddgs_with_regularizing_priors.txt' # pips ddgs file calculated with regularizing priors\\n hydrophobicitypriorpipsddgsfile = 'pips_ddgs_with_hydrophobicity_priors.txt' # pips ddgs file calculated with hydrophobicity priors\\n\\n # Begin execution of the program\\n seq = open(seqfile).read().strip() # read in protein sequence\\n\\n # Get the ddG values from CUPSAT and store in the dictionary cupsat_ddgs. Note that\\n # in this and all subsequent ddG dictionaries, the first residue is numbered as 0.\\n print \\\"\\\\nObtaining CUPSAT ddG values...\\\"\\n sys.stdout.flush()\\n if os.path.isfile(cupsatfile): # ddG values already obtained, just read from file\\n (datetime, cupsat_ddgs) = pips.ddg_inference.ReadDDGs(cupsatfile)\\n print \\\"Read the stored CUPSAT values from %s from the file %s.\\\" % (datetime, cupsatfile)\\n else: # we need to obtain the ddG values from the CUPSAT webserver\\n datetime = time.asctime()\\n print \\\"Beginning to calculate and download CUPSAT ddGs at %s...\\\" % datetime\\n sys.stdout.flush()\\n cupsat_ddgs = pips.cupsat.RunCUPSAT(pdbfile, seq, pdbchain)\\n pips.ddg_inference.WriteDDGs(cupsat_ddgs, cupsatfile, datetime)\\n print \\\"Completed download of CUPSAT ddG values, stored in the file %s.\\\" % cupsatfile\\n rescaled_cupsat_ddgs = pips.ddg_inference.RescaleDDGs(cupsat_ddgs, 10.0, '10TH_TO_90TH', recenter=5.0, min_max=(-3.0, 13.0)) \\n\\n # Read the literature-culled ddG data from ddgdatafile and store in the dictionary ddg_data\\n print \\\"\\\\nReading the literature-culled ddG data from %s...\\\" % ddgdatafile\\n sys.stdout.flush()\\n ddgmatch = re.compile(\\\"^(?P<wt>[A-Y])(?P<r>\\\\d+)(?P<mut>[A-Y])\\\\s+(?P<ddg>\\\\-{0,1}\\\\d+\\\\.\\\\d+)$\\\")\\n ddg_data = {}\\n for r in range(len(seq)):\\n rdict = {}\\n wt = seq[r]\\n for aa in pips.ddg_inference.AminoAcids():\\n if aa != wt:\\n rdict[aa] = []\\n ddg_data[r] = (wt, rdict)\\n for line in open(ddgdatafile).readlines(): # loop over all lines in ddgdatafile\\n if line[0] == '#':\\n continue # line is a comment\\n m = ddgmatch.search(line.strip()) # match the ddG value\\n if not m:\\n raise ValueError, \\\"Cannot read ddG value of %s\\\" % line\\n (wt, r, mut, ddg) = (m.group('wt'), int(m.group('r')), m.group('mut'), float(m.group('ddg')))\\n r -= 1 # we decrement r because we are calling the first residue 0\\n if seq[r] != wt:\\n raise ValueError, \\\"Wildtype residue does not match protein sequence in %s\\\" % line\\n ddg_data[r][1][mut].append(ddg) \\n nddgs = 0\\n ddgslist = []\\n for (r, (wt, rddgs)) in ddg_data.iteritems():\\n for mut in rddgs.iterkeys():\\n if not rddgs[mut]:\\n rddgs[mut] = None # no ddG value\\n else:\\n nddgs += 1\\n ddg0 = rddgs[mut][0]\\n allthesame = True\\n for ddgi in rddgs[mut][1 : ]: # see if all ddG values are the same for mutation\\n if ddgi != ddg0:\\n allthesame = False\\n if allthesame: # all of the ddG values are the same, take this value\\n rddgs[mut] = ddg0\\n ddgslist.append(ddg0)\\n else: # ddG values differ, print warning and take the average value\\n ddg = pips.stats.Mean(rddgs[mut])\\n if ddgdatafile_warning:\\n print \\\"WARNING: Mutation %s%d%s has multiple ddG values of\\\" % (wt, r + 1, mut),\\n for ddgi in rddgs[mut]:\\n print \\\"%.2f\\\" % ddgi,\\n print \\\"--- taking the average value of %.2f.\\\" % ddg\\n sys.stdout.flush()\\n rddgs[mut] = ddg\\n ddgslist.append(ddg)\\n print \\\"Read a total of %d different ddG values from %s. The mean value is %.2f, the maximum value is %.2f, and the minimum value is %.2f.\\\" % (nddgs, ddgdatafile, pips.stats.Mean(ddgslist), max(ddgslist), min(ddgslist))\\n\\n # Read the aligned sequences (into sequences), give short names for phylip\\n sequences = pips.fasta.Read(alignment_file)\\n nsequences = len(sequences)\\n sequences = [(\\\"SEQ%d\\\" % (i + 1), sequences[i][1]) for i in range(nsequences)] # rename \\n pips.fasta.Write(sequences, 'renamed_alignment.fasta')\\n sequences = pips.align.StripGapsToFirstSequence(sequences) \\n print \\\"\\\\nThere are %d sequences in the alignment.\\\" % nsequences\\n\\n # Construct the phylogenetic tree\\n if os.path.isfile(treefile):\\n print \\\"A phylogenetic tree has already been constructed for these sequences, and is being read from %s.\\\" % treefile\\n newick_tree = open(treefile).read()\\n else:\\n print \\\"Constructing a phylogenetic tree for these sequences...\\\"\\n sys.stdout.flush()\\n pips.phylip.WritePhylipSequenceFile(sequences, phylipsequencefile)\\n open(phylipdistancefile, 'w').write(pips.phylip.Protdist(phylipsequencefile, phylip_path))\\n newick_tree = pips.phylip.DistanceTree(phylipdistancefile, phylip_path, molecular_clock=True, neighbor_joining=True)\\n print \\\"Finished constructing the phylogenetic tree, writing it to %s.\\\" % treefile\\n sys.stdout.flush()\\n open(treefile, 'w').write(newick_tree)\\n\\n # Perform the pips analysis\\n sequences = pips.fasta.UnknownsToGaps(sequences) # replace unknown amino acids with gaps\\n random.seed(1) # seed the random number generator to make output predictable\\n (datetime, pips_ddgs) = pips.ddg_inference.ReadDDGs(pipsddgsfile)\\n\\n # Read things in with the new pips\\n tree = pips.tree.Tree(newick_tree, tipnames_sequences=sequences) # phylogenetic tree data\\n ddgset = pips.ddg_inference.DDGSet(seq, tree, ('TRANSITION_TRANSVERSION_RATIO', 0.5), ('SPECIFIED', pips_ddgs, 0, 0), ('BETA', 3, ('KYTE_DOOLITTLE_HYDROPHOBICITY', 1, 0)), 5.0, underflow=5, runtestcode=False)\\n ddgset.MaximizePosterior(nrandomstarts=1, printprogress=True)\\n new_pips_ddgs = ddgset.DDGDict()\\n pips.ddg_inference.WriteDDGs(new_pips_ddgs, 'new_pips_ddgs.txt', time.asctime())\\n\\n # Get the consensus ddG\\n consensus_ddgs = pips.ddg_inference.ConsensusDDGs(seq, sequences, pseudocounts=1)\\n\\n sys.exit()\\n\\n # Perform analysis of correlations, and make pylab plots\\n print \\\"\\\\nAnalysis of correlations to experimental ddG values...\\\"\\n ddgtypes = ['actual', 'CUPSAT', 'consensus', '\\\\\\\\begin{tabular}{c} PIPS with \\\\\\\\\\\\\\\\ informative prior \\\\end{tabular}', '\\\\\\\\begin{tabular}{c} PIPS with \\\\\\\\\\\\\\\\ regularizing prior \\\\end{tabular}', '\\\\\\\\begin{tabular}{c} PIPS with \\\\\\\\\\\\\\\\ hydrophobicity prior \\\\end{tabular}']\\n zippedlists = pips.ddg_inference.ZippedDDGLists(ddg_data, cupsat_ddgs, consensus_ddgs, pips_ddgs, pips_ddgs_regularizing, pips_ddgs_hydrophobicity)\\n mutations = zippedlists[0]\\n nmutations = len(mutations)\\n ddgs = dict([(ddgtypes[i], zippedlists[i + 1]) for i in range(len(ddgtypes))])\\n pylab.rc('text', usetex=True)\\n nplots = len(ddgtypes) - 1 # number of different plots\\n invnplots = 1.0 / nplots\\n (xscale, yscale) = (2.8, 2.5) # each plot covers a rectangle of this size, in inches\\n bottom = 1.06\\n (tmargin, bmargin, lmargin, rmargin) = (0.03, 0, 0.22, 0.03)\\n fig = pylab.figure(figsize=(xscale * (1 + lmargin + rmargin), 3 * yscale * (1 + tmargin + bmargin) * bottom))\\n figaxes = pylab.axes([0, 0, 1, 1])\\n figaxes.axison = False\\n iplot = 0\\n maxticks = 5\\n (xmin, xmax) = (int(round(min(ddgs['actual'])) - 1), int(round(max(ddgs['actual'])) + 1))\\n xtick = 1\\n while (xmax - xmin) / float(xtick) > maxticks:\\n xtick += 1\\n nxticks = int(math.ceil((xmax - xmin) / float(xtick)))\\n xticks = [x for x in range(xmin, xmin + nxticks * xtick + 1, xtick)]\\n xticklocator = matplotlib.ticker.FixedLocator(xticks)\\n xtickformatter = matplotlib.ticker.FixedFormatter([\\\"%d\\\" % x for x in xticks])\\n for ddgtype in ddgtypes[1 : ]:\\n if ddgtype == ddgtypes[-1]:\\n xlabel = 'experimental $\\\\Delta\\\\Delta G$ values'\\n else:\\n xlabel = ''\\n (r, p, npoints) = pips.stats.PearsonCorrelation(ddgs['actual'], ddgs[ddgtype])\\n axes = pylab.axes([lmargin, 1.0 - invnplots * (1 + iplot + bmargin) / bottom, 1.0 - rmargin - lmargin, invnplots * (1.0 - tmargin - bmargin) / bottom], xlabel=xlabel, ylabel=ddgtype)\\n nolabels = matplotlib.ticker.NullFormatter()\\n (ymin, ymax) = (int(round(min(ddgs[ddgtype])) - 1), int(round(max(ddgs[ddgtype])) + 1))\\n ytick = 1\\n while (ymax - ymin) / float(ytick) > maxticks:\\n ytick += 1\\n nyticks = int(math.ceil((ymax - ymin) / float(ytick)))\\n yticks = [y for y in range(ymin, ymin + nyticks * ytick + 1, ytick)]\\n yticklocator = matplotlib.ticker.FixedLocator(yticks)\\n ytickformatter = matplotlib.ticker.FixedFormatter([\\\"%d\\\" % y for y in yticks])\\n axes.xaxis.set_major_locator(xticklocator)\\n axes.yaxis.set_major_locator(yticklocator)\\n axes.yaxis.set_major_formatter(ytickformatter)\\n if ddgtype != ddgtypes[-1]:\\n axes.xaxis.set_major_formatter(nolabels)\\n else:\\n axes.xaxis.set_major_formatter(xtickformatter)\\n iplot += 1\\n pylab.text(0.64, 0.14, '$R^2 = %.2f$' % r**2, transform=axes.transAxes, ha='left', va='top', size=14)\\n pylab.scatter(ddgs['actual'], ddgs[ddgtype], figure=fig, axes=axes)\\n pylab.savefig(\\\"%s_vertical_plot.eps\\\" % protein_w_underscores)\\n\\n pylab.show()\",\n \"def generate_schemas(structure, n_paths, draw_chains=False):\\n base_state_chain, max_id_in_chain = extract_nodes_from_structure(structure)\\n num_edges_in_chain = max_id_in_chain\\n num_nodes_in_chain = num_edges_in_chain + 1\\n node_list = list(itertools.chain(*base_state_chain))\\n node_list = list(more_itertools.unique_everseen(node_list))\\n base_node_id_list = list(range(max_id_in_chain + 1))\\n\\n # num_nodes = n_paths * (n_nodes_in_structure - 1) + 1\\n num_nodes_needed = n_paths * max_id_in_chain + 1\\n num_schemas_possibe = pow(2, num_nodes_needed - max_id_in_chain)\\n\\n # add to our node list\\n for i in range(max_id_in_chain + 1, num_nodes_needed):\\n node_list.append(\\\"state\\\" + str(i))\\n # node_list.append(\\\"action\\\" + str(i))\\n node_to_id_bidir_dict = create_birdirectional_dict(node_list, SchemaNodeID)\\n\\n # generate all possible chains from nodes\\n node_id_list = [node_to_id_bidir_dict[x] for x in node_list]\\n base_state_chain_id = [\\n (node_to_id_bidir_dict[x], node_to_id_bidir_dict[y])\\n for x, y in base_state_chain\\n ]\\n\\n possible_edges = set(itertools.permutations(node_id_list, r=2))\\n\\n possible_chains = set(itertools.permutations(possible_edges, r=num_edges_in_chain))\\n\\n # remove base base chain (having the base chain produces duplicates)\\n possible_chains.remove(tuple(base_state_chain_id))\\n\\n # check that each chain forms a valid chain (each child of an edge has a matching parent of the next edge\\n possible_chains = [chain for chain in possible_chains if valid_chain(chain)]\\n\\n possible_chains_with_npaths = []\\n for nchains in range(1, n_paths):\\n possible_chains_with_npaths.extend(\\n list(itertools.combinations(possible_chains, r=nchains))\\n )\\n\\n counter = 0\\n print_update_rate = 10000\\n\\n schema_chains = []\\n schema_graphs = []\\n chains_producing_schemas = []\\n for chains in possible_chains_with_npaths:\\n counter += 1\\n if counter % print_update_rate == 0:\\n print(\\n \\\"Generated {}/{} schema_chains with {} chains and {} nodes\\\".format(\\n counter,\\n len(possible_chains_with_npaths),\\n n_paths,\\n num_nodes_in_chain,\\n )\\n )\\n\\n # create new chain from chain\\n chains = list(chains)\\n new_edges = set(itertools.chain(*chains))\\n chains.append(tuple(base_state_chain_id))\\n\\n # add in base chain (required for all schema_chains\\n new_edges.update(base_state_chain_id)\\n new_edges = list(new_edges)\\n\\n # is_target_chain, target_chain_name = check_target(new_edges)\\n # if is_target_chain:\\n # print(\\\"target schema: {}\\\".format(target_chain_name))\\n\\n new_node_list = list(itertools.chain(*new_edges))\\n new_node_list = set(new_node_list)\\n\\n # checks if this schema has a valid node list\\n if not valid_node_ids(new_node_list):\\n # if is_target_chain:\\n # print(\\\"removing target chain {}\\\".format(target_chain_name))\\n continue\\n\\n root_nodes = find_root_nodes(new_edges, new_node_list)\\n leaf_nodes = find_leaf_nodes(new_edges, new_node_list)\\n\\n new_graph = nx.DiGraph(new_edges)\\n\\n # verify there are no disjoint subchains\\n if disjoint_subchains_present(new_graph):\\n # if is_target_chain:\\n # print(\\\"removing target chain {}\\\".format(target_chain_name))\\n continue\\n\\n # verify this chain has no cycles\\n if len(list(nx.simple_cycles(new_graph))) != 0:\\n # if is_target_chain:\\n # print(\\\"removing target chain {}\\\".format(target_chain_name))\\n continue\\n\\n # verify this chain has valid depths (specifically, every path from root to leaf\\n # should have length num_nodes_in_chain)\\n if not schema_depths_valid(\\n new_edges, new_graph, root_nodes, leaf_nodes, num_nodes_in_chain, n_paths\\n ):\\n # if is_target_chain:\\n # print(\\\"removing target chain {}\\\".format(target_chain_name))\\n # schema_depths_valid(\\n # new_edges, new_graph, root_nodes, leaf_nodes, num_nodes_in_chain, n_paths\\n # )\\n continue\\n\\n # store schema as list of edges\\n # schema_chains.append(new_edges)\\n # store schema as list of chains\\n schema_chains.append(chains)\\n schema_graphs.append(new_graph)\\n chains_producing_schemas.append(chains)\\n\\n # get set of schema edges of unique chains - by checking if each chain is isomporphic\\n final_schema_chains = set()\\n final_schema_graphs = set()\\n for i in range(len(schema_graphs)):\\n graph = schema_graphs[i]\\n chain = tuple(schema_chains[i])\\n # if chain1 is not in out schema set and it is not isomorphic to any chain in our schema set, add the chain to our schema set\\n if chain not in final_schema_chains and all(\\n [not nx.is_isomorphic(graph, final_graph) for final_graph in final_schema_graphs]\\n ):\\n final_schema_chains.add(chain)\\n final_schema_graphs.add(graph)\\n schema_chains = list(final_schema_chains)\\n\\n if draw_chains:\\n save_chains_to_files(\\n schema_chains,\\n os.path.expanduser(\\\"~/Desktop/schema_chains/\\\"),\\n num_nodes_in_chain,\\n n_paths,\\n )\\n\\n print(\\n \\\"Generated {}/{} schema_chains with {} chains and {} nodes\\\".format(\\n len(possible_chains_with_npaths),\\n len(possible_chains_with_npaths),\\n n_paths,\\n num_nodes_in_chain,\\n )\\n )\\n return schema_chains\",\n \"def main():\\n\\t# GET THE DIALOG CONTENT\\n\\tpolicyFlag = int(sys.argv[3])\\n\\tif policyFlag == 0:\\n\\t\\texistedIterNum = 15000\\n\\t\\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05'\\n\\telif policyFlag == 1:\\n\\t\\texistedIterNum = 10000\\n\\t\\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05Retroflex'\\n\\n\\tqLearnOpts = {'gamma': 1.0, \\n\\t\\t\\t\\t 'alpha': 0.0, \\n\\t\\t\\t\\t 'epsilon': 0.0}\\n\\tnumOfTurn = util.returnConvertedIndexListCount('b','cycle_tree')\\n\\tnumofgauss = 5\\n\\tvar = 0.0625\\n\\tlamda = 0.05\\n\\tunitNum = 101\\n\\ta = qlearningAgents.FittedQLearningAgent(numOfTurn,numofgauss,var,lamda,unitNum, **qLearnOpts)\\t\\t\\n\\ta.openThetaFile(existedThetaFileName,existedIterNum)\\n\\n\\tturnNum = int(sys.argv[1])\\n\\tuserUnitScore = []\\n\\tuserUnitScoreVector = sys.argv[2].split(',')\\n\\tfor i in userUnitScoreVector:\\n\\t\\t\\tuserUnitScore.append(float(i)/100.0)\\n\\n\\tstate = State.State(turnNum, userUnitScore)\\n\\tprint a.getAction(state)\",\n \"def SolveAndPrint(self, model, decisions, constraints):\\n\\t\\tself.root = Toplevel()\\n\\t\\tmenubar = Menu(self.root)\\n\\t\\ttext=Text(self.root)\\n\\t\\t\\n\\t\\tfilemenu=Menu(menubar, tearoff=0)\\n\\t\\tfilemenu.add_command(label=\\\"Save As...\\\", \\n\\t\\t\\t\\t\\tcommand=(lambda text=text: file_save(text)), \\n\\t\\t\\t\\t\\taccelerator=\\\"Ctrl+Shift+S\\\")\\n\\n\\t\\tfilemenu.add_command(label=\\\"Reload Module\\\", command=(lambda: reload(simplex_class)), accelerator=\\\"Ctrl+T\\\")\\n\\n\\t\\tfilemenu.add_command(label=\\\"Close\\\", \\n\\t\\t\\t\\t\\tcommand=donothing, \\n\\t\\t\\t\\t\\taccelerator=\\\"Ctrl+w\\\") #come back to this\\n\\t\\tfilemenu.add_separator()\\n\\t\\tfilemenu.add_command(label=\\\"Exit\\\", command=self.root.quit)\\n\\n\\t\\tmenubar.add_cascade(label=\\\"File\\\", menu=filemenu)\\n\\n\\t\\thelpmenu = Menu(menubar, tearoff=0)\\n\\t\\thelpmenu.add_command(label=\\\"Help\\\", command=donothing) #come back to this\\n\\t\\ttext.insert(END, \\n\\t\\t\\t\\t\\\"\\\\nNumber of variables = %d\\\\n\\\"%(model.NumVariables()))\\n\\n\\t\\tprint (\\\"Number of variables = %d\\\"%(model.NumVariables()))\\n\\t\\tprint (\\\"Number of constraints = %d\\\"%(model.NumConstraints()))\\n\\n\\t\\ttext.insert(END, \\\"\\\\nNumber of constraints = %d\\\\n\\\"%(model.NumConstraints()))\\n\\t\\t\\n\\t\\tresult_status = model.Solve()\\n\\n\\t\\ttext.insert(END, \\\"\\\\nsolve output = %s\\\"%(result_status))\\n\\n\\t\\tassert model.VerifySolution(1e-7, True), \\\"model is not verifiable\\\" # % equivalent to infeasibility\\n\\n\\t\\tassert result_status == pywraplp.Solver.OPTIMAL, \\\"not an optimal solution present\\\" #The problem has an optimal solution\\n\\n\\t\\ttext.insert(END, \\\"\\\\nProblem solved in %f ms \\\\n\\\"%(model.wall_time()))\\n\\n\\t\\tprint (\\\"\\\\nProblem solved in %f milliseconds \\\\n\\\" %(model.wall_time()))\\n\\n\\t\\ttext.insert(END, \\\"\\\\nOptimal objective value = %f \\\\n\\\" %(model.Objective().Value())) #The objective value of the solution `no reduced costs`\\n\\t\\tprint (\\\"\\\\nOptimal objective value = %f\\\\n\\\" %(model.Objective().Value()))\\n\\n\\t\\tfor variable in decisions:\\n\\t\\t\\ttext.insert(END, \\\"\\\\n%s = %f\\\\n\\\"%(variable.name(), variable.solution_value()))\\n\\t\\t\\tprint (\\\"%s = %f\\\" %(variable.name(), variable.solution_value()))\\n\\n\\t\\ttext.insert(END, \\\"\\\\n \\\\nAdvanced Usage: \\\\n\\\")\\n\\t\\tprint (\\\"\\\\n \\\\nAdvanced Stats: \\\\n\\\")\\n\\t\\ttext.insert(END, \\\"\\\\n \\\\nProblem Solved in %d iterations\\\"%model.iterations())\\n\\t\\tprint (\\\"\\\\n \\\\n Problem solved in %d iterations\\\" %model.iterations())\\n\\n\\t\\tfor variable in decisions:\\n\\t\\t\\ttext.insert(END, \\\"\\\\n \\\\n%s: reduced cost = %f\\\" %(variable.name(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\tvariable.reduced_cost()))\\n\\t\\t\\tprint (\\\"%s: reduced cost = %f\\\" %(variable.name(), variable.reduced_cost()))\\n\\n\\t\\tactivities = model.ComputeConstraintActivities() #printout of RHS = `b` in AX = b\\n\\n\\t\\tfor i, constraint in enumerate(constraints):\\n\\t\\n\\t\\t\\tprint(dir(constraint))\\n\\t\\t\\ttext.insert(END, \\n\\t\\t\\t\\t\\\"\\\\n\\\\n constraint %s: dual value = %f\\\\n activity=%f\\\" %(constraint.name(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.dual_value(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tactivities[constraint.index()]))\\n\\n\\t\\t\\tprint (\\\"constraint %s: dual value = %f\\\\nactivity=%f\\\" %(constraint.name(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.dual_value(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tactivities[constraint.index()]))\\n\\t\\t\\ttext.insert(END, \\n\\t\\t\\t\\t\\t\\\"\\\\n \\\\n constraint %s Lower to Upper Boundary:\\\\n \\\\t %f < %.2d < %f\\\" %(constraint.name(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.Lb(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tactivities[constraint.index()],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.Ub()))\\n\\n\\t\\t\\tprint (\\\"constraint %s Lower.....to.....Upper Boundary: %f < %.2d < %f\\\" %(constraint.name(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.Lb(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tactivities[constraint.index()],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.Ub()))\\n\\t\\ttext.config(state=DISABLED)\\n\\t\\ttext.pack()\\n\\t\\tself.root.config(menu=menubar)\",\n \"def toCNF (N, instance, outputfile):\\r\\n \\\"\\\"\\\" OUTPUT: Write Dimacs CNF to output_file \\\"\\\"\\\"\\r\\n import itertools\\r\\n n = N\\r\\n output_file = open(outputfile, \\\"w\\\")\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n constraint = []\\r\\n constraint_2 = []\\r\\n constraint_3 = []\\r\\n counter = 0\\r\\n count = 0\\r\\n for i in range(N):\\r\\n for j in range(N):\\r\\n if instance [i][j] != 0:\\r\\n counter = counter + 1\\r\\n\\r\\n #Write the first line p cnf NNN and Line\\r\\n count = (N*N) + (N-1)*(N*N*N)*3 + counter + 1\\r\\n output_file.write(\\\"p cnf \\\" + str(str(N)+str(N)+str(N)))\\r\\n output_file.write(\\\" \\\" + str(count))\\r\\n output_file.write(\\\"\\\\n\\\")\\r\\n\\r\\n\\r\\n #First Constraint\\r\\n for i in range(N):\\r\\n for j in range(N):\\r\\n for k in range(N):\\r\\n output_file.write(str(i+1)+str(j+1)+str(k+1)+ \\\" \\\")\\r\\n output_file.write(str(0))\\r\\n output_file.write(\\\"\\\\n\\\")\\r\\n\\r\\n \\r\\n #Second Constraint\\r\\n for i in range(N):\\r\\n for j in range(N):\\r\\n for k in range(N):\\r\\n for l in range(N):\\r\\n if k != l:\\r\\n output_file.write(\\\"-\\\"+str(i+1)+str(j+1)+str(k+1)+ \\\" \\\")\\r\\n output_file.write(\\\"-\\\"+str(i+1)+str(j+1)+str(l+1)+ \\\" \\\")\\r\\n output_file.write(str(0))\\r\\n output_file.write(\\\" \\\")\\r\\n output_file.write(\\\"\\\\n\\\")\\r\\n\\r\\n\\r\\n #Third Constraint\\r\\n for i in range(N):\\r\\n for k in range(N):\\r\\n for j1 in range(N):\\r\\n for j2 in range(N):\\r\\n if j1 != j2:\\r\\n output_file.write(\\\"-\\\"+str(i+1)+str(j1+1)+str(k+1)+ \\\" \\\")\\r\\n output_file.write(\\\"-\\\"+str(i+1)+str(j2+1)+str(k+1)+ \\\" \\\")\\r\\n output_file.write(str(0))\\r\\n output_file.write(\\\" \\\")\\r\\n output_file.write(\\\"\\\\n\\\")\\r\\n \\r\\n\\r\\n #Fourth Constraint\\r\\n for j in range(N):\\r\\n for k in range(N):\\r\\n for i1 in range(N):\\r\\n for i2 in range(N):\\r\\n if i1 != i2:\\r\\n output_file.write(\\\"-\\\"+str(i1+1)+str(j+1)+str(k+1)+ \\\" \\\")\\r\\n output_file.write(\\\"-\\\"+str(i2+1)+str(j+1)+str(k+1)+ \\\" \\\")\\r\\n output_file.write(str(0))\\r\\n output_file.write(\\\" \\\")\\r\\n output_file.write(\\\"\\\\n\\\") \\r\\n\\r\\n\\r\\n #Fifth Constraint\\r\\n for i in range(N):\\r\\n for j in range(N):\\r\\n if instance [i][j] != 0 :\\r\\n output_file.write(str(i+1)+str(j+1))\\r\\n output_file.write(str(instance[i][j]))\\r\\n output_file.write(\\\" \\\")\\r\\n output_file.write(str(0))\\r\\n output_file.write(\\\"\\\\n\\\") \\r\\n \\\"*** YOUR CODE ENDS HERE ***\\\"\\r\\n output_file.close()\",\n \"def print_solution():\\n pass\",\n \"def __init__(self):\\n\\n # names of atoms that make up relevant segements of each chain\\n self.chains = {'a': {'C': 'C1', 'C1': 'C2', 'C2': 'C3', 'C3': 'C4', 'C4': 'C5', 'H': 'H1', 'H1': 'H2',\\n 'H2': 'H3', 'H3': 'H4', 'H4': 'H5'},\\n 'b': {'C45': 'C1', 'C44': 'C2', 'C43': 'C3', 'C42': 'C4', 'C41': 'C5', 'H81': 'H1', 'H80': 'H2',\\n 'H79': 'H3', 'H78': 'H4', 'H77': 'H5'}\\n }\\n\\n self.nchains = len(list(self.chains.keys()))\\n\\n self.chain_numbers = {'a': 0, 'b': 1} # used to number chains\\n\\n # self.initial_types = {'C1': 'c2', 'C2': 'ce', 'C3': 'ce', 'C4': 'c2', 'H1': 'ha', 'H2': 'ha', 'H3': 'ha',\\n # 'H4': 'ha', 'H5': 'ha'}\\n\\n # all indices numbered from 0. D1, D2, ... correspond to dummies attached to C1, C2, ... respectively\\n self.indices = {'a': {'C1': 0, 'C2': 1, 'C3': 2, 'C4': 3, 'C5': 4, 'H1': 52, 'H2': 53, 'H3': 54, 'H4': 55,\\n 'H5': 56, 'D1': 136, 'D2': 137, 'D3': 138, 'D4': 139},\\n 'b': {'C1': 49, 'C2': 48, 'C3': 47, 'C4': 46, 'C5': 45, 'H1': 133, 'H2': 132, 'H3': 131,\\n 'H4': 130, 'H5': 129, 'D1': 140, 'D2': 141, 'D3': 142, 'D4': 143}\\n }\\n\\n self.dummy_connectivity = {'a': {'C': 'D1', 'C1': 'D2', 'C2': 'D3', 'C3': 'D4'},\\n 'b': {'C45': 'D1', 'C44': 'D2', 'C43': 'D3', 'C42': 'D4'}}\\n\\n self.hydrogen_connectivity = {'C': ['H1', 'H2'], 'C1': ['H3'], 'C2': ['H4'], 'C3': ['H5'],\\n 'C45': ['H1', 'H2'], 'C44': ['H3'], 'C43': ['H4'], 'C42': ['H5']}\\n\\n self.dummy_mass = 1.008 # mass of hydrogen\\n\\n # write these in order of priority\\n # for efficiency, don't repeat things. For example self.carbons['C1']: self.carbons['C2'] is the same as\\n # self.carbons['C2']: self.carbons['C1']. Otherwise, computational expense goes up and a new reaction has\\n # to be defined below.\\n self.carbons = {'C1': ['C', 'C45'], 'C2': ['C1', 'C44'], 'C3': ['C2', 'C43'], 'C4': ['C3', 'C42']}\\n self.bonds_with = [[self.carbons['C1'], self.carbons['C2']]]\\n\\n # define which improper dihedrals to remove -- written in same order as .itp file!!!\\n # note that the order of the atoms may be different for each chain\\n # NOTE: C3 not tested\\n self.impropers = {'a': {'C1': ['H2', 'C1', 'H1', 'C2'], 'C2': ['C1', 'C3', 'C2', 'H3'],\\n 'C3': ['C4', 'C2', 'C3', 'H4'], 'C4': ['C5', 'C3', 'C4', 'H5']},\\n 'b': {'C1': ['C2', 'H2', 'C1', 'H1'], 'C2': ['C1', 'C3', 'C2', 'H3'],\\n 'C3': ['C4', 'C2', 'C3', 'H4'], 'C4': ['C5', 'C3', 'C4', 'H5']}}\",\n \"def constraint_test():\\n import itertools, sys\\n\\n show_analysis = False\\n #Generated via grammar\\n gr = grammar.Grammar('grammars/test_constraints.bnf')\\n inputs = ([1 for _ in range(100)], [ i%3 for i in range(100)])\\n for _input in inputs: \\n output = gr.generate(_input)\\n azr = analyser.Analyser('test',output['phenotype'],True)\\n try:\\n azr.create_graph()\\n except ValueError as e:\\n print(__name__, \\\"ERROR\\\", _input, e)\\n continue\\n azr.parse_graph()\\n azr.apply_stresses()\\n azr.create_slf_file()\\n azr.test_slf_file()\\n azr.parse_results()\\n azr.print_stresses()\\n if show_analysis:\\n azr.show_analysis()\\n \\n #Fixed generated\\n lengths = (1000, 10000)\\n levels = (5, 10)\\n for length_idx, level_idx in itertools.permutations([0,1]):\\n try:\\n GRAPH = constrained_offset_graph(lengths[length_idx],\\n levels[length_idx])\\n except ValueError as e:\\n print(__name__, \\\"ERROR\\\", lengths[length_idx], levels[length_idx], e)\\n continue\\n GRAPH.save_graph(\\\"pylon\\\")\\n print \\\"nodes:\\\", GRAPH.number_of_nodes()\\n print \\\"edges\\\", GRAPH.number_of_edges()\\n #will it blend?\\n azr = analyser.Analyser('test',\\\"moo\\\",True)\\n azr.my_graph = GRAPH\\n azr.parse_graph()\\n azr.apply_stresses()\\n azr.create_slf_file()\\n azr.test_slf_file()\\n azr.parse_results()\\n azr.print_stresses()\\n if show_analysis:\\n azr.show_analysis()\",\n \"def main():\\n\\n config = read_json_file(CONFIG_FILE)\\n posititve_path = (\\n config[\\\"main\\\"][\\\"DATASET_BASE_PATH_DIR\\\"]\\n + config[\\\"main\\\"][\\\"POSITIVE_FILENAME\\\"]\\n )\\n negative_path = (\\n config[\\\"main\\\"][\\\"DATASET_BASE_PATH_DIR\\\"]\\n + config[\\\"main\\\"][\\\"NEGATIVE_FILENAME\\\"]\\n )\\n complexity_factor = config[\\\"main\\\"][\\\"COMPLEXITY_FACTOR\\\"]\\n max_sequences_to_fit_pos = config[\\\"main\\\"][\\\"MAX_SEQUENCES_TO_FIT_POS\\\"]\\n max_sequences_to_fit_neg = config[\\\"main\\\"][\\\"MAX_SEQUENCES_TO_FIT_NEG\\\"]\\n\\n input_organisms_path = config[\\\"main\\\"][\\\"INPUT_FILENAME\\\"]\\n mean_nodes = 3.0\\n mean_fitness = 150\\n positive_dataset = read_fasta_file(posititve_path)\\n positive_dataset.sort()\\n negative_dataset = read_fasta_file(negative_path)\\n print(\\\"{} {}\\\".format(len(positive_dataset), len(negative_dataset)))\\n\\n organism_factory = OrganismFactory(\\n config[\\\"organism\\\"],\\n config[\\\"organismFactory\\\"],\\n config[\\\"connector\\\"],\\n config[\\\"pssm\\\"],\\n )\\n\\n a_organisms = organism_factory.import_organisms(input_organisms_path)\\n # random.shuffle(negativeDataset)\\n\\n for org in a_organisms:\\n\\n # org.print()\\n nodes = org.count_nodes()\\n\\n p_1 = org.get_seq_set_fitness(\\n positive_dataset[:max_sequences_to_fit_pos]\\n )\\n n_1 = org.get_seq_set_fitness(\\n negative_dataset[:max_sequences_to_fit_neg]\\n )\\n # p1 = 20\\n # n1 = org.getSeqSetFitness(negativeDataset[31:32])\\n c_1 = org.get_complexity(mean_nodes, mean_fitness)\\n\\n # Score\\n fitness = p_1 - n_1\\n effective_fitness = fitness - complexity_factor * c_1\\n print(\\n (\\n \\\"ORG {} N: {:.2f} P: {:.2f} N: {:.2f} C: {:.2f} F: {:.2f}\\\"\\n + \\\" EF: {:.2f}\\\\n\\\"\\n ).format(org._id, nodes, p_1, n_1, c_1, fitness, effective_fitness)\\n )\\n\\n export_organism(\\n org,\\n positive_dataset,\\n \\\"{}positive_{}\\\".format(\\n config[\\\"main\\\"][\\\"RESULT_TEST_BASE_PATH_DIR\\\"], org._id\\n ),\\n organism_factory,\\n )\\n # exportOrganism(\\n # org,\\n # negativeDataset[31:32],\\n # \\\"{}negative_{}\\\".format(config[\\\"main\\\"][\\\"RESULT_TEST_BASE_PATH_DIR\\\"], org.ID),\\n # organismFactory,\\n # )\\n\\n export_organism(\\n org,\\n negative_dataset[:50],\\n \\\"{}negative_{}\\\".format(\\n config[\\\"main\\\"][\\\"RESULT_TEST_BASE_PATH_DIR\\\"], org._id\\n ),\\n organism_factory,\\n )\",\n \"def main():\\n\\n rules, evolutions = [int(i) for i in input().strip().split()]\\n\\n rule = {}\\n for _ in range(rules):\\n start, finish = input().strip().split(' -> ')\\n rule[start] = finish\\n\\n print(lindenmayor(rule, evolutions, input().strip()))\",\n \"def main():\\n \\n # 1. Learn a decision tree from the data in training.txt\\n print \\\"--Building trees--\\\"\\n train_examples = read_file('training.txt')\\n print(train_examples)\\n attrs = range(len(train_examples[0])-1)\\n rand_tree = decision_tree_learning(train_examples, attrs, use_gain=False)\\n gain_tree = decision_tree_learning(train_examples, attrs, use_gain=True)\\n print \\\"--Done building--\\\"\\n print\\n\\n # 2. Document the tree you got\\n print \\\"--Random tree--\\\"\\n print_tree(rand_tree)\\n print\\n print \\\"--Learn tree--\\\"\\n print_tree(gain_tree)\\n print\\n\\n # 3. Classify all examples in the test-set\\n test_examples = read_file('test.txt')\\n print \\\"--Testing random tree--\\\"\\n test(rand_tree, test_examples, attrs)\\n print\\n print \\\"--Testing information gain tree--\\\"\\n test(gain_tree, test_examples, attrs)\\n print \\\"--Done testings--\\\"\",\n \"def main():\\n # create a list of test employees and managers\\n testList = [\\n {'type': 'employee', 'firstName': 'Mickey', 'lastName': 'Mouse', 'SSN': '100-12-3456', 'salary': 1500.00},\\n {'type': 'manager', 'firstName': 'Walt', 'lastName': 'Disney', 'SSN': '100-00-0000', 'salary': 5000.00,\\n 'title': 'Head Of Disneyland', 'yearBonus': 1000.00},\\n {'type': 'employee', 'firstName': 'Donald', 'lastName': 'Duck', 'SSN': '100-65-4321', 'salary': 1000.00},\\n {'type': 'manager', 'firstName': 'Minnie', 'lastName': 'Mouse', 'SSN': '999-99-999', 'salary': 10000.00,\\n 'title': 'Head Of Mouse HouseHold', 'yearBonus': 15000.00},\\n {'type': 'manager', 'firstName': 'Daisy', 'lastName': 'Duck', 'SSN': '100-65-4321', 'salary': 12000.00,\\n 'title': 'Head Of Duck HouseHold', 'yearBonus': 10000.00}]\\n\\n # Define percentRaise (0.1 == 10%)\\n percentRaise = 0.1\\n\\n # Create Employees and Managers Object using the Test data\\n employeeList = loadEmployees(testList)\\n\\n # Sort employee List, which will ustilize Employee's __lt__ and __eq__ methods\\n employeeList.sort()\\n\\n # Loop over Employee and Manager Objects\\n print(\\\"Employees and Manager should be sorted by last name, then first\\\\n\\\")\\n for employee in employeeList:\\n if type(employee) == Manager:\\n print(\\\"Manager:\\\")\\n else:\\n print(\\\"Employee:\\\")\\n # Print Employee or Manager\\n print(employee)\\n # Give Raise to Employee or Manager\\n employee.giveRaise(percentRaise)\\n # Print New Salary\\n print(\\\"With %.2f%% Raise, Salary: $%.2f\\\\n\\\" % (percentRaise * 100, employee.salary))\\n\\n # Employee docStrings\\n print(\\\"\\\\nEmployee docstring for each method\\\")\\n print(\\\"Employee.__doc__=\\\" + Employee.__doc__)\\n print(\\\"Employee.__init__.__doc__=\\\" + Employee.__init__.__doc__)\\n print(\\\"Employee.giveRaise.__doc__=\\\" + Employee.giveRaise.__doc__)\\n print(\\\"Employee.__str__.__doc__=\\\" + Employee.__str__.__doc__)\\n print(\\\"Employee.__eq__.__doc__=\\\" + Employee.__eq__.__doc__)\\n print(\\\"Employee.__lt__.__doc__=\\\" + Employee.__lt__.__doc__)\\n\\n print(\\\"\\\\nManger docstring for each method\\\")\\n print(\\n \\\"Since Manager inherits from Employee, several of the methods ('giveRaise', '__eq__' and '__lt__') and the corresponding docstring will originate from the Employee class\\\\n\\\")\\n print(\\\"Manager.__doc__=\\\" + Manager.__doc__)\\n print(\\\"Manager.__init__.__doc__=\\\" + Manager.__init__.__doc__)\\n print(\\\"Manager.giveRaise.__doc__=\\\" + Manager.giveRaise.__doc__)\\n print(\\\"Manager.__str__.__doc__=\\\" + Manager.__str__.__doc__)\\n print(\\\"Manager.__eq__.__doc__=\\\" + Manager.__eq__.__doc__)\\n print(\\\"Manager.__lt__.__doc__=\\\" + Manager.__lt__.__doc__)\",\n \"def chainsetup(filename, cation, facets, operation, end_radii, nradii,\\n adensity):\\n\\n # Load the Cage from the file\\n try:\\n # If that fails, try other file formats supported by pymatgen\\n anion = Cage.from_file(filename)\\n except ValueError:\\n # If that fails, try the VASP POSCAR format\\n anion = Cage.from_poscar(filename)\\n\\n # Center the anion around the origin\\n anion.center()\\n\\n # Find the chain edges, i.e. the paths between the edge sharing facets of\\n # the chain of non-equivalent facets.\\n anion.find_surface_facets(ignore=IGNORE)\\n\\n if not facets == tuple:\\n chosen_facets = [anion.facets[index] for index in facets]\\n edges = anion.find_noneq_chain_links(chosen_facets)\\n else:\\n edges = anion.find_noneq_chain_links()\\n\\n total_mol = anion.copy()\\n\\n chain_dir = 'chain_' + operation\\n try:\\n os.mkdir(chain_dir)\\n except FileExistsError:\\n pass\\n\\n # For each edge, set up the calculation input files\\n edge_number = 1\\n\\n for edge in edges:\\n\\n # Set up the edge directory\\n edge_dir = os.path.join(chain_dir, \\\"edge\\\" + str(edge_number))\\n\\n while os.path.exists(edge_dir):\\n edge_number += 1\\n edge_dir = os.path.join(chain_dir, \\\"edge\\\" + str(edge_number))\\n\\n os.mkdir(edge_dir)\\n\\n # Write out the molecule and path facets to the edge directory\\n anion.to(fmt=\\\"json\\\", filename=os.path.join(edge_dir, \\\"molecule.json\\\"))\\n edge[0].to(fmt=\\\"json\\\", filename=os.path.join(edge_dir,\\n \\\"init_facet.json\\\"))\\n edge[1].to(fmt=\\\"json\\\", filename=os.path.join(edge_dir,\\n \\\"final_facet.json\\\"))\\n\\n # Get copies so the originals aren't mutated\\n edge_mol = anion.copy()\\n facet1 = edge[0].copy()\\n facet2 = edge[1].copy()\\n\\n if edge == edges[-1]:\\n remove_endline = False\\n else:\\n remove_endline = True\\n\\n # Set up the landscape\\n landscape = set_up_edge_landscape(facet1, facet2,\\n endpoint_radii=end_radii,\\n number_of_radii=nradii,\\n angle_density=adensity,\\n remove_endline=remove_endline)\\n\\n # Get the molecule for each landscape point\\n molecules = set_up_molecules(edge_mol, landscape, cation)\\n\\n # Set up an xyz file to visualize the edge and total landscape\\n for point in landscape.points:\\n try:\\n total_mol.append(pmg.Specie(cation, 1), point,\\n validate_proximity=False)\\n edge_mol.append(pmg.Specie(cation, 1), point,\\n validate_proximity=False)\\n except ValueError:\\n pass\\n\\n edge_mol.to(fmt=\\\"xyz\\\", filename=os.path.join(edge_dir, \\\"edge.xyz\\\"))\\n\\n # In case the molecules must be optimized, add the constraints and\\n # optimization setup (DRIVER)\\n if operation == \\\"optimize\\\":\\n far_facet = anion.find_farthest_facet(landscape.center)\\n constraints = find_constraints(anion, far_facet.sites)\\n constraints['fix atom'] += ' ' + str(len(anion.sites) + 1)\\n ALT_SETUP['constraints'] = constraints\\n ALT_SETUP[\\\"driver\\\"] = DRIVER_SETUP\\n\\n # Set up the task for the calculations\\n tasks = [nwchem.NwTask(molecules[0].charge, None, BASIS,\\n theory=\\\"dft\\\",\\n operation=operation,\\n theory_directives=THEORY_SETUP,\\n alternate_directives=ALT_SETUP)]\\n\\n # Set up the input files\\n study = Study(molecules, tasks)\\n study.set_up_input(edge_dir, sort_comp=False,\\n geometry_options=GEO_SETUP)\\n\\n edge_number += 1\\n\\n # Set up an xyz file with all the paths\\n total_mol.to(fmt=\\\"xyz\\\", filename=os.path.join(chain_dir, \\\"total_mol.xyz\\\"))\",\n \"def main():\\n ref_seq = {}\\n ent_spe_sero = {}\\n tag_dict = {\\\"Contigs_with_VP1\\\":\\\"contigs\\\", \\\"P1_sequences\\\":\\\"p1\\\",\\n \\\"VP1_sequences\\\":\\\"vp1\\\", \\\"5UTR_sequences\\\":\\\"5utr\\\", \\\"3D_sequences\\\":\\\"3d\\\"}\\n args = get_arguments()\\n # Load query elements\\n print(\\\"Load resume file\\\")\\n (query_dict, classify_list,\\n classify_specie_list, serotype_list) = get_query(args.resume_file,\\n args.tag,\\n args.incomplete)\\n print(\\\"{} descriptions loaded\\\".format(len(query_dict)))\\n # Load specie association\\n if args.ent_serotype_file and args.template_seq_file:\\n # Load enterovirus serotype\\n print(\\\"Load enterovirus serotype association\\\")\\n ent_spe_sero = load_spe_sero(args.ent_serotype_file)\\n # Load template sequence\\n print(\\\"Load template sequence\\\")\\n ref_seq = get_template_sequence(args.template_seq_file, ent_spe_sero)\\n # Grab query sequence in the database\\n print(\\\"Load database sequence\\\")\\n sequence_data = get_sequence(query_dict, args.fasta_file)\\n print(\\\"{} sequences loaded\\\".format(len(sequence_data)))\\n # Write the new fasta file\\n print(\\\"Write the new fasta\\\")\\n write_sequence(args.results, sequence_data, query_dict, classify_list,\\n tag_dict[args.tag], ref_seq, ent_spe_sero)\\n #print(save_association)\\n print(\\\"Write the itol label\\\")\\n write_itol_label(args.itol_dir, sequence_data, query_dict, classify_list,\\n tag_dict[args.tag])\\n print(\\\"Write the itol tree color\\\")\\n write_itol_tree_color(args.itol_dir, sequence_data, query_dict, classify_specie_list, serotype_list,\\n tag_dict[args.tag])\\n print(\\\"Done\\\")\",\n \"def check_proof(self):\\n for gene in self.population:\\n if gene.is_proof:\\n print(gene.chromosome)\\n for state in gene.coq_states:\\n print(state)\\n self.proofs.append(Gene(chromosome=gene.valid_tactics))\",\n \"def test_markov_to_chain():\\n chain = {\\n 'PIKARD': [('Q', 2.0 / 3), ('DORF', 1.0 / 3)],\\n 'Q': [('PIKARD', 2.0 / 3), ('ROKER', 1.0 / 3)],\\n 'DORF': [('PIKARD', 1.0)],\\n 'ROKER': [('Q', 1.0)],\\n }\\n with markov.DialogChainDatastore() as store:\\n store.reinitialize()\\n store.store_chain('speakers', chain)\\n new_chain = store.to_chain('speakers')\\n assert set(chain.keys()) == set(new_chain.keys())\\n for speaker, probabilities in six.iteritems(chain):\\n assert sort_probs(probabilities) == sort_probs(new_chain[speaker])\",\n \"def InfoPrint(currentFile):\\n Chains = ReturnChain(currentFile)\\n chainlist = ReturnChain(currentFile)\\n if len(chainlist) > 1:\\n chainlist.insert(len(chainlist)-1,'and')\\n print('CHAINS:',' '.join(chainlist))\\n else:\\n print('CHAIN: %s'%''.join(chainlist))\\n x= ' '\\n for chain in Chains:\\n with open(currentFile) as fileIn:\\n sequence=[]\\n helix_count = 0\\n sheet_count = 0\\n line = fileIn.readline()\\n while line:\\n if line.startswith('SEQRES'):\\n words = line.split()\\n chaintype = words[2]\\n if chaintype == chain:\\n for word in words:\\n if word in aminoacidsCode.values():\\n sequence.append(word)\\n\\n else:\\n pass\\n\\n\\n if line.startswith('HELIX'):\\n helixInfo = line.split()\\n chaintype = helixInfo[4]\\n if chaintype == chain:\\n helix_count = helix_count + 1\\n\\n else:\\n pass\\n\\n if line.startswith('SHEET'):\\n sheetInfo = line.split()\\n chaintype = sheetInfo[5]\\n if chaintype == chain:\\n sheet_count = sheet_count + 1\\n\\n else:\\n pass\\n\\n line = fileIn.readline()\\n\\n print('- Chain %s'%chain)\\n print('Number of amino acids: %s'%len(sequence))\\n print('Number of helix:%s %s'%(x*7,helix_count))\\n print('Number of sheet:%s %s'%(x*7,sheet_count))\\n print('Sequence:'),seqprint(sequence)\",\n \"def test_claim_generation():\\n print(\\\"Executing test_claim_generation:\\\")\\n append_9_theory=[\\n (13,9),\\n (30,)\\n ]\\n set_false_and_append_9_theory=[\\n (13,0),\\n (28,),\\n (13,9),\\n (30,)\\n ]\\n\\n print(\\\"append_9_theory:\\\")\\n print(language.program_string(append_9_theory))\\n print(\\\"set_false_and_append_9_theory:\\\")\\n print(language.program_string(set_false_and_append_9_theory))\\n\\n mind=minds.new_mind(theories=[append_9_theory,set_false_and_append_9_theory],claims=[(True,[])])\\n\\n for i in range(10):\\n minds.generate_claims(mind)\\n\\n print(minds.mind_string(mind))\",\n \"def __repr__(self):\\n st = '\\\\nProof(syntax=\\\\\\\"' + self.syntax + '\\\\\\\", formula_list=[\\\\n'\\n for l in self.proof[:-1]:\\n st += str(l) + ',\\\\n'\\n return st + str(self.proof[-1]) + '])'\",\n \"def tree_produce(self, n, verbose=True):\\n # only for finite axioms\\n root = dict()\\n ref = root\\n for a in self.axioms:\\n assert not a.is_axiom_schema\\n a = a.axiom\\n ref[a] = dict()\\n ref = ref[a]\\n self._tree_produce(a, 0, n, ref, verbose)\\n return root\",\n \"def __init__(self,\\n point_size: int,\\n max_levels=6,\\n min_levels=3,\\n mutation_prob=0.5\\n ) -> None:\\n self.rec_refs = {}\\n self.mutation_prob = mutation_prob\\n\\n vars1 = []\\n vars2 = []\\n for i in range(point_size):\\n vars1 += [f\\\"X1[{i}]\\\"]\\n\\n for i in range(point_size):\\n vars2 += [f\\\"X2[{i}]\\\"]\\n\\n self.grammar = {\\n **{f\\\"<expr_{i}>\\\": [f\\\"<expr_{i+1}> <op> <expr_{i+1}>\\\", f\\\"<func> ( <expr_{i+1}> <op> <expr_{i+1}> )\\\"] for i in range(min_levels)},\\n **{f\\\"<expr_{min_levels + i}>\\\": [f\\\"<expr_{min_levels + i+1}> <op> <expr_{min_levels + i+1}>\\\", f\\\"<func> ( <expr_{min_levels + i + 1}> <op> <expr_{min_levels + i + 1}> )\\\", \\\"<term>\\\"] for i in range(max_levels - min_levels)},\\n f\\\"<expr_{max_levels}>\\\": [\\\"<term_1> <op> <term_2>\\\", \\\"<term_2> <op> <term_1>\\\"],\\n \\\"<term>\\\": [\\n \\\"<term_1>\\\", \\\"<term_2>\\\"\\n ],\\n \\\"<term_1>\\\": [\\n \\\"<var_1>\\\",\\n \\\"<pre-op> ( <var_1> )\\\",\\n ],\\n \\\"<term_2>\\\": [\\n \\\"<var_2>\\\",\\n \\\"<pre-op> ( <var_2> )\\\",\\n ],\\n \\\"<pre-op>\\\": [\\n \\\"1/\\\",\\n \\\"-\\\",\\n \\\"+\\\",\\n \\\"abs\\\",\\n \\\"numpy.math.sqrt\\\"\\n ],\\n \\\"<func>\\\": [\\n \\\"abs\\\",\\n \\\"\\\"\\n ],\\n \\\"<op>\\\": [\\n \\\"+\\\",\\n \\\"*\\\",\\n \\\"-\\\",\\n \\\"/\\\",\\n ],\\n \\\"<var_1>\\\": vars1,\\n \\\"<var_2>\\\": vars2,\\n }\\n\\n self.non_terminals = sorted(self.grammar.keys())\\n\\n # these two lines are described in the pseudocode of the reference paper\\n rec_refs = self.countRecursiveReferences()\\n self.ref_count = {\\n key: self.findReferences(key, *rec_refs) for key in self.grammar.keys()\\n }\",\n \"def produce(self, n, verbose=True):\\n gen = self._produce(verbose)\\n for _ in range(n):\\n new_theorem = next(gen)\\n self.theorems.update({new_theorem.theorem: new_theorem})\\n if verbose:\\n print(new_theorem)\",\n \"def make_control_knowledge(self, horizon):\\n\\n \\\"\\\"\\\" *** YOUR CODE HERE *** \\\"\\\"\\\"\\n\\n # ADD_RULE1_COUNT = 0\\n # ADD_RULE2_COUNT = 0\\n # ADD_RULE3_COUNT = 0\\n\\n close = list()\\n far = list()\\n\\n for g in self.problem.goal:\\n for p in self.problem.propositions:\\n if re.match(r'at\\\\spackage\\\\d+\\\\scity\\\\d+-\\\\d+', str(p)):\\n p_split = str(p).split()\\n g_split = str(g).split()\\n\\n # if \\\"at\\\" and \\\"package[oo]\\\" match\\n if p_split[0] == g_split[0] and p_split[1] == g_split[1]:\\n # also \\\"city[oo]-[xx]\\\" match\\n if p_split[2][:-2] == g_split[2][:-2]:\\n close.append(p)\\n else:\\n far.append(p)\\n\\n # Rule 1:\\n # ===============================\\n # If a package is at its goal location, then it must remain there.\\n # p@t and goal@t) -> p@t+1), where p is at(package, location)\\n # cnf: not p@t or not goal@t or p@t+1\\n\\n for g in self.problem.goal:\\n for t in range(0, horizon):\\n clause = list()\\n clause.append(-self.proposition_fluent_codes[(g, t)])\\n clause.append(self.proposition_fluent_codes[(g, t + 1)])\\n self.add_clause(clause, \\\"control\\\")\\n # ADD_RULE1_COUNT += 1\\n\\n for t in range(0, horizon):\\n for a in self.problem.actions:\\n\\n # Rule 2\\n # ===============================\\n\\n # RULE\\n # close -> do not load airplane\\n # p1: close@t\\n # p2: at the location of an airport @t\\n # p3: airplane at this location @t\\n # p4: plane is not loaded\\n # a: load this airplane\\n #\\n # p1@t and p2@t and p3@t and p4@t => a@t\\n # not p1@t or not p2@t or not p3@t or not p4@t or a@t\\n # cnf: not p@t or not a@t\\n if str(a).startswith('load-airplane'):\\n for i in close:\\n package = str(i).split()[1]\\n if str(a).split()[1] == package:\\n clause = list()\\n clause.append(\\n -self.proposition_fluent_codes[(i, t)])\\n clause.append(-self.action_fluent_codes[(a, t)])\\n self.add_clause(clause, \\\"control\\\")\\n # ADD_RULE2_COUNT += 1\\n\\n # Rule 3\\n # ===============================\\n\\n # RULE\\n # far -> do not unload airplane\\n # p@t -> not a@t, where p is far, a is unload-airplane\\n # cnf: not p@t or not a@t\\n if str(a).startswith('unload-airplane'):\\n for j in far:\\n package = str(j).split()[1]\\n if str(a).split()[1] == package:\\n clause = list()\\n clause.append(\\n -self.proposition_fluent_codes[(j, t)])\\n clause.append(-self.action_fluent_codes[(a, t)])\\n self.add_clause(clause, \\\"control\\\")\\n # ADD_RULE3_COUNT += 1\\n\\n # # RULE\\n # # if an airplane has a package on it and the package's\\n # # destination is close do not fly this airplane.\\n # # in fact, if the destination of package is far,\\n # # fly this plane to it.\\n # #\\n # # p1: package on airplane @ t\\n # # p2: package at a place @ t\\n # # p3: the place and the goal are in the same city\\n # # rule: p1@t and p2@t and p@3 => not fly plane@t\\n # # and unload the plane@t\\n #\\n # # not p1@t or not p2@t or not fly@t\\n # # not p1@t or not p2@t or unload\\n #\\n # # rule: p1@t and p2@t and not p3@t => fly plane@t and not\\n # # unload the plane@t\\n #\\n # if str(a).startswith('fly-airplane'):\\n # plane = str(a).split()[1]\\n # # loc_from = str(a).split()[2]\\n # for p1 in self.problem.propositions:\\n # if str(p1).startswith('in package') and str(p1).split()[2] == plane: # in package plane\\n # package = str(p1).split()[1]\\n # for p2 in self.problem.propositions:\\n # if p2 in close and str(p2).split()[1] == package: # at package location\\n # clause = list()\\n # clause.append(-self.proposition_fluent_codes[p1, t])\\n # clause.append(-self.proposition_fluent_codes[p2, t])\\n # clause.append(-self.action_fluent_codes[a, t])\\n # self.add_clause(clause, 'control')\\n # ADD_RULE2_COUNT += 1\\n #\\n #\\n # for g in self.problem.goal:\\n # if str(g).split()[1] == package:\\n # destination = str(g).split()[2]\\n # for do in self.problem.actions:\\n # # unload-airplane package00 plane00 city00-00\\n # if str(do).startswith('unload') and str(do).split()[1] == package and str(do).split()[2] == plane and str(do).split()[3] == destination:\\n # clause2 = list()\\n # clause2.append(-\\n # self.proposition_fluent_codes[\\n # p1, t])\\n # clause2.append(-\\n # self.proposition_fluent_codes[\\n # p2, t])\\n # clause2.append(\\n # self.action_fluent_codes[\\n # do, t])\\n # self.add_clause(clause2,\\n # 'control')\\n #\\n # ADD_RULE3_COUNT += 1\\n\\n # RULE\\n # if there is no package needs to be transferred at a location,\\n # and the location has a truck\\n # drive the truck to its airport\\n\\n # p1: (at package__ city__-__ /\\\\ (it is a goal)@t\\n # p2: (at truck__ city__-__)@t\\n # p3: (city__-__ is not airport)\\n # not p1/\\\\p2/\\\\p3 => drive_truck_to_its_airport@t\\n #\\n #\\n # CNF: p1 V not p2 V not p3 V drive_truck_to_its_airport@t\\n # if str(a).startswith('DRIVE-TRUCK'):\\n # for p1 in self.problem.goal:\\n # city = str(p1).split()[2]\\n # for p2 in self.problem.propositions:\\n # if str(p2).startswith('at truck') and str(p2).split()[2] == city:\\n # for p3 in self.problem.propositions:\\n # if str(p3).startswith('airport') and str(p3).split()[1] == city:\\n # clause = list()\\n # clause.append(self.proposition_fluent_codes[(p1, t)])\\n # clause.append(-self.proposition_fluent_codes[(p2, t)])\\n # clause.append(-self.proposition_fluent_codes[(p3, t)])\\n # clause.append(self.action_fluent_codes[(a, t)])\\n # self.add_clause(clause, \\\"control\\\")\\n\\n # RULE\\n # if there is an airplane is loaded with a package need\\n # transfer (to another city), fly airplane to the corresponding\\n # city.\\n\\n # p1: (at airplane__ city__-__)@t\\n # p2: (in package__ airplane__)@t\\n # p3: ( p2 is in far)\\n # p1/\\\\p2/\\\\p3 => fly_airplane_to_its_airport@t\\n #\\n #\\n # CNF: not p1@t V not p2@t V not p3@t V fly_plane_to_airport@t\\n\\n # print(\\\"ADDED RULE 1:\\\")\\n # print(ADD_RULE1_COUNT)\\n #\\n # print(\\\"ADDED RULE 2:\\\")\\n # print(ADD_RULE2_COUNT)\\n #\\n # print(\\\"ADDED RULE 3:\\\")\\n # print(ADD_RULE3_COUNT)\",\n \"def sat_all(props, f):\\n solver = Solver()\\n solver.add(f)\\n result = []\\n while solver.check() == sat:\\n m = solver.model()\\n result.append(m)\\n block = []\\n for prop in props:\\n prop_is_true = m.eval(prop, model_completion=True)\\n\\n if prop_is_true:\\n new_prop = prop\\n else:\\n new_prop = Not(prop)\\n\\n block.append(new_prop)\\n \\n # Exercise 1-6 begin\\n f = And(f, Not(And(*block)))\\n solver.add(f)\\n # Exercise 1-6 end\\n\\n print(\\\"the given proposition: \\\", f)\\n print(\\\"the number of solutions: \\\", len(result))\\n\\n def print_model(m):\\n print(sorted([(d, m[d]) for d in m], key=lambda x: str(x[0])))\\n\\n for m in result:\\n print_model(m)\",\n \"def main(supply):\\n\\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\\n # between each pair. For instance, the arc from node 0 to node 1 has a\\n # capacity of 15 and a unit cost of 4.\\n\\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\\n\\n # Define an array of supplies at each node.\\n supplies = supply\\n\\n\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n\\n # Add each arc.\\n for i in range(0, len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\\n capacities[i], unit_costs[i])\\n\\n # Add node supplies.\\n\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n\\n\\n # Find the minimum cost flow between node 0 and node 4.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n flag = 1\\n optimal_flows = np.zeros(36)\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # save answer to the variable\\n optimal_flows[i] = min_cost_flow.Flow(i)\\n return flag, optimal_flows\\n else:\\n print('There was an issue with the min cost flow input.')\\n flag = 0\\n return flag, 0\",\n \"def prove_and_commutativity() -> Proof:\\n all_lines = []\\n all_lines.append(Proof.Line(Formula.parse('(p&q)')))\\n all_lines.append(Proof.Line(Formula.parse('q'), AE1_RULE, [0]))\\n all_lines.append(Proof.Line(Formula.parse('p'), AE2_RULE, [0]))\\n all_lines.append(Proof.Line(Formula.parse('(q&p)'), A_RULE, [1, 2]))\\n statement = InferenceRule([Formula.parse('(p&q)')], Formula.parse('(q&p)'))\\n all_rules = {A_RULE, AE1_RULE, AE2_RULE}\\n return Proof(statement, all_rules, all_lines)\",\n \"def proposed_order_print(proposed_order_list):\\n for item_details in proposed_order_list:\\n proposed_order_item_print(item_details)\",\n \"def run(self):\\n import standard\\n \\n # runs the checkpoints\\n def checkpoints():\\n result = True\\n for chk in self.checkpoints:\\n if chk(self) == False: result = False\\n return result\\n\\n\\n # Checks that self is complete and fills in where possible\\n if hasattr(self, \\\"fill_attributes\\\"): self.fill_attributes()\\n else: self = standard.fill_attributes(self)\\n assert hasattr(self, \\\"Individual\\\"), \\\"No Individual type.\\\\n\\\"\\n assert hasattr(self, \\\"taboo\\\"), \\\"No taboo operation.\\\\n\\\"\\n assert hasattr(self, \\\"population\\\"), \\\"No population attribute.\\\\n\\\"\\n assert hasattr(self, \\\"popsize\\\"), \\\"No popsize attribute.\\\\n\\\"\\n assert hasattr(self, \\\"current_gen\\\"), \\\"No current_gen attribute.\\\\n\\\"\\n assert hasattr(self, \\\"evaluation\\\"), \\\"No evaluation operation.\\\\n\\\"\\n assert hasattr(self, \\\"rate\\\"), \\\"No rate attribute.\\\\n\\\"\\n assert hasattr(self, \\\"mating\\\"), \\\"No mating functor.\\\\n\\\"\\n assert hasattr(self, \\\"offspring\\\"), \\\"No offspring attribute.\\\\n\\\"\\n assert hasattr(self, \\\"comparison\\\"), \\\"No comparison operation.\\\\n\\\"\\n\\n # creates population if it does not exist.\\n if self.comm.is_root: \\n while len(self.population) < self.popsize:\\n j = 0\\n loop = True\\n while loop:\\n indiv = self.Individual()\\n loop = self.taboo(indiv)\\n j += 1\\n assert j < max(50*self.popsize, 100), \\\"Could not create offspring.\\\\n\\\"\\n indiv.birth = self.current_gen\\n self.population.append(indiv)\\n self.population = self.comm.broadcast(self.population)\\n \\n # evaluates population if need be.\\n self.evaluation() \\n # now makes sure evaluation did not create twins.\\n dummy, self.population = self.population, []\\n for indiv in dummy:\\n if any(indiv == u for u in self.population): continue\\n self.population.append(indiv)\\n\\n # Number of offspring per generation.\\n nboffspring = max(int(float(self.popsize)*self.rate), 1)\\n\\n # generational loop\\n while checkpoints(): \\n if self.comm.do_print:\\n print \\\"\\\\nStarting generation \\\", self.current_gen\\n\\n # tries and creates offspring.\\n if self.comm.rank == 0:\\n while len(self.offspring) < nboffspring:\\n j = 0\\n loop = True\\n while loop:\\n indiv = self.mating()\\n loop = self.taboo(indiv)\\n j += 1\\n assert j < max(10*self.popsize, 100), \\\"Could not create offspring.\\\\n\\\"\\n indiv.birth = self.current_gen\\n self.offspring.append(indiv)\\n self.comm.broadcast(self.offspring)\\n else: self.offspring = self.comm.broadcast(self.offspring)\\n\\n\\n # now evaluates population.\\n self.evaluation()\\n\\n # finally, sort and replace.\\n if self.comm.rank == 0:\\n # deal with differences in function sorted between python versions.\\n from platform import python_version_tuple\\n if python_version_tuple()[0] > 2:\\n from functools import cmp_to_key\\n self.population = sorted(self.population, key=cmp_to_key(self.comparison))\\n else: \\n self.population = sorted(self.population, cmp=self.comparison)\\n # Inserts individual one by one ensuring they do not yet exist in the\\n # population. This ensures that duplicates are not allowed.\\n for indiv in self.offspring:\\n if any(indiv == u for u in self.population): continue\\n self.population.insert(0, indiv)\\n # In case population smaller than expected, use conditional.\\n if len(self.population) > self.popsize: self.population.pop(-1)\\n self.population = self.comm.broadcast(self.population)\\n \\n self.offspring = []\\n self.current_gen += 1 \\n\\n # final stuff before exiting.\\n if hasattr(self, \\\"final\\\"): self.final()\\n elif self.comm.do_print: print \\\"done\\\"\",\n \"def run(args):\\n # Load the pedigree file\\n print('Parsing pedigree...', file=sys.stderr)\\n pedigree = Pedigree.parse(args.input_ped)\\n for member in pedigree.members:\\n print(member, file=sys.stderr)\\n # load the HLA calls for each donor\\n print('Loading HLA calls...', file=sys.stderr)\\n all_calls = {}\\n calls = {}\\n for donor, fcalls in zip(args.donor_name, args.donor_calls):\\n print(donor, fcalls.name, file=sys.stderr)\\n all_calls[donor] = []\\n calls[donor] = {'A': [], 'B': [], 'C': []}\\n for hla_type in sorted(HLAType.parse(line.strip())\\n for line in fcalls):\\n calls[donor][hla_type.gene_name].append(hla_type)\\n all_calls[donor].append(hla_type)\\n print('Checking for consistency...', file=sys.stderr)\\n # get IDs of parents\\n index_member = pedigree.by_name[args.index_donor]\\n father = index_member.father\\n mother = index_member.mother\\n # check for 4 digit consistency\\n mm4 = check_consistency(4, calls[args.index_donor], calls.get(father),\\n calls.get(mother))\\n # check for 2 digit consistency\\n mm2 = check_consistency(2, calls[args.index_donor], calls.get(father),\\n calls.get(mother))\\n num_parents = len({father, mother} - {'0'})\\n # print result line\\n print('\\\\t'.join(map(str, [\\n args.index_donor, num_parents, mm2 or 'OK', mm4 or 'OK'\\n ])))\",\n \"def proof_by_way_of_contradiction(proof: Proof, assumption: Formula,\\r\\n print_as_proof_forms: bool = False) -> Proof:\\r\\n assert proof.is_valid()\\r\\n assert Schema(assumption) in proof.assumptions\\r\\n assert proof.assumptions.issuperset(Prover.AXIOMS)\\r\\n for line in proof.lines:\\r\\n if isinstance(line, Proof.UGLine):\\r\\n assert line.formula.variable not in assumption.free_variables()\\r\\n\\r\\n # Remove the proof assumption while basing a fully-fledged proof on it\\r\\n proof = remove_assumption(proof, assumption)\\r\\n\\r\\n # Create a prover out of this proof assumptions\\r\\n prover = Prover(proof.assumptions)\\r\\n\\r\\n # Append\\r\\n step = prover.add_proof(proof.conclusion, proof)\\r\\n\\r\\n # Conclude\\r\\n prover.add_tautological_implication(assumption.inverse(), {step})\\r\\n return prover.qed()\",\n \"def generate(self, analysis):\\n\\n #analysis = ['p','a','n','i','c','+past form']\\n # Let's define our first FST\\n\\n f1 = FST('morphology-generate')\\n \\n f1.add_state('1')\\n f1.add_state('2')\\n f1.add_state('3')\\n f1.add_state('4')\\n f1.add_state('5') \\n f1.add_state('6') #non-c state\\n f1.add_state('7') #c state\\n f1.add_state('8') #add k\\n f1.add_state('9') #+present \\n f1.add_state('10') #+past\\n \\n f1.initial_state = '1'\\n #f1.set_final('8')\\n f1.set_final('9')\\n f1.set_final('10')\\n \\n #state 1 to 2, and 2 to 3. we don't care about vowel or consonant here\\n for letter in list(string.ascii_letters):\\n f1.add_arc('1', '2', letter, letter)\\n f1.add_arc('2', '3', letter, letter)\\n \\n #3 to 5 input/output consonants\\n vowels = ['a','e','i','o','u','A','E','I','O','U']\\n consonants = [c for c in list(string.ascii_letters) if c not in vowels]\\n non_c_con = [c for c in consonants if c not in ['c', 'C']]\\n for letter in consonants:\\n f1.add_arc('3', '5', letter, letter)\\n f1.add_arc('5', '5', letter, letter)\\n \\n #the third and fourth input should be a vowel\\n for letter in vowels:\\n f1.add_arc('3', '4', letter, letter)\\n f1.add_arc('4', '4', letter, letter)\\n \\n #if the fourth input is a non c consonant, go to 5\\n for letter in non_c_con:\\n f1.add_arc('4', '5', letter, letter)\\n \\n #if the input at state 5 is a vowel, go back to 4 \\n for letter in vowels:\\n f1.add_arc('5', '4', letter, letter)\\n \\n #if the second last letter is a c, go to 7\\n f1.add_arc('4', '7', 'c', 'c')\\n \\n #add k after 7\\n f1.add_arc('7', '8', '', 'k')\\n #output nothing from 5 to 8\\n f1.add_arc('5', '8', '', '')\\n \\n f1.add_arc('8','9','+present participle form','ing')\\n f1.add_arc('8','10','+past form','ed')\\n \\n output = f1.transduce(analysis)[0]\\n return ''.join(output)\",\n \"def main():\\n\\trelations = [json.loads(x) for x in open('tutorial/pdtb_trial_data.json')]\\n\\toutput_relations = [convert_to_output(x) for x in relations]\\n\\toutput_relations[1]['Connective']['TokenList'] = [0]\\n\\toutput_relations[3]['Arg1']['TokenList'].pop(4)\\n\\toutput_relations[4]['Arg2']['TokenList'].pop(4)\\n\\toutput_relations[5]['Arg2']['TokenList'].pop(4)\\n\\toutput_relations[6]['Sense'] = [u'Contingency.Condition'] # This will hurt sense recall\\n\\toutput_relations.pop(0) # This will hurt all precision\\n\\tscorer.evaluate(relations, output_relations)\\n\\treturn output_relations\",\n \"def sample_chains():\\n c = chain(add.s(1, 1), add.s(1), add.s(1))\\n res = c()\\n print(res.get())\\n print(res.parent.get())\\n print(res.parent.parent.get())\",\n \"def process_tree(tree):\\n c = circuit()\\n l = line()\\n names = {}\\n procedures = []\\n for lst in tree.children:\\n print(lst)\\n if type(lst[0]) is str:\\n names[lst[0]] = lst[1]\\n else:\\n procedures.append(lst)\\n print(names)\\n #print(procedures)\\n\\n for proc in procedures:\\n\\n proc_elements_names = proc[0]\\n proc_name = proc[1]\\n\\n #print(proc_elements_names)\\n #print(proc_name)\\n\\n if proc_name == \\\"set_mode\\\":\\n mode_name = proc_elements_names[0]\\n if mode_name != \\\"draw-mode\\\": \\n c.set_mode(mode_name)\\n elif mode_name == \\\"draw-mode\\\":\\n l1 = line()\\n # draw mode is different from other modes\\n for element in names:\\n e = CompleteElement(element)\\n e.set_other_attrs(names[element])\\n e.process_other_attrs()\\n l1.addElement(e)\\n c.connectInSeries(l1)\\n c.set_mode(\\\"draw-mode\\\")\\n \\n \\n if proc_name == \\\"series\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n l = l1\\n c.connectInSeries(l)\\n #raise SyntaxError(\\\"Alias {0} referrenced before assignment\\\".format(item[0]))\\n\\n elif proc_name == \\\"parallel\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n c.connectInParallel(l1)\\n l1 = line()\\n\\n\\n elif proc_name == \\\"add_parallel\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n l1 = line()\\n l1.addElement(names[new_element])\\n c.connection.append(l1)\\n\\n\\n elif proc_name == \\\"add_series\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n for ln in c.connection:\\n for e in ln.elements:\\n if names[old_element] == e:\\n ln.addElement(names[new_element])\\n\\n\\n c.evaluate(\\\"output.png\\\")\\n #print(c)\",\n \"def load_model_and_test_composition(alg_name, tester, curriculum, num_times, new_task, show_print):\\n for n in range(num_times):\\n random.seed(n)\\n sess = tf.Session()\\n\\n curriculum.restart()\\n\\n # Initialize a policy_bank graph to be loaded with saved model\\n task_aux = Game(tester.get_task_params(curriculum.get_current_task()))\\n num_features = len(task_aux.get_features())\\n num_actions = len(task_aux.get_actions())\\n policy_bank = PolicyBankDQN(sess, num_actions, num_features,\\n tester.learning_params, tester.get_reward_machines())\\n\\n # Load the model\\n saver = tf.train.Saver()\\n\\n # Get path\\n if task_aux.params.game_type == \\\"craftworld\\\":\\n save_model_path = '../model/' + str(task_aux.params.game_type) + '/' + task_aux.game.get_map_id()\\n else:\\n save_model_path = '../model/' + str(task_aux.params.game_type)\\n\\n saver.restore(sess, tf.train.latest_checkpoint(save_model_path))\\n\\n reward_machines = tester.get_reward_machines()\\n print(\\\"Loaded {} policies (RMs)\\\".format(len(reward_machines)))\\n\\n # partial-ordered RM of new task\\n new_task_rm = RewardMachine(new_task.rm_file)\\n linearized_plans = new_task.get_linearized_plan()\\n print(\\\"There are {} possible linearized plans: {}\\\".format(len(linearized_plans), linearized_plans))\\n least_cost = float('inf')\\n best_policy = [] # list of (rm_id, state_id) corresponding to each action\\n\\n for i, curr_plan in enumerate(linearized_plans):\\n # Get the least cost path for the current linearized plan\\n # cost, switching_seq = search_policy(curr_plan, tester, curriculum, new_task_rm, reward_machines,\\n # policy_bank, bound=least_cost)\\n cost, switching_seq = dfs_search_policy(curr_plan, tester, curriculum, new_task_rm, reward_machines,\\n policy_bank, bound=least_cost)\\n if cost < least_cost:\\n print(cost, switching_seq)\\n least_cost = cost\\n best_policy = switching_seq\\n\\n # Execute the best policy\\n print(\\\"Executing Best Policy...{} ({} steps)\\\".format(best_policy, least_cost))\\n task = Game(tester.get_task_params(curriculum.get_current_task()))\\n new_task_u1 = new_task_rm.get_initial_state()\\n s1, s1_features = task.get_state_and_features()\\n r_total = 0\\n curr_policy = None\\n for t in range(int(least_cost)):\\n if show_print:\\n task.render()\\n if curr_policy is None:\\n curr_policy = best_policy.pop(0)\\n curr_policy_rm = reward_machines[curr_policy[0]]\\n\\n a = policy_bank.get_best_action(curr_policy[0], curr_policy[1],\\n s1_features.reshape((1, num_features)),\\n add_noise=False)\\n if show_print: print(\\\"Action:\\\", Actions(a))\\n task.execute_action(a)\\n\\n s2, s2_features = task.get_state_and_features()\\n new_task_u2 = new_task_rm.get_next_state(new_task_u1, task.get_true_propositions())\\n\\n curr_policy_u2 = curr_policy_rm.get_next_state(curr_policy[1], task.get_true_propositions())\\n desired_next_state = curr_policy_rm.get_next_state(curr_policy[1], curr_policy[2])\\n if curr_policy_u2 == desired_next_state:\\n logger.info(\\\"EXECUTED ACTION {}, SWITCHING POLICIES\\\".format(curr_policy[2]))\\n curr_policy = None\\n\\n r = new_task_rm.get_reward(new_task_u1, new_task_u2, s1, a, s2)\\n r_total += r * tester.learning_params.gamma ** t\\n\\n s1, s1_features = s2, s2_features\\n new_task_u1 = new_task_u2\\n if show_print:\\n task.render()\\n print(\\\"Rewards:\\\", r_total)\\n\\n return r_total\",\n \"def test_theories():\\n print(\\\"Executing test_theories:\\\")\\n increment_theory=[\\n (26,-1),\\n (13,1),\\n (14,),\\n (31,-1),\\n (30,),\\n (8,0),\\n (8,0),\\n (8,0)\\n ]\\n\\n repeat_increment_theory=[\\n (3,),\\n (33,0),\\n (4,)\\n ]\\n\\n repeat_increment_10_times_theory=[\\n (13,10),\\n (33,1)\\n ]\\n\\n sum_theory=[\\n (13,0),\\n (13,1),\\n (2,),\\n (8,0),\\n\\n (26,-1),\\n (31,-1),\\n (14,),\\n (8,1),\\n (8,1),\\n\\n (24,),\\n (4,),\\n \\n (8,0),\\n (30,)\\n ]\\n\\n print(\\\"increment_theory:\\\")\\n print(language.program_string(increment_theory))\\n\\n print(\\\"Running increment_theory on (True, [0, 0])\\\")\\n print(language.run_theory(0, [increment_theory], [], [(True, [0, 0])]))\\n print(\\\"\\\\n\\\")\\n\\n print(\\\"repeat_increment_theory:\\\")\\n print(language.program_string(repeat_increment_theory))\\n\\n print(\\\"repeat_increment_10_times_theory:\\\")\\n print(language.program_string(repeat_increment_10_times_theory))\\n\\n print(\\\"Running repeat_increment_10_times_theory on (True, [0, 0])\\\")\\n print(language.run_theory(0, [repeat_increment_10_times_theory], [increment_theory, repeat_increment_theory], [(True, [0, 0])]))\",\n \"def printGraph(self):\\n print \\\"-----\\\"\\n for feature in self.features:\\n feature.printFeature()\\n for constraint in self.constraints:\\n constraint.printConstraint()\\n print \\\"-----\\\"\",\n \"def main(test=False):\\n vocabulary = chainer.datasets.get_ptb_words_vocabulary()\\n freq_thresh = 0 ## ARBITRARY\\n word_freqs = FreqDist(ptb.words())\\n\\n if not os.path.isfile('parsers/grammar.pkl'):\\n\\n productions = []\\n add_dict = {}\\n\\n # use the entire treebank's parsed sentences to generate the CFG\\n for i, tree in enumerate(ptb.parsed_sents()):\\n\\n # is it a good idea to combine this with my preprocessing?\\n tree.collapse_unary(collapsePOS=False)\\n tree.chomsky_normal_form(horzMarkov=2)\\n\\n # preprocess all productions by removing all tags\\n these_productions = tree.productions()\\n for production in these_productions:\\n\\n # remove all tags from the LHS (only keep primary tag)\\n production._lhs = preprocess_nt(production._lhs)\\n\\n rhs = []\\n for item in production._rhs:\\n\\n # remove all tags from the Nonterminals on the RHS\\n if type(item) == nltk.grammar.Nonterminal:\\n rhs.append(preprocess_nt(item))\\n\\n # replace numbers with N\\n elif is_number(item):\\n rhs.append('N')\\n\\n # items not in dictionary replaced with <unk>\\n # dictionary requires lower\\n elif not is_key(vocabulary, item.lower()):\\n rhs.append('<unk>')\\n\\n # replace infrequent words with <unk>\\n elif word_freqs[item] < freq_thresh:\\n rhs.append('<unk>')\\n\\n # lowercase all entries in the grammar\\n else:\\n rhs.append(item.lower())\\n\\n production._rhs = tuple(rhs)\\n\\n if not is_key(add_dict, production.unicode_repr()):\\n add_dict[production.unicode_repr()] = True\\n productions.append(production)\\n\\n print('** {} productions found! **'.format(len(productions)))\\n grammar = induce_pcfg(Nonterminal('S'), productions)\\n\\n with open('parsers/grammar.pkl', 'wb') as f:\\n f.write(pickle.dumps(grammar))\\n\\n if not os.path.isfile('parsers/viterbi_parser.pkl'):\\n filename = open('parsers/grammar.pkl', 'rb')\\n grammar = pickle.load(filename)\\n viterbi_parser = ViterbiParser(grammar, trace=0) # cubic time\\n\\n with open('parsers/viterbi_parser.pkl', 'wb') as f:\\n f.write(pickle.dumps(viterbi_parser))\\n\\n if not os.path.isfile('parsers/shift_reduce_parser.pkl'):\\n filename = open('parsers/grammar.pkl', 'rb')\\n grammar = pickle.load(filename)\\n shift_reduce_parser = ShiftReduceParser(grammar, trace=0) # linear time\\n\\n with open('parsers/shift_reduce_parser.pkl', 'wb') as f:\\n f.write(pickle.dumps(shift_reduce_parser))\\n\\n with open('data/ptb.train.txt', 'r') as f:\\n data = f.readlines()\\n\\n if test:\\n for sample in [1, 23, 20330, 20332, 443]:\\n\\n t1 = time.time()\\n viterbi_parser.parse_one(data[sample].split())\\n t2 = time.time()\\n print('viterbi = {:.2f} sec for {} words'.format(\\n t2-t1, len(data[sample].split())))\\n\\n t1 = time.time()\\n shift_reduce_parser.parse_one(data[sample].split())\\n t2 = time.time()\\n print('shift reduce = {:.2f} sec for {} words'.format(\\n t2-t1, len(data[sample].split())))\",\n \"def regenerateTable():\\n deleteAll()\\n\\n # Start generating records from start nodes, and continue generating\\n # records for their children until either the bottom of the ANAD_PART_OF\\n # tree is reached, or stop nodes are reached.\\n\\n for perspective in Perspectives.Iterator():\\n perspectiveName = perspective.getName()\\n starts = PerspectiveAmbits.getStartAmbitForPerspective(perspectiveName)\\n stops = PerspectiveAmbits.getStopAmbitForPerspective(perspectiveName)\\n startNodeOids = sets.Set(starts.keys())\\n stopNodeOids = sets.Set(stops.keys())\\n \\n #print perspectiveName\\n #print startNodeOids\\n #print stopNodeOids\\n \\n startApos = [PartOfs.getPrimaryPathApoForNodeOid(nodeOid)\\n for nodeOid in startNodeOids]\\n apoList = startApos[:]\\n\\n while len(apoList) > 0:\\n partOf = apoList.pop()\\n\\n # create POP record for this part of.\\n \\n pop = AnadPartOfPerspectiveDb.AnadPartOfPerspectiveDbRecord()\\n pop.setPerspectiveName(perspectiveName)\\n pop.setApoOid(partOf.getOid())\\n pop.setIsAncestor(False)\\n pop.setNodeOid(partOf.getNodeOid())\\n pop.insert()\\n \\n #if partOf.getOid() == 68470:\\n # print \\n # print pop.getPerspectiveName()\\n # print pop.getApoOid()\\n # print pop.isAncestor()\\n # print pop.getNodeOid()\\n # print\\n # print partOf.getOid()\\n # print partOf.getSpecies()\\n # print partOf.getNodeStartStageOid()\\n # print partOf.getNodeEndStageOid()\\n # print partOf.getPathStartStageOid()\\n # print partOf.getPathEndStageOid()\\n # print partOf.getNodeOid()\\n # print partOf.getSequence()\\n # print partOf.getDepth()\\n # print partOf.getFullPathEmapas()\\n # print partOf.getFullPath()\\n # print partOf.isPrimaryPath()\\n # print partOf.getParentApoOid()\\n\\n _addToKnowledge(pop)\\n\\n # if this is not a stop node, then add all its part-of kids\\n # to the list of APOs to generate POP records for.\\n if partOf.getNodeOid() not in stopNodeOids:\\n apoList.extend(PartOfs.getByParentOid(partOf.getOid()))\\n\\n # for each start node, add any ancestor APOs that were not added\\n # by the above process.\\n ancesApos = sets.Set()\\n for apo in startApos:\\n parentApoOid = apo.getParentApoOid()\\n if parentApoOid != None:\\n parentApo = PartOfs.getByOid(parentApoOid)\\n if (_byApoOid.get(parentApoOid) == None or\\n _byApoOid[parentApoOid].get(perspectiveName) == None):\\n ancesApos.add(parentApo)\\n\\n while len(ancesApos) > 0:\\n ancesApo = ancesApos.pop()\\n # create POP record for this ancestor\\n pop = AnadPartOfPerspectiveDb.AnadPartOfPerspectiveDbRecord()\\n pop.setPerspectiveName(perspectiveName)\\n pop.setApoOid(ancesApo.getOid())\\n pop.setIsAncestor(True)\\n pop.setNodeOid(ancesApo.getNodeOid())\\n pop.insert()\\n _addToKnowledge(pop)\\n\\n # if this APO has a parent that hasn't yet been processed then\\n # add it to list of ancestor APOs to generate records for.\\n parentApoOid = ancesApo.getParentApoOid()\\n if (parentApoOid != None and\\n (_byApoOid.get(parentApoOid) == None or\\n _byApoOid[parentApoOid].get(perspectiveName) == None)):\\n parentApo = PartOfs.getByOid(parentApoOid)\\n ancesApos.add(parentApo)\\n \\n \\n \\n return\",\n \"def execute_print_chain(arg):\\n blockchain = Blockchain()\\n blockchain.read_blockchain()\\n blockchain.print_blocks()\",\n \"def main_loop(num_models, output, interaction_dict, verbose=False, max_chains=100, dirty=False,\\n stech_dict=False):\\n out_models = []\\n for i in range(1, num_models + 1):\\n print(\\\"Macrocomplex \\\" + str(i) + \\\" ...\\\")\\n macrocomplex = get_starting_model(interaction_dict, verbose).copy() # Selects a starting model\\n model_stech = generate_model_profile(macrocomplex) # Generates the stechometry of the first two chains\\n macrocomplex.id = \\\"Model_\\\" + str(i)\\n run = True # WHile this variable is true, the program will keep trying to add chains to the macrocomplex\\n num_of_chains = 2 # The model starts with 2 chains already\\n num_empty_chains = 0 # NUmber of chains that have all their interactions depleted\\n while run:\\n for chain in macrocomplex: # Iterates the macrocomplex chains\\n if num_of_chains < max_chains: # If the number of chains still hasn't reached the maximum allowed\\n if chain.interactions: # If this chain still has pending interactions\\n random.shuffle(chain.interactions) # Shuffle the interactions list (to avoid\\n # repetitive behaviour)\\n for inter_tple in chain.interactions:\\n if stech_dict: # If there is stechometry input (either as stirng or template pdb)\\n target_chain_id = interaction_dict[chain.id][inter_tple][1].id # chain to be added\\n model_stech.setdefault(target_chain_id, 0)\\n model_number_chain = model_stech[target_chain_id] # Get the number of repetitions\\n stech_dict.setdefault(target_chain_id, 0)\\n if stech_dict[target_chain_id] <= model_number_chain: # If the number of this target\\n # chain would surpass the stechemestry given, don't add the chain and\\n if verbose:\\n print(\\\"(S) Chain NOT added: interaction \\\" + chain.id + \\\": \\\" +\\n str(inter_tple[:1]) + \\\" ... \\\" + str(inter_tple[-1]) + \\\" to \\\" + target_chain_id)\\n continue # jump to the next interaction tuple\\n fix, to_move = interaction_dict[chain.id][inter_tple] # Get the interaction chain instances\\n sup = Bio.PDB.Superimposer() # Generates a superimposer instance\\n chain_atoms, fix_atoms = chain.get_common_atoms(fix) # Get common atoms between the\\n # macrocomplex chain and the one in the interaction dictionary\\n sup.set_atoms(chain_atoms, fix_atoms) # Generate the superposition\\n move = to_move.copy() # Make a copy of the chain to move\\n sup.apply(move) # Apply superposition matrix\\n move_atoms = sorted(move.get_atoms())\\n # Now it checks if the target chain has clashes with the model\\n if not has_clashes(move_atoms, macrocomplex): # If it hasn't\\n if verbose:\\n print(\\\"Chain \\\" + str(num_of_chains) + \\\" added: interaction \\\" + chain.id + \\\": \\\" +\\n str(inter_tple[0]) + \\\" ... \\\" + str(inter_tple[-1]) + \\\" to \\\" + move.id)\\n move.parent = None # Sets the parent to none to evade biopython's strict id policy\\n macrocomplex.add(move) # Adds the target chain to the model\\n model_stech.setdefault(move.id, 0) # Updates stech dict\\n model_stech[move.id] += 1\\n num_of_chains += 1\\n if dirty: # Generates a cif file for each step in the building of the model\\n macrocomplex.save_to_mmCIF(output + str(i) + \\\"_tmp_\\\" + str(num_of_chains))\\n elif verbose: # If it has don't add the target chain\\n print(\\\"Chain NOT added: interaction \\\" + chain.id + \\\": \\\" +\\n str(inter_tple[:1]) + \\\" ... \\\" + str(inter_tple[-1]) + \\\" to \\\" + move.id)\\n chain.interactions = False # Set the interaction attribute to 0, this chain now will be ignored\\n else:\\n if verbose:\\n print(\\\"Chain \\\" + chain.id + \\\" empty\\\")\\n num_empty_chains += 1\\n else:\\n run = False # When the maximum chain treshold is reached stop running\\n break\\n if num_empty_chains >= len(macrocomplex): # If all chains are empty of interactions stop running\\n run = False\\n if verbose:\\n stechometry_string = \\\"\\\" # Print the model's stechometry\\n for key in sorted(model_stech.keys()):\\n stechometry_string += key + \\\":\\\" + str(model_stech[key]) + \\\",\\\"\\n stechometry_string = stechometry_string[:-1]\\n print(\\\"Macrocomplex's\\\"+str(i)+\\\" Stoichiometry is: \\\"+stechometry_string)\\n print(\\\"Macrocomplex \\\" + str(i) + \\\" finished\\\")\\n out_models.append(macrocomplex) # Add model to the models list\\n return out_models\",\n \"def main():\\n data = read_data()\\n print('Part one solution: {}'.format(part_one(data)))\\n print('Part two solution: {}'.format(part_two(data)))\",\n \"def init_sequential_planning_program() -> str:\\n # We reason about the state of the world at particular time steps: [0, t_max]\\n seq_encoding = 'time(0..horizon).\\\\n'\\n\\n # Predicates evaluate to True or False\\n seq_encoding += 'boolean(true).\\\\n'\\n seq_encoding += 'boolean(false).\\\\n'\\n # The contains/2 atom captures this relationship\\n seq_encoding += 'contains(X, value(X, B)) :- predicate(X), boolean(B).\\\\n'\\n\\n # The initial state is at time t=0\\n # The holds/3 atom captures the value of a predicate at a particular timestep t >= 0\\n seq_encoding += 'holds(Predicate, Value, 0) :- initialState(Predicate, Value).\\\\n'\\n\\n # Closed World Assumption (CWA): Any ground atoms in the initial state which are not explicitly declared True\\n # are set to False\\n seq_encoding += 'initialState(X, value(X, false)) :- predicate(X), not initialState(X, value(X, true)).\\\\n'\\n\\n # The solution to the planning problem is extracted from occurs/2 atoms\\n # This is a sequential encoding: only one action may occur at a particular timestep\\n # Also, actions may only occur AFTER the initial state.\\n seq_encoding += '1 {occurs(Action, T) : action(Action)} 1 :- time(T), T > 0.\\\\n'\\n\\n # An action may not occur unless its preconditions are met (i.e., for an action to occur at time t,\\n # all applicable predicates must hold the values specified in the precondition at time t-1)\\n seq_encoding += (\\n ':- occurs(Action, T), precondition(Action, Predicate, Value), '\\n 'not holds(Predicate, Value, T - 1).\\\\n'\\n )\\n\\n # Capture the effects of an action: at time t, the value of a predicate is changed to the one specified in the\\n # action's effect as long as the action was valid (see previous statement).\\n seq_encoding += (\\n 'caused(Predicate, Value, T) :- '\\n 'occurs(Action, T), '\\n 'effect(Action, Predicate, Value), '\\n 'holds(PredicatePre, ValuePre, T - 1) : precondition(Action, PredicatePre, ValuePre).\\\\n'\\n )\\n\\n # A predicate is considered modified if its value was changed by an action\\n seq_encoding += 'modified(Predicate, T) :- caused(Predicate, Value, T).\\\\n'\\n\\n # The so-called 'inertia' statements. At a particular timestep, the value of a predicate was either:\\n # 1) Modified and therefore holds a new value\\n seq_encoding += 'holds(Predicate, Value, T) :- caused(Predicate, Value, T).\\\\n'\\n # 2) Was not modified and therefore continues to hold its previous value\\n seq_encoding += (\\n 'holds(predicate(V), Value, T) :- holds(predicate(V), Value, T - 1), '\\n 'not modified(predicate(V), T), time(T).\\\\n'\\n )\\n\\n # The goal is not met unless the appropriate predicates hold their goal values at the final timestep\\n seq_encoding += ':- goal(Predicate, Value), not holds(Predicate, Value, horizon).\\\\n'\\n\\n return seq_encoding\",\n \"def shannon_parry_markov_chain(self):\\n from sage.modules.free_module_element import vector\\n if not self.is_deterministic():\\n raise NotImplementedError(\\\"Automaton must be deterministic.\\\")\\n if not self.digraph().is_aperiodic():\\n raise NotImplementedError(\\\"Automaton must be aperiodic.\\\")\\n if not self.digraph().is_strongly_connected():\\n raise NotImplementedError(\\\"Automaton must be strongly connected.\\\")\\n if not all(s.is_final for s in self.iter_states()):\\n raise NotImplementedError(\\\"All states must be final.\\\")\\n from sage.rings.integer_ring import ZZ\\n M = self.adjacency_matrix().change_ring(ZZ)\\n states = {state: i for i, state in enumerate(self.iter_states())}\\n w_all = sorted(M.eigenvectors_right(),\\n key=lambda x: abs(x[0]),\\n reverse=True)\\n w = w_all[0][1][0]\\n mu = w_all[0][0]\\n u_all = sorted(M.eigenvectors_left(),\\n key=lambda x: abs(x[0]),\\n reverse=True)\\n u = u_all[0][1][0]\\n u = 1/(u*w) * u\\n final = vector(int(s.is_final) for s in self.iter_states())\\n ff = u*final\\n\\n assert u*w == 1\\n P = Transducer(initial_states=[s.label() for s in self.iter_initial_states()],\\n final_states=[s.label() for s in self.iter_final_states()],\\n on_duplicate_transition=duplicate_transition_add_input)\\n for t in self.iter_transitions():\\n P.add_transition(t.from_state.label(),\\n t.to_state.label(),\\n w[states[t.to_state]]/w[states[t.from_state]]/mu,\\n t.word_in)\\n for s in self.iter_states():\\n P.state(s.label()).color = 1/(w[states[s]] * ff)\\n P.state(s.label()).initial_probability = w[states[s]] * u[states[s]]\\n return P\",\n \"def prove_or_disprove(prop):\\n #create sequent\\n sequent = Sequent([],[prop])\\n #create proof tree\\n tree = ProofTree(sequent)\\n tree.build_proof()\\n #check leaves\\n found = True\\n seq_leaves = tree.get_leaves()\\n for s in seq_leaves:\\n if s.is_id() == False:\\n assign(prop, s)\\n found = False\\n break\\n if found == True:\\n print tree\",\n \"def generate_demonstration(start, policy, mdp):\\n demonstration = []\\n curr_state = start\\n #print('start',curr_state)\\n \\n while curr_state not in mdp.terminals:\\n #print('action',policy[curr_state])\\n demonstration.append((curr_state, policy[curr_state]))\\n curr_state = mdp.go(curr_state, policy[curr_state])\\n #print('next state', curr_state)\\n #append the terminal state\\n demonstration.append((curr_state, None))\\n return demonstration\",\n \"def exercise():\\n pi_good = get_pdb_inputs(pdb_str=pdb_str_answer, restraints=False)\\n map_data = get_map(xrs=pi_good.xrs)\\n xrs_good = pi_good.xrs.deep_copy_scatterers()\\n pi_good.ph.write_pdb_file(file_name=\\\"answer.pdb\\\",\\n crystal_symmetry=xrs_good.crystal_symmetry())\\n #\\n pi_poor = get_pdb_inputs(pdb_str=pdb_str_poor, restraints=True)\\n pi_poor.ph.write_pdb_file(file_name=\\\"poor.pdb\\\")\\n xrs_poor = pi_poor.xrs.deep_copy_scatterers()\\n #\\n d = xrs_good.distances(other=xrs_poor)\\n print(d.min_max_mean().as_tuple())\\n assert flex.max(d)>2\\n assert flex.mean(d)>0.7\\n #\\n xrs_refined = xrs_poor\\n for i in range(3):\\n ero = individual_sites.easy(\\n map_data = map_data,\\n xray_structure = xrs_refined,\\n pdb_hierarchy = pi_poor.ph,\\n geometry_restraints_manager = pi_poor.grm)\\n xrs_refined = ero.xray_structure\\n # comapre\\n d = xrs_good.distances(other=xrs_refined)\\n print(d.min_max_mean().as_tuple())\\n assert flex.max(d)<0.15\\n assert flex.mean(d)<0.03\\n ero.pdb_hierarchy.write_pdb_file(file_name=\\\"refined.pdb\\\",\\n crystal_symmetry=xrs_good.crystal_symmetry())\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--file', '-f', type=str, help='path to corpus file', default='./train')\\n args = parser.parse_args()\\n\\n corpus_reader = CorpusReader(args.file)\\n model = BigramModel(corpus_reader.sents())\\n\\n test_sentences = ['Suggestive, Watson, is it not?',\\n 'It is amazing that a family can be torn apart by something as simple as a pack of wild dogs!',\\n 'So spoke Sherlock Holmes and turned back to the great scrapbook in which he was arranging and indexing some of his recent material.',\\n 'What I like best about my friends is that they are few.',\\n 'Friends what is like are they about I best few my that.']\\n\\n # prints two paragraphs with each five sentences\\n for _ in range(2):\\n print(generate(model, 5) + '\\\\n')\\n\\n # for each sentence in the test_sentences print the perplexity\\n for sentence in test_sentences:\\n print(model.perplexity(nltk.word_tokenize(sentence)))\",\n \"def evaljointbayes(fname):\\n #read file and save lines to contents\\n contents = []\\n f = open(fname)\\n for line in f:\\n randomVar = line.rstrip().split()\\n if randomVar[0] != 'END':\\n contents.append(randomVar)\\n print \\\"1. Read file\\\", fname, \\\"successfully.\\\"\\n f.close()\\n \\n #count numbers of nodes and probabilities in each line\\n length = len(contents)\\n nodes, prob = [0] * length, [0] * length\\n table = [] #save all probabilities for each node \\n for num in range(0, length):\\n tableline = []\\n for i in contents[num]:\\n try:\\n j = float(i)\\n prob[num] += 1\\n tableline.append(j) \\n except ValueError:\\n if i != 'NONE':\\n nodes[num] += 1 \\n table.append(tableline) \\n \\n #print out the joint distribution formular\\n print \\\"2. The joint distribution using this network is:\\\"\\n nodelist = []\\n for line in contents:\\n nodelist.append(line[0])\\n print \\\"P(\\\", printElement(nodelist), \\\") = \\\"\\n for num in range(0, length):\\n line = contents[num]\\n if nodes[num] == 1:\\n print \\\"P(\\\", line[0], \\\")\\\", \\n else: \\n print \\\"P(\\\", line[0], '|', printElement(line[1:nodes[num]]),\\\\\\n \\\")\\\", \\n if num == length - 1:\\n print ' '\\n else: \\n print ' * ', \\n \\n #print out the full joint distribution table \\n###This is the revised version using recursive calls and###\\n###print out the cpt table to a .txt file###\\n #further revision includes deleting depth by pop() table, contents and nodes\\n #also, I can extract the parents in the previous step, then contents will not be used here\\n fo=open(fname+'.zz.txt','w')\\n result = 1.0\\n depth = 0\\n global additions, multiplications\\n additions, multiplications = 0, 0\\n fullCPT(nodelist, [], result, depth, fo, contents, table, nodes)\\n fo.close()\\n\\n #print out result of step 3 \\n print \\\"3. Additions and multiplications needed to calculate\\\",\\\\\\n \\\"the joint distribution is:\\\", additions, \\\"and\\\", multiplications\\n print \\\"The number of nodes in the network is: \\\", length\\n\\n #print out reselt of step 4\\n spaceFull = int(math.pow(2,length)) - 1\\n spaceBN = sum(prob)\\n print \\\"4. Space this network saved is (Compactness): \\\", spaceBN, \\\"/\\\", \\\\\\n spaceFull, \\\"=\\\", float(spaceBN) / float(spaceFull), '\\\\n'\\n return\",\n \"def main():\\n\\n # Generate the network from the given file, and get its original weight\\n matrix = generate_matrix('network.txt')\\n old_weight = total_weight(matrix)\\n\\n # Generate a network graph from the input network to be used in Prim's\\n # algorithm\\n graph = generate_network_graph(matrix)\\n\\n # Generate a minimum spanning tree from the network graph using Prim's\\n # algorithm\\n mst = prim(graph)\\n\\n print(f\\\"Old network weight: {old_weight}\\\")\\n print(f\\\"New network weight: {old_weight - sum(mst.values())}\\\")\",\n \"def proof_by_way_of_contradiction(proof: Proof, assumption: Formula,\\n print_as_proof_forms: bool = False) -> Proof:\\n assert proof.is_valid()\\n assert Schema(assumption) in proof.assumptions\\n assert proof.assumptions.issuperset(Prover.AXIOMS)\\n for line in proof.lines:\\n if isinstance(line, Proof.UGLine):\\n assert line.formula.variable not in assumption.free_variables()\\n # Task 11.2\",\n \"def main():\\r\\n\\timport sys\\r\\n\\r\\n\\tlistofSequences = FastAreader(sys.stdin).readFasta() \\r\\n\\tPAMSequences = PAMfinder(listofSequences).classController() # Calls on controller class to return desired models.\\r\\n\\tf = open('Guide Sequences.txt','w') \\r\\n\\tfor i in range(len(PAMSequences[0])):\\r\\n\\t\\tf.write(PAMSequences[0][i]) # Prints the header sequence into the file.\\r\\n\\t\\tf.write('\\\\n') \\r\\n\\t\\tprint(PAMSequences[0][i]) \\r\\n\\t\\tfor j in range(len(PAMSequences[1][i])): \\r\\n\\t\\t\\tif j == 0: \\r\\n\\t\\t\\t\\tf.write(\\\"Forward Strand PAM Sites:\\\") \\r\\n\\t\\t\\t\\tf.write('\\\\n')\\r\\n\\t\\t\\t\\tprint(\\\"Forward Strand PAM Sites:\\\") \\r\\n\\t\\t\\tprint(PAMSequences[1][i][j]) # Prints the forward sequences\\r\\n\\t\\t\\ty = str(PAMSequences[1][i][j]) # Changes from int to string characters.\\r\\n\\t\\t\\tx = ''.join(y) # Joining all the string values so we can print to file.\\r\\n\\t\\t\\tf.write(x) # Write the joined forward sequences to the file.\\r\\n\\t\\t\\tf.write('\\\\n')\\r\\n\\t\\tfor k in range(len(PAMSequences[2][i])): # For reverse sequences, and follows same logic as forward. \\r\\n\\t\\t\\tif k == 0:\\r\\n\\t\\t\\t\\tf.write(\\\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\\\")\\r\\n\\t\\t\\t\\tf.write('\\\\n')\\r\\n\\t\\t\\t\\tprint(\\\"Reverse Strand PAM Sites (in reference to the Top Strand Position):\\\")\\r\\n\\t\\t\\tprint(PAMSequences[2][i][k]) # Prints the reverse sequences with the corresponding positions. \\r\\n\\t\\t\\ta = str(PAMSequences[2][i][k]) # Changes the integer to string characters, allowing for the values to join.\\r\\n\\t\\t\\tb = ''.join(a)\\r\\n\\t\\t\\tf.write(b) # Write all of the reverse sequences onto the text file with their positions. \\r\\n\\t\\t\\tf.write('\\\\n')\\r\\n\\tf.close() # Close the file.\\r\",\n \"def main():\\n # Read input from file, returns all objects\\n objects = read_input()\\n for obj in objects:\\n try:\\n # Generate the objects answer, yields new object\\n obj = generate_answer(obj)\\n except Exception:\\n # If an error might occur that is not covered, catch it here! Continue where left off\\n print('ERROR: An unrecoverable error occured during the processing of ' + obj.get(\\n 'operation') + '. Continuing...')\\n obj['answer'] = 'ERROR'\\n\\n print(obj) # TODO: Remove before production\\n # Generate an output file\\n print_output(objects)\",\n \"def CreateDecisionMdp(self):\\n print(\\\"Creating MDP\\\")\\n self.states = {}\\n self.actions = {}\\n self.rewards = []\\n stateNodes = map(lambda x:x.name,\\\\\\n filter(lambda x: x.type not in [\\\"ActionNode\\\",\\\"MotorNode\\\"],self.nodes.values()) )\\n actionNodes = map(lambda x:x.name,\\\\\\n filter(lambda x: x.type is \\\"ActionNode\\\",self.nodes.values()))\\n self.states = sorted(list(stateNodes))\\n self.actions = sorted(list(actionNodes))\\n if(len(self.states) < 2 or len(self.actions) < 1):\\n print(\\\"Error: States and actions must be non-empty\\\")\\n\\n # Transition probabilities\\n self.P = []\\n self.hasPredictions = False\\n for n in range(0,len(self.actions)):\\n actionNode = self.nodes[self.actions[n]]\\n b = []\\n for state1 in range(0,len(self.states)):\\n a = []\\n for state2 in range(0,len(self.states)):\\n if(actionNode.predictions.has_key(self.states[state2])):\\n a.append(actionNode.predictions[self.states[state2]])\\n hasPredictions = True\\n else: a.append(0.0)\\n b.append(a)\\n self.P.append(b)\\n # Rewards matrix\\n self.R = []\\n for i in (range(0,len(self.actions))):\\n b = []\\n for j in (range(0,len(self.states))):\\n a = []\\n for k in (range(0,len(self.states))):\\n key = (self.states[j],self.actions[i],self.states[k])\\n if self.expectedRewards.has_key(key):\\n a.append(self.expectedRewards[key])\\n else: a.append(0.0)\\n b.append(a)\\n self.R.append(b)\\n\\n if self.hasPredictions:\\n print(\\\"Number of states: \\\" + str(len(self.states)))\\n print(\\\"Number of actions: \\\" + str(len(self.actions)))\\n print(np.array(self.R))\\n self.vi = mdptoolbox.mdp.QLearning(np.array(self.P), np.array(self.R), self.discountFactor)\\n self.vi.run()\\n else:\\n print(\\\"MDP not created. No prediction values available.\\\")\",\n \"def create_proof_and_forkproof(self, mainblocks, fork_index, forkblocks):\\n\\n # Initial blockchain\\n header = None\\n header_map = None\\n interlink_map = None\\n blockchain_name = self.proof_dir() + \\\"blockchain_\\\" + str(mainblocks) + \\\".pkl\\\"\\n try:\\n open(blockchain_name)\\n header, header_map, interlink_map = blockchain_utils.load_blockchain(\\n blockchain_name\\n )\\n except Exception:\\n (header, header_map, interlink_map) = blockchain_utils.create_blockchain(\\n blocks=mainblocks\\n )\\n blockchain_utils.save_blockchain(\\n blockchain_name, header, header_map, interlink_map\\n )\\n # Initial proof\\n proof = []\\n proof_name = self.make_proof_filename(mainblocks)\\n proof = blockchain_utils.make_proof(header, header_map, interlink_map)\\n\\n # Fork blockchain\\n fork_header = None\\n fork_header_map = None\\n fork_interlink_map = None\\n f_header = header\\n fork_blockchain_name = (\\n self.proof_dir()\\n + \\\"blockchain_\\\"\\n + str(mainblocks)\\n + \\\"-\\\"\\n + str(fork_index)\\n + \\\"+\\\"\\n + str(forkblocks)\\n + \\\".pkl\\\"\\n )\\n\\n # TODO: Chech if the fork blockchain can be exported as well\\n (\\n fork_header,\\n fork_header_map,\\n fork_interlink_map,\\n ) = blockchain_utils.create_fork(\\n f_header,\\n header_map.copy(),\\n interlink_map.copy(),\\n fork=fork_index,\\n blocks=forkblocks,\\n )\\n blockchain_utils.save_blockchain(\\n fork_blockchain_name, fork_header, fork_header_map, fork_interlink_map\\n )\\n\\n # Fork proof\\n fork_proof = []\\n fork_proof_name = self.make_fork_proof_filename(\\n mainblocks, fork_index, forkblocks\\n )\\n fork_proof = blockchain_utils.make_proof(\\n fork_header, fork_header_map, fork_interlink_map\\n )\\n\\n fixed_fork_proof, lca = self.truncate_fork_proof(proof, fork_proof)\\n self.export_proof(fixed_fork_proof, fork_proof_name)\\n\\n return (\\n proof_name,\\n fork_proof_name,\\n lca,\\n fork_header,\\n fork_header_map,\\n fork_interlink_map,\\n )\",\n \"def make_chains(input_text, n):\\n\\n # contents = open_and_read_file(sys.argv[1])\\n\\n chains = {}\\n\\n words = input_text.split()\\n\\n for i in range(len(words) - 2):\\n a, b = words[i], words[i+1]\\n pair = (a, b,)\\n\\n if pair in chains:\\n chains[pair] += [words[i+2]]\\n else:\\n chains[pair] = [words[i+2]]\\n # if chains.get(pair, False):\\n # c = words[i + 2]\\n # chains[pair].append(c)\\n # # how can we have an empty list as a value and not reset?\\n # else:\\n # c = words[i + 2]\\n # chains[pair] = []\\n # chains[pair].append(c)\\n\\n # print \\\"C equals: \\\", c\\n # chains[pair].append(c)\\n # else add \\\"\\\" to dictionary\\n return chains\",\n \"def simplex(params, out_prefix = None, yule=True, n_model = 5, n_seqgen=5,\\n JC=False, alphabet='nuc_nogap', alpha=1.0, rate_alpha=1.5, W_dirichlet_alpha=2.0):\\n from Bio import AlignIO\\n # generate a model\\n T = betatree(params['n'], alpha=2.0)\\n T.yule=yule\\n T.coalesce()\\n # ladderize the tree and name internal nodes via loading into TreeAnc\\n T.BioTree.ladderize()\\n tt = TreeAnc(tree=T.BioTree)\\n if out_prefix:\\n Phylo.write(tt.tree, tree_name(out_prefix, params), 'newick')\\n\\n for mi in range(n_model):\\n params['model']=mi\\n if JC:\\n myGTR = GTR_site_specific.random(L=params['L'], alphabet=alphabet,\\n pi_dirichlet_alpha=False, W_dirichlet_alpha=False, mu_gamma_alpha=rate_alpha)\\n else:\\n myGTR = GTR_site_specific.random(L=params['L'], alphabet=alphabet, pi_dirichlet_alpha = alpha,\\n mu_gamma_alpha=rate_alpha, W_dirichlet_alpha=W_dirichlet_alpha)\\n\\n myGTR.mu*=params['m']\\n\\n if out_prefix:\\n save_model(myGTR, model_name(out_prefix, params))\\n\\n for si in range(n_seqgen):\\n params['seqgen']=si\\n # generate sequences\\n mySeq = SeqGen(params['L'], gtr=myGTR, tree=T.BioTree)\\n mySeq.evolve()\\n\\n if out_prefix:\\n save_mutation_count(mySeq, mutation_count_name(out_prefix, params))\\n with open(alignment_name_raw(out_prefix, params), 'wt') as fh:\\n AlignIO.write(mySeq.get_aln(), fh, 'fasta')\\n reconstruct_tree(out_prefix, params, aa='aa' in alphabet)\\n os.system('gzip '+alignment_name_raw(out_prefix, params))\",\n \"def main():\\n parser = create_argument_parser(\\n \\\"generate a wheel spinning loose on an axle\\\",\\n default_gravity=[0, -9.81, 0])\\n parser.add_argument(\\\"--num-links\\\",\\n type=int,\\n default=11,\\n help=\\\"number of links in the chain\\\")\\n args = parser.parse_args()\\n\\n if args.out_path is None:\\n directory = pathlib.Path(__file__).resolve().parents[1] / \\\"fixtures\\\"\\n args.out_path = directory / \\\"chain-cross-section.json\\\"\\n args.out_path.parent.mkdir(parents=True, exist_ok=True)\\n\\n print_args(args)\\n\\n fixture = generate_fixture(args)\\n\\n save_fixture(fixture, args.out_path)\",\n \"def print_seq(self):\\n names, values = [], []\\n for each in self.minions:\\n names.append(each.name)\\n values.append(f'{each.atk}/{each.dfs}')\\n t = PrettyTable()\\n t.add_row(names)\\n t.add_row(values)\\n print(t)\",\n \"def makeTrainingExamples(trace):\\n current = SimpleBrep()\\n spec = trace[-1][1]\\n examples = []\\n for command, new_state in trace + [(\\\"RETURN\\\",spec)]:\\n state = Object.extract(current, False) + Object.extract(spec, True)\\n def horizontalPointer(x):\\n try:\\n x = float(x)\\n pi = None\\n for objectIndex, o in enumerate(state):\\n if o.isVertex and o.p[0] == x or \\\\\\n o.isLine and o.isVertical and o.p1[0] == x:\\n pi = objectIndex\\n break\\n if pi is None:\\n print(\\\"FATAL\\\")\\n print(x)\\n print(state)\\n assert pi is not None\\n return Pointer(pi)\\n except (ValueError, TypeError): return x\\n def verticalPointer(y):\\n try:\\n y = float(y)\\n pi = None\\n for objectIndex, o in enumerate(state):\\n if o.isVertex and o.p[1] == y or \\\\\\n o.isLine and o.isHorizontal and o.p1[1] == y:\\n pi = objectIndex\\n break\\n if pi is None:\\n print(\\\"FATAL\\\")\\n print(y)\\n print(state)\\n assert pi is not None\\n return Pointer(pi)\\n except (ValueError, TypeError): return y\\n\\n tokens = command.split(\\\" \\\")\\n if tokens[0] == \\\"RETURN\\\":\\n command = [\\\"RETURN\\\"]\\n elif tokens[0] == \\\"translation\\\":\\n command = tokens[1:]\\n command = [ token if token[0] not in ['n','l'] else \\\\\\n Pointer([pi for pi,obj in enumerate(state) \\\\\\n if obj.name == token and not obj.spec][0]) \\n for token in command ]\\n command = [\\\"translation\\\"] + command\\n else:\\n command = tokens[1:]\\n # convert the command into a list of symbols and pointers\\n # First convert pointers\\n command = [ token if token[0] not in ['n','l'] else \\\\\\n Pointer([pi for pi,obj in enumerate(state) if obj.name == token][0]) \\n for token in command ]\\n if tokens[0][0] == 'n': # vertex\\n command[0] = horizontalPointer(command[0])\\n command[1] = verticalPointer(command[1])\\n elif tokens[0][0] == 'l':\\n pass # lines never use absolute coordinates\\n else:\\n assert False\\n command = [tokens[0][0]] + command\\n\\n examples.append((state, command))\\n current = new_state\\n if False:\\n print(trace)\\n print(\\\"EXAMPLES\\\")\\n for state, command in examples:\\n print(\\\"in the state\\\",state)\\n print(\\\"execute\\\",command)\\n \\n return examples\",\n \"def build_proof(self):\\n if not self.root.is_atomic():\\n l = apply_rule(self.root)\\n self.left_subtree = ProofTree(l[0])\\n if l[1] != None:\\n self.right_subtree = ProofTree(l[1]) \\n if self.left_subtree is not None:\\n self.rule = l[2]\\n left_tree= ProofTree(self.left_subtree.build_proof())\\n if self.right_subtree is not None:\\n self.rule = l[2]\\n right_tree = ProofTree(self.right_subtree.build_proof())\",\n \"def SolveAndPrint(self, model, decisions, constraints, solver_type):\\n\\t\\ttry:\\n\\t\\t\\tresult_status = model.Solve()\\n\\t\\t\\tassert result_status == pywraplp.Solver.OPTIMAL #The problem has an optimal solution\\n\\t\\t\\tassert model.VerifySolution(1e-7, True)\\n\\t\\t\\tprint (\\\"Success\\\")\\n\\n\\t\\texcept AssertionError:\\n\\t\\t\\tresult_status = 3\\n\\t\\t\\tprint('linear problem is not sovable/infeasible for %s method'%(solver_type))\\n\\t\\t\\ttkMessageBox.showerror('infeasible', message='Problem is infeasible, no x* node for %s'%(solver_type))\\n\\t\\t\\tif solver_type == 'clp':\\n\\t\\t\\t\\treturn self.optimization_problem(2,\\n\\t\\t\\t\\t\\t\\t\\t\\t self.variables,\\n\\t\\t\\t\\t\\t\\t\\t\\t self.constraints,\\n\\t\\t\\t\\t\\t\\t\\t\\t self.type,\\n\\t\\t\\t\\t\\t\\t\\t\\t self.objective,\\n\\t\\t\\t\\t\\t\\t\\t\\t 'glop')\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\tprint('an error has occured, please review data')\\n\\t\\t\\t\\ttkMessageBox.showerror('an error has occured, please review data')\\n\\t\\t\\t\\treturn\\t\\n\\n\\t\\tfinally:\\n\\t\\t\\tpass\\n\\n\\t\\t######## SOLUTION IS OPTIMAL ######\\n\\t\\tself.root = Toplevel()\\n\\t\\tmenubar = Menu(self.root)\\n\\t\\ttext=Text(self.root)\\n\\t\\n\\t\\tfilemenu=Menu(menubar, tearoff=0)\\n\\t\\tfilemenu.add_command(label=\\\"Save As...\\\", \\n\\t\\t\\t\\t\\tcommand=(lambda text=text: file_save(text)), \\n\\t\\t\\t\\t\\taccelerator=\\\"Ctrl+Shift+S\\\")\\n\\n\\t\\tfilemenu.add_command(label=\\\"Reload Module\\\", \\n\\t\\t\\t\\t\\tcommand=(lambda: reload(simplex_class)), \\n\\t\\t\\t\\t\\taccelerator=\\\"Ctrl+T\\\")\\n\\n\\t\\tfilemenu.add_command(label=\\\"Close\\\", \\n\\t\\t\\t\\t\\tcommand=(lambda: checkwork(self.root, text)), \\n\\t\\t\\t\\t\\taccelerator=\\\"Ctrl+w\\\") #come back to this\\n\\t\\tfilemenu.add_separator()\\n\\t\\tfilemenu.add_command(label=\\\"Exit\\\", command=(lambda: checkwork(self.root, text)))\\n\\n\\t\\tmenubar.add_cascade(label=\\\"File\\\", menu=filemenu)\\n\\n\\t\\thelpmenu = Menu(menubar, tearoff=0)\\n\\t\\thelpmenu.add_command(label=\\\"Help\\\", command=donothing) #come back to this\\n\\n\\n\\t\\t################### STATS ########################\\n\\t\\ttext.insert(END, \\\"\\\\n ___%s___ \\\\n\\\" %(self.title.upper()))\\n\\n\\t\\ttext.insert(END, \\\"\\\\nsolve output = %s\\\"%(result_status))\\n\\t\\tprint(\\\"\\\\n\\\\nsolve output = %d\\\"%(result_status))\\n\\n\\t\\ttext.insert(END, \\n\\t\\t\\t\\t\\\"\\\\nNumber of variables = %d\\\\n\\\"%(model.NumVariables()))\\n\\n\\t\\tprint (\\\"Number of variables = %d\\\"%(model.NumVariables()))\\n\\t\\tprint (\\\"Number of constraints = %d\\\"%(model.NumConstraints()))\\n\\n\\t\\ttext.insert(END, \\\"\\\\nNumber of constraints = %d\\\\n\\\"%(model.NumConstraints()))\\n\\t\\t\\n\\n\\t\\ttext.insert(END, \\\"\\\\nProblem solved in %f ms \\\\n\\\"%(model.wall_time()))\\n\\n\\t\\tprint (\\\"\\\\nProblem solved in %f milliseconds \\\\n\\\" %(model.wall_time()))\\n\\n\\t\\ttext.insert(END, \\\"\\\\nOptimal objective value = %f \\\\n\\\" %(model.Objective().Value())) #The objective value of the solution `no reduced costs`\\n\\t\\tprint (\\\"\\\\nOptimal objective value = %f\\\\n\\\" %(model.Objective().Value()))\\n\\n\\t\\tfor variable in decisions:\\n\\t\\t\\ttext.insert(END, \\\"\\\\n%s = %f\\\\n\\\"%(variable.name(), variable.solution_value()))\\n\\t\\t\\tprint (\\\"%s = %f\\\" %(variable.name(), variable.solution_value()))\\n\\n\\t\\ttext.insert(END, \\\"\\\\n \\\\nAdvanced Stats: \\\\n\\\")\\n\\t\\tprint (\\\"\\\\n \\\\nAdvanced Stats: \\\\n\\\")\\n\\t\\ttext.insert(END, \\\"\\\\n \\\\nProblem Solved in %d iterations\\\"%model.iterations())\\n\\t\\tprint (\\\"\\\\n \\\\n Problem solved in %d iterations\\\" %model.iterations())\\n\\n\\t\\tfor variable in decisions:\\n\\t\\t\\ttext.insert(END, \\\"\\\\n \\\\n%s: reduced cost = %f\\\" %(variable.name(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\tvariable.reduced_cost()))\\n\\t\\t\\tprint (\\\"%s: reduced cost = %f\\\" %(variable.name(), variable.reduced_cost()))\\n\\n\\t\\tactivities = model.ComputeConstraintActivities() #printout of RHS = `b` in AX = b\\n\\n\\t\\tfor i, constraint in enumerate(constraints):\\n\\t\\t\\ttext.insert(END, \\n\\t\\t\\t\\t\\\"\\\\n\\\\nconstraint %s: \\\\ndual value = %f\\\\n activity=%f\\\" %(constraint.name(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.dual_value(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tactivities[constraint.index()]))\\n\\n\\t\\t\\tprint (\\\"constraint %s: dual value = %f\\\\nactivity=%f\\\" %(constraint.name(), \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconstraint.dual_value(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tactivities[constraint.index()]))\\n\\t\\t\\ttext.insert(END, \\n\\t\\t\\t\\t\\t\\\"\\\\nLower to Upper Boundary:\\\\n \\\\t %f < %.2d < %f\\\" %(constraint.Lb(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t activities[constraint.index()],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t constraint.Ub()))\\n\\n\\t\\t\\tprint (\\\"\\\\nLower.....to.....Upper Boundary:\\\\n\\\\t %f < %.2d < %f\\\" %(constraint.Lb(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t activities[constraint.index()],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t constraint.Ub()))\\n\\n\\t\\t\\tprint(\\\"\\\\nSLACK/SURPLUS status:\\\\n\\\\t %s\\\"%(constraint.basis_status()))\\n\\n\\t\\t\\ttext.insert(END,\\n\\t\\t\\t\\t\\t\\\"\\\\nSLACK/SURPLUS status:\\\\n\\\\t %s\\\"%(constraint.basis_status()))\\n\\t\\ttext.config(state=DISABLED)\\n\\t\\ttext.pack()\\n\\t\\tself.root.config(menu=menubar)\",\n \"def test_4():\\n h = iotbx.pdb.input(source_info=None, lines=test_pdb_4).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 main (cmd):\\n#################################################################\\n#step 1: generate common block list report from block list folder\\n#################################################################\\n#step 2: folder read learning list\\n\\trecord_sequences = sequence_pattern_mining.multi_file_folder_sequence_learning_list_read(cmd)\\n\\tresult = sequence_pattern_mining.multi_file_sequence_prior_matrix_gen (record_sequences)\\n\\tprior_matrix = result[0]\\n\\tdone_block_name_list = result[1]\\n\\tprint \\\"block total number\\\"\\n\\tprint len (done_block_name_list)\\n\\n\\t#done block name list contains all block names we need to ananlyze\\n\\t#left_candidate_list = sequence_pattern_mining.generate_critical_path(done_block_name_list, prior_matrix)\\n\\ttotal_result = sequence_pattern_mining.topology_path_find(done_block_name_list, prior_matrix)\\n\\tprint record_sequences[3]\\n\\tsequence_pattern_mining.sub_path_list_verify_2 (total_result , record_sequences[3])\\n\\t\\t\\n\\n\\t\\\"\\\"\\\"\\n\\tfor sub_list in total_result:\\n\\t\\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[0])\\n\\t\\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[1])\\n\\t\\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[2])\\n\\t\\tsequence_pattern_mining.sub_path_list_verify_2 (sub_list , record_sequences[3])\\n\\t\\\"\\\"\\\"\\n\\n\\t\\n\\t\\\"\\\"\\\"\\n\\tstatus_matrix = sequence_pattern_mining.gen_status_matrix_based_on_prior_matrix(done_block_name_list, prior_matrix)\\n\\t\\n\\tdone_block_name_list = ['block_106','block_75', 'block_22', 'block_72', 'block_73' ]\\n\\tsub_path_list = sequence_pattern_mining.find_sub_path (done_block_name_list, status_matrix, prior_matrix)\\n\\tprint sub_path_list\\n\\t\\n\\tdone_block_name_list = ['block_106','block_75', 'block_22', 'block_73', 'block_72' ]\\n\\tsub_path_list = sequence_pattern_mining.find_sub_path (done_block_name_list, status_matrix, prior_matrix)\\n\\tprint sub_path_list\\n\\t\\n\\tgrowing_pattern = [ 'block_22', 'block_73', 'block_75','block_106']\\n\\tinsert_pos = sequence_pattern_mining.search_sub_block_insert_into_growing_pattern_position_1 (growing_pattern, \\\"block_72\\\", status_matrix)\\n\\tprint insert_pos\\n\\tnew_list = list(growing_pattern)\\n\\tnew_list.insert(insert_pos, \\\"block_72\\\")\\n\\tprint new_list\\n\\t\\n\\tgrowing_pattern = [ 'block_22', 'block_72', 'block_75','block_106']\\t\\n\\tinsert_pos = sequence_pattern_mining.search_sub_block_insert_into_growing_pattern_position_1 (growing_pattern, \\\"block_73\\\", status_matrix)\\n\\tprint insert_pos\\n\\tnew_list = list(growing_pattern)\\n\\tnew_list.insert(insert_pos, \\\"block_73\\\")\\n\\tprint new_list\\n\\t\\\"\\\"\\\"\",\n \"def logic_program_form(self):\\r\\n s = ''\\r\\n for x in self.new_sorts:\\r\\n s = s + 'dom(' + x + ').\\\\nis_a(' + x + ', nodes).\\\\n' \\r\\n for y in self.supersorts:\\r\\n s = s + 'link(' + x + ', ' + y + ').\\\\n'\\r\\n return s\",\n \"def test_BuildModel3(self):\\n print(\\\"\\\\nTest 7: Building a more complicated Model\\\")\\n builder = StaticBuilder(\\\"BreakIt\\\")\\n in1 = builder.addInput(10)\\n in2 = builder.addInput(20)\\n enc1 = builder.addInner(3)\\n enc2 = builder.addInner(5, num_islots=2)\\n out1 = builder.addOutput()\\n out2 = builder.addOutput()\\n \\n builder.addDirectedLink(in1, enc1)\\n builder.addDirectedLink(in2, enc2, islot=0)\\n builder.addDirectedLink(enc1, enc2, islot=1)\\n builder.addDirectedLink(enc1, out1)\\n builder.addDirectedLink(enc2, out2)\\n \\n builder.build()\",\n \"def test_markov_word_chain_builder():\\n input_sequence = (\\n 'PIKARD', 'Q', 'PIKARD', 'DORF', 'PIKARD', 'Q', 'ROKER', 'Q', 'PIKARD'\\n )\\n expected_probabilities = {\\n 'PIKARD': [('Q', 2.0 / 3), ('DORF', 1.0 / 3)],\\n 'Q': [('PIKARD', 2.0 / 3), ('ROKER', 1.0 / 3)],\\n 'DORF': [('PIKARD', 1.0)],\\n 'ROKER': [('Q', 1.0)],\\n }\\n builder = markov.WordChainBuilder()\\n for word in input_sequence:\\n builder.add_next(word)\\n chain = builder.normalize()\\n\\n for leader, probs in expected_probabilities.items():\\n assert leader in chain\\n assert sort_probs(probs) == sort_probs(chain[leader])\",\n \"def generate_problems(ctx):\\n\\timport random\\n\\timport subprocess\\n\\toutput_folder = \\\"problems\\\"\\n\\tproblem_type = 'octdiff'\\n\\tcommand = \\\"./plas.py\\\"\\n\\tnvals = 10\\n\\tmin_val = 1\\n\\tmax_val = 100\\n\\tmut_chance = 1/8\\n\\tinc_chance = 0.9\\n\\tnvars_list = [2, 3, 5, 10, 15, 20]\\n\\toutput_format = \\\"{}-problem-@n-@s.@t.plas\\\"\\n\\ttotals_per_mode = [(25, 0, 0), (25, inc_chance, 0), (25, 0, mut_chance), (25, inc_chance, mut_chance)] # No mutation, only removal, only mutation, removal + mutation\\n\\tabs_totals = 0\\n\\t\\n\\tfor x in totals_per_mode:\\n\\t\\tabs_totals += x[0]\\n\\tproblems_node = ctx.path.make_node(output_folder)\\n\\tproblems_node.delete()\\n\\tproblems_node.mkdir()\\n\\n\\tfor nvars in nvars_list:\\n\\t\\tnvars_name = \\\"%dv\\\" % nvars\\n\\t\\tnvars_node = problems_node.make_node(nvars_name)\\n\\t\\tnvars_node.mkdir()\\n\\t\\tnumber_seed = int(random.uniform(1, 2**32 - 1)) # int(random.uniform(1, 2 ** (2 ** 6) + 1) % sys.maxsize)\\n\\t\\tremove_seed = int(random.uniform(1, 2**32 - 1)) # int(random.uniform(1, 2 ** (2 ** 6) + 1) % sys.maxsize)\\n\\t\\tmutate_seed = int(random.uniform(1, 2**32 - 1)) # int(random.uniform(1, 2 ** (2 ** 6) + 1) % sys.maxsize)\\n\\t\\tcount = 1\\n\\t\\tfor totals_idx in range(len(totals_per_mode)):\\n\\t\\t\\ttotals = totals_per_mode[totals_idx][0]\\n\\t\\t\\ttotals_inc_chance = totals_per_mode[totals_idx][1]\\n\\t\\t\\ttotals_mut_chance = totals_per_mode[totals_idx][2]\\n\\t\\t\\tcmdline = [command,\\n\\t\\t\\t\\t\\\"gen\\\",\\n\\t\\t\\t\\t\\\"--problem-type=%s\\\" % problem_type,\\n\\t\\t\\t\\t\\\"--nvars=%d\\\" % nvars,\\n\\t\\t\\t\\t\\\"--nvals=%d\\\" % nvals,\\n\\t\\t\\t\\t\\\"--min=%g\\\" % min_val,\\n\\t\\t\\t\\t\\\"--max=%g\\\" % max_val,\\n\\t\\t\\t\\t\\\"--nproblems=%d\\\" % totals,\\n\\t\\t\\t\\t\\\"--nproblems-startnum=%d\\\" % count,\\n\\t\\t\\t\\t\\\"--nproblems-total=%d\\\" % abs_totals,\\n\\t\\t\\t\\t\\\"--output=%s\\\" % (nvars_node.abspath() + \\\"/\\\" + output_format.format(nvars_name)),\\n\\t\\t\\t\\t\\\"--seed=%d\\\" % number_seed,\\n\\t\\t\\t\\t\\\"--mutation-seed=%d\\\" % mutate_seed,\\n\\t\\t\\t\\t\\\"--inclusion-seed=%d\\\" % remove_seed,\\n\\t\\t\\t\\t\\\"--mutation-chance=%g\\\" % totals_mut_chance,\\n\\t\\t\\t\\t\\\"--inclusion-chance=%g\\\" % totals_inc_chance,\\n\\t\\t\\t]\\n\\t\\t\\tprint(\\\"Generating problems: \\\\\\\"%s\\\\\\\"\\\" % (\\\" \\\".join(cmdline)) )\\n\\t\\t\\tresult = subprocess.call(cmdline)\\n\\t\\t\\tif result:\\n\\t\\t\\t\\tprint(\\\"ERROR while generating previous command! Exit code: %d\\\" % result)\\n\\t\\t\\tcount += totals\",\n \"def asp_problem(choices: TextIO, rules: TextIO = None, positives: TextIO = None, main: Union[str, TextIO] = '', outf: TextIO = None):\\n if outf is None:\\n outf = sys.stdout\\n\\n def asp_section(name):\\n print('\\\\n' + ('%' * 30) + '\\\\n%%%% ' + name + '\\\\n', file=outf)\\n\\n def asp_comment(txt: str):\\n print(ASPenc.comment(txt), file=outf)\\n\\n actions = set()\\n asp_section('Choices')\\n asp_comment('constraints in choices are in all possible constraints')\\n print(ASPenc.rule(ASPenc.all_constraintsp('C'), [ASPenc.choicep('_', 'C')]), file=outf)\\n outf.write('\\\\n')\\n choices2asp(choices, actions, out=outf)\\n\\n if positives is not None:\\n asp_section('Positive')\\n asp_comment('positive constraints holds by assumption')\\n print(ASPenc.rule(ASPenc.holdsp('C'), [ASPenc.fixedp('C')]), file=outf)\\n outf.write('\\\\n')\\n asp_comment('positive constraints constraints in choices are in all possible constraints')\\n print(ASPenc.rule(ASPenc.all_constraintsp('C'), [ASPenc.fixedp('C')]), file=outf)\\n constraints2asp(positives, actions, outf=outf)\\n outf.write('\\\\n')\\n\\n asp_section('Actions')\\n for a in actions:\\n print(ASPenc.all_actionsp(ASPenc.const(a)) + '.', file=outf)\\n\\n asp_section('Declare rules')\\n asp_comment(f'selected constraints holds')\\n print(ASPenc.rule(ASPenc.holdsp('C'), [ASPenc.selectedp('C')]), file=outf)\\n outf.write('\\\\n')\\n if rules is not None:\\n rules2asp(rules, outf=outf)\\n\\n asp_section('Constraints structure')\\n max_arity = 3\\n for i in range(1, max_arity+1):\\n asp_comment(f'Constraints of arity {i}')\\n avars = [f'A{j}' for j in range(1, i+1)]\\n rhead = ASPenc.constraint_namep('C', 'P', i)\\n rbody = [\\n ASPenc.all_constraintsp('C'),\\n 'C = ' + ASPenc.constraint('P', avars, quote=False),\\n ]\\n print(ASPenc.rule(rhead, rbody), file=outf)\\n for j in range(i):\\n rhead = ASPenc.constraint_actionp('C', avars[j])\\n print(ASPenc.rule(rhead, rbody), file=outf)\\n\\n asp_section('Main')\\n if isinstance(main, str):\\n outf.write(main)\\n else:\\n outf.write(main.read())\\n\\n asp_comment('print selected constraints')\\n print(r'#show ${predicate_selected}/1.', file=outf)\",\n \"def prover9(assume_list, goal_list, mace_seconds=2, prover_seconds=60,\\n domain_cardinality=None, one=False, options=[], noniso=True, hints_list=None, keep_list=None, \\n delete_list=None):\\n fh = open('tmp.in','w')\\n for st in options:\\n fh.write(st+'.\\\\n')\\n fh.write('formulas(assumptions).\\\\n')\\n for st in assume_list:\\n fh.write(st+'.\\\\n')\\n fh.write('end_of_list.\\\\nformulas(goals).\\\\n')\\n for st in goal_list:\\n fh.write(st+'.\\\\n')\\n fh.write('end_of_list.\\\\n')\\n fh.close()\\n\\n if mace_seconds!=0:\\n mace_params = ''\\n if domain_cardinality != None:\\n st = str(domain_cardinality)\\n mace_params = ' -n '+st+' -N '+st+('' if one else ' -m -1')+' -S 1' #set skolem_last\\n res = os.system(uapth+'mace4 -t '+str(mace_seconds)+mace_params+' -f tmp.in >tmp.out 2>tmpe')\\n fh = open('tmp.out')\\n out_str = fh.read()\\n fh.close()\\n ind = out_str.find(\\\"%%ERROR\\\")\\n if ind != -1: \\n print out_str[ind+2:]\\n return\\n if out_str.find('Exiting with failure') == -1:\\n if domain_cardinality != None and not one and noniso:\\n os.system(uapth+'interpformat standard -f tmp.out | '+uapth+'isofilter '+\\n 'check \\\\\\\"+ * v ^ \\\\' - ~ \\\\\\\\ / -> B C D E F G H I J K P Q R S T U V W b c d e f g h i j k p q r s t 0 1 <= -<\\\\\\\" '+\\n 'output \\\\\\\"+ * v ^ \\\\' - ~ \\\\\\\\ / -> B C D E F G H I J K P Q R S T U V W b c d e f g h i j k p q r s t 0 1 <= -<\\\\\\\" | '+\\n uapth+'interpformat portable >tmpe')\\n else:\\n os.system(uapth+'interpformat portable -f tmp.out >tmpe')\\n fh = open('tmpe')\\n out_str = fh.read()\\n fh.close()\\n if out_str!=\\\"\\\":\\n li = eval(out_str.replace(\\\"\\\\\\\\\\\",\\\"\\\\\\\\\\\\\\\\\\\"))\\n else:\\n print \\\"No models found (so far)\\\"\\n return\\n models = []\\n for m in li:\\n models += [Model(m[0],len(models),getops(m[2],'function'),getops(m[2],'relation'))]\\n if domain_cardinality != None and not one:\\n print \\\"Number of \\\"+(\\\"nonisomorphic \\\" if noniso else \\\"\\\")+ \\\"models of cardinality\\\", domain_cardinality, \\\" is \\\", len(models)\\n #else: print \\\"(Counter)example of minimal cardinality:\\\"\\n return models\\n elif domain_cardinality != None and out_str.find('exit (exhausted)') != -1:\\n if not one: print 'No model of cardinality '+str(domain_cardinality)\\n return []\\n\\n res = os.system(uapth+'prover9 -t '+str(prover_seconds)+' -f tmp.in >tmp.out 2>tmpe')\\n fh = open('tmp.out')\\n out_str = fh.read()\\n fh.close()\\n ind = out_str.find(\\\"%%ERROR\\\")\\n if ind != -1: \\n print out_str[ind+2:]\\n return\\n if True:#res==0 or res==1 or res==256: \\n os.system(uapth+'prooftrans expand renumber parents_only -f tmp.out >tmpe')\\n fh = open('tmpe')\\n out_str = fh.read()\\n fh.close()\\n lst = []\\n ind1 = out_str.find(\\\"PROOF ===\\\")\\n ind2 = out_str.find(\\\"end of proof ===\\\")\\n while ind1 != -1:\\n lst.append([proofstep2list(x) for x in out_str[ind1:ind2].split('\\\\n')[10:-2]])\\n ind1 = out_str.find(\\\"PROOF ===\\\",ind2)\\n ind2 = out_str.find(\\\"end of proof ===\\\",ind2+1)\\n return [Proof(li) for li in lst]\\n print 'No conclusion (timeout)'\\n return 'No conclusion (timeout)'\",\n \"def print_generations(start, n):\\n pb(start)\\n for c in range(n):\\n print(\\\"---\\\")\\n start = life_generation(start)\\n pb(start)\\n return start\",\n \"def alg(self):\\n\\n # Find freq ordering of vars and initialize lowest level mdps\\n self.mdps[0] = set()\\n self.freq, self.state_dim = self.find_freq()\\n\\n # Build the task hierarchy\\n for level in range(self.state_dim):\\n # Randomly execute actions from level and fill MDP properties (trans prob, adj, etc)\\n self.explore(level=level, exploration_iterations=self.args.exploration_iterations)\\n # Using MDP properties, find exits, MERs, and form MDPs at level+1\\n self.create_sub_mdps(level+1)\\n # Train a policy to reach every exit in the MDPs at level+1\\n self.train_sub_mdps(self.mdps[level+1])\\n\\n # Serialize the MDPs\\n with open(self.args.binary_file, 'wb') as handle:\\n pickle.dump(self.mdps, handle, protocol=pickle.HIGHEST_PROTOCOL)\\n handle.close()\\n\\n self.log[self.args.log_name].info(\\\"Finished pickling MDPs, saved at {}!\\\\n\\\".format(self.args.binary_file))\",\n \"def pre_flight(self):\\n\\n def check_already_chain():\\n \\\"\\\"\\\"In case a user runs the command twice on the same input\\\"\\\"\\\"\\n all_are_already_rigids = True\\n for transform, _ in self._pairs:\\n if not transform.shape(type=\\\"rdRigid\\\"):\\n all_are_already_rigids = False\\n break\\n\\n assert not all_are_already_rigids, (\\n \\\"Every transform is already dynamic\\\"\\n )\\n\\n def check_hierarchy():\\n \\\"\\\"\\\"Ensure incoming chain reflects a physical hierarchy\\n\\n For example, this is what a valid selection looks like,\\n including a non-selected offset group that is still part\\n of the hierarchy.\\n\\n o- clavicle\\n |-o upperArm\\n |-o lowerArm\\n |-o ( offsetGroup )\\n |-o hand\\n\\n \\\"\\\"\\\"\\n\\n pairs = self._pairs[:]\\n while pairs:\\n transform, _ = pairs.pop()\\n expected_parent, _ = pairs[-1] if pairs else (None, None)\\n\\n if not expected_parent:\\n break\\n\\n # Walk up the hierarchy until you find what\\n # is supposed to be the parent.\\n #\\n # .\\n # |--o a /|\\\\\\n # |--o B |\\n # |--o c |\\n # |--o d |\\n # |\\n #\\n valid = False\\n for parent in transform.lineage():\\n if parent == expected_parent:\\n valid = True\\n break\\n\\n problem = (\\n \\\"%s was not a parent of %s\\\" % (\\n expected_parent, transform)\\n )\\n\\n # Ok, so the prior link isn't a parent, but we\\n # also must make it isn't a child of the subsequent\\n # link, as that would mean a cycle\\n #\\n # |\\n # |--o a |\\n # |--o B |\\n # |--o c |\\n # |--o d |\\n # \\\\ /\\n # `\\n if not valid:\\n is_child = False\\n for child in transform.descendents():\\n if child == expected_parent:\\n is_child = True\\n break\\n\\n # It's valid if the Maya parent isn't a Ragdoll child\\n valid = not is_child\\n\\n # This flips the problem on its head\\n problem = (\\n \\\"%s cannot be a child of %s, that's a cycle\\\" % (\\n expected_parent, transform)\\n )\\n\\n assert valid, problem\\n\\n def pre_cache():\\n \\\"\\\"\\\"Pre-cache attributes to avoid needless evaluation\\\"\\\"\\\"\\n for transform, _ in self._pairs:\\n world_matrix = transform[\\\"worldMatrix\\\"][0].asMatrix()\\n parent_matrix = transform[\\\"parentMatrix\\\"][0].asMatrix()\\n matrix = transform[\\\"matrix\\\"].asMatrix()\\n translate = transform[\\\"translate\\\"].as_vector()\\n rotate = transform[\\\"rotate\\\"].as_euler()\\n\\n if \\\"jointOrient\\\" in transform:\\n joint_orient = transform[\\\"jointOrient\\\"].as_quaternion()\\n else:\\n # Only joints have these\\n joint_orient = cmdx.Quaternion()\\n\\n self._cache[(transform, \\\"worldMatrix\\\")] = world_matrix\\n self._cache[(transform, \\\"parentMatrix\\\")] = parent_matrix\\n self._cache[(transform, \\\"matrix\\\")] = matrix\\n self._cache[(transform, \\\"translate\\\")] = translate\\n self._cache[(transform, \\\"rotate\\\")] = rotate\\n self._cache[(transform, \\\"jointOrient\\\")] = joint_orient\\n\\n def remember_existing_inputs():\\n # Remember existing animation\\n for transform, _ in self._pairs:\\n transform.data[\\\"priorConnections\\\"] = {}\\n for channel in (\\\"translate\\\", \\\"rotate\\\"):\\n for axis in \\\"XYZ\\\":\\n src = transform[channel + axis]\\n src = src.connection(plug=True, destination=False)\\n\\n if src is not None:\\n anim = transform.data[\\\"priorConnections\\\"]\\n dst = \\\"in%s%s1\\\" % (channel.title(), axis)\\n anim[src] = dst\\n\\n check_already_chain()\\n check_hierarchy()\\n remember_existing_inputs()\\n pre_cache()\\n\\n return True\",\n \"def main():\\n n, m = map(int, raw_input().split(' '))\\n knowledge = []\\n for i in xrange(n):\\n knowledge.append(raw_input())\\n print '\\\\n'.join(map(str, acm_icpc_team(knowledge)))\",\n \"def main():\\n\\n N, k = map(int, sys.stdin.readline().split())\\n initial_state = tuple( map(int, sys.stdin.readline().split()) )\\n final_state = tuple( map(int, sys.stdin.readline().split()) )\\n\\n init_path = [initial_state]\\n all_paths = [init_path]\\n\\n visited_states = set()\\n visited_states.add(initial_state)\\n\\n while all_paths:\\n popped_path = all_paths.pop(0)\\n current_state = popped_path[-1]\\n\\n if current_state == final_state:\\n solution = popped_path\\n break\\n\\n for state, action in generate_moves(current_state, N, k).items():\\n if state not in visited_states:\\n visited_states.add(state)\\n new_path = popped_path + [action,state]\\n all_paths.append(new_path)\\n\\n display_solution(solution)\",\n \"def main():\\n target = 'Coding:Level1'\\n output_root = f'problem_5_output/{target.replace(\\\":\\\", \\\"_\\\")}'\\n if not os.path.exists(output_root):\\n os.makedirs(output_root, exist_ok=True)\\n\\n # dictionary of parameter grids, one for each process\\n param_grids = {\\n 'early_stopping': ParameterGrid([\\n {\\n 'patience': [15], # , 20, 40]\\n },\\n ]),\\n 'fit': ParameterGrid([\\n {\\n 'batch_size': [128], # , 64, 128, 256],\\n 'epochs': [16], # 20, 50],\\n },\\n ]),\\n 'model_preprocessor': ParameterGrid([\\n {\\n 'num_unique_words': [5000], # 4000, 1000, 6000, 10000],\\n 'max_sequence_length': [150], # 50, 75, 100, 125, 150, 200],\\n },\\n ]),\\n 'model': ParameterGrid([\\n # {\\n # Dense single hidden layer model hyperparameters:\\n # 'name': ['dense_h1'],\\n # 'embedded_dims': [8], # , 16, 32, 64, 128, 256],\\n # 'num_units_h1': [8], # , 16, 32, 64, 128, 256],\\n # 'drop_h1': [None], # , 0.1, 0.2, 0.25, 0.5, 0.75],\\n # 'optimizer': ['nadam', 'adam'],\\n # 'learning_rate': [None], # , 0.01, 0.001],\\n # 'activation': ['relu', 'tanh'],\\n # },\\n # {\\n # Dense double hidden layer model hyperparameters:\\n # 'name': ['dense_h2'],\\n # 'embedded_dims': [64],\\n # 'num_units_h1': [128],\\n # 'num_units_h2': [128],\\n # 'drop_h1': [None],\\n # 'drop_h2': [0.5],\\n # 'optimizer': ['nadam'],\\n # 'activation': ['relu'],\\n # 'learning_rate': [0.01],\\n # },\\n # {\\n # CNN single hidden layer model hyperparameters\\n # 'name': ['conv_h1'],\\n # 'embedded_dims': [64],\\n # 'num_units_h1': [32], # , 64, 256],\\n # 'k_conv_h1': [2], # , 3, 4],\\n # 'drop_embed': [0.2], # , 0.5],\\n # 'activation': ['relu', 'tanh'],\\n # 'optimizer': ['adam', 'nadam']\\n # },\\n # {\\n # CNN double hidden layer model hyperparameters\\n # 'name': ['conv_h2'],\\n # 'embedded_dims': [128], # , 64, 32, 16, 8],\\n # 'num_units_h1': [32], # , 64, 128],\\n # 'drop_h2': [0.5], # , 0.75, 0.25, 0.1],\\n # 'k_conv_h1': [2], # , 3, 4],\\n # 'num_units_h2': [128], # , 64, 32, 16, 8],\\n # 'drop_embed': [0.2], # , 0.50],\\n # 'activation': ['relu'],\\n # 'optimizer': ['adam'], # , 'nadam'],\\n # },\\n # {\\n # CNN double hidden layer model hyperparameters\\n # 'name': ['conv_h2.1'],\\n # 'embedded_dims': [64],\\n # 'num_units_h1': [32], # , 64, 128],\\n # 'k_conv_h1': [2], # , 3, 4],\\n # 'drop_embed': [0.2], # , 0.5],\\n # 'activation': ['relu'],\\n # 'optimizer': ['adam'], # , 'nadam']\\n # },\\n # {\\n # RNN single hidden layer model hyperparameters\\n # 'name': ['rnn_h1'],\\n # 'embedded_dims': [64],\\n # 'drop_embed': [0.2],\\n # 'num_units_h1': [128],\\n # 'optimizer': ['nadam'],\\n # 'learning_rate': [0.01]\\n # },\\n # {\\n # # LSTM double hidden layer (second layer dense FC) model hyperparameters\\n # 'name': ['lstm_h1'],\\n # 'embedded_dims': [64],\\n # 'drop_embed': [0.2],\\n # 'drop_h1': [0.5],\\n # 'num_units_h1': [128],\\n # 'optimizer': ['nadam'],\\n # },\\n # {\\n # LSTM double hidden layer (second layer dense FC) model hyperparameters\\n # 'name': ['lstm_h2'],\\n # 'embedded_dims': [64],\\n # 'drop_embed': [0.2],\\n # 'num_units_h1': [128],\\n # 'drop_h1': [0.5],\\n # 'num_units_h2': [128],\\n # 'optimizer': ['nadam'],\\n # 'activation': ['relu']\\n # },\\n # {\\n # # Bi-directional LSTM single hidden layer model hyperparameters\\n # 'name': ['bi_lstm_h1'],\\n # 'embedded_dims': [32], # , 64, 128],\\n # 'drop_embed': [0.2], # , 0.25, 0.5],\\n # 'num_units_h1': [32], # , 64, 128],\\n # 'drop_h1': [0.2], # , 0.25, 0.5],\\n # 'optimizer': ['nadam', 'adam']\\n # },\\n # {\\n # Bi-directional LSTM double hidden layer (second layer Bi-LSTM) model hyperparameters\\n # 'name': ['bi_lstm_h2'],\\n # 'embedded_dims': [32], # , 64, 128],\\n # 'num_units_h1': [32], # , 64, 128],\\n # 'num_units_h2': [32], # , 64, 128],\\n # 'drop_h1': [0.25, 0.5],\\n # 'drop_h2': [0.25, 0.5],\\n # 'optimizer': ['nadam', 'adam']\\n # },\\n {\\n # Multi Convolutional model hyperparameters\\n 'name': ['multi_conv_h3_s2'],\\n 'drop_embed': [0.5], # , 0.3],\\n 'embedded_dims': [128], # , 64, 128, 256],\\n 'num_units_h1': [128], # , 64, 128, 256],\\n 'num_units_h2': [128], # , 64, 128, 256],\\n 'num_units_h3': [128], # , 64, 128, 256],\\n 'num_units_h4': [128], # , 64, 128, 256],\\n 'k_conv_h1': [3],\\n 'k_conv_h2': [2],\\n 'activation': ['relu'], # , 'tanh'],\\n 'drop_h3': [0.2], # , 0.2, 0.25, 0.5, 0.75],\\n 'optimizer': ['adam'], # 'nadam']\\n },\\n # {\\n # # Multi Convolutional model hyperparameters\\n # 'name': ['multi_conv_h3_s3'],\\n # 'drop_embed': [0.5], # , 0.3],\\n # 'embedded_dims': [32], # , 64, 128, 256],\\n # 'num_units_h1': [32], # , 64, 128, 256],\\n # 'num_units_h2': [32], # , 64, 128, 256],\\n # 'num_units_h3': [32], # , 64, 128, 256],\\n # 'num_units_h4': [32], # , 64, 128, 256],\\n # 'k_conv_h1': [3],\\n # 'k_conv_h2': [2],\\n # 'k_conv_h3': [4],\\n # 'k_conv_h4': [4],\\n # 'activation': ['relu', 'tanh'],\\n # 'drop_h4': [0.1], # , 0.2, 0.25, 0.5, 0.75],\\n # 'optimizer': ['adam', 'nadam']\\n # },\\n ]),\\n 'preprocessor': ParameterGrid([\\n # {\\n # 'do_clean': [False],\\n # 'pad_type': ['pre', 'post'],\\n # 'trunc_type': ['pre', 'post'],\\n # },\\n {\\n 'do_clean': [True],\\n 'pad_type': ['post'], # , 'post'],\\n 'trunc_type': ['post'], # 'post'],\\n 'omit_stopwords': [False],\\n 'ignore_urls': [False],\\n 'fix_contractions': [True],\\n 'stem': [True],\\n 'remove_foreign_characters': [False], # , False],\\n 'lower': [True], # , False],\\n 'remove_punctuation': [True], # , False],\\n 'bigrams': [True], # , False]\\n },\\n ])\\n }\\n\\n def prod(a):\\n if len(a) == 0:\\n return 1\\n return a[0] * prod(a[1:])\\n\\n num_models = prod([len(pg) for pg in param_grids.values()])\\n\\n param_grid_names = sorted(list(param_grids.keys()))\\n param_grid_list = [param_grids[k] for k in param_grid_names]\\n\\n all_params, best_params = assemble_results(output_root)\\n\\n if CHECK_ONLY:\\n for i, params in enumerate(itertools.product(*param_grid_list[3:5])):\\n params = {k: v for k, v in zip(param_grid_names[3:5], params)}\\n print(i, params)\\n Preprocessor(**params['preprocessor'], **params['model_preprocessor'])\\n\\n for i, params in enumerate(itertools.product(*param_grid_list[2:4])):\\n params = {k: v for k, v in zip(param_grid_names[2:4], params)}\\n print(i, params)\\n build_fn(num_classes=3, **params['model'], **params['model_preprocessor'])\\n return\\n\\n for i, params in enumerate(itertools.product(*param_grid_list)):\\n mem = psutil.virtual_memory()\\n percent_used = 1 - mem.available / mem.total\\n print(f'{percent_used:.2%} memory used')\\n if percent_used > 0.80:\\n # exit failure\\n print('Exiting (-1)')\\n exit(-1)\\n\\n params = {k: v for k, v in zip(param_grid_names, params)}\\n print(f'\\\\n{i + 1}/{num_models}: {params}\\\\n')\\n\\n if params in all_params:\\n # skip this one because we already ran it.\\n continue\\n\\n if best_params is not None:\\n # print best performance so far\\n print(f'best params: {best_params}')\\n print(f'best val loss: {best_params[\\\"results\\\"][\\\"valid\\\"][\\\"loss\\\"]:.6f}')\\n print(f'best val acc: {best_params[\\\"results\\\"][\\\"valid\\\"][\\\"accuracy\\\"]:.4%}')\\n\\n # create a new output directory with path to model file.\\n date = datetime.datetime.utcnow().strftime(\\\"%Y-%m-%d-%H.%M.%S.%f\\\")\\n output_dir = os.path.join(output_root, date)\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n model_file = os.path.join(output_dir, 'model.h5')\\n\\n # get the preprocessed training and validation data\\n preprocess_time = time.time()\\n classes, data_sets, set_names = get_xy(Preprocessor(**params['preprocessor'], **params['model_preprocessor']),\\n target=target)\\n ((x_train, y_train), (x_valid, y_valid)) = data_sets\\n preprocess_time -= time.time()\\n\\n # build and compile model\\n model = build_fn(num_classes=len(classes), **params['model'], **params['model_preprocessor'])\\n\\n # setup callbacks\\n early_stopping = EarlyStopping(monitor='val_loss', verbose=1, **params['early_stopping'])\\n model_checkpoint = ModelCheckpoint(\\n filepath=model_file,\\n save_weights_only=False, save_freq='epoch',\\n save_best_only=True, monitor='val_loss', verbose=1)\\n callbacks = [early_stopping, model_checkpoint]\\n\\n # Use sample weights to treat classes equally in loss and accuracy.\\n sample_weight = get_sample_weight(y_train)\\n sample_weight_valid = get_sample_weight(y_valid)\\n\\n # fit the model\\n train_time = time.time()\\n model.fit(x=x_train, y=y_train, sample_weight=sample_weight, verbose=1,\\n validation_data=(x_valid, y_valid, sample_weight_valid), callbacks=callbacks, **params['fit'])\\n train_time -= time.time()\\n\\n # load the best model (last one saved)\\n model = load_model(model_file, compile=True)\\n\\n # compute results\\n results = get_performance(model, data_sets, set_names)\\n results['time'] = {'train': train_time, 'preprocess': preprocess_time}\\n\\n print(pd.DataFrame(data=results).T)\\n params['results'] = results\\n\\n # save params and results\\n with open(os.path.join(output_dir, 'params.json'), 'w') as fp:\\n json.dump(params, fp)\\n\\n # save a copy of *this* Python file.\\n shutil.copyfile(__file__, os.path.join(output_dir, 'roatan.py'))\\n\\n # for convenience, show the validation loss and accuracy in a file name in the same directory.\\n result_file_name = f'{params[\\\"results\\\"][\\\"valid\\\"][\\\"loss\\\"]:.6f}_{params[\\\"results\\\"][\\\"valid\\\"][\\\"accuracy\\\"]:.4f}.out'\\n with open(os.path.join(output_dir, result_file_name), 'w'):\\n pass\\n\\n # check_model(output_dir)\\n\\n if best_params is None or (params['results']['valid']['loss'] < best_params['results']['valid']['loss']):\\n best_params = params\\n\\n # assemble results from all runs into one CSV file in output root.\\n assemble_results(output_root)\",\n \"def reveal(self):\\n if not all([self.u, self.P, self.P2, self.s, self.e]):\\n raise PoDLEError(\\\"Cannot generate proof, data is missing\\\")\\n if not self.commitment:\\n self.get_commitment()\\n Phex, P2hex, shex, ehex, commit = [\\n safe_hexlify(x) for x in [self.P.serialize(),\\n self.P2.serialize(),\\n self.s, self.e, self.commitment]]\\n return {'used': str(self.used), 'utxo': self.u, 'P': Phex, 'P2': P2hex,\\n 'commit': commit, 'sig': shex, 'e': ehex}\",\n \"def make_text(chains):\\n key = choice(list(chains.keys()))\\n\\n words = []\\n\\n while key in chains:\\n word = get_new_word(key, chains)\\n words.append(word)\\n key = get_new_key(key, word)\\n\\n return \\\" \\\".join(words)\",\n \"def __init__(self, lines=[], people=[], name=''):\\n\\n self.name=repr(name)\\n self.relable=defaultdict(str)\\n self.people=set(people + self.keys())\\n self.new_names=list(set(people)-set(self.keys())) #New People being added.\\n self.process_lines(lines)\\n self.concepts=set(self.relable.keys())\\n# have to store all concepts and then check for each concept (before adding it to a causal graph) if it already exists in the set or not; if it exists, I find the representative label with which it is labelled in the first causal graph to which it was added. Also, this set of concepts is the raw material of the data set of concepts wherein 3000 or so concepts that are identical in meaning are paired by hand and then a machiene learning algorithm will be trained on the training set (the first x paired concepts) to learn which concepts are in meaning identical. Later, the causal-belief-graphs will be simplified, using this tool. The concepts are also stored in each node, under the key \\\"concept\\\". The greatest advantage of using networkx is that all kinds of information, including affective information, can be stored in each link and each concept, making these cognitive maps greatly extendable beyond the causal!\\n\\n for name in self.new_names:\\n self[name]=CausalGraph()\",\n \"def print_details():\\n\\n print('\\\\n'\\n 'SCORE: {0}\\\\n'\\n 'COMPLEXITY: {1}\\\\n'\\n .format(pwd_score, pwd_complex))\\n\\n print('Password as list: {0}\\\\n'.format(pwd_list))\\n print('ns calculations: {0}\\\\n'.format(ns))\\n print('Scores calculations: {0}\\\\n'.format(scores))\\n print('Entropy: {0}\\\\n'.format(entropy))\\n\\n # store string lengths for table\\n plength = {\\n 'counts': 0,\\n 'scores': 0,\\n 'heading': 0\\n }\\n # loop value dicts to get lengths for table\\n for k, v in ns.items():\\n if len(str(v)) > plength['counts']:\\n plength['counts'] = len(str(v))\\n for k, v in scores.items():\\n if len(str(v)) > plength['scores']:\\n plength['scores'] = len(str(v))\\n for k, v in stext.items():\\n if len(v) > plength['heading']:\\n plength['heading'] = len(v)\\n\\n # print table heading\\n # t00, t11, t22 calculate indentation\\n t00 = int(((plength['heading'] + 2 - 6) / 2)) * ' '\\n t11 = int(((plength['counts'] + 1) / 2)) * ' '\\n t22 = int(((plength['scores'] + 1) / 2)) * ' '\\n print('{0}Metric{0}{1}Count{1}{2}Bonus'.format(t00, t11, t22))\\n\\n # print table content\\n for k, v in stext.items():\\n # get description\\n t0 = stext[k]\\n # indent count\\n t1 = (plength['heading'] + plength['counts'] - len(stext[k]) - len(\\n str(ns[k])) + 5) * ' '\\n # get count\\n t2 = ns[k]\\n # indent score\\n t3 = (plength['scores'] - len(str(scores[k])) + 5) * ' '\\n # get score\\n t4 = scores[k]\\n print('{0}{1}{2}{3}{4}'.format(t0, t1, t2, t3, t4))\",\n \"def proofs(df):\\n proofs_df = df.dropna()\\n proofs_ids = proofs_df['proof_id'].unique()\\n\\n for proof_id in proofs_ids:\\n ctx = proofs_df[proofs_df['proof_id'] == proof_id]\\n proof = df[df['proof_id'] == proof_id]\\n\\n start_token, proof_token, end_token = \\\\\\n (ctx[ctx['proof_context'] == x].iloc[0] for x in (\\n 'goal',\\n 'enter',\\n 'leave'\\n ))\\n\\n ids = [int(x['token_id']) for x in (\\n start_token,\\n proof_token,\\n end_token\\n )]\\n\\n definition = proof[\\n [x >= ids[0] and x < ids[1] for x in proof['token_id']]\\n ]\\n demonstration = proof[\\n [x >= ids[1] and x < ids[2] for x in proof['token_id']]\\n ]\\n yield proof_id, definition, demonstration\",\n \"def main():\\n with open(sys.argv[1], 'r') as test_cases:\\n\\n # Initialize possible pairs, pairs, and social graph Graph\\n possible_pairs = set()\\n pairs = set()\\n social_graph = Graph()\\n\\n # Find true pairs of sender, recipient and vice versa for graph\\n for test in test_cases:\\n # Parse line into sender, recipient\\n parsed_line = test.rstrip().split('\\\\t')\\n sender, recipient = parsed_line[1], parsed_line[2]\\n\\n # Determine which sender, recipient reciprocal pairs exist\\n # Candidates are tested against possible pairs\\n # True pairs are stored in pairs\\n if (recipient, sender) in possible_pairs:\\n pairs.add(frozenset({x for x in (sender, recipient)}))\\n else:\\n possible_pairs.add((sender, recipient))\\n\\n # From pairs, add to social graph\\n for pair in pairs:\\n u, v = pair\\n social_graph.add_pair(u, v)\\n\\n # Compute maximal cliques of size >= 3 only\\n max_cliques_gt_3 = [\\n clique\\n for clique in social_graph.max_cliques()\\n if len(clique) >= 3]\\n\\n # Sort maximal cliques, ascending, and pretty print\\n for cluster in sorted(map(\\n lambda x: \\\", \\\".join(sorted(x)),\\n max_cliques_gt_3)):\\n print cluster\",\n \"def main() -> None:\\n with open(f'{os.path.dirname(__file__)}/input.txt', 'r') as input_file:\\n for solution in solve(input_file):\\n print(solution)\",\n \"def main() -> None:\\n with open(f'{os.path.dirname(__file__)}/input.txt', 'r') as input_file:\\n for solution in solve(input_file):\\n print(solution)\",\n \"def main() -> None:\\n with open(f'{os.path.dirname(__file__)}/input.txt', 'r') as input_file:\\n for solution in solve(input_file):\\n print(solution)\",\n \"def generate_trajectories():\\n\\n setup_timestamp_logging()\\n\\n logger = logging.getLogger()\\n\\n substance = Substance.from_components('C(C(C(C(C(F)(F)Br)(F)F)(F)F)(F)F)(C(C(C(F)(F)F)(F)F)(F)F)(F)F')\\n\\n logger.info('Building system.')\\n\\n build_system = BuildSmirnoffSystem('build_system')\\n build_system.coordinate_file_path = 'coords.pdb'\\n build_system.substance = substance\\n build_system.force_field_path = 'smirnoff99Frosst-1.1.0.offxml'\\n build_system.execute('', None)\\n\\n logger.info('System built.')\\n\\n production_simulation = RunOpenMMSimulation(f'production_simulation')\\n production_simulation.steps_per_iteration = 500\\n production_simulation.output_frequency = 1\\n production_simulation.timestep = 2.0 * unit.femtosecond\\n production_simulation.thermodynamic_state = ThermodynamicState(temperature=298.15*unit.kelvin,\\n pressure=1.0*unit.atmosphere)\\n production_simulation.input_coordinate_file = 'coords.pdb'\\n production_simulation.system_path = 'system.xml'\\n\\n compute_resources = ComputeResources(number_of_threads=4)\\n\\n logger.info(f'Simulation started.')\\n production_simulation_schema = production_simulation.schema\\n production_simulation.execute('', compute_resources)\\n production_simulation.schema = production_simulation_schema\\n logger.info(f'Simulation finished.')\",\n \"def launch(self):\\n out_log, err_log = fu.get_logs(path=self.path, mutation=self.mut, step=self.step)\\n if self.mutation is not None:\\n # Read structure with Biopython\\n parser = PDBParser(PERMISSIVE=1)\\n st = parser.get_structure('s', self.input_pdb_path) # s random id never used\\n\\n # Remove the side chain of the AA to be mutated\\n if self.mutation['chain']!='*':\\n chains = [self.mutation['chain']]\\n else:\\n chains = [chain.id for chain in st[0]]\\n\\n resnum = int(self.mutation['resnum'])\\n\\n for chain in chains:\\n residue = st[0][chain][(' ', resnum, ' ')]\\n backbone_atoms = ['N', 'CA', 'C', 'O', 'CB']\\n not_backbone_atoms = []\\n\\n # The following formula does not work. Biopython bug?\\n # for atom in residue:\\n # if atom.id not in backbone_atoms:\\n # residue.detach_child(atom.id)\\n\\n for atom in residue:\\n if atom.id not in backbone_atoms:\\n not_backbone_atoms.append(atom)\\n for atom in not_backbone_atoms:\\n residue.detach_child(atom.id)\\n\\n # Change residue name\\n residue.resname = self.mutation['mt'].upper()\\n\\n # Write resultant structure\\n w = PDBIO()\\n w.set_structure(st)\\n prepared_file_path = self.mut+self.step+'prepared.pdb'\\n w.save(prepared_file_path)\\n else:\\n prepared_file_path = self.input_pdb_path\\n\\n scrwl = 'Scwrl4' if self.scwrl4_path is None else self.scwrl4_path\\n cmd = [scrwl, '-i', prepared_file_path, '-o', self.output_pdb_path]\\n\\n command = cmd_wrapper.CmdWrapper(cmd, out_log, err_log)\\n return command.launch()\",\n \"def logic_program_form(self):\\r\\n return '% -------------------------------------\\\\n' +\\\\\\r\\n '% Theory ' + self.name + '\\\\n' +\\\\\\r\\n '% -------------------------------------\\\\n\\\\n' +\\\\\\r\\n GENERAL_AXIOMS\",\n \"def test_3():\\n h = iotbx.pdb.input(source_info=None, lines=test_pdb_3).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 generate_tree(tree, out_file='tree'):\\n activities = [\\n 'Working at Computer',\\n 'Standing Up, Walking and Going up/down stairs',\\n 'Standing',\\n 'Walking',\\n 'Going Up/Down Stairs',\\n 'Walking and Talking with Someone',\\n 'Talking while Standing',\\n ]\\n file_name = path.join('..', 'proposal', out_file)\\n export_graphviz(tree, out_file=\\\"{}.dot\\\".format(file_name), class_names=activities, rounded=True)\\n # system(\\\"dot -Tpng {0}.dot -o {0}.png\\\".format(out_file))\",\n \"def main():\\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument('rest_conn', type=__validate_conn_pattern, default='127.0.0.1:2049', help='REST connection information')\\n parser.add_argument('ledger_conn', type=__validate_conn_pattern, default='127.0.0.1:2048', help='TCP master information')\\n parser.add_argument('-a', '--auth', type=str, default=None, help='REST authentication information')\\n parser.add_argument('-t', '--timeout', type=int, default=30, help='REST timeout period')\\n args = parser.parse_args()\\n\\n # connect to AnyLog\\n auth = ()\\n if args.auth is not None: \\n auth = tuple(args.auth.split(','))\\n\\n # personalized hierarchy\\n policy = {'panel': {\\n 'name': None,\\n 'city': None,\\n 'loc': None,\\n 'owner': 'AFG'\\n }}\\n\\n for location in LOCATIONS:\\n policy['panel']['name'] = f'Panel {str(int(list(LOCATIONS).index(location)) + 1)}'\\n policy['panel']['city'] = location\\n policy['panel']['loc'] = LOCATIONS[location]\\n status = __publish_policy(conn=args.rest_conn, ledger_conn=args.ledger_conn, policy=policy, auth=auth,\\n timeout=args.timeout)\\n\\n if status is True:\\n print('Policy for %s added to blockchain' % policy['panel']['city'])\\n else:\\n print('Failed to add policy to blockchain')\",\n \"def gen_option_trajectories(O_a, skills, beta, g, theta=[], vals=-1*np.ones(4604), Zs=None, povs=None):\\n adj = adjusted_adj_list_4\\n T_o = [[[]] for i in range(len(O_a))] #Generate empty list-of-lists-of-lists\\n Ps = [[] for i in range(len(O_a))]\\n Ps[0] = [1]\\n for i in range(len(O_a)):\\n if T_o[i] != [] or i == 0:\\n for k in range(1, len(O_a) - i):\\n Os = adj[O_a[i]] + skills if skills != [] else adj[O_a[i]]\\n for o in Os:\\n # print o, k\\n # print prob_consistent(O_a[i:i+k+1], o) != 0\\n p = prob_consistent(O_a[i:i+k+1], o, beta, g, theta, vals, Zs)\\n if p != 0:\\n to_add = [[]]\\n for index, t in enumerate(T_o[i]):\\n if to_add == [[]]:\\n to_add = [t + [o]]\\n p_add = [Ps[i][index] * p]\\n else:\\n to_add.append(t + [o])\\n p_add.append(p * Ps[i][index])\\n for index, t1 in enumerate(to_add):\\n if T_o[i+k] == [[]]:\\n T_o[i+k] = [t1]\\n Ps[i+k] = [p_add[0]]\\n else:\\n T_o[i+k].append(t1)\\n Ps[i+k].append(p_add[index])\\n for index, o in enumerate(skills):\\n p = prob_consistent(O_a[i:i+k+1], o, beta, g, theta,\\n povs[3][:, index], povs[4][:, index], option_flag=True)\\n if p != 0:\\n to_add = [[]]\\n for index, t in enumerate(T_o[i]):\\n if to_add == [[]]:\\n to_add = [t + [o]]\\n p_add = [Ps[i][index] * p]\\n else:\\n to_add.append(t + [o])\\n p_add.append(p * Ps[i][index])\\n for index, t1 in enumerate(to_add):\\n if T_o[i+k] == [[]]:\\n T_o[i+k] = [t1]\\n Ps[i+k] = [p_add[0]]\\n else:\\n T_o[i+k].append(t1)\\n Ps[i+k].append(p_add[index]) \\n # T_o[i+k].extend(to_add) #Add to trajectories getting to i+k\\n return T_o[-1], Ps[-1] #Return all trajectories that get to the final state.\",\n \"def initialization():\\r\\n\\r\\n # # Transition function P(s'|s,a)\\r\\n p_tran = {}\\r\\n # s' is \\\"save\\\" and a is not \\\"ask\\\"\\r\\n p_tran[\\\"000\\\"] = p_tran[\\\"001\\\"] = p_tran[\\\"010\\\"] = p_tran[\\\"011\\\"] = 0.65\\r\\n # s' is \\\"delete\\\" and a is not \\\"ask\\\"\\r\\n p_tran[\\\"100\\\"] = p_tran[\\\"101\\\"] = p_tran[\\\"110\\\"] = p_tran[\\\"111\\\"] = 0.35\\r\\n # a is \\\"ask\\\"\\r\\n p_tran[\\\"002\\\"] = p_tran[\\\"112\\\"] = 1.0\\r\\n p_tran[\\\"102\\\"] = p_tran[\\\"012\\\"] = 0.0\\r\\n\\r\\n # # Observation function P(o'|s', a)\\r\\n p_obsv = {}\\r\\n # a is \\\"ask\\\"\\r\\n p_obsv[\\\"002\\\"] = 0.8 ; p_obsv[\\\"102\\\"] = 0.2\\r\\n p_obsv[\\\"012\\\"] = 0.3 ; p_obsv[\\\"112\\\"] = 0.7\\r\\n # a is not \\\"ask\\\", observation gives no useful information\\r\\n for i in [1,0]:\\r\\n for j in [1,0]:\\r\\n for k in [1,0]:\\r\\n p_obsv[str(i)+str(j)+str(k)] = 0.5\\r\\n\\r\\n # # reward function r(s, a)\\r\\n reward = {}\\r\\n # case of \\\"asking\\\"\\r\\n reward[\\\"02\\\"] = -1\\r\\n reward[\\\"12\\\"] = -1\\r\\n # case of correct action\\r\\n reward[\\\"00\\\"] = 5\\r\\n reward[\\\"11\\\"] = 5\\r\\n # case of wrong action\\r\\n reward[\\\"01\\\"] = -20\\r\\n reward[\\\"10\\\"] = -10\\r\\n \\r\\n gama = 0.95\\r\\n action_set = (\\\"0\\\", \\\"1\\\", \\\"2\\\")\\r\\n # (\\\"0\\\", \\\"1\\\", \\\"2\\\") correspondingly refers to (\\\"dosave\\\", \\\"dodelete\\\", \\\"ask\\\")\\r\\n state_set = (\\\"0\\\", \\\"1\\\")\\r\\n # (\\\"0\\\", \\\"1\\\") correspondingly refers to (\\\"save\\\", \\\"delete\\\")\\r\\n obsv_set = (\\\"0\\\", \\\"1\\\")\\r\\n # (\\\"0\\\", \\\"1\\\") correspondingly refers to (\\\"save\\\", \\\"delete\\\")\\r\\n \\r\\n return state_set, action_set, p_tran, reward, obsv_set, p_obsv, gama\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6269092","0.593019","0.5699991","0.566571","0.558477","0.5554511","0.5437828","0.53985196","0.5362294","0.53594774","0.5350961","0.5350664","0.5346109","0.53326225","0.5318476","0.5311653","0.53101516","0.5306257","0.5296305","0.52940077","0.529166","0.52852803","0.5285113","0.52604055","0.5258697","0.52540255","0.5246223","0.52317756","0.52255094","0.52142733","0.52110124","0.52041173","0.5201282","0.5189293","0.5188606","0.5183762","0.51768714","0.5156533","0.5156432","0.5155471","0.5143779","0.51411366","0.5136748","0.51313245","0.51222724","0.51219076","0.512008","0.5111811","0.5111129","0.5109636","0.51089364","0.5100614","0.5099875","0.50972515","0.50852096","0.5081718","0.5067466","0.5065516","0.506122","0.50609696","0.50525784","0.5052072","0.504695","0.503847","0.50366473","0.50234467","0.50225425","0.50204784","0.5020025","0.5016966","0.50131154","0.50089717","0.500163","0.49958035","0.49919406","0.4990439","0.49848032","0.49820402","0.49793702","0.49704796","0.49691403","0.49664623","0.4955574","0.49553514","0.4953425","0.49521402","0.49520934","0.4947285","0.49429545","0.49382687","0.49382687","0.49382687","0.49346948","0.4932959","0.49257156","0.49164554","0.49143228","0.4914071","0.49134287","0.49118477"],"string":"[\n \"0.6269092\",\n \"0.593019\",\n \"0.5699991\",\n \"0.566571\",\n \"0.558477\",\n \"0.5554511\",\n \"0.5437828\",\n \"0.53985196\",\n \"0.5362294\",\n \"0.53594774\",\n \"0.5350961\",\n \"0.5350664\",\n \"0.5346109\",\n \"0.53326225\",\n \"0.5318476\",\n \"0.5311653\",\n \"0.53101516\",\n \"0.5306257\",\n \"0.5296305\",\n \"0.52940077\",\n \"0.529166\",\n \"0.52852803\",\n \"0.5285113\",\n \"0.52604055\",\n \"0.5258697\",\n \"0.52540255\",\n \"0.5246223\",\n \"0.52317756\",\n \"0.52255094\",\n \"0.52142733\",\n \"0.52110124\",\n \"0.52041173\",\n \"0.5201282\",\n \"0.5189293\",\n \"0.5188606\",\n \"0.5183762\",\n \"0.51768714\",\n \"0.5156533\",\n \"0.5156432\",\n \"0.5155471\",\n \"0.5143779\",\n \"0.51411366\",\n \"0.5136748\",\n \"0.51313245\",\n \"0.51222724\",\n \"0.51219076\",\n \"0.512008\",\n \"0.5111811\",\n \"0.5111129\",\n \"0.5109636\",\n \"0.51089364\",\n \"0.5100614\",\n \"0.5099875\",\n \"0.50972515\",\n \"0.50852096\",\n \"0.5081718\",\n \"0.5067466\",\n \"0.5065516\",\n \"0.506122\",\n \"0.50609696\",\n \"0.50525784\",\n \"0.5052072\",\n \"0.504695\",\n \"0.503847\",\n \"0.50366473\",\n \"0.50234467\",\n \"0.50225425\",\n \"0.50204784\",\n \"0.5020025\",\n \"0.5016966\",\n \"0.50131154\",\n \"0.50089717\",\n \"0.500163\",\n \"0.49958035\",\n \"0.49919406\",\n \"0.4990439\",\n \"0.49848032\",\n \"0.49820402\",\n \"0.49793702\",\n \"0.49704796\",\n \"0.49691403\",\n \"0.49664623\",\n \"0.4955574\",\n \"0.49553514\",\n \"0.4953425\",\n \"0.49521402\",\n \"0.49520934\",\n \"0.4947285\",\n \"0.49429545\",\n \"0.49382687\",\n \"0.49382687\",\n \"0.49382687\",\n \"0.49346948\",\n \"0.4932959\",\n \"0.49257156\",\n \"0.49164554\",\n \"0.49143228\",\n \"0.4914071\",\n \"0.49134287\",\n \"0.49118477\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68124014"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74282,"cells":{"query":{"kind":"string","value":"Compute the structure factor through a fourier transform of the radial distribution function. The consdered trajectory must include valid elements. Atomic form factors are estimated by atomic number. The computed structure factor is only valid for certain values of Q. The lowest value of Q that can sufficiently be described by a box of characteristic length `L` is `2 pi / (L / 2)`."},"document":{"kind":"string","value":"def structure_factor(trj, Q_range=(0.5, 50), n_points=1000, framewise_rdf=False, weighting_factor='fz'):\n if weighting_factor not in ['fz']:\n raise ValueError('Invalid weighting_factor `{}` is given.'\n ' The only weighting_factor currently supported is `fz`.'.format(\n weighting_factor))\n\n rho = np.mean(trj.n_atoms / trj.unitcell_volumes)\n L = np.min(trj.unitcell_lengths)\n\n top = trj.topology\n elements = set([a.element for a in top.atoms])\n\n compositions = dict()\n form_factors = dict()\n rdfs = dict()\n\n Q = np.logspace(np.log10(Q_range[0]),\n np.log10(Q_range[1]),\n num=n_points)\n S = np.zeros(shape=(len(Q)))\n\n for elem in elements:\n compositions[elem.symbol] = len(top.select('element {}'.format(elem.symbol)))/trj.n_atoms\n form_factors[elem.symbol] = elem.atomic_number\n\n for i, q in enumerate(Q):\n num = 0\n denom = 0\n\n for elem in elements:\n denom += compositions[elem.symbol] * form_factors[elem.symbol]\n\n for (elem1, elem2) in it.product(elements, repeat=2):\n e1 = elem1.symbol\n e2 = elem2.symbol\n\n f_a = form_factors[e1]\n f_b = form_factors[e2]\n\n x_a = compositions[e1]\n x_b = compositions[e2]\n \n try:\n g_r = rdfs['{0}{1}'.format(e1, e2)]\n except KeyError:\n pairs = top.select_pairs(selection1='element {}'.format(e1),\n selection2='element {}'.format(e2))\n if framewise_rdf:\n r, g_r = rdf_by_frame(trj,\n pairs=pairs,\n r_range=(0, L / 2),\n bin_width=0.001)\n else:\n r, g_r = md.compute_rdf(trj,\n pairs=pairs,\n r_range=(0, L / 2),\n bin_width=0.001)\n rdfs['{0}{1}'.format(e1, e2)] = g_r\n integral = simps(r ** 2 * (g_r - 1) * np.sin(q * r) / (q * r), r)\n\n if weighting_factor == 'fz':\n pre_factor = 4 * np.pi * rho\n partial_sq = (integral*pre_factor) + 1\n num += (x_a*f_a*x_b*f_b) * (partial_sq)\n S[i] = (num/(denom**2))\n return Q, S"},"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 StructureFactor(ID,f,hkl,z=None):\n ID=goodID(ID)\n i=complex(0,1)\n h=hkl[0]\n k=hkl[1]\n l=hkl[2]\n L=latticeType[ID]\n if L=='fcc':\n F=f*(1+np.exp(-i*np.pi*(k+l))+np.exp(-i*np.pi*(h+l))+np.exp(-i*np.pi*(h+k)))\n elif L=='bcc':\n F=f*(1+np.exp(-i*np.pi*(h+k+l))) \n elif L=='cubic':\n F=f\n elif L=='diamond':\n F=f*(1+np.exp(-i*np.pi*(k+l))+np.exp(-i*np.pi*(h+l))+np.exp(-i*np.pi*(h+k)))*(1+np.exp(-i*2*np.pi*(h/4.0+k/4.0+l/4.0)))\n # elif L=='rhomb':\n # z=latticeParamRhomb[ID]\n # F=f*(1+np.exp(2*i*np.pi*(h+k+l)*z)) \n elif L=='tetr':\n F=f\n elif L=='hcp':\n F=f*(1+np.exp(2*i*np.pi*(h/3.0+2*k/3.0+l/2.0)))\n else:\n raise Exception(f'Unrecognized L: {L}')\n return F","def qft(self) -> None:\n random.seed(self.seed)\n self.__qft_input_state(self.circ_size)\n\n for i in range(self.circ_size):\n for j in range(i):\n self.cu1(math.pi / float(2 ** (i - j)), i, j)\n self.h(i)\n\n if self.meas: self.measure(self.qr, self.cr)","def Magnus4(self,direction='x'):\n self.reset()\n self.mol.orthoDen()\n self.mol.orthoFock()\n h = -1j*self.stepsize\n for idx,time in enumerate((self.time)):\n if direction.lower() == 'x':\n self.mol.computeDipole()\n self.dipole.append(np.real(self.mol.mu[0]))\n elif direction.lower() == 'y':\n self.mol.computeDipole()\n self.dipole.append(np.real(self.mol.mu[1]))\n elif direction.lower() == 'z':\n self.mol.computeDipole()\n self.dipole.append(np.real(self.mol.mu[2]))\n # record pulse envelope for later plotting, etc.\n self.shape.append(self.pulse(time))\n curDen = np.copy(self.mol.PO)\n \n self.addField(time + 0.0*self.stepsize,direction=direction)\n k1 = h*self.mol.FO \n Q1 = k1\n U = expm(0.5*Q1)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n self.addField(time + 0.5*self.stepsize,direction=direction)\n k2 = h*self.mol.FO\n Q2 = k2 - k1\n U = expm(0.5*Q1 + 0.25*Q2)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n\n self.addField(time + 0.5*self.stepsize,direction=direction)\n k3 = h*self.mol.FO\n Q3 = k3 - k2\n U = expm(Q1 + Q2)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n\n self.addField(time + 1.0*self.stepsize,direction=direction)\n k4 = h*self.mol.FO\n Q4 = k4 - 2*k2 + k1\n L = 0.5*Q1 + 0.25*Q2 + (1/3.)*Q3 - (1/24.)*Q4\n L += -(1/48.)*self.mol.comm(Q1,Q2)\n U = expm(L)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n self.addField(time + 0.5*self.stepsize,direction=direction)\n k5 = h*self.mol.FO\n Q5 = k5 - k2 \n L = Q1 + Q2 + (2/3.)*Q3 + (1/6.)*Q4 - (1/6.)*self.mol.comm(Q1,Q2)\n U = expm(L)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n self.addField(time + 1.0*self.stepsize,direction=direction)\n k6 = h*self.mol.FO\n Q6 = k6 -2*k2 + k1\n L = Q1 + Q2 + (2/3.)*Q5 + (1/6.)*Q6\n L += -(1/6.)*self.mol.comm(Q1, (Q2 - Q3 + Q5 + 0.5*Q6))\n\n U = expm(L)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n # density and Fock are done updating, wrap things up\n self.mol.unOrthoFock() \n self.mol.unOrthoDen() \n self.mol.computeEnergy()\n self.Energy.append(np.real(self.mol.energy))","def _structure_factor_wave_number(\n rdf: freud.density.RDF, wave_number: float, num_particles: int\n):\n dr = rdf.R[1] - rdf.R[0]\n integral = dr * np.sum((rdf.RDF - 1) * rdf.R * np.sin(wave_number * rdf.R))\n density = num_particles / rdf.box.volume\n return 1 + 4 * np.pi * density / wave_number * integral","def do_factor(m=4, q=11):\n from sage.rings.finite_rings.integer_mod_ring import IntegerModRing\n from sage.matrix.constructor import identity_matrix, block_matrix\n from sage.matrix.matrix_space import MatrixSpace\n from sage.rings.integer_ring import IntegerRing\n from sage.modules.free_module_integer import IntegerLattice\n \n \n m=n+1\n ZZ = IntegerRing()\n ZZ_q = IntegerModRing(q)\n \n \n \n from sage.arith.all import euler_phi\n from sage.misc.functional import cyclotomic_polynomial\n \n for a in range(\n R = ZZ_q['x']#.quotient(cyclotomic_polynomial(k, 'x'), 'x')\n f=cyclotomic_polynomial(m,'x')\n return f.factor()","def sqrtCF(d):\n sqrtD = sqrt(d)\n P = 0\n Q = 1\n while True:\n a = int(floor((P + sqrtD) / Q))\n yield a\n P = a * Q - P\n Q = (d - P*P) // Q # It can be shown that Q evenly divides d - P*P","def QCD(fp):\n lqcd = unpack('>H', fp.read(2))[0]\n sqcd = unpack('B', fp.read(1))[0]\n\n _spqcd = []\n _remaining = lqcd - 3\n bitstring = '{:>08b}'.format(sqcd)\n while _remaining > 0:\n if bitstring[3:] == '00000':\n # xxx0 0000: no quantisation\n _spqcd.append(unpack('B', fp.read(1))[0])\n _remaining -= 1\n elif bitstring[3:] == '00001':\n # xxx0 0001: scalar derived\n _spqcd.append(unpack('>H', fp.read(2))[0])\n _remaining -= 2\n elif bitstring[3:] == '00010':\n # xxx0 0010: scalar expounded\n _spqcd.append(unpack('>H', fp.read(2))[0])\n _remaining -= 2\n else:\n raise NotImplementedError('QCD invalid value')\n\n #guard_bits = int(bitstring[3:], 2)\n\n info = {\n 'Lqcd' : lqcd,\n 'Sqcd' : sqcd,\n 'SPqcd' : _spqcd\n }\n\n return info","def pointChargeElecFluxDensity(q: T, r: T) -> float:\n return q / surfaceIntSphere(r)","def get_coherent_scattering_factor(self, element: str, q):\n if element not in self.coherent_param.index.values:\n raise ElementNotImplementedException(element)\n fs_coh = 0\n s = q / (4 * np.pi)\n for ind in range(1, 5):\n A = self.coherent_param['A' + str(ind)][element]\n B = self.coherent_param['B' + str(ind)][element]\n fs_coh += A * np.exp(-B * s ** 2)\n\n C = self.coherent_param['C'][element]\n fs_coh += C\n return fs_coh","def get_coherent_scattering_factor(self, element: str, q):\n if element not in self.coherent_params.index.values:\n raise ElementNotImplementedException(element)\n fs_coh = 0\n s = q / (4 * np.pi)\n for ind in range(1, 5):\n A = self.coherent_params['a' + str(ind)][element]\n B = self.coherent_params['b' + str(ind)][element]\n fs_coh += A * np.exp(-B * s ** 2)\n\n C = self.coherent_params['c'][element]\n fs_coh += C\n return fs_coh","def _Schoof_mod_l(self, l):\n if l == 2:\n return self._Schoof_mod2()\n E = self.cubic\n D = self.division_polynomials\n lth_div = self.division_polynomials[l]\n field = self.basefield\n bfsize = card(field)\n x = UniVarPolynomial({1:field.one}, field)\n k = bfsize % l\n x_frob = PolyPow(x, bfsize, lth_div) #x_frob=x^q\n x_frobfrob = PolyPow(x_frob, bfsize, lth_div) #x_frobfrob=x^{q^2}\n\n # test for x^{q^2} - x\n f, P = self._sub1(k, x_frobfrob - x, lth_div)\n f0, f3 = f[0], f[3]\n\n if GCD(lth_div, P).degree() > 0:\n if arith1.legendre(k, l) == -1:\n _log.debug(\"%s $\" % str((0, l)))\n return (0, l)\n\n # arith1.legendre(k, l) == 1 <=> k is QR\n w = arith1.modsqrt(k, l)\n f, P = self._sub1(w, x_frob - x, lth_div)\n\n if GCD(lth_div, P).degree() == 0: # coprime\n _log.debug(\"%s $$$$\" % str((0, l)))\n return (0, l)\n\n # there exist non trivial common divisors\n g0 = PolyPow(E, (bfsize - 1) // 2, lth_div) #y^(q-1)\n P = self._sub2(w, g0, f[3], lth_div)\n\n if GCD(lth_div, P).degree() > 0:\n _log.debug(\"%s $$\" % str((2*w % l, l)))\n return (2*w % l, l)\n else:\n _log.debug(\"%s $$$\" % str((-2*w % l, l)))\n return (-2*w % l, l)\n\n else: # coprime (GCD(P, lth_div).degree() == 0)\n Y = x - x_frobfrob\n g0 = PolyPow(E, (bfsize - 1) // 2, lth_div) #y^(q-1)\n g1 = PolyPow(g0, bfsize + 1, lth_div) #y^(q^2-1)\n f = -self._sub2(k, g1, f3, lth_div)\n h1 = PolyMulRed([f, f], lth_div)\n if k % 2 == 0:\n g = (PolyMulRed([Y, E, f3], lth_div) - f0) * 4\n h0 = PolyMulRed([g, g], lth_div)\n aux1 = PolyMulRed([f0, h0], lth_div) + h1\n X_d = PolyMulRed([E, f3, h0], lth_div)\n else:\n g = (PolyMulRed([Y, f3], lth_div) - PolyMulRed([E, f0], lth_div)) * 4\n h0 = PolyMulRed([g, g], lth_div)\n aux1 = PolyMulRed([E, PolyMulRed([f0, h0], lth_div) + h1], lth_div)\n X_d = PolyMulRed([f3, h0], lth_div)\n X_n = PolyMulRed([X_d, x_frobfrob + x_frob + x], lth_div) - aux1\n\n # loop of t\n e_q = PolyPow(self.cubic, bfsize, lth_div)\n for t in range(1, (l - 1)//2 + 1):\n Z_d_x, Z_n_x = self._Z_x(t, D, e_q, bfsize, lth_div)\n # X_n * Z_d_x == X_d * Z_n_x (mod lth_div)?\n if not PolyMod(X_n * Z_d_x - X_d * Z_n_x, lth_div):\n break\n else: # loop of t exhausted\n _log.debug(\"%s @@@\" % str((0, l)))\n return (0, l)\n\n # found: X_n * Z_d_x == X_d * Z_n_x (mod lth_div)\n y0 = PolyMulRed([-2*x_frobfrob - x, X_d], lth_div) + aux1\n if k % 2 == 0:\n Y_d = PolyMulRed([E, D[k], g, X_d], lth_div)\n else:\n Y_d = PolyMulRed([D[k], g, X_d], lth_div)\n Y_n = -PolyMulRed([g1, Y_d], lth_div) - PolyMulRed([f, y0], lth_div)\n Z_d_y, Z_n_y = self._Z_y(t, D, g0, bfsize, lth_div)\n\n # Y_n * Z_d_y == Y_d * Z_n_y (mod lth_div)?\n if PolyMod(Y_n * Z_d_y - Y_d * Z_n_y, lth_div):\n _log.debug(\"%s @@\" % str((l-t, l)))\n return (l-t, l)\n else:\n _log.debug(\"%s @\" % str((t, l)))\n return (t, l)","def q_(w,R,lam=1064.0e-9):\n\n if R!=np.inf:\n q=np.pi*w**2*R/(np.pi*w**2-1j*R*lam)\n else:\n q=1j*np.pi*w**2/lam\n\n return q","def cdq4(f, x, h=1e-5):\n return (f(x-2*h) - 8*f(x-h) + 8*f(x+h) - f(x+2*h))/(12*h)\n raise NotImplementedError(\"Problem 2 Incomplete\")","def _list_coefficients_by_discriminant(self, fd=True, pos=True, neg=True, printimag=False, norm_neg=True, dmin=0, dmax=0, latex=False, nd=0, Lvals=False, prime=False):\n sig = 1\n S = \"$\"\n if(self._space.WR.is_dual()):\n sig = -1\n maxn = max(self._coeffs[list(self._coeffs.keys())[0]].keys())\n maxD = self._space.WR.level() * (maxn + 1)\n N = self._space.WR.N\n if(dmax > 0):\n w1 = len(str(dmax)) + 1\n else:\n w1 = len(str(maxD)) + 1\n w2 = max(list(map(len, str(self._space.WR.D()).split())))\n w3 = len(str(maxn)) + 1\n mp0 = mpmath.mpf(0)\n mpold = mpmath.mp.dps\n if(mpmath.mp.dps < self.maxdigs):\n mpmath.mp.dps = self.maxdigs\n if(norm_neg and neg):\n cnorm = 0\n tnorm = (0, 0)\n for j in range(1, 100):\n t = rn_from_D(self.space.WR, -j * sig)\n if(t is None):\n continue\n if(t[1] + self._space.WR.Qv[t[0]] >= 0):\n continue\n c1 = self.get_coefficient(t[0], t[1])\n if(c1 is None):\n continue\n # print \"c1 =\",c1\n # If the first coefficient is zero to the precision we assume we shouldn't divide by it\n if(abs(c1) > mpmath.power(10, -self.prec)):\n cnorm = c1 * mpmath.sqrt(j)\n tnorm = t\n print(\"c1=c({0})=c({1})={2}\".format(tnorm, -j * sig, cnorm))\n break\n\n for sn in [1, -1]:\n for D in range(1, maxD):\n # print \"D=\",D\n if(dmin > 0 and abs(D) < dmin):\n continue\n if dmax > 0 and abs(D) > dmax:\n continue\n DD = sig * D * sn\n # print \"D=\",D,is_fundamental_discriminant(D)\n if fd and not is_fundamental_discriminant(DD) and DD != 1:\n # print \"D=\",D,is_fundamental_discriminant(D)\n continue\n if prime and gcd(D, N) > 1:\n continue\n t = rn_from_D(self._space.WR, DD)\n if t is None:\n continue\n else:\n (r, n) = t\n # print \" DD=\",DD,t\n nn = n + self._space.WR.Qv[r]\n if(not pos and nn >= 0):\n continue\n if(not neg and nn < 0):\n continue\n\n c = self.get_coefficient(r, n)\n cs = \"\"\n erms = \"\"\n erm = 10\n if c != 0 and c is not None:\n if nn >= 0:\n ss = \"+\"\n if nn < 0:\n ss = \"-\"\n if(norm_neg):\n if ((r, n) != tnorm) and cnorm != 0:\n c = c / cnorm * mpmath.sqrt(mpmath.mpf(abs(D)))\n x = c.real()\n x1 = floor(x)\n x2 = ceil(x)\n er1 = abs(x1 - x)\n er2 = abs(x2 - x)\n erm = min(er1, er2)\n erms = sci_pretty_print(erm, 2, latex_pow=latex)\n if(erm < 0.001):\n if(er1 < er2):\n cs = str(x1)\n else:\n cs = str(x2)\n elif not printimag:\n if(nd > 0):\n cs = str(c.real()).strip()\n cs = sci_pretty_print(cs, nd, latex_pow=latex)\n else:\n cs = str(c.real())\n else:\n if(nd > 0):\n cs = str(c).strip()\n cs = sci_pretty_print(cs, nd, latex_pow=latex)\n else:\n cs = str(c)\n if(c.real() >= 0 and latex):\n cs = r\"\\hphantom{-}\" + cs\n elif(c.real() >= 0):\n cs = \" \" + cs\n if(latex):\n O = \" & \"\n if(Lvals and list(self._Lv.keys()).count(DD) == 1):\n ls = \"&\" + S + sci_pretty_print(self._Lv[DD], nd, latex_pow=latex) + S\n else:\n ls = \"\"\n if(len(erms) == 0):\n s = S + str(DD).center(w1) + S + \"&\" + S + cs + S + ls + \"\\\\\\\\\"\n else:\n s = S + str(DD).center(w1) + S + \"&\" + S + cs + S + ls + O + S + erms + S + \"\\\\\\\\\"\n else:\n if(Lvals and list(self._Lv.keys()).count(DD) == 1):\n ls = \"\\t\" + sci_pretty_print(self._Lv[DD], nd)\n else:\n ls = \"\"\n if(len(erms) == 0):\n s = \"C^\" + ss + \"[\" + str(DD).center(w1) + \"] = \" + cs + ls\n else:\n s = \"C^\" + ss + \"[\" + str(DD).center(w1) + \"] = \" + cs + ls + \" \" + erms + \"\\n\"\n # s=s+str(self._space.WR.D[r]).ljust(w2)+\",\"+str(n).ljust(w3)+\"] = \"+cs\n print(s)\n mpmath.mp.dps = mpold","def calculate_coherent_scattering_factor(element, q):\n return current_calculator.get_coherent_scattering_factor(element, q)","def width_l_pi0_pi(\n model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi, **kwargs\n):\n mx = model.mx\n ml = _lepton_masses[model.gen]\n if mx < ml + 2 * MPI:\n return 0.0\n\n xl2 = (ml / mx) ** 2\n u = 0.5 * np.tan(2 * model.theta)\n\n def integrand(s):\n z = s / mx**2\n poly = (1 - xl2) ** 2 + z * (1 + xl2) - 2 * z**2\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\n beta = (1.0 - 4 * MPI**2 / s) ** 1.5\n p = np.sqrt(kallen_lambda(1.0, z, xl2))\n return poly * np.abs(ff) ** 2 * p * beta\n\n pre = u**2 * np.abs(VUD) ** 2 * GF**2 * mx**3 / (384.0 * np.pi**3)\n quad_kwargs = _get_quad_kwargs(**kwargs)\n return (\n pre * integrate.quad(integrand, 4 * MPI**2, (mx - ml) ** 2, **quad_kwargs)[0]\n )","def _radius_from_q(q):\n\n return 1 / (np.real(1 / q))","def stretch_factor(self):\n p = self._pants_decomposition\n\n # pick a curve to iterate\n c = PantsLamination.random(p)\n # print(c)\n\n cc = (self**100) * c\n # print(self**100)\n # print(cc)\n return float(sum(abs(x) for x in (self*cc).to_vector())) / \\\n sum(abs(x) for x in cc.to_vector())","def Q_term(\n omega1, # vorticity-1 component\n omega2, # vorticity-2 component\n omega3, # vorticity-3 component\n s11, # strain rate-11 component\n s12, # strain rate-12 component\n s13, # strain rate-13 component\n s22, # strain rate-22 component\n s23, # strain rate-23 component\n s33): # strain rate-33 component\n #---------------------------------------------------------------------#\n # Numerator and denominator #\n #---------------------------------------------------------------------#\n num = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\n den1 = omega1*omega1 + omega2*omega2 + omega3*omega3\n den2 = (s11*s11 + s12*s12 + s13*s13 + s12*s12 + s22*s22 + s23*s23 +\\\n s13*s13 + s23*s23 + s33*s33)**0.5\n den = ((2.0/3.0)**0.5)* den1 * den2\n #---------------------------------------------------------------------#\n # Q calculation #\n #---------------------------------------------------------------------#\n Q = num/den\n\n return Q","def width_v_pi_pi(\n model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi, **kwargs\n):\n mx = model.mx\n if mx < 2.0 * MPI:\n return 0.0\n\n u = 0.5 * np.tan(2 * model.theta)\n\n def integrand(s):\n z = s / mx**2\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\n beta = (1.0 - 4 * MPI**2 / s) ** 1.5\n poly = (1 - z) ** 2 * (1 + 2 * z)\n return np.abs(ff) ** 2 * beta * poly\n\n pre = u**2 * GF**2 * mx**3 * (1 - 2 * SW**2) ** 2 / (768 * np.pi**3)\n quad_kwargs = _get_quad_kwargs(**kwargs)\n return pre * integrate.quad(integrand, 4 * MPI**2, mx**2, **quad_kwargs)[0]","def scale(structure):\n from numpy.linalg import det\n if \"O\" in [atom.type for atom in structure]: spvol = 8.5**3/4e0\n elif \"Se\" in [atom.type for atom in structure]: spvol = 9.5**3/4e0\n elif \"Te\" in [atom.type for atom in structure]: spvol = 10.5**3/4e0\n else: raise ValueError(\"unknown atom.type: %s\" % (atom.type,))\n\n nfu = float(len(structure)/7)*0.5 # 0.5 because 2 f.u. in spinel unit-cell.\n vol = det(structure.cell)\n return (nfu * spvol / vol)**(1e0/3e0)","def get_dihedral(p0,p1,p2,p3,unit):\n if unit == 'Ang':\n p0 = p0*0.529177249\n p1 = p1*0.529177249\n p2 = p2*0.529177249\n p3 = p3*0.529177249\n\n b0 = -1.0*(p1 - p0)\n b1 = p2 - p1\n b2 = p3 - p2\n\n # normalize b1 so that it does not influence magnitude of vector\n # rejections that come next\n b1 /= linalg.norm(b1)\n\n # vector rejections\n # v = projection of b0 onto plane perpendicular to b1\n # = b0 minus component that aligns with b1\n # w = projection of b2 onto plane perpendicular to b1\n # = b2 minus component that aligns with b1\n v = b0 - dot(b0, b1)*b1\n w = b2 - dot(b2, b1)*b1\n\n # angle between v and w in a plane is the torsion angle\n # v and w may not be normalized but that's fine since tan is y/x\n x = dot(v, w)\n y = dot(cross(b1, v), w)\n return degrees(arctan2(y, x))\n\n #q1 = subtract(p1,p0) # b - a \n #q2 = subtract(p2,p1) # c - b \n #q3 = subtract(p3,p2) # d - c\n #print(q1,q2)\n\n #q1_x_q2 = cross(q1,q2) \n #q2_x_q3 = cross(q2,q3)\n\n #n1 = q1_x_q2/sqrt(dot(q1_x_q2,q1_x_q2)) \n #n2 = q2_x_q3/sqrt(dot(q2_x_q3,q2_x_q3))\n\n #u1 = n2\n #u3 = q2/(sqrt(dot(q2,q2))) \n #u2 = cross(u3,u1)\n\n #cos_theta = dot(n1,u1)\n #sin_theta = dot(n1,u2)\n ## Calculate theta\n #theta = -atan2(sin_theta,cos_theta)\n ## it is different from atan2 from fortran math.atan2(y,x)\n #theta_deg = degrees(theta)\n #return(theta_deg)","def fkine_ur5(q):\n \n \n T1 = dh(0.08916, +q[0], 0.0, +pi/2)\n T2 = dh( 0.0, +q[1], -0.425, 0.0)\n T3 = dh( 0.0, +q[2], -0.392, 0.0)\n T4 = dh(0.10915, +q[3], 0.0, +pi/2)\n T5 = dh(0.09465, +pi+q[4], 0.0, +pi/2)\n T6 = dh( 0.0823, +pi+q[5], 0.0, 0.0)\n \n # Efector final con respecto a la base\n T = np.dot(np.dot(np.dot(np.dot(np.dot(T1,T2),T3),T4),T5),T6)\n return T","def msqrd_v_pi_pi(\n s, t, model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi\n):\n mx = model.mx\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\n u = 0.5 * np.tan(2 * model.theta)\n\n return (\n u**2\n * GF**2\n * (1 - 2 * SW**2) ** 2\n * (\n mx**4\n + 4 * MPI**4\n + 4 * t * (-2 * MPI**2 + s + t)\n - mx**2 * (s + 4 * t)\n )\n * np.abs(ff) ** 2\n )","def q_wi_per_head(self):\n assert self.ff % self.heads == 0\n # fuses W and V from swiGLU, and the q computation\n # note both W and V have output dim .ff, not\n # 2/3 ff as in https://arxiv.org/pdf/2002.05202.pdf\n return (self.ff * 2 // (self.heads-self.padded_heads)) + self.qkv","def dcm2quat(c):\n tr = c[0, 0] + c[1, 1] + c[2, 2]\n tmp = np.array([0.0, 0.0, 0.0, 0.0])\n q = np.array([0.0, 0.0, 0.0, 0.0])\n if tr > 0.0:\n tmp[0] = 0.5 * math.sqrt(1.0 + tr)\n tmp[1] = 0.25 / tmp[0] * (c[1, 2] - c[2, 1])\n tmp[2] = 0.25 / tmp[0] * (c[2, 0] - c[0, 2])\n tmp[3] = 0.25 / tmp[0] * (c[0, 1] - c[1, 0])\n else:\n if (c[1, 1] > c[0, 0]) and (c[1, 1] > c[2, 2]):\n sqdip1 = math.sqrt(c[1, 1] - c[0, 0] - c[2, 2] + 1.0)\n tmp[2] = 0.5*sqdip1\n if sqdip1 != 0.0: #// if it equals 0, something is wrong\n sqdip1 = 0.5/sqdip1\n tmp[0] = (c[2, 0] - c[0, 2]) * sqdip1\n tmp[1] = (c[0, 1] + c[1, 0]) * sqdip1\n tmp[3] = (c[1, 2] + c[2, 1]) * sqdip1\n elif c[2, 2] > c[0, 0]:\n sqdip1 = math.sqrt(c[2, 2] - c[0, 0] - c[1, 1] + 1.0)\n tmp[3] = 0.5*sqdip1\n if sqdip1 != 0.0: #// if it equals 0, something is wrong\n sqdip1 = 0.5/sqdip1\n tmp[0] = (c[0, 1] - c[1, 0]) * sqdip1\n tmp[1] = (c[2, 0] + c[0, 2]) * sqdip1\n tmp[2] = (c[1, 2] + c[2, 1]) * sqdip1\n else:\n sqdip1 = math.sqrt(c[0, 0] - c[1, 1] - c[2, 2] + 1.0)\n tmp[1] = 0.5*sqdip1\n if sqdip1 != 0.0: #// if it equals 0, something is wrong\n sqdip1 = 0.5/sqdip1\n tmp[0] = (c[1, 2] - c[2, 1]) * sqdip1\n tmp[2] = (c[0, 1] + c[1, 0]) * sqdip1\n tmp[3] = (c[2, 0] + c[0, 2]) * sqdip1\n # quaternion normalization, *** no need if dcm is really a dcm\n #quatNormalize(tmp,q)\n\t# ensure q[0] is non-negative\n if tmp[0] < 0:\n q = -1.0 * tmp\n else:\n q = tmp\n return q","def structure(self):\n if self.abelian:\n return self.abelian\n\n # step 1. find order E/F_p.\n simplified = self.simple()\n N = simplified.order()\n if prime.primeq(N):\n return (1, N)\n\n # step 2. decompose N.\n r = gcd.gcd(simplified.ch - 1, N)\n _log.debug(\"r = %d, N = %d\" % (r, N))\n r_factor = factor_methods.factor(r)\n N0 = r\n N1, N2 = 1, N\n for p, _ in r_factor:\n k, N2 = arith1.vp(N2, p=p)\n N1 *= p**k\n \n while 1:\n P1 = self.infpoint\n while P1 == self.infpoint:\n P1 = simplified.point()\n P2 = self.infpoint\n while P2 == self.infpoint:\n P2 = simplified.point()\n P1, P2 = simplified.mul(N2, P1), simplified.mul(N2, P2)\n s = simplified.pointorder(P1, r, r_factor)\n t = simplified.pointorder(P2, r, r_factor)\n m = gcd.lcm(s, t)\n if m > 1:\n e = simplified.WeilPairing(m, P1, P2)\n if e != self.basefield.one:\n d = e.order()\n else:\n d = 1\n if m*d == N1:\n _log.debug(\"N1 = %d\" % N1)\n _log.debug(\"P1 = %s (pointorder=%d)\" % (P1, s))\n _log.debug(\"P2 = %s (pointorder=%d)\" % (P2, t))\n assert (not (N//d) % d), d\n self.abelian = (d, N//d)\n return self.abelian","def _q_z(self):\n D = self.latt_par['D'].value\n lambda_r = self.latt_par['lambda_r'].value\n gamma = self.latt_par['gamma'].value\n return 2*np.pi*(self.h/D - self.k/lambda_r/np.tan(gamma))","def q_div(self, PFC, MHD, q):\n psi = PFC.psimin\n xyz = PFC.centers\n\n R_div,Z_div,phi_div = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\n\n R_omp = self.map_R_psi(psi,PFC)\n Z_omp = np.zeros(R_omp.shape)\n # Dot product between surface normal and B field\n #self.HFincidentAngle(PFC, MHD)\n # Calculate Magnitude of B at Divertor\n Bp_div = PFC.ep.BpFunc.ev(R_div,Z_div)\n Bt_div = PFC.ep.BtFunc.ev(R_div,Z_div)\n B_div = np.sqrt(Bp_div**2 + Bt_div**2)\n # Evaluate B at outboard midplane\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\n\n# Bt_omp = MHD.ep.BtFunc.ev(R_omp,Z_omp)\n# BR_omp = MHD.ep.BRFunc.ev(R_omp,Z_omp)\n# BZ_omp = MHD.ep.BZFunc.ev(R_omp,Z_omp)\n# B_omp = np.sqrt(Bt_omp**2 + BR_omp**2 + BZ_omp**2)\n#\n# Bt_div = MHD.ep.BtFunc.ev(R_div,Z_div)\n# BR_div = MHD.ep.BRFunc.ev(R_div,Z_div)\n# BZ_div = MHD.ep.BZFunc.ev(R_div,Z_div)\n# B_div = np.sqrt(Bt_div**2 + BR_div**2 + BZ_div**2)\n\n\n #For Debugging, plot Bfield Ratio\n #import matplotlib.pyplot as plt\n #testB_div = B_div.reshape(self.grid['Nphi'],self.grid['Nswall']).T\n #testB_omp = B_omp.reshape(self.grid['Nphi'],self.grid['Nswall']).T\n #B_ratio = testB_div/testB_omp\n #CS = plt.contourf(self.grid['phi'], self.grid['Swall'],B_ratio,levels=30,cmap=plt.cm.cool)\n #plt.colorbar(CS, label=r'$B Ratio$')\n #plt.show()\n #Divertor heat flux\n q_div = np.zeros((len(xyz)))\n use = np.where(PFC.shadowed_mask == 0)[0]\n\n #Matt's method\n# q_div[use] = q[use] * B_div[use]/B_omp * PFC.bdotn[use]\n #Menard's Method\n q_div[use] = q[use] * B_div[use] * PFC.bdotn[use]\n\n #for i in range(len(q_div)):\n #\tif q_div[i] > 8.0: q_div[i] = 0.0\n #Plot q|| and qdiv\n #import matplotlib.pyplot as plt\n #plt.scatter(self.grid['Swall'][:,0], q_div[0:self.grid['Nswall']], label='qdiv')\n #plt.scatter(self.grid['Swall'][:,0], q[0:self.grid['Nswall']], label='q||')\n #plt.legend()\n #plt.show()\n return np.abs(q_div)","def universal_cir(q: List[QRegStorage], i: int, para: List[float]):\n\n RZ(para[0])(q[i])\n RY(para[1])(q[i])\n RZ(para[2])(q[i])\n\n RZ(para[3])(q[i + 1])\n RY(para[4])(q[i + 1])\n RZ(para[5])(q[i + 1])\n\n CX(q[i + 1], q[i])\n\n RZ(para[6])(q[i])\n RY(para[7])(q[i + 1])\n\n CX(q[i], q[i + 1])\n\n RY(para[8])(q[i + 1])\n\n CX(q[i + 1], q[i])\n\n RZ(para[9])(q[i])\n RY(para[10])(q[i])\n RZ(para[11])(q[i])\n\n RZ(para[12])(q[i + 1])\n RY(para[13])(q[i + 1])\n RZ(para[14])(q[i + 1])","def get_structure_factor(\n scalar_field: ScalarField,\n smoothing: Union[None, float, str] = \"auto\",\n wave_numbers: Union[Sequence[float], str] = \"auto\",\n add_zero: bool = False,\n) -> Tuple[np.ndarray, np.ndarray]:\n logger = logging.getLogger(__name__)\n\n if not isinstance(scalar_field, ScalarField):\n raise TypeError(\n \"Length scales can only be calculated for scalar \"\n f\"fields, not {scalar_field.__class__.__name__}\"\n )\n\n grid = scalar_field.grid\n if not isinstance(grid, CartesianGridBase):\n raise NotImplementedError(\n \"Structure factor can currently only be calculated for Cartesian grids\"\n )\n if not all(grid.periodic):\n logger.warning(\n \"Structure factor calculation assumes periodic boundary \"\n \"conditions, but not all grid dimensions are periodic\"\n )\n\n # do the n-dimensional Fourier transform and calculate the structure factor\n f1 = np_fftn(scalar_field.data, norm=\"ortho\").flat[1:]\n flat_data = scalar_field.data.flat\n sf = np.abs(f1) ** 2 / np.dot(flat_data, flat_data)\n\n # an alternative calculation of the structure factor is\n # f2 = np_ifftn(scalar_field.data, norm='ortho').flat[1:]\n # sf = (f1 * f2).real\n # sf /= (scalar_field.data**2).sum()\n # but since this involves two FFT, it is probably slower\n\n # determine the (squared) components of the wave vectors\n k2s = [\n np.fft.fftfreq(grid.shape[i], d=grid.discretization[i]) ** 2\n for i in range(grid.dim)\n ]\n # calculate the magnitude\n k_mag = np.sqrt(reduce(np.add.outer, k2s)).flat[1:]\n\n no_wavenumbers = wave_numbers is None or (\n isinstance(wave_numbers, str) and wave_numbers == \"auto\"\n )\n\n if smoothing is not None and smoothing != \"none\":\n # construct the smoothed function of the structure factor\n if smoothing == \"auto\":\n smoothing = k_mag.max() / 128\n smoothing = float(smoothing) # type: ignore\n sf_smooth = SmoothData1D(k_mag, sf, sigma=smoothing)\n\n if no_wavenumbers:\n # determine the wave numbers at which to evaluate it\n k_min = 2 / grid.cuboid.size.max()\n k_max = k_mag.max()\n k_mag = np.linspace(k_min, k_max, 128)\n\n else:\n k_mag = np.array(wave_numbers)\n\n # obtain the smoothed values at these points\n sf = sf_smooth(k_mag)\n\n elif not no_wavenumbers:\n logger.warning(\n \"Argument `wave_numbers` is only used when `smoothing` is enabled.\"\n )\n\n if add_zero:\n sf = np.r_[1, sf]\n k_mag = np.r_[0, k_mag]\n\n return k_mag, sf","def Build_quadrant(self) :\n\n self.omega = np.zeros((self.n_dir,3))\n self.weight = np.zeros((self.n_dir))\n\n if self.sn==2 :\n direction = 0.577350269189625764509149\n weight = 1.\n\n self.omega[0,0] = direction\n self.omega[0,1] = direction\n self.omega[0,2] = direction\n \n self.weight[0] = weight\n \n elif self.sn==4 :\n direction_1 = 0.350021174581540677777041\n direction_2 = 0.868890300722201205229788\n weight = 1./3.\n\n self.omega[0,0] = direction_2\n self.omega[0,1] = direction_1\n self.omega[0,2] = direction_1\n \n self.omega[1,0] = direction_1\n self.omega[1,1] = direction_2\n self.omega[1,2] = direction_1\n\n self.omega[2,0] = direction_1\n self.omega[2,1] = direction_1\n self.omega[2,2] = direction_2\n\n self.weight[0] = weight\n self.weight[1] = weight\n self.weight[2] = weight\n\n elif self.sn==6 :\n direction_1 = 0.266635401516704720331535\n direction_2 = 0.681507726536546927403750\n direction_3 = 0.926180935517489107558380\n weight_1 = 0.176126130863383433783565\n weight_2 = 0.157207202469949899549768\n\n self.omega[0,0] = direction_3\n self.omega[0,1] = direction_1\n self.omega[0,2] = direction_1\n\n self.omega[1,0] = direction_2\n self.omega[1,1] = direction_2\n self.omega[1,2] = direction_1\n\n self.omega[2,0] = direction_1\n self.omega[2,1] = direction_3\n self.omega[2,2] = direction_1\n\n self.omega[3,0] = direction_2\n self.omega[3,1] = direction_1\n self.omega[3,2] = direction_2\n \n self.omega[4,0] = direction_1\n self.omega[4,1] = direction_2\n self.omega[4,2] = direction_2\n\n self.omega[5,0] = direction_1\n self.omega[5,1] = direction_1\n self.omega[5,2] = direction_3\n\n self.weight[0] = weight_1\n self.weight[1] = weight_2\n self.weight[2] = weight_1\n self.weight[3] = weight_2\n self.weight[4] = weight_2\n self.weight[5] = weight_1\n\n elif self.sn==8 :\n direction_1 = 0.218217890235992381266097\n direction_2 = 0.577350269189625764509149\n direction_3 = 0.786795792469443145800830\n direction_4 = 0.951189731211341853132399\n\n weight_1 = 0.120987654320987654320988\n weight_2 = 0.0907407407407407407407407\n weight_3 = 0.0925925925925925925925926\n\n self.omega[0,0] = direction_4\n self.omega[0,1] = direction_1\n self.omega[0,2] = direction_1\n\n self.omega[1,0] = direction_3\n self.omega[1,1] = direction_2\n self.omega[1,2] = direction_1\n \n self.omega[2,0] = direction_2\n self.omega[2,1] = direction_3\n self.omega[2,2] = direction_1\n\n self.omega[3,0] = direction_1\n self.omega[3,1] = direction_4\n self.omega[3,2] = direction_1\n\n self.omega[4,0] = direction_3\n self.omega[4,1] = direction_1\n self.omega[4,2] = direction_2\n\n self.omega[5,0] = direction_2\n self.omega[5,1] = direction_2\n self.omega[5,2] = direction_2\n\n self.omega[6,0] = direction_1\n self.omega[6,1] = direction_3\n self.omega[6,2] = direction_2\n\n self.omega[7,0] = direction_2\n self.omega[7,1] = direction_1\n self.omega[7,2] = direction_3\n\n self.omega[8,0] = direction_1\n self.omega[8,1] = direction_2\n self.omega[8,2] = direction_3\n\n self.omega[9,0] = direction_1\n self.omega[9,1] = direction_1\n self.omega[9,2] = direction_4\n\n self.weight[0] = weight_1\n self.weight[1] = weight_2\n self.weight[2] = weight_2\n self.weight[3] = weight_1\n self.weight[4] = weight_2\n self.weight[5] = weight_3\n self.weight[6] = weight_2\n self.weight[7] = weight_2\n self.weight[8] = weight_2\n self.weight[9] = weight_1\n\n elif self.sn==10 :\n direction_1 = 0.189321326478010476671494\n direction_2 = 0.508881755582618974382711\n direction_3 = 0.694318887594384317279217\n direction_4 = 0.839759962236684758403029\n direction_5 = 0.963490981110468484701598\n\n weight_1 = 0.0893031479843567214704325\n weight_2 = 0.0725291517123655242296233\n weight_3 = 0.0450437674364086390490892\n weight_4 = 0.0539281144878369243545650\n\n self.omega[0,0] = direction_5\n self.omega[0,1] = direction_1\n self.omega[0,2] = direction_1\n \n self.omega[1,0] = direction_4\n self.omega[1,1] = direction_2\n self.omega[1,2] = direction_1\n \n self.omega[2,0] = direction_3\n self.omega[2,1] = direction_3\n self.omega[2,2] = direction_1\n \n self.omega[3,0] = direction_2\n self.omega[3,1] = direction_4\n self.omega[3,2] = direction_1\n\n self.omega[4,0] = direction_1\n self.omega[4,1] = direction_5\n self.omega[4,2] = direction_1\n\n self.omega[5,0] = direction_4\n self.omega[5,1] = direction_1\n self.omega[5,2] = direction_2\n\n self.omega[6,0] = direction_3\n self.omega[6,1] = direction_2\n self.omega[6,2] = direction_2\n\n self.omega[7,0] = direction_2\n self.omega[7,1] = direction_3\n self.omega[7,2] = direction_2\n\n self.omega[8,0] = direction_1\n self.omega[8,1] = direction_4\n self.omega[8,2] = direction_2\n\n self.omega[9,0] = direction_3\n self.omega[9,1] = direction_1\n self.omega[9,2] = direction_3\n\n self.omega[10,0] = direction_2\n self.omega[10,1] = direction_2\n self.omega[10,2] = direction_3\n\n self.omega[11,0] = direction_1\n self.omega[11,1] = direction_3\n self.omega[11,2] = direction_3\n\n self.omega[12,0] = direction_2\n self.omega[12,1] = direction_1\n self.omega[12,2] = direction_4\n\n self.omega[13,0] = direction_1\n self.omega[13,1] = direction_2\n self.omega[13,2] = direction_4\n\n self.weight[0] = weight_1\n self.weight[1] = weight_2\n self.weight[2] = weight_3\n self.weight[3] = weight_2\n self.weight[4] = weight_1\n self.weight[5] = weight_2\n self.weight[6] = weight_4\n self.weight[7] = weight_4\n self.weight[8] = weight_2\n self.weight[9] = weight_3\n self.weight[10] = weight_4\n self.weight[11] = weight_3\n self.weight[12] = weight_2\n self.weight[13] = weight_2\n self.weight[14] = weight_1\n\n elif self.sn==12 :\n direction = np.zeros((6,1))\n\n direction[0] = 0.167212652822713264084504\n direction[1] = 0.459547634642594690016761\n direction[2] = 0.628019096642130901034766\n direction[3] = 0.760021014833664062877138\n direction[4] = 0.872270543025721502340662\n direction[5] = 0.971637719251358378302376\n\n weight_1 = 0.0707625899700910439766549\n weight_2 = 0.0558811015648888075828962\n weight_3 = 0.0373376737588285824652402\n weight_4 = 0.0502819010600571181385765\n weight_5 = 0.0258512916557503911218290\n\n for i in xrange(0,6) :\n self.omega[i,0] = direction[5-i]\n self.omega[i,1] = direction[i]\n self.omega[i,2] = direction[0]\n \n offset = 6\n for i in xrange(0,5) :\n self.omega[offset+i,0] = direction[4-i]\n self.omega[offset+i,1] = direction[i]\n self.omega[offset+i,2] = direction[1]\n\n offset += 5\n for i in xrange(0,4) :\n self.omega[offset+i,0] = direction[3-i]\n self.omega[offset+i,1] = direction[i]\n self.omega[offset+i,2] = direction[2]\n \n offset += 4\n for i in xrange(0,3) :\n self.omega[offset+i,0] = direction[2-i]\n self.omega[offset+i,1] = direction[i]\n self.omega[offset+i,2] = direction[3]\n\n offset += 3\n for i in xrange(0,2) :\n self.omega[offset+i,0] = direction[1-i]\n self.omega[offset+i,1] = direction[i]\n self.omega[offset+i,2] = direction[4]\n \n offset += 2\n self.omega[offset+i,0] = direction[0]\n self.omega[offset+i,1] = direction[1]\n self.omega[offset+i,2] = direction[5]\n\n self.weight[0] = weigth_1\n self.weight[1] = weight_2\n self.weight[2] = weight_3\n self.weight[3] = weight_3\n self.weight[4] = weight_2\n self.weight[5] = weight_1\n self.weight[6] = weight_2\n self.weight[7] = weight_4\n self.weight[8] = weight_5\n self.weight[9] = weight_4\n self.weight[10] = weight_2\n self.weight[11] = weight_3\n self.weight[12] = weight_5\n self.weight[13] = weight_5\n self.weight[14] = weight_3\n self.weight[15] = weight_3\n self.weight[16] = weight_4\n self.weight[17] = weight_3\n self.weight[18] = weight_2\n self.weight[19] = weight_2\n self.weight[20] = weight_1","def get_element_density(mt):\r\n fraction_matrix = zeros(100)\r\n \r\n composition = Composition(mt['pretty_formula'])\r\n \r\n for element in composition:\r\n fraction = composition.get_atomic_fraction(element) # get the atomic fraction.\r\n fraction_matrix[element.Z] = fraction\r\n \r\n return fraction_matrix","def compute_duty_factor():\n [time,\n ankle_l_trajectory,\n ankle_r_trajectory,\n foot_l_contact,\n foot_r_contact,\n muscle_lh_activations,\n muscle_rh_activations,\n muscle_lh_forces,\n muscle_rh_forces,\n joint_lh_positions,\n joint_rh_positions] = load_data()\n \n print(np.sum(foot_l_contact)/len(foot_l_contact))\n print(np.sum(foot_r_contact)/len(foot_r_contact))\n\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5","def compute_rf_field(self, r):\r\n\t\tE = np.zeros((3))\r\n\t\tfor nam, e in self.rf_electrode_list:\r\n\t\t\tE += e.compute_electric_field(r)\r\n\t\treturn E","def cntd_qed_furry_class_coeff( L, rt2, m):\n\n if rt2 % 2 != 0:\n return 0\n \n r = rt2/2\n s = m + 2*r + 2*(L - 1)\n\n if s<0:\n return 0\n\n A = [ [ [ qed_furry_cc(sp, mp, rp) for mp in range(m+1) ] for rp in range(r+1) ] for sp in range(s+1) ]\n Alog = lLog( A )\n \n return Alog[s][r][m]","def test_mag_form_fac_case1():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac()[0], ion.calc_mag_form_fac()[1:]\n del _temp\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)","def annihilation_branching_fractions(self, Q):\n CSs = self.cross_sections(Q)\n\n if CSs[\"total\"] == 0.0:\n return {\"mu mu\": 0.0, \"e e\": 0.0, \"pi0 pi pi\": 0.0, \"a a\": 0.0}\n else:\n return {\n \"mu mu\": CSs[\"mu mu\"] / CSs[\"total\"],\n \"e e\": CSs[\"e e\"] / CSs[\"total\"],\n \"pi0 pi pi\": CSs[\"pi0 pi pi\"] / CSs[\"total\"],\n \"a a\": CSs[\"a a\"] / CSs[\"total\"],\n }","def compute_density_ari(cur, N):\n ## arithmetic average cardinality\n avg_card = 0\n for n in range(N):\n card = get_parameter(cur, par=(\"card_B%d\" % n))\n avg_card += card / float(N)\n\n ## average mass\n if avg_card == 0:\n return (-1, 0)\n else:\n return (get_parameter(cur, par=\"B_mass\") / avg_card, avg_card)","def msqrd_l_pi0_pi(\n s, t, model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi\n):\n mx = model.mx\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\n ml = _lepton_masses[model.gen]\n ckm = abs(VUD) ** 2\n u = 0.5 * np.tan(2 * model.theta)\n\n return (\n 2\n * ckm\n * u**2\n * GF**2\n * (\n 4 * MPI**4\n + (ml**2 + mx**2) * (ml**2 + mx**2 - s)\n - 4 * (ml**2 + mx**2 + 2 * MPI**2 - s) * t\n + 4 * t**2\n )\n * np.abs(ff) ** 2\n )","def _reduced_mass(structure) -> float:\n reduced_comp = structure.composition.reduced_composition\n num_elems = len(reduced_comp.elements)\n elem_dict = reduced_comp.get_el_amt_dict()\n\n denominator = (num_elems - 1) * reduced_comp.num_atoms\n\n all_pairs = combinations(elem_dict.items(), 2)\n mass_sum = 0\n\n for pair in all_pairs:\n m_i = Composition(pair[0][0]).weight\n m_j = Composition(pair[1][0]).weight\n alpha_i = pair[0][1]\n alpha_j = pair[1][1]\n\n mass_sum += (alpha_i + alpha_j) * (m_i * m_j) / (m_i + m_j) # type: ignore\n\n reduced_mass = (1 / denominator) * mass_sum\n\n return reduced_mass","def factor(P):\n cd = P[-1]\n if P.deg == 0:\n return (cd, defaultdict(int))\n P = P * (1 / cd)\n return (cd, P.factor_unit())","def radial4(self) -> float:\n return self.distortion_coefficients[1]","def multiplicity(q, N):\n return int(_math.factorial(q + N - 1) /\n (_math.factorial(q) * _math.factorial(N - 1)))","def question_c():\n 4*math.pi*(r**2)","def d(J,Mp,M):\n\tdd=0.0\n\tif so3.multJ(J,M)==1 and so3.multJ(J,Mp)==1:\n\t\t## defining the limits of k\n\t\tkmax=max(J+M,J-M,J-Mp)\n\t\t#kmin=max(Mp-M,0)\n\t\t##suming over k\n\t\tfor k in range(int(kmax)+1):\n\t\t\tdd=dd+parity(k)*choose(int(J+M),int(J-Mp-k))*choose(int(J-M),k)\n\t\tdd=(parity(J-Mp)\n\t\t\t*math.sqrt(\n\t\t\t\tmath.factorial(int(J+Mp))\n\t\t\t\t*math.factorial(int(J-Mp))\n\t\t\t\t/(\n\t\t\t\t\t2.**(2*J)\n\t\t\t\t\t*math.factorial(int(J+M))\n\t\t\t\t\t*math.factorial(int(J-M))\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\t)*dd\n\t#print \"dd\",dd\n\treturn dd","def sol549(design_parameters, phi_0, N):\r\n prt('Design governing by this mantras (in oder of importance): \\nsize, stall margin, cost, off-design', 'blue')\r\n n = 0\r\n m = 0\r\n phi_f = phi_0*1.2\r\n N_lineal_phi = int(0.4 * N)\r\n step = (phi_f-phi_0)/(N_lineal_phi-1)\r\n phi_dist = [float_f(phi_0+i*step, 4) for i in range(N_lineal_phi)] + [float_f(phi_f, 4) for i in range(N_lineal_phi, N)]\r\n phi_dist = Distribution(phi_dist)\r\n N_lineal_R = int(0.3 * N)\r\n R_0 = 0.7\r\n R_f = 0.65\r\n step = (R_f - R_0) / (N_lineal_R - 1)\r\n R_dist = [float_f(R_0+i*step, 4) for i in range(N_lineal_R)] + [float_f(R_f, 4) for i in range(N_lineal_R, N)]\r\n R_dist = Distribution(R_dist)\r\n\r\n Kc = 1-0.5*design_parameters[1]\r\n psi_dist = Distribution(psi_limit(phi_dist, R_dist, Kc))\r\n if inlet_angle_flow(phi_dist,psi_dist,R_dist):\r\n pass\r\n\r\n return phi_dist, psi_dist, R_dist, n,m","def radio_lumfn(L, _params):\n print _params\n # Number density as a function of sfr, dn/dlog(sfr)\n sfr = L * 5.52e-29 # erg/s/Hz, Bell (2003), Eq. 6\n dndlogsfr_sfms, dndlogsfr_pass = g.sfr_fn(hm, sfr, z=0., params=_params)\n #phi = dndlogsfr_sfms #+ dndlogsfr_pass\n return dndlogsfr_sfms, dndlogsfr_pass","def qFelder(h):\n\treturn (0.92 + 0.153 * h/1.01) * math.sqrt(9.8 * (2/3.0 * h)**3)","def BeamDeflection(I, E, L, q):\n w = q * L**4 / (8*E*I)\n return w","def quadratureDetector(d, fs):\n\n k = fs / (2 * numpy.pi)\n\n # lazy version\n def g(d):\n prev = None\n for b in d:\n if prev is not None:\n x = numpy.concatenate((prev[1:], b[:1]))\n yield numpy.angle(x * prev.conj()) * k\n prev = b\n yield numpy.angle(prev[1:] * prev[:-1].conj()) * k\n\n if isinstance(d, types.GeneratorType):\n return g(d)\n else:\n return numpy.angle(d[1:] * d[:-1].conj()) * k","def guess_baudrate_divisor(klass, config):\n\t\t# build a list of all the millisecond time values to check\n\t\ttimes_tuples_keys = ['header', 'three', 'two', 'one', 'zero',\n\t\t 'foot', 'repeat', 'pre', 'post']\n\t\ttimes_keys = ['ptrail', 'phead', 'gap', 'repeat_gap']\n\t\ttimes = []\n\t\ttimes.append(1000000)\t# can't have a baudrate of less than 1\n\t\tfor k in times_tuples_keys:\n\t\t\tif k in config:\n\t\t\t\ttimes.append(config[k][0])\n\t\t\t\ttimes.append(config[k][1])\n\t\tfor k in times_keys:\n\t\t\tif k in config:\n\t\t\t\ttimes.append(config[k])\n\t\t# try finding a common factor among them all\n\t\ttotal_factor = 1\n\t\tfactored = True\n\t\twhile factored:\n\t\t\tfactored = False\n\t\t\tfactor_errors = {}\n\t\t\tfor factor in [2,3,5,7,11,17,19,23]:\n\t\t\t\tnew_factor = 1.0 * total_factor * factor\n\t\t\t\tint_times = [int(t / new_factor) for t in times]\n\t\t\t\trounded_times = [t * new_factor for t in int_times]\n\t\t\t\terrors = [abs(o-n)*1.0/o for o,n in zip(times, rounded_times)]\n\t\t\t\tfactor_errors[factor] = max(errors)\n\t\t\t# figure out which factor had the least error\n\t\t\tnew_factor = None\n\t\t\tmin_error = 0.05\n\t\t\tfor f,e in factor_errors.items():\n\t\t\t\tif e < min_error:\n\t\t\t\t\tmin_error = e\n\t\t\t\t\tnew_factor = total_factor * f\n\t\t\tif new_factor:\n\t\t\t\tfactored = True\n\t\t\t\ttotal_factor = new_factor\n\t\treturn total_factor","def deriv_matrix_block(\n atomic_number,\n total_rad_recomb_coefficients,\n total_coll_ion_coefficients,\n total_coll_recomb_coefficients,\n current_ion_number_densities,\n current_electron_density,\n ):\n ion_numbers = np.arange(0, atomic_number)\n radiative_rate_coeff_matrix = NLTERateEquationSolver.recomb_matrix(\n total_rad_recomb_coefficients, atomic_number, ion_numbers\n )\n coll_recomb_matrix = (\n NLTERateEquationSolver.recomb_matrix(\n total_coll_recomb_coefficients, atomic_number, ion_numbers\n )\n * current_electron_density\n * 2\n )\n coll_ion_coeff_matrix = NLTERateEquationSolver.ion_matrix(\n total_coll_ion_coefficients, atomic_number, ion_numbers\n )\n deriv_matrix = (\n radiative_rate_coeff_matrix\n + coll_ion_coeff_matrix\n + coll_recomb_matrix\n )\n return np.dot(deriv_matrix, current_ion_number_densities)","def factor_unit(P):\n assert all(isinstance(c, ModInt) for c in P)\n assert len(set(c.n for c in P)) == 1\n if P.deg == 1:\n return defaultdict(int, {P: 1})\n\n p = P[0].n\n\n S = Polynomial.gcd(P, P.prime())\n if S.deg == P.deg:\n # P' = 0 so P = R^p\n R = Polynomial(P.C[::p])\n return defaultdict(int,\n {D: p * v\n for D, v in Polynomial.factor_unit(R).items()})\n else:\n factors = defaultdict(int)\n if S.deg:\n for D, v in S.factor_unit().items():\n factors[D] += v\n P //= S\n # P is now square-free\n # We look for Q in Ker(F-Id) \\ {1}\n Q = Polynomial.computeQ(P)\n if Q is None:\n # P is irreducible\n factors[P] += 1\n else:\n # P is the product of the gcd(P, Q-i)\n # that are factored recursively\n for i in range(p):\n D = Polynomial.gcd(P, Q - Polynomial([ModInt(i, p)]))\n if D.deg:\n for DD, v in D.factor_unit().items():\n factors[DD] += v\n return factors","def qcd_cc( s, m, r, u ):\n\n l2_min = r\n l3_min = u\n l1_min = (m+1)/2\n l1_max = l2_max = l3_max = (3*s+m+2*r+2*u)/2\n\n S = 0\n for l1 in range(l1_min, l2_max+1):\n for l2 in range(l2_min, l2_max+1):\n for l3 in range(l3_min, l3_max+1):\n n1 = 2*l1 + l2 + l3 - 2*s - m - r - u\n n2_t2 = -2*(l1+l2+l3) + 3*s + m + 2*r + 2*u\n n3 = l2-r\n n4 = l3-u\n if n2_t2%2 != 0:\n continue\n n2 = n2_t2/2\n if n1 < 0 or n2 < 0 or n3 < 0 or n4 < 0:\n continue\n\n denom = factorial(n1)*factorial(n2)*factorial(n3)*factorial(n4)*factorial(3)**n1*factorial(4)**n2*factorial(m)*factorial(r)**2*factorial(u)**2\n\n nom = double_factorial(2*l1-1)*factorial(l2)*factorial(l3)\n S+= Fraction(nom, denom)\n\n return S","def test_mag_form_fac():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac(q=1.)[0], ion.calc_mag_form_fac(q=1.)[1:]\n del _temp\n assert (abs(formfac - 0.932565) < 1e-6)","def gas_zfactor(T_pr, P_pr):\n # T_pr : calculated pseudoreduced temperature\n # P_pr : calculated pseudoreduced pressure \n from scipy.optimize import fsolve # non-linear solver\n import numpy as np\n\n a1 = 0.3265; a2 = -1.0700; a3 = -0.5339; a4 = 0.01569; a5 = -0.05165; a6 = 0.5475\n a7 = -0.7361; a8 = 0.1844; a9 = 0.1056; a10 = 0.6134; a11 = 0.7210\n\n def f(y):\n rho_pr, z = y\n c1 = a1 + (a2/T_pr) + (a3/(T_pr**3))+ (a4/(T_pr**4))+ (a5/(T_pr**5))\n c2 = a6 + (a7/T_pr) + (a8/(T_pr**2))\n c3 = a9*((a7/T_pr) + (a8/(T_pr**2)))\n c4 = (a10)*(1+(a11*(rho_pr**2)))*((rho_pr**2)/(T_pr**3))*(np.exp(-a11*(rho_pr**2)))\n\n f1 = z + (c3*(rho_pr**5)) - (c2*(rho_pr**2)) - (c1*(rho_pr**1)) - c4 - 1\n f2 = rho_pr - ((0.27 * P_pr) / (z * T_pr))\n return[f1, f2]\n\n solve = fsolve(f, [1, 1]) # initial guess\n return(solve[0], solve[1]) # result is density, z-factor","def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[ int(uD) ]\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \n \n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\n \n dJ_a = self.jacobian_actuators_diff( q , dq )\n \n C = self.C( q , dq )\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\n \n D = self.D( q , dq )\n Da = np.dot( B , np.dot( self.Da , B.T ) )\n \n CD_all = C + D + Ca + Da\n \n G = self.G( q )\n \n # External forces\n J_e = self.jacobian_endeffector( q )\n f_e = self.F_ext( q , dq )\n \n # Disturbance force\n f_d = self.F_dist( t )\n \n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\n \n return ddq","def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[ int(uD) ]\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \n \n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\n \n dJ_a = self.jacobian_actuators_diff( q , dq )\n \n C = self.C( q , dq )\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\n \n D = self.D( q , dq )\n Da = np.dot( B , np.dot( self.Da , B.T ) )\n \n CD_all = C + D + Ca + Da\n \n G = self.G( q )\n \n # External forces\n J_e = self.jacobian_endeffector( q )\n f_e = self.F_ext( q , dq )\n \n # Disturbance force\n f_d = self.F_dist( t )\n \n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\n \n return ddq","def qed_furry_class_coeff( L, rt2, m ):\n\n if rt2 % 2 != 0:\n return 0\n \n r = rt2/2\n s = m + 2*r + 2*(L - 1)\n \n if s<0:\n return 0\n\n return qed_furry_cc(s,m,r)","def harmSpinorPrefactor(l, m):\n sign = (-1)**(l-m)\n prefactor = math.sqrt((2*l+1) / (4*math.pi))\n lastfactornumer = math.factorial(l+m) * math.factorial(l-m)\n lastfactordenom = math.factorial(l+1/2) * math.factorial(l-1/2)\n lastfactorsq = lastfactornumer / lastfactordenom\n factor = sign * prefactor * math.sqrt(lastfactorsq)\n return factor","def get_quad_dip(q):\n N = get_quad_normal(q)\n V = get_vertical_vector(q)\n dip = np.degrees(np.arccos(Vector.dot(N, V)))\n return dip","def quatreal(q):\n a = q[0,0]\n b = q[0,1]\n c = q[0,2]\n d = q[0,3]\n amat = a*np.identity(4)\n bmat = b*np.array([[0,1,0,0],[-1,0,0,0],[0,0,0,-1],[0,0,1,0]])\n cmat = c*np.array([[0,0,1,0],[0,0,0,1],[-1,0,0,0],[0,-1,0,0]])\n dmat = d*np.array([[0,0,0,1],[0,0,-1,0],[0,1,0,0],[-1,0,0,0]])\n return amat+bmat+cmat+dmat","def _get_deform_field_dm(self):\n self.deformationStrength = self.deformrandomstate.rand()\n adr = [w // d + 4 for w, d in zip(self.w, self.deform)]\n deformshape = [len(self.w)] + adr\n tmp = np.zeros([4] * (len(self.w) - 1) + [len(self.w)] + self.w)\n\n if np.isscalar(self.deformSigma):\n myDeformSigma = np.array(len(self.w), self.deformSigma)\n else:\n myDeformSigma = np.asarray(self.deformSigma)\n\n strngs = [self.deformrandomstate.normal(0, myDeformSigma[i], deformshape[1:]) * self.deformationStrength\n for i in range(len(myDeformSigma))]\n tdf = np.asarray(strngs, dtype=np.float32)\n\n if self.truncated_deform:\n upperBound = 3 * myDeformSigma\n for i in range(len(myDeformSigma)):\n overshoot_coordinates = np.where(np.abs(tdf[i]) > upperBound[i])\n while len(overshoot_coordinates[0]):\n tdf[i][overshoot_coordinates] = np.float32(self.deformrandomstate.normal(0, myDeformSigma[i], len(\n overshoot_coordinates[0])) * self.deformationStrength)\n overshoot_coordinates = np.where(np.abs(tdf[i]) > upperBound[i])\n\n # logging.getLogger('data').info('truncated deformation field')\n\n def cint(x, pnm1, pn, pnp1, pnp2):\n return 0.5 * (\n x * ((2 - x) * x - 1) * pnm1 + (x * x * (3 * x - 5) + 2) * pn + x * ((4 - 3 * x) * x + 1) * pnp1 + (\n x - 1) * x * x * pnp2)\n\n r = [np.asarray([x * 1.0 / self.deform[i] - x // self.deform[i] for x in range(self.w[i])]).reshape(\n [self.w[i] if t == i + 1 else 1 for t in range(len(self.w) + 1)]) for i in range(len(self.w))]\n d = [np.asarray([x // self.deform[i] for x in range(self.w[i])]).reshape(\n [self.w[i] if t == i else 1 for t in range(len(self.w))]) for i in range(len(self.w))]\n\n if len(self.w) == 3:\n for i in range(4):\n for j in range(4):\n xx = d[0] + i\n yy = d[1] + j\n zz = d[2] + 1\n tmp[i, j] = cint(r[2], tdf[:, xx, yy, zz - 1], tdf[:, xx, yy, zz], tdf[:, xx, yy, zz + 1],\n tdf[:, xx, yy, zz + 2])\n for i in range(4):\n tmp[i, 0] = cint(r[1], tmp[i, 0], tmp[i, 1], tmp[i, 2], tmp[i, 3])\n return cint(r[0], tmp[0, 0], tmp[1, 0], tmp[2, 0], tmp[3, 0])\n\n elif len(self.w) == 2:\n for j in range(4):\n xx = d[0] + j\n yy = d[1] + 1\n tmp[j] = cint(r[1], tdf[:, xx, yy - 1], tdf[:, xx, yy], tdf[:, xx, yy + 1], tdf[:, xx, yy + 2])\n return cint(r[0], tmp[0], tmp[1], tmp[2], tmp[3])\n\n else:\n raise Exception('only implemented for 2d and 3d case. feel free to contribute')","def __init__(self, coefficient, basefield=None):\n\n try:\n character = basefield.getCharacteristic()\n self.basefield = basefield\n except:\n # backward compatibility support\n if isinstance(basefield, rational.RationalField) or (not basefield):\n character = 0\n self.basefield = rational.theRationalField\n elif isinstance(basefield, int):\n character = basefield\n if character == 1 or character < 0:\n raise ValueError(\"basefield characteristic must be 0 or prime.\")\n self.basefield = finitefield.FinitePrimeField.getInstance(character)\n else:\n raise ValueError(\"basefield must be FiniteField.\")\n\n self.ch = character\n self.infpoint = [self.basefield.zero]\n if isinstance(coefficient, list):\n self.coefficient = coefficient\n if self.ch == 0:\n if len(self) == 5:\n self.a1 = self.coefficient[0]\n self.a2 = self.coefficient[1]\n self.a3 = self.coefficient[2]\n self.a4 = self.coefficient[3]\n self.a6 = self.coefficient[4]\n self.b2 = self.a1**2+4*self.a2\n self.b4 = self.a1*self.a3+2*self.a4\n self.b6 = self.a3**2+4*self.a6\n self.b8 = self.a1**2*self.a6+4*self.a2*self.a6-self.a1*self.a3*self.a4+self.a2*self.a3**2-self.a4**2\n self.c4 = self.b2**2-24*self.b4\n self.c6 = -self.b2**3+36*self.b2*self.b4-216*self.b6\n self.disc = -self.b2**2*self.b8-8*self.b4**3-27*self.b6**2+9*self.b2*self.b4*self.b6\n elif len(self) == 2:\n self.a = self.coefficient[0]\n self.b = self.coefficient[1]\n self.a1 = 0\n self.a2 = 0\n self.a3 = 0\n self.a4 = self.coefficient[0]\n self.a6 = self.coefficient[1]\n self.b2 = 0\n self.b4 = 2*self.a\n self.b6 = 4*self.b\n self.b8 = -self.a**2\n self.c4 = -48*self.a\n self.c6 = -864*self.b\n self.disc = (self.c4**3-self.c6**2)/1728\n else:\n raise ValueError(\"coefficient is less or more, can't defined EC.\")\n if self.disc == 0:\n raise ValueError(\"this curve is singular.\")\n self.j = (self.c4**3)/self.disc\n self.cubic = UniVarPolynomial({0:self.a6, 1:self.a4,\n 3:self.basefield.one},\n self.basefield)\n else:\n pass # support for subclass\n else:\n raise ValueError(\"parameters must be (coefficient, basefield)\")","def Lq(self):\n if not self.isVaild():\n pass\n temp = ((self.r()**self.C)*self.Rho()) / \\\n (math.factorial(self.C)*((1 - self.Rho())**2))\n return temp*self.P0()","def calc_iqr(data: list) -> float:\n return calc_q3(data) - calc_q1(data)","def DQT(fp):\n # length is 2 + sum(t=1, N) of (65 + 64 * Pq(t))\n length = unpack('>H', fp.read(2))[0]\n _remaining = length - 2\n\n _pq, _tq, _qk = [], [], []\n while _remaining > 0:\n precision, table_id = _split_byte(fp.read(1))\n _remaining -= 1\n _pq.append(precision)\n _tq.append(table_id)\n\n # If Pq is 0, Qk is 8-bit, if Pq is 1, Qk is 16-bit\n Q_k = []\n for ii in range(64):\n if precision == 0:\n Q_k.append(unpack('>B', fp.read(1))[0])\n _remaining -= 1\n elif precision == 1:\n Q_k.append(unpack('>H', fp.read(2))[0])\n _remaining -= 2\n\n _qk.append(Q_k)\n\n info = {\n 'Lq' : length,\n 'Pq' : _pq,\n 'Tq' : _tq,\n 'Qk' : _qk\n }\n\n return info","def ADT_QCD_LEPTON():\n\n # As input for the quark-mass ratios, we use the quark masses at MZ and the lepton masses\n ip = Num_input()\n\n mu = ip.mu_at_MZ\n md = ip.md_at_MZ\n ms = ip.ms_at_MZ\n me = ip.me\n mmu = ip.mmu\n mtau = ip.mtau\n\n # Create the ADT:\n\n gamma_hat_P63eu_Q81u = np.hstack((-16 * me**2/mu**2, np.zeros(5)))\n gamma_hat_P63muu_Q81u = np.hstack((np.zeros(1), -16 * mmu**2/mu**2, np.zeros(4)))\n gamma_hat_P63tauu_Q81u = np.hstack((np.zeros(2), -16 * mtau**2/mu**2, np.zeros(3)))\n\n gamma_hat_P63ed_Q81d = np.hstack((-16 * me**2/md**2, np.zeros(5)))\n gamma_hat_P63mud_Q81d = np.hstack((np.zeros(1), -16 * mmu**2/md**2, np.zeros(4)))\n gamma_hat_P63taud_Q81d = np.hstack((np.zeros(2), -16 * mtau**2/md**2, np.zeros(3)))\n\n gamma_hat_P63es_Q81s = np.hstack((-16 * me**2/ms**2, np.zeros(5)))\n gamma_hat_P63mus_Q81s = np.hstack((np.zeros(1), -16 * mmu**2/ms**2, np.zeros(4)))\n gamma_hat_P63taus_Q81s = np.hstack((np.zeros(2), -16 * mtau**2/ms**2, np.zeros(3)))\n\n\n\n gamma_hat_P63eu_Q82u = np.hstack((np.zeros(3), -16 * me**2/mu**2, np.zeros(2)))\n gamma_hat_P63muu_Q82u = np.hstack((np.zeros(4), -16 * mmu**2/mu**2, np.zeros(1)))\n gamma_hat_P63tauu_Q82u = np.hstack((np.zeros(5), -16 * mtau**2/mu**2))\n\n gamma_hat_P63ed_Q82d = np.hstack((np.zeros(3), -16 * me**2/md**2, np.zeros(2)))\n gamma_hat_P63mud_Q82d = np.hstack((np.zeros(4), -16 * mmu**2/md**2, np.zeros(1)))\n gamma_hat_P63taud_Q82d = np.hstack((np.zeros(5), -16 * mtau**2/md**2))\n\n gamma_hat_P63es_Q82s = np.hstack((np.zeros(3), -16 * me**2/ms**2, np.zeros(2)))\n gamma_hat_P63mus_Q82s = np.hstack((np.zeros(4), -16 * mmu**2/ms**2, np.zeros(1)))\n gamma_hat_P63taus_Q82s = np.hstack((np.zeros(5), -16 * mtau**2/ms**2))\n\n\n\n gamma_hat_P62ue_Q83u = np.hstack((-16 * me**2/mu**2, np.zeros(5)))\n gamma_hat_P62umu_Q83u = np.hstack((np.zeros(1), -16 * mmu**2/mu**2, np.zeros(4)))\n gamma_hat_P62utau_Q83u = np.hstack((np.zeros(2), -16 * mtau**2/mu**2, np.zeros(3)))\n\n gamma_hat_P62de_Q83d = np.hstack((-16 * me**2/md**2, np.zeros(5)))\n gamma_hat_P62dmu_Q83d = np.hstack((np.zeros(1), -16 * mmu**2/md**2, np.zeros(4)))\n gamma_hat_P62dtau_Q83d = np.hstack((np.zeros(2), -16 * mtau**2/md**2, np.zeros(3)))\n\n gamma_hat_P62se_Q83s = np.hstack((-16 * me**2/ms**2, np.zeros(5)))\n gamma_hat_P62smu_Q83s = np.hstack((np.zeros(1), -16 * mmu**2/ms**2, np.zeros(4)))\n gamma_hat_P62stau_Q83s = np.hstack((np.zeros(2), -16 * mtau**2/ms**2, np.zeros(3)))\n\n\n\n gamma_hat_P62ue_Q84u = np.hstack((np.zeros(3), -16 * me**2/mu**2, np.zeros(2)))\n gamma_hat_P62umu_Q84u = np.hstack((np.zeros(4), -16 * mmu**2/mu**2, np.zeros(1)))\n gamma_hat_P62utau_Q84u = np.hstack((np.zeros(5), -16 * mtau**2/mu**2))\n\n gamma_hat_P62de_Q84d = np.hstack((np.zeros(3), -16 * me**2/md**2, np.zeros(2)))\n gamma_hat_P62dmu_Q84d = np.hstack((np.zeros(4), -16 * mmu**2/md**2, np.zeros(1)))\n gamma_hat_P62dtau_Q84d = np.hstack((np.zeros(5), -16 * mtau**2/md**2))\n\n gamma_hat_P62se_Q84s = np.hstack((np.zeros(3), -16 * me**2/ms**2, np.zeros(2)))\n gamma_hat_P62smu_Q84s = np.hstack((np.zeros(4), -16 * mmu**2/ms**2, np.zeros(1)))\n gamma_hat_P62stau_Q84s = np.hstack((np.zeros(5), -16 * mtau**2/ms**2))\n\n\n\n gamma_hat_Q81u = np.vstack((gamma_hat_P63eu_Q81u, gamma_hat_P63muu_Q81u, gamma_hat_P63tauu_Q81u, np.zeros((15,6))))\n gamma_hat_Q81d = np.vstack((np.zeros((3,6)), gamma_hat_P63ed_Q81d, gamma_hat_P63mud_Q81d, gamma_hat_P63taud_Q81d, np.zeros((12,6))))\n gamma_hat_Q81s = np.vstack((np.zeros((6,6)), gamma_hat_P63es_Q81s, gamma_hat_P63mus_Q81s, gamma_hat_P63taus_Q81s, np.zeros((9,6))))\n\n gamma_hat_Q82u = np.vstack((gamma_hat_P63eu_Q82u, gamma_hat_P63muu_Q82u, gamma_hat_P63tauu_Q82u, np.zeros((15,6))))\n gamma_hat_Q82d = np.vstack((np.zeros((3,6)), gamma_hat_P63ed_Q82d, gamma_hat_P63mud_Q82d, gamma_hat_P63taud_Q82d, np.zeros((12,6))))\n gamma_hat_Q82s = np.vstack((np.zeros((6,6)), gamma_hat_P63es_Q82s, gamma_hat_P63mus_Q82s, gamma_hat_P63taus_Q82s, np.zeros((9,6))))\n\n gamma_hat_Q83u = np.vstack((np.zeros((9,6)), gamma_hat_P62ue_Q83u, gamma_hat_P62umu_Q83u, gamma_hat_P62utau_Q83u, np.zeros((6,6))))\n gamma_hat_Q83d = np.vstack((np.zeros((12,6)), gamma_hat_P62de_Q83d, gamma_hat_P62dmu_Q83d, gamma_hat_P62dtau_Q83d, np.zeros((3,6))))\n gamma_hat_Q83s = np.vstack((np.zeros((15,6)), gamma_hat_P62se_Q83s, gamma_hat_P62smu_Q83s, gamma_hat_P62stau_Q83s))\n\n gamma_hat_Q84u = np.vstack((np.zeros((9,6)), gamma_hat_P62ue_Q84u, gamma_hat_P62umu_Q84u, gamma_hat_P62utau_Q84u, np.zeros((6,6))))\n gamma_hat_Q84d = np.vstack((np.zeros((12,6)), gamma_hat_P62de_Q84d, gamma_hat_P62dmu_Q84d, gamma_hat_P62dtau_Q84d, np.zeros((3,6))))\n gamma_hat_Q84s = np.vstack((np.zeros((15,6)), gamma_hat_P62se_Q84s, gamma_hat_P62smu_Q84s, gamma_hat_P62stau_Q84s))\n\n\n\n\n gamma_hat = np.array([gamma_hat_Q81u, gamma_hat_Q81d, gamma_hat_Q81s, gamma_hat_Q82u, gamma_hat_Q82d, gamma_hat_Q82s,\n gamma_hat_Q83u, gamma_hat_Q83d, gamma_hat_Q83s, gamma_hat_Q84u, gamma_hat_Q84d, gamma_hat_Q84s])\n\n\n # Return the tensor\n\n # tensor, zeile, spalte\n\n return gamma_hat","def calculation_time_analysis():\n\tfrom . import spectra as sp\n\tp_dict = {'Bfield':700,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':0*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\n\tchiL,chiR,chiZ = sp.calc_chi([-3500],p_dict)\n\t\n\tfor angle in [0, np.pi/32, np.pi/16, np.pi/8, np.pi/4, np.pi/2]:\n\t\tprint(('Angle (degrees): ',angle*180/np.pi))\n\t\tRotMat, n1, n2 = solve_diel(chiL,chiR,chiZ,angle)","def estimate_pi():\n total = 0\n k = 0\n factor = 2 * sqrt(2) / 9801\n while True:\n num = factorial(4 * k) * (1103 + 26390 * k)\n den = factorial(k) ** 4 * 396 ** (4 * k)\n term = factor * num / den\n total += term\n\n if abs(term) < 1e-15:\n break\n k += 1\n\n return 1 / total","def ADT_QCD(nf):\n\n # As input for the quark-mass ratios, we use the quark masses at MZ\n ip = Num_input()\n\n mu = ip.mu_at_MZ\n md = ip.md_at_MZ\n ms = ip.ms_at_MZ\n mc = ip.mc_at_MZ\n mb = ip.mb_at_MZ\n\n # Create the ADT:\n\n gamma_hat_P63cu_Q81u = np.hstack((np.zeros(3), -48 * mc**2/mu**2, np.zeros(6)))\n gamma_hat_P63bu_Q81u = np.hstack((np.zeros(4), -48 * mb**2/mu**2, np.zeros(5)))\n\n gamma_hat_P63cd_Q81d = np.hstack((np.zeros(3), -48 * mc**2/md**2, np.zeros(6)))\n gamma_hat_P63bd_Q81d = np.hstack((np.zeros(4), -48 * mb**2/md**2, np.zeros(5)))\n\n gamma_hat_P63cs_Q81s = np.hstack((np.zeros(3), -48 * mc**2/ms**2, np.zeros(6)))\n gamma_hat_P63bs_Q81s = np.hstack((np.zeros(4), -48 * mb**2/ms**2, np.zeros(5)))\n\n\n\n gamma_hat_P63cu_Q82u = np.hstack((np.zeros(8), -48 * mc**2/mu**2, np.zeros(1)))\n gamma_hat_P63bu_Q82u = np.hstack((np.zeros(9), -48 * mb**2/mu**2))\n\n gamma_hat_P63cd_Q82d = np.hstack((np.zeros(8), -48 * mc**2/md**2, np.zeros(1)))\n gamma_hat_P63bd_Q82d = np.hstack((np.zeros(9), -48 * mb**2/md**2))\n\n gamma_hat_P63cs_Q82s = np.hstack((np.zeros(8), -48 * mc**2/ms**2, np.zeros(1)))\n gamma_hat_P63bs_Q82s = np.hstack((np.zeros(9), -48 * mb**2/ms**2))\n\n\n\n gamma_hat_P62uc_Q83u = np.hstack((np.zeros(3), -48 * mc**2/mu**2, np.zeros(6)))\n gamma_hat_P62ub_Q83u = np.hstack((np.zeros(4), -48 * mb**2/mu**2, np.zeros(5)))\n\n gamma_hat_P62dc_Q83d = np.hstack((np.zeros(3), -48 * mc**2/md**2, np.zeros(6)))\n gamma_hat_P62db_Q83d = np.hstack((np.zeros(4), -48 * mb**2/md**2, np.zeros(5)))\n\n gamma_hat_P62sc_Q83s = np.hstack((np.zeros(3), -48 * mc**2/ms**2, np.zeros(6)))\n gamma_hat_P62sb_Q83s = np.hstack((np.zeros(4), -48 * mb**2/ms**2, np.zeros(5)))\n\n\n\n gamma_hat_P62uc_Q84u = np.hstack((np.zeros(8), -48 * mc**2/mu**2, np.zeros(1)))\n gamma_hat_P62ub_Q84u = np.hstack((np.zeros(9), -48 * mb**2/mu**2))\n\n gamma_hat_P62dc_Q84d = np.hstack((np.zeros(8), -48 * mc**2/md**2, np.zeros(1)))\n gamma_hat_P62db_Q84d = np.hstack((np.zeros(9), -48 * mb**2/md**2))\n\n gamma_hat_P62sc_Q84s = np.hstack((np.zeros(8), -48 * mc**2/ms**2, np.zeros(1)))\n gamma_hat_P62sb_Q84s = np.hstack((np.zeros(9), -48 * mb**2/ms**2))\n\n\n\n gamma_hat_Q81u = np.vstack((np.zeros((19,10)), gamma_hat_P63cu_Q81u, np.zeros((7,10)), gamma_hat_P63bu_Q81u, np.zeros((52,10))))\n gamma_hat_Q81d = np.vstack((np.zeros((43,10)), gamma_hat_P63cd_Q81d, np.zeros((7,10)), gamma_hat_P63bd_Q81d, np.zeros((28,10))))\n gamma_hat_Q81s = np.vstack((np.zeros((59,10)), gamma_hat_P63cs_Q81s, np.zeros((7,10)), gamma_hat_P63bs_Q81s, np.zeros((12,10))))\n\n gamma_hat_Q82u = np.vstack((np.zeros((19,10)), gamma_hat_P63cu_Q82u, np.zeros((7,10)), gamma_hat_P63bu_Q82u, np.zeros((52,10))))\n gamma_hat_Q82d = np.vstack((np.zeros((43,10)), gamma_hat_P63cd_Q82d, np.zeros((7,10)), gamma_hat_P63bd_Q82d, np.zeros((28,10))))\n gamma_hat_Q82s = np.vstack((np.zeros((59,10)), gamma_hat_P63cs_Q82s, np.zeros((7,10)), gamma_hat_P63bs_Q82s, np.zeros((12,10))))\n\n gamma_hat_Q83u = np.vstack((np.zeros((17,10)), gamma_hat_P62uc_Q83u, np.zeros((7,10)), gamma_hat_P62ub_Q83u, np.zeros((54,10))))\n gamma_hat_Q83d = np.vstack((np.zeros((41,10)), gamma_hat_P62dc_Q83d, np.zeros((7,10)), gamma_hat_P62db_Q83d, np.zeros((30,10))))\n gamma_hat_Q83s = np.vstack((np.zeros((57,10)), gamma_hat_P62sc_Q83s, np.zeros((7,10)), gamma_hat_P62sb_Q83s, np.zeros((14,10))))\n\n gamma_hat_Q84u = np.vstack((np.zeros((17,10)), gamma_hat_P62uc_Q84u, np.zeros((7,10)), gamma_hat_P62ub_Q84u, np.zeros((54,10))))\n gamma_hat_Q84d = np.vstack((np.zeros((41,10)), gamma_hat_P62dc_Q84d, np.zeros((7,10)), gamma_hat_P62db_Q84d, np.zeros((30,10))))\n gamma_hat_Q84s = np.vstack((np.zeros((57,10)), gamma_hat_P62sc_Q84s, np.zeros((7,10)), gamma_hat_P62sb_Q84s, np.zeros((14,10))))\n\n\n\n gamma_hat = np.array([gamma_hat_Q81u, gamma_hat_Q81d, gamma_hat_Q81s, gamma_hat_Q82u, gamma_hat_Q82d, gamma_hat_Q82s,\n gamma_hat_Q83u, gamma_hat_Q83d, gamma_hat_Q83s, gamma_hat_Q84u, gamma_hat_Q84d, gamma_hat_Q84s])\n\n\n # Return the tensor for given number of active quark flavors\n\n # tensor, zeile, spalte\n\n if nf == 5:\n return gamma_hat\n elif nf == 4:\n return np.delete(np.delete(gamma_hat, np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80]], 1), [4, 9], 2)\n else:\n raise Exception(\"nf has to be 4 or 5\")","def test_mag_form_fac_case2():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac(qrange=[0, 2])[0], ion.calc_mag_form_fac(qrange=[0, 2])[1:]\n del _temp\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)","def ddq_a(self, q = np.zeros(1) , dq = np.zeros(1) , T = np.zeros(1) , R = 1 , t = 0 ): \n \n \n Ha = self.H( q ) + np.dot( R , np.dot( R , self.Ia ) )\n \n C = self.C( q , dq )\n D = self.D( q , dq )\n \n Ca = C + D + np.dot( R , np.dot( R , self.Da ) )\n \n G = self.G( q )\n \n # Disturbance force\n f_d = self.F_dist( t )\n \n ddq = np.dot( 1. / Ha , ( np.dot( R , T ) + self.F_ext( q , dq ) - f_d - np.dot( Ca , dq ) - G ) )\n \n return ddq","def fourier_coeff(period,f):\n if(period!=int(period) or period<1):\n raise ValueError(\n \"period must be positive integer\"\n )\n if(len(f)!=period):\n raise ValueError(\n \"f must contain exactly period number of values\"\n )\n g = []\n for n in range(0,period):\n sum = complex(0,0)\n for m in range(0,period):\n sum = sum + (f[m]*cmath.rect(1,-1*(2*(math.pi)*m*n)/period ) )\n sum = sum/period\n g.append(sum)\n return g","def _fd_matrix(step_ratio, parity, nterms):\n _assert(0 <= parity <= 6,\n 'Parity must be 0, 1, 2, 3, 4, 5 or 6! ({0:d})'.format(parity))\n step = [1, 2, 2, 4, 4, 4, 4][parity]\n inv_sr = 1.0 / step_ratio\n offset = [1, 1, 2, 2, 4, 1, 3][parity]\n c0 = [1.0, 1.0, 1.0, 2.0, 24.0, 1.0, 6.0][parity]\n c = c0 / \\\n special.factorial(np.arange(offset, step * nterms + offset, step))\n [i, j] = np.ogrid[0:nterms, 0:nterms]\n return np.atleast_2d(c[j] * inv_sr ** (i * (step * j + offset)))","def Q(self):\n return np.array(list(self.center_frequencies)) \\\n / np.array(list(self.bandwidths))","def dI_SZ(self, l):\n # Valid in RJ limit, x << 1\n \n # Get dimensionless frequency\n x = X_SCALE * NU_WMAP_W / ( T_CMB * (1. + self.z) )\n \n # Integrate pressure profile at fixed radius\n xmax = 5. * self.r500; xmin = -xmax\n pp, err = scipy.integrate.quad( lambda x: self.xP(np.sqrt(x**2. + l**2.)), \n xmin, xmax )\n y = Y_SCALE * pp * self._P500\n dI = -2. * y * (1. + 0.5*x)\n return dI","def IDFT(fourier_signal):\n n = fourier_signal.shape[0]\n omega = np.exp((((2 * np.pi)*1j) / n))\n\n e_items = np.vander(omega**np.arange(n), n, True)\n org_signal = np.dot(e_items, fourier_signal)/n\n\n return org_signal","def focused_diameter(f, lambda0, d, M2=1):\n return 4 * M2**2 * lambda0 * f / (np.pi * d)","def _mbondi_radii(atom_list):\n radii = [0.0 for atom in atom_list]\n for i, atom in enumerate(atom_list):\n # Radius of H atom depends on element it is bonded to\n if atom.type.atomic_number == 1:\n bondeds = list(atom.bond_partners)\n if bondeds[0].type.atomic_number in (6, 7): # C or N\n radii[i] = 1.3\n elif bondeds[0].type.atomic_number in (8, 16): # O or S\n radii[i] = 0.8\n else:\n radii[i] = 1.2\n # Radius of C atom depends on what type it is\n elif atom.type.atomic_number == 6:\n radii[i] = 1.7\n # All other elements have fixed radii for all types/partners\n elif atom.type.atomic_number == 7:\n radii[i] = 1.55\n elif atom.type.atomic_number == 8:\n radii[i] = 1.5\n elif atom.type.atomic_number == 9:\n radii[i] = 1.5\n elif atom.type.atomic_number == 14:\n radii[i] = 2.1\n elif atom.type.atomic_number == 15:\n radii[i] = 1.85\n elif atom.type.atomic_number == 16:\n radii[i] = 1.8\n elif atom.type.atomic_number == 17:\n radii[i] = 1.5\n else:\n radii[i] = 1.5\n return radii # converted to nanometers above","def boxcar(self, box_dm: float = 0.5, n: int = 4, el_included=None, m_uplim: float=np.inf, is_info: bool = False):\n clone = self.clone()\n abund = clone.abund()\n # abun = np.zeros((clone.nzon, len(clone.Elements)))\n if el_included is None:\n el_included = clone.Elements\n if m_uplim is None:\n m_uplim = np.inf\n m = clone.m / phys.M_sun\n dmass = np.diff(m)\n dmass = np.insert(dmass, -1, dmass[-1])\n\n # todo Check left boundary condition fo Fe, Si\n for l in range(n): # the iteration number\n logger.debug(f'Attempt # {l}')\n for k in range(clone.nzon):\n if m[k] > m_uplim:\n logger.warn(f'Exit from zone cycle m[k] > m_uplim: k= {k} m= {m[k]:.4f} m_uplim= {m_uplim:.4f}')\n break # stop because mass is over the limit\n kk = k + 1\n dm = dmass[k]\n while dm < box_dm and kk <= clone.nzon:\n kk += 1\n dm = np.sum(dmass[k:kk])\n\n logger.debug(f'{k}: kk= {kk} dm= {dm:.4f} m= {m[k]:.4f}')\n if dm > 1e-6:\n for i, ename in enumerate(clone.Elements):\n if ename in el_included:\n dm_e = np.dot(abund[k:kk, i], dmass[k:kk])\n abund[k, i] = dm_e / dm\n # abun[k,i] = x[k]\n for i, ename in enumerate(clone.Elements):\n clone.set_chem(ename, abund[:, i]) \n logger.debug(f\"{ename}: {clone.el(ename)}\")\n\n return clone","def omega(self, i, rosetta_definitions = True):\n res = self.all_residues[i]\n\n try:\n n = res['N'].get_vector()\n ca = res['CA'].get_vector()\n c = res['C'].get_vector()\n\n\n\n if rosetta_definitions and i < len(self.all_residues) -1 and self.connected_to_next(i):\n res_plus_one = self.all_residues[i + 1]\n next_n = res_plus_one['N'].get_vector()\n next_ca = res_plus_one['CA'].get_vector()\n omega = calc_dihedral(ca, c, next_n, next_ca)\n return omega\n\n elif not rosetta_definitions and i > 1 and self.connected_to_previous(i):\n res_minus_one = self.all_residues[i - 1]\n pre_c = res_minus_one['C'].get_vector()\n pre_ca = res_minus_one['CA'].get_vector()\n omega = calc_dihedral(pre_ca, pre_c, n, ca)\n return omega\n else:\n return 0.0\n\n except BaseException:\n print \"Could not get omega for \"+repr(i)\n raise LookupError","def getDistMat(structure, tol):\n \n if tol>1:\n print('WARNING: Increase in radius is greater than 100%')\n \n # Find interatomic distances)\n s = structure\n distance_matrix = np.array(s.distance_matrix)\n \n \n # Ensure diagonal will be identified as not bonded\n np.fill_diagonal(distance_matrix,100)\n\n radii = [ELEMENT_RADII[site.species_string] for site in s.sites]\n radiiS = []\n for r in radii:\n radiiS.append(r*(1+tol))\n radii_transpose = np.array(radii)[np.newaxis].T\n \n \n # Create matrix for sum of radii of each species, scaled by 'tol'\n radii_matrix = radiiS + radii_transpose*(1+tol)\n \n \n # Take difference between atomic distances and summed radii\n temp = distance_matrix-radii_matrix\n \n \n # Turn bonded indexes to '1' and non-bonded to '0'\n binary_matrix = (temp < 0).astype(int)\n return(binary_matrix)","def computeA(diameter):\n radius = diameter / 2.0\n return np.pi * (radius**2)","def test_units_normalized_fourier_transform():\n fake_data = np.zeros((1, 13, 21)) * units.m\n fake_data[0, 7, 11] += 1 * units.m\n fake_corr = utils.normalized_fourier_transform(\n fake_data, 1 * units.Hz, taper=windows.boxcar, axis=2\n )\n test_units = units.m * units.Hz\n assert test_units == fake_corr.unit","def DFT(signal):\n n = signal.shape[0]\n omega = np.exp(((((-2) * np.pi)*1j) / n))\n\n e_items = np.vander(omega**np.arange(n), n, True)\n fourier_signal = np.dot(e_items, signal)\n\n return fourier_signal.astype(np.complex128)","def generate_fiducial(seed=235, th=150, time=0.5):\n \n # impact parameters\n M = 3e7*u.Msun\n B = 19.95*u.kpc\n B = 20.06*u.kpc\n V = 190*u.km/u.s\n phi = coord.Angle(0*u.deg)\n th = 155\n theta = coord.Angle(th*u.deg)\n Tenc = 0.01*u.Gyr\n T = time*u.Gyr\n dt = 0.05*u.Myr\n rs = 0*u.pc\n \n # potential parameters\n potential = 3\n Vh = 220*u.km/u.s\n q = 1*u.Unit(1)\n rhalo = 20*u.pc\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\n \n # setup tube\n Nstar = 4000\n wx = 30*u.kpc\n wy = 0*u.pc\n wz = 0*u.pc\n sx = 0*u.km/u.s\n \n np.random.seed(seed)\n observer = {'z_sun': -2000.*u.pc, 'galcen_distance': 8.3*u.kpc, 'roll': 50*u.deg, 'galcen_coord': coord.SkyCoord(ra=300*u.deg, dec=-90*u.deg, frame='icrs')}\n vobs = {'vcirc': 220*u.km/u.s, 'vlsr': [0, 0, 0]*u.km/u.s}\n wangle = 180*u.deg\n \n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\n #xphi0 = np.linspace(-0.1*np.pi, 0.1*np.pi, 2000)\n #xphi1 = np.linspace(-0.28*np.pi, -0.1*np.pi, 400)\n #xphi2 = np.linspace(0.1*np.pi, 0.32*np.pi, 400)\n #xphi = np.concatenate([xphi1, xphi0, xphi2])\n \n xr = 20*u.kpc + np.random.randn(Nstar)*0.0*u.kpc\n x = np.sin(xphi) * xr\n y = np.cos(xphi) * xr\n z = x * 0\n vx = -np.cos(xphi) * Vh\n vy = np.sin(xphi) * Vh\n vz = vx * 0\n # closest to impact\n ienc = np.argmin(np.abs(x))\n \n # generate stream model\n potential_perturb = 1\n par_perturb = np.array([M.si.value, 0., 0., 0.])\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal = coord.Galactocentric(stream['x'], **observer)\n xeq = xgal.transform_to(coord.ICRS)\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\n veq = [None] * 3\n veq[0] = veq_[0].to(u.mas/u.yr)\n veq[1] = veq_[1].to(u.mas/u.yr)\n veq[2] = veq_[2].to(u.km/u.s)\n \n # unperturbed stream\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream0 = {}\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\n xeq0 = xgal0.transform_to(coord.ICRS)\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\n veq0 = [None] * 3\n veq0[0] = veq0_[0].to(u.mas/u.yr)\n veq0[1] = veq0_[1].to(u.mas/u.yr)\n veq0[2] = veq0_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n R = find_greatcircle(xeq0.ra.deg[::10], xeq0.dec.deg[::10])\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\n xi0 = coord.Angle(xi0*u.deg)\n \n # place gap at xi~0\n xioff = xi0[ienc]\n xi0 -= xioff\n \n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\n xi = coord.Angle(xi*u.deg)\n xi -= xioff\n \n # velocity differences\n dv = []\n for i in range(3):\n # interpolate expected kinematics from an unperturbed stream\n vexp = np.interp(xi.wrap_at(wangle), xi0.wrap_at(wangle), veq0[i].value) * veq0[i].unit\n dv += [veq[i]-vexp]\n \n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'veq': veq, 'dv': dv, 'observer': observer, 'vobs': vobs, 'R': R, 'xioff': xioff, 'x0': stream0['x'], 'v0': stream0['v'], 'xi0': xi0, 'eta0': eta, 'veq0': veq0}\n pickle.dump(outdict, open('../data/gd1_fiducial_t{:.4f}.pkl'.format(time), 'wb'))","def __q2v_cf(self, w, rhom, q):\n return float(q / (rhom + q / w))","def homogeneousDirichlet(N, Nq, f):\n A, F, edge, p, tri = createAandF(f, N, Nq)\n nodes = np.unique(edge)\n F[nodes] = 0\n epsilon = 1e-16\n A[nodes, nodes] = 1 / epsilon\n u = np.linalg.solve(A, F)\n return u, p","def dipolePotential(x,y,q,d):\n k = 8.99e9\n V = (k * q) / (sqrt(x**2 + (y - d)**2)) - (k * q) / (sqrt(x**2 + (y + d)**2))\n return V","def lindivQ(sample, quantity, criteria=len):\n sizes = [criteria(dna) for dna in sample]\n return [size*quantity/sum(sizes) for size in sizes]","def ADM_QED(nf):\n Qu = 2/3\n Qd = -1/3\n Qe = -1\n nc = 3\n gamma_QED = np.array([[8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc],\n [8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc],\n [8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc],\n [8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc],\n [8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc],\n [8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qd, 8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qe, 8/3*Qe*Qe, 8/3*Qe*Qe],\n [8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qd, 8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qe, 8/3*Qe*Qe, 8/3*Qe*Qe],\n [8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qd, 8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qe, 8/3*Qe*Qe, 8/3*Qe*Qe]])\n gamma_QED_1 = np.zeros((2,154))\n gamma_QED_2 = np.hstack((np.zeros((8,2)),gamma_QED,np.zeros((8,144))))\n gamma_QED_3 = np.hstack((np.zeros((8,10)),gamma_QED,np.zeros((8,136))))\n gamma_QED_4 = np.zeros((136,154))\n gamma_QED = np.vstack((gamma_QED_1, gamma_QED_2, gamma_QED_3, gamma_QED_4))\n\n if nf == 5:\n return gamma_QED\n elif nf == 4:\n return np.delete(np.delete(gamma_QED, [6, 14, 22, 30, 42, 50, 58, 66, 74, 82, 94, 102, 110, 118, 126, 134, 142, 150], 0)\\\n , [6, 14, 22, 30, 42, 50, 58, 66, 74, 82, 94, 102, 110, 118, 126, 134, 142, 150], 1)\n elif nf == 3:\n return np.delete(np.delete(gamma_QED, [5,6, 13,14, 21,22, 29,30, 41,42, 49,50, 57,58, 65,66, 73,74, 81,82,\\\n 93,94, 101,102, 109,110, 117,118, 125,126, 133,134, 141,142, 149,150], 0)\\\n , [5,6, 13,14, 21,22, 29,30, 41,42, 49,50, 57,58, 65,66, 73,74, 81,82,\\\n 93,94, 101,102, 109,110, 117,118, 125,126, 133,134, 141,142, 149,150], 1)\n else:\n raise Exception(\"nf has to be 3, 4 or 5\")","def EulerBucklingForce(I, E, L):\n # http://en.wikipedia.org/wiki/Buckling\n K = 2.0 # for a vertical cantilever\n F = np.pi**2 * E*I / (K*L)**2\n return F","def _like4(init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoef, i):\r\n\t\r\n\tplx_mod, v, sigma_v = init_par[i], init_par[-4:-1], init_par[-1] \r\n\tp, q, r = normalTriad(alpha, delta)\r\n\tmualpha_mod = np.dot(np.transpose(p),v)*plx_mod/_A ### [mas/yr]\r\n\tmudelta_mod = np.dot(np.transpose(q),v)*plx_mod/_A ### [mas/yr]\r\n\t### Add the model vector for the radial velocities:\r\n\tvrad_mod = np.dot(np.transpose(r),v) ### [km/s]\r\n \t\r\n\tsigma_plx, sigma_mualpha, sigma_mudelta = np.transpose(sigma_obs)\r\n\tC = np.zeros((4,4),dtype=np.float64) ### This is a 4x4 matrix \r\n\t### Diagonal terms:\r\n\tC[0,0],C[1,1],C[2,2] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\r\n\tC[3,3] = sigma_vrad**2.\r\n\t\r\n\tr_plx_muRa, r_plx_muDec, r_muRa_muDec = ccoef[0], ccoef[1], ccoef[2] \r\n \r\n\t### Correlation terms:\r\n\tC[0,1], C[0,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_plx_muDec*sigma_plx*sigma_mudelta\r\n\tC[1,0], C[1,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_muRa_muDec*sigma_mualpha*sigma_mudelta\r\n\tC[2,0], C[2,1] = r_plx_muDec*sigma_plx*sigma_mudelta, r_muRa_muDec*sigma_mualpha*sigma_mudelta\r\n\r\n\tE = np.zeros((4,4),dtype=np.float64) ### 4x4 matrix \r\n\tE[1,1],E[2,2] = (sigma_v**2.)*(plx_mod/_A)**2., (sigma_v**2.)*(plx_mod/_A)**2. ### [mas/yr]\r\n\tE[3,3] = sigma_v**2.\t\t\t\t\t\t\t\t ### [km/s]\r\n\r\n\t\r\n\tD = np.add(E,C)\r\n\tdetD = det(D) \r\n\tinvD = inv(D)\r\n\t\t\r\n\ta_c = np.array([plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod, vrad_obs - vrad_mod])\r\n\tg_func = row_matrix_col_4d(a_c, a_c, invD) \r\n\t\r\n\t\r\n\treturn detD, g_func","def chi_c_real(params):\n Qi = Q_i(params)\n Qc = params['Q_e_real'].value\n return ((4 * Qc * Qi) /\n (Qc + Qi) ** 2)","def _Q(self, chi, eta, L):\n return self.r**2 * chi**2 * np.cos(eta)**2 + L**2 / np.tan(self.theta)**2","def find_basis_normal(q):\n n, T = q.shape\n\n f1 = zeros((n, T))\n f2 = zeros((n, T))\n for i in range(0, T):\n f1[:, i] = q[0, i] * q[:, i] / norm(q[:, i]) + array([norm(q[:, i]),\n 0])\n f2[:, i] = q[1, i] * q[:, i] / norm(q[:, i]) + array([0,\n norm(q[:, i])])\n\n h3 = f1\n h4 = f2\n integrandb3 = zeros(T)\n integrandb4 = zeros(T)\n for i in range(0, T):\n a = q[:, i].T\n integrandb3[i] = a.dot(h3[:, i])\n integrandb4[i] = a.dot(h4[:, i])\n\n b3 = h3 - q * trapz(integrandb3, linspace(0, 1, T))\n b4 = h4 - q * trapz(integrandb4, linspace(0, 1, T))\n\n basis = [b3, b4]\n\n return (basis)","def conc_final(V, R, Q):\n if Q > 0:\n C = 0.21/(Q+R)*Q\n elif abs(Q) <= abs(R):\n C = 0\n elif abs(Q) > abs(R):\n C = 0.21*(1-R/abs(Q))\n return C","def qfunc(x):\n # Error check inputs\n if isinstance(x, np.ndarray):\n if x.dtype == np.complex128:\n raise TypeError(\"complex input not supported\")\n else:\n if isinstance(x, complex):\n raise TypeError(\"complex input not supported\")\n\n Q = 0.5 * erfc(x / np.sqrt(2.0))\n return Q"],"string":"[\n \"def StructureFactor(ID,f,hkl,z=None):\\n ID=goodID(ID)\\n i=complex(0,1)\\n h=hkl[0]\\n k=hkl[1]\\n l=hkl[2]\\n L=latticeType[ID]\\n if L=='fcc':\\n F=f*(1+np.exp(-i*np.pi*(k+l))+np.exp(-i*np.pi*(h+l))+np.exp(-i*np.pi*(h+k)))\\n elif L=='bcc':\\n F=f*(1+np.exp(-i*np.pi*(h+k+l))) \\n elif L=='cubic':\\n F=f\\n elif L=='diamond':\\n F=f*(1+np.exp(-i*np.pi*(k+l))+np.exp(-i*np.pi*(h+l))+np.exp(-i*np.pi*(h+k)))*(1+np.exp(-i*2*np.pi*(h/4.0+k/4.0+l/4.0)))\\n # elif L=='rhomb':\\n # z=latticeParamRhomb[ID]\\n # F=f*(1+np.exp(2*i*np.pi*(h+k+l)*z)) \\n elif L=='tetr':\\n F=f\\n elif L=='hcp':\\n F=f*(1+np.exp(2*i*np.pi*(h/3.0+2*k/3.0+l/2.0)))\\n else:\\n raise Exception(f'Unrecognized L: {L}')\\n return F\",\n \"def qft(self) -> None:\\n random.seed(self.seed)\\n self.__qft_input_state(self.circ_size)\\n\\n for i in range(self.circ_size):\\n for j in range(i):\\n self.cu1(math.pi / float(2 ** (i - j)), i, j)\\n self.h(i)\\n\\n if self.meas: self.measure(self.qr, self.cr)\",\n \"def Magnus4(self,direction='x'):\\n self.reset()\\n self.mol.orthoDen()\\n self.mol.orthoFock()\\n h = -1j*self.stepsize\\n for idx,time in enumerate((self.time)):\\n if direction.lower() == 'x':\\n self.mol.computeDipole()\\n self.dipole.append(np.real(self.mol.mu[0]))\\n elif direction.lower() == 'y':\\n self.mol.computeDipole()\\n self.dipole.append(np.real(self.mol.mu[1]))\\n elif direction.lower() == 'z':\\n self.mol.computeDipole()\\n self.dipole.append(np.real(self.mol.mu[2]))\\n # record pulse envelope for later plotting, etc.\\n self.shape.append(self.pulse(time))\\n curDen = np.copy(self.mol.PO)\\n \\n self.addField(time + 0.0*self.stepsize,direction=direction)\\n k1 = h*self.mol.FO \\n Q1 = k1\\n U = expm(0.5*Q1)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n self.addField(time + 0.5*self.stepsize,direction=direction)\\n k2 = h*self.mol.FO\\n Q2 = k2 - k1\\n U = expm(0.5*Q1 + 0.25*Q2)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n\\n self.addField(time + 0.5*self.stepsize,direction=direction)\\n k3 = h*self.mol.FO\\n Q3 = k3 - k2\\n U = expm(Q1 + Q2)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n\\n self.addField(time + 1.0*self.stepsize,direction=direction)\\n k4 = h*self.mol.FO\\n Q4 = k4 - 2*k2 + k1\\n L = 0.5*Q1 + 0.25*Q2 + (1/3.)*Q3 - (1/24.)*Q4\\n L += -(1/48.)*self.mol.comm(Q1,Q2)\\n U = expm(L)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n self.addField(time + 0.5*self.stepsize,direction=direction)\\n k5 = h*self.mol.FO\\n Q5 = k5 - k2 \\n L = Q1 + Q2 + (2/3.)*Q3 + (1/6.)*Q4 - (1/6.)*self.mol.comm(Q1,Q2)\\n U = expm(L)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n self.addField(time + 1.0*self.stepsize,direction=direction)\\n k6 = h*self.mol.FO\\n Q6 = k6 -2*k2 + k1\\n L = Q1 + Q2 + (2/3.)*Q5 + (1/6.)*Q6\\n L += -(1/6.)*self.mol.comm(Q1, (Q2 - Q3 + Q5 + 0.5*Q6))\\n\\n U = expm(L)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n # density and Fock are done updating, wrap things up\\n self.mol.unOrthoFock() \\n self.mol.unOrthoDen() \\n self.mol.computeEnergy()\\n self.Energy.append(np.real(self.mol.energy))\",\n \"def _structure_factor_wave_number(\\n rdf: freud.density.RDF, wave_number: float, num_particles: int\\n):\\n dr = rdf.R[1] - rdf.R[0]\\n integral = dr * np.sum((rdf.RDF - 1) * rdf.R * np.sin(wave_number * rdf.R))\\n density = num_particles / rdf.box.volume\\n return 1 + 4 * np.pi * density / wave_number * integral\",\n \"def do_factor(m=4, q=11):\\n from sage.rings.finite_rings.integer_mod_ring import IntegerModRing\\n from sage.matrix.constructor import identity_matrix, block_matrix\\n from sage.matrix.matrix_space import MatrixSpace\\n from sage.rings.integer_ring import IntegerRing\\n from sage.modules.free_module_integer import IntegerLattice\\n \\n \\n m=n+1\\n ZZ = IntegerRing()\\n ZZ_q = IntegerModRing(q)\\n \\n \\n \\n from sage.arith.all import euler_phi\\n from sage.misc.functional import cyclotomic_polynomial\\n \\n for a in range(\\n R = ZZ_q['x']#.quotient(cyclotomic_polynomial(k, 'x'), 'x')\\n f=cyclotomic_polynomial(m,'x')\\n return f.factor()\",\n \"def sqrtCF(d):\\n sqrtD = sqrt(d)\\n P = 0\\n Q = 1\\n while True:\\n a = int(floor((P + sqrtD) / Q))\\n yield a\\n P = a * Q - P\\n Q = (d - P*P) // Q # It can be shown that Q evenly divides d - P*P\",\n \"def QCD(fp):\\n lqcd = unpack('>H', fp.read(2))[0]\\n sqcd = unpack('B', fp.read(1))[0]\\n\\n _spqcd = []\\n _remaining = lqcd - 3\\n bitstring = '{:>08b}'.format(sqcd)\\n while _remaining > 0:\\n if bitstring[3:] == '00000':\\n # xxx0 0000: no quantisation\\n _spqcd.append(unpack('B', fp.read(1))[0])\\n _remaining -= 1\\n elif bitstring[3:] == '00001':\\n # xxx0 0001: scalar derived\\n _spqcd.append(unpack('>H', fp.read(2))[0])\\n _remaining -= 2\\n elif bitstring[3:] == '00010':\\n # xxx0 0010: scalar expounded\\n _spqcd.append(unpack('>H', fp.read(2))[0])\\n _remaining -= 2\\n else:\\n raise NotImplementedError('QCD invalid value')\\n\\n #guard_bits = int(bitstring[3:], 2)\\n\\n info = {\\n 'Lqcd' : lqcd,\\n 'Sqcd' : sqcd,\\n 'SPqcd' : _spqcd\\n }\\n\\n return info\",\n \"def pointChargeElecFluxDensity(q: T, r: T) -> float:\\n return q / surfaceIntSphere(r)\",\n \"def get_coherent_scattering_factor(self, element: str, q):\\n if element not in self.coherent_param.index.values:\\n raise ElementNotImplementedException(element)\\n fs_coh = 0\\n s = q / (4 * np.pi)\\n for ind in range(1, 5):\\n A = self.coherent_param['A' + str(ind)][element]\\n B = self.coherent_param['B' + str(ind)][element]\\n fs_coh += A * np.exp(-B * s ** 2)\\n\\n C = self.coherent_param['C'][element]\\n fs_coh += C\\n return fs_coh\",\n \"def get_coherent_scattering_factor(self, element: str, q):\\n if element not in self.coherent_params.index.values:\\n raise ElementNotImplementedException(element)\\n fs_coh = 0\\n s = q / (4 * np.pi)\\n for ind in range(1, 5):\\n A = self.coherent_params['a' + str(ind)][element]\\n B = self.coherent_params['b' + str(ind)][element]\\n fs_coh += A * np.exp(-B * s ** 2)\\n\\n C = self.coherent_params['c'][element]\\n fs_coh += C\\n return fs_coh\",\n \"def _Schoof_mod_l(self, l):\\n if l == 2:\\n return self._Schoof_mod2()\\n E = self.cubic\\n D = self.division_polynomials\\n lth_div = self.division_polynomials[l]\\n field = self.basefield\\n bfsize = card(field)\\n x = UniVarPolynomial({1:field.one}, field)\\n k = bfsize % l\\n x_frob = PolyPow(x, bfsize, lth_div) #x_frob=x^q\\n x_frobfrob = PolyPow(x_frob, bfsize, lth_div) #x_frobfrob=x^{q^2}\\n\\n # test for x^{q^2} - x\\n f, P = self._sub1(k, x_frobfrob - x, lth_div)\\n f0, f3 = f[0], f[3]\\n\\n if GCD(lth_div, P).degree() > 0:\\n if arith1.legendre(k, l) == -1:\\n _log.debug(\\\"%s $\\\" % str((0, l)))\\n return (0, l)\\n\\n # arith1.legendre(k, l) == 1 <=> k is QR\\n w = arith1.modsqrt(k, l)\\n f, P = self._sub1(w, x_frob - x, lth_div)\\n\\n if GCD(lth_div, P).degree() == 0: # coprime\\n _log.debug(\\\"%s $$$$\\\" % str((0, l)))\\n return (0, l)\\n\\n # there exist non trivial common divisors\\n g0 = PolyPow(E, (bfsize - 1) // 2, lth_div) #y^(q-1)\\n P = self._sub2(w, g0, f[3], lth_div)\\n\\n if GCD(lth_div, P).degree() > 0:\\n _log.debug(\\\"%s $$\\\" % str((2*w % l, l)))\\n return (2*w % l, l)\\n else:\\n _log.debug(\\\"%s $$$\\\" % str((-2*w % l, l)))\\n return (-2*w % l, l)\\n\\n else: # coprime (GCD(P, lth_div).degree() == 0)\\n Y = x - x_frobfrob\\n g0 = PolyPow(E, (bfsize - 1) // 2, lth_div) #y^(q-1)\\n g1 = PolyPow(g0, bfsize + 1, lth_div) #y^(q^2-1)\\n f = -self._sub2(k, g1, f3, lth_div)\\n h1 = PolyMulRed([f, f], lth_div)\\n if k % 2 == 0:\\n g = (PolyMulRed([Y, E, f3], lth_div) - f0) * 4\\n h0 = PolyMulRed([g, g], lth_div)\\n aux1 = PolyMulRed([f0, h0], lth_div) + h1\\n X_d = PolyMulRed([E, f3, h0], lth_div)\\n else:\\n g = (PolyMulRed([Y, f3], lth_div) - PolyMulRed([E, f0], lth_div)) * 4\\n h0 = PolyMulRed([g, g], lth_div)\\n aux1 = PolyMulRed([E, PolyMulRed([f0, h0], lth_div) + h1], lth_div)\\n X_d = PolyMulRed([f3, h0], lth_div)\\n X_n = PolyMulRed([X_d, x_frobfrob + x_frob + x], lth_div) - aux1\\n\\n # loop of t\\n e_q = PolyPow(self.cubic, bfsize, lth_div)\\n for t in range(1, (l - 1)//2 + 1):\\n Z_d_x, Z_n_x = self._Z_x(t, D, e_q, bfsize, lth_div)\\n # X_n * Z_d_x == X_d * Z_n_x (mod lth_div)?\\n if not PolyMod(X_n * Z_d_x - X_d * Z_n_x, lth_div):\\n break\\n else: # loop of t exhausted\\n _log.debug(\\\"%s @@@\\\" % str((0, l)))\\n return (0, l)\\n\\n # found: X_n * Z_d_x == X_d * Z_n_x (mod lth_div)\\n y0 = PolyMulRed([-2*x_frobfrob - x, X_d], lth_div) + aux1\\n if k % 2 == 0:\\n Y_d = PolyMulRed([E, D[k], g, X_d], lth_div)\\n else:\\n Y_d = PolyMulRed([D[k], g, X_d], lth_div)\\n Y_n = -PolyMulRed([g1, Y_d], lth_div) - PolyMulRed([f, y0], lth_div)\\n Z_d_y, Z_n_y = self._Z_y(t, D, g0, bfsize, lth_div)\\n\\n # Y_n * Z_d_y == Y_d * Z_n_y (mod lth_div)?\\n if PolyMod(Y_n * Z_d_y - Y_d * Z_n_y, lth_div):\\n _log.debug(\\\"%s @@\\\" % str((l-t, l)))\\n return (l-t, l)\\n else:\\n _log.debug(\\\"%s @\\\" % str((t, l)))\\n return (t, l)\",\n \"def q_(w,R,lam=1064.0e-9):\\n\\n if R!=np.inf:\\n q=np.pi*w**2*R/(np.pi*w**2-1j*R*lam)\\n else:\\n q=1j*np.pi*w**2/lam\\n\\n return q\",\n \"def cdq4(f, x, h=1e-5):\\n return (f(x-2*h) - 8*f(x-h) + 8*f(x+h) - f(x+2*h))/(12*h)\\n raise NotImplementedError(\\\"Problem 2 Incomplete\\\")\",\n \"def _list_coefficients_by_discriminant(self, fd=True, pos=True, neg=True, printimag=False, norm_neg=True, dmin=0, dmax=0, latex=False, nd=0, Lvals=False, prime=False):\\n sig = 1\\n S = \\\"$\\\"\\n if(self._space.WR.is_dual()):\\n sig = -1\\n maxn = max(self._coeffs[list(self._coeffs.keys())[0]].keys())\\n maxD = self._space.WR.level() * (maxn + 1)\\n N = self._space.WR.N\\n if(dmax > 0):\\n w1 = len(str(dmax)) + 1\\n else:\\n w1 = len(str(maxD)) + 1\\n w2 = max(list(map(len, str(self._space.WR.D()).split())))\\n w3 = len(str(maxn)) + 1\\n mp0 = mpmath.mpf(0)\\n mpold = mpmath.mp.dps\\n if(mpmath.mp.dps < self.maxdigs):\\n mpmath.mp.dps = self.maxdigs\\n if(norm_neg and neg):\\n cnorm = 0\\n tnorm = (0, 0)\\n for j in range(1, 100):\\n t = rn_from_D(self.space.WR, -j * sig)\\n if(t is None):\\n continue\\n if(t[1] + self._space.WR.Qv[t[0]] >= 0):\\n continue\\n c1 = self.get_coefficient(t[0], t[1])\\n if(c1 is None):\\n continue\\n # print \\\"c1 =\\\",c1\\n # If the first coefficient is zero to the precision we assume we shouldn't divide by it\\n if(abs(c1) > mpmath.power(10, -self.prec)):\\n cnorm = c1 * mpmath.sqrt(j)\\n tnorm = t\\n print(\\\"c1=c({0})=c({1})={2}\\\".format(tnorm, -j * sig, cnorm))\\n break\\n\\n for sn in [1, -1]:\\n for D in range(1, maxD):\\n # print \\\"D=\\\",D\\n if(dmin > 0 and abs(D) < dmin):\\n continue\\n if dmax > 0 and abs(D) > dmax:\\n continue\\n DD = sig * D * sn\\n # print \\\"D=\\\",D,is_fundamental_discriminant(D)\\n if fd and not is_fundamental_discriminant(DD) and DD != 1:\\n # print \\\"D=\\\",D,is_fundamental_discriminant(D)\\n continue\\n if prime and gcd(D, N) > 1:\\n continue\\n t = rn_from_D(self._space.WR, DD)\\n if t is None:\\n continue\\n else:\\n (r, n) = t\\n # print \\\" DD=\\\",DD,t\\n nn = n + self._space.WR.Qv[r]\\n if(not pos and nn >= 0):\\n continue\\n if(not neg and nn < 0):\\n continue\\n\\n c = self.get_coefficient(r, n)\\n cs = \\\"\\\"\\n erms = \\\"\\\"\\n erm = 10\\n if c != 0 and c is not None:\\n if nn >= 0:\\n ss = \\\"+\\\"\\n if nn < 0:\\n ss = \\\"-\\\"\\n if(norm_neg):\\n if ((r, n) != tnorm) and cnorm != 0:\\n c = c / cnorm * mpmath.sqrt(mpmath.mpf(abs(D)))\\n x = c.real()\\n x1 = floor(x)\\n x2 = ceil(x)\\n er1 = abs(x1 - x)\\n er2 = abs(x2 - x)\\n erm = min(er1, er2)\\n erms = sci_pretty_print(erm, 2, latex_pow=latex)\\n if(erm < 0.001):\\n if(er1 < er2):\\n cs = str(x1)\\n else:\\n cs = str(x2)\\n elif not printimag:\\n if(nd > 0):\\n cs = str(c.real()).strip()\\n cs = sci_pretty_print(cs, nd, latex_pow=latex)\\n else:\\n cs = str(c.real())\\n else:\\n if(nd > 0):\\n cs = str(c).strip()\\n cs = sci_pretty_print(cs, nd, latex_pow=latex)\\n else:\\n cs = str(c)\\n if(c.real() >= 0 and latex):\\n cs = r\\\"\\\\hphantom{-}\\\" + cs\\n elif(c.real() >= 0):\\n cs = \\\" \\\" + cs\\n if(latex):\\n O = \\\" & \\\"\\n if(Lvals and list(self._Lv.keys()).count(DD) == 1):\\n ls = \\\"&\\\" + S + sci_pretty_print(self._Lv[DD], nd, latex_pow=latex) + S\\n else:\\n ls = \\\"\\\"\\n if(len(erms) == 0):\\n s = S + str(DD).center(w1) + S + \\\"&\\\" + S + cs + S + ls + \\\"\\\\\\\\\\\\\\\\\\\"\\n else:\\n s = S + str(DD).center(w1) + S + \\\"&\\\" + S + cs + S + ls + O + S + erms + S + \\\"\\\\\\\\\\\\\\\\\\\"\\n else:\\n if(Lvals and list(self._Lv.keys()).count(DD) == 1):\\n ls = \\\"\\\\t\\\" + sci_pretty_print(self._Lv[DD], nd)\\n else:\\n ls = \\\"\\\"\\n if(len(erms) == 0):\\n s = \\\"C^\\\" + ss + \\\"[\\\" + str(DD).center(w1) + \\\"] = \\\" + cs + ls\\n else:\\n s = \\\"C^\\\" + ss + \\\"[\\\" + str(DD).center(w1) + \\\"] = \\\" + cs + ls + \\\" \\\" + erms + \\\"\\\\n\\\"\\n # s=s+str(self._space.WR.D[r]).ljust(w2)+\\\",\\\"+str(n).ljust(w3)+\\\"] = \\\"+cs\\n print(s)\\n mpmath.mp.dps = mpold\",\n \"def calculate_coherent_scattering_factor(element, q):\\n return current_calculator.get_coherent_scattering_factor(element, q)\",\n \"def width_l_pi0_pi(\\n model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi, **kwargs\\n):\\n mx = model.mx\\n ml = _lepton_masses[model.gen]\\n if mx < ml + 2 * MPI:\\n return 0.0\\n\\n xl2 = (ml / mx) ** 2\\n u = 0.5 * np.tan(2 * model.theta)\\n\\n def integrand(s):\\n z = s / mx**2\\n poly = (1 - xl2) ** 2 + z * (1 + xl2) - 2 * z**2\\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\\n beta = (1.0 - 4 * MPI**2 / s) ** 1.5\\n p = np.sqrt(kallen_lambda(1.0, z, xl2))\\n return poly * np.abs(ff) ** 2 * p * beta\\n\\n pre = u**2 * np.abs(VUD) ** 2 * GF**2 * mx**3 / (384.0 * np.pi**3)\\n quad_kwargs = _get_quad_kwargs(**kwargs)\\n return (\\n pre * integrate.quad(integrand, 4 * MPI**2, (mx - ml) ** 2, **quad_kwargs)[0]\\n )\",\n \"def _radius_from_q(q):\\n\\n return 1 / (np.real(1 / q))\",\n \"def stretch_factor(self):\\n p = self._pants_decomposition\\n\\n # pick a curve to iterate\\n c = PantsLamination.random(p)\\n # print(c)\\n\\n cc = (self**100) * c\\n # print(self**100)\\n # print(cc)\\n return float(sum(abs(x) for x in (self*cc).to_vector())) / \\\\\\n sum(abs(x) for x in cc.to_vector())\",\n \"def Q_term(\\n omega1, # vorticity-1 component\\n omega2, # vorticity-2 component\\n omega3, # vorticity-3 component\\n s11, # strain rate-11 component\\n s12, # strain rate-12 component\\n s13, # strain rate-13 component\\n s22, # strain rate-22 component\\n s23, # strain rate-23 component\\n s33): # strain rate-33 component\\n #---------------------------------------------------------------------#\\n # Numerator and denominator #\\n #---------------------------------------------------------------------#\\n num = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\\n den1 = omega1*omega1 + omega2*omega2 + omega3*omega3\\n den2 = (s11*s11 + s12*s12 + s13*s13 + s12*s12 + s22*s22 + s23*s23 +\\\\\\n s13*s13 + s23*s23 + s33*s33)**0.5\\n den = ((2.0/3.0)**0.5)* den1 * den2\\n #---------------------------------------------------------------------#\\n # Q calculation #\\n #---------------------------------------------------------------------#\\n Q = num/den\\n\\n return Q\",\n \"def width_v_pi_pi(\\n model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi, **kwargs\\n):\\n mx = model.mx\\n if mx < 2.0 * MPI:\\n return 0.0\\n\\n u = 0.5 * np.tan(2 * model.theta)\\n\\n def integrand(s):\\n z = s / mx**2\\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\\n beta = (1.0 - 4 * MPI**2 / s) ** 1.5\\n poly = (1 - z) ** 2 * (1 + 2 * z)\\n return np.abs(ff) ** 2 * beta * poly\\n\\n pre = u**2 * GF**2 * mx**3 * (1 - 2 * SW**2) ** 2 / (768 * np.pi**3)\\n quad_kwargs = _get_quad_kwargs(**kwargs)\\n return pre * integrate.quad(integrand, 4 * MPI**2, mx**2, **quad_kwargs)[0]\",\n \"def scale(structure):\\n from numpy.linalg import det\\n if \\\"O\\\" in [atom.type for atom in structure]: spvol = 8.5**3/4e0\\n elif \\\"Se\\\" in [atom.type for atom in structure]: spvol = 9.5**3/4e0\\n elif \\\"Te\\\" in [atom.type for atom in structure]: spvol = 10.5**3/4e0\\n else: raise ValueError(\\\"unknown atom.type: %s\\\" % (atom.type,))\\n\\n nfu = float(len(structure)/7)*0.5 # 0.5 because 2 f.u. in spinel unit-cell.\\n vol = det(structure.cell)\\n return (nfu * spvol / vol)**(1e0/3e0)\",\n \"def get_dihedral(p0,p1,p2,p3,unit):\\n if unit == 'Ang':\\n p0 = p0*0.529177249\\n p1 = p1*0.529177249\\n p2 = p2*0.529177249\\n p3 = p3*0.529177249\\n\\n b0 = -1.0*(p1 - p0)\\n b1 = p2 - p1\\n b2 = p3 - p2\\n\\n # normalize b1 so that it does not influence magnitude of vector\\n # rejections that come next\\n b1 /= linalg.norm(b1)\\n\\n # vector rejections\\n # v = projection of b0 onto plane perpendicular to b1\\n # = b0 minus component that aligns with b1\\n # w = projection of b2 onto plane perpendicular to b1\\n # = b2 minus component that aligns with b1\\n v = b0 - dot(b0, b1)*b1\\n w = b2 - dot(b2, b1)*b1\\n\\n # angle between v and w in a plane is the torsion angle\\n # v and w may not be normalized but that's fine since tan is y/x\\n x = dot(v, w)\\n y = dot(cross(b1, v), w)\\n return degrees(arctan2(y, x))\\n\\n #q1 = subtract(p1,p0) # b - a \\n #q2 = subtract(p2,p1) # c - b \\n #q3 = subtract(p3,p2) # d - c\\n #print(q1,q2)\\n\\n #q1_x_q2 = cross(q1,q2) \\n #q2_x_q3 = cross(q2,q3)\\n\\n #n1 = q1_x_q2/sqrt(dot(q1_x_q2,q1_x_q2)) \\n #n2 = q2_x_q3/sqrt(dot(q2_x_q3,q2_x_q3))\\n\\n #u1 = n2\\n #u3 = q2/(sqrt(dot(q2,q2))) \\n #u2 = cross(u3,u1)\\n\\n #cos_theta = dot(n1,u1)\\n #sin_theta = dot(n1,u2)\\n ## Calculate theta\\n #theta = -atan2(sin_theta,cos_theta)\\n ## it is different from atan2 from fortran math.atan2(y,x)\\n #theta_deg = degrees(theta)\\n #return(theta_deg)\",\n \"def fkine_ur5(q):\\n \\n \\n T1 = dh(0.08916, +q[0], 0.0, +pi/2)\\n T2 = dh( 0.0, +q[1], -0.425, 0.0)\\n T3 = dh( 0.0, +q[2], -0.392, 0.0)\\n T4 = dh(0.10915, +q[3], 0.0, +pi/2)\\n T5 = dh(0.09465, +pi+q[4], 0.0, +pi/2)\\n T6 = dh( 0.0823, +pi+q[5], 0.0, 0.0)\\n \\n # Efector final con respecto a la base\\n T = np.dot(np.dot(np.dot(np.dot(np.dot(T1,T2),T3),T4),T5),T6)\\n return T\",\n \"def msqrd_v_pi_pi(\\n s, t, model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi\\n):\\n mx = model.mx\\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\\n u = 0.5 * np.tan(2 * model.theta)\\n\\n return (\\n u**2\\n * GF**2\\n * (1 - 2 * SW**2) ** 2\\n * (\\n mx**4\\n + 4 * MPI**4\\n + 4 * t * (-2 * MPI**2 + s + t)\\n - mx**2 * (s + 4 * t)\\n )\\n * np.abs(ff) ** 2\\n )\",\n \"def q_wi_per_head(self):\\n assert self.ff % self.heads == 0\\n # fuses W and V from swiGLU, and the q computation\\n # note both W and V have output dim .ff, not\\n # 2/3 ff as in https://arxiv.org/pdf/2002.05202.pdf\\n return (self.ff * 2 // (self.heads-self.padded_heads)) + self.qkv\",\n \"def dcm2quat(c):\\n tr = c[0, 0] + c[1, 1] + c[2, 2]\\n tmp = np.array([0.0, 0.0, 0.0, 0.0])\\n q = np.array([0.0, 0.0, 0.0, 0.0])\\n if tr > 0.0:\\n tmp[0] = 0.5 * math.sqrt(1.0 + tr)\\n tmp[1] = 0.25 / tmp[0] * (c[1, 2] - c[2, 1])\\n tmp[2] = 0.25 / tmp[0] * (c[2, 0] - c[0, 2])\\n tmp[3] = 0.25 / tmp[0] * (c[0, 1] - c[1, 0])\\n else:\\n if (c[1, 1] > c[0, 0]) and (c[1, 1] > c[2, 2]):\\n sqdip1 = math.sqrt(c[1, 1] - c[0, 0] - c[2, 2] + 1.0)\\n tmp[2] = 0.5*sqdip1\\n if sqdip1 != 0.0: #// if it equals 0, something is wrong\\n sqdip1 = 0.5/sqdip1\\n tmp[0] = (c[2, 0] - c[0, 2]) * sqdip1\\n tmp[1] = (c[0, 1] + c[1, 0]) * sqdip1\\n tmp[3] = (c[1, 2] + c[2, 1]) * sqdip1\\n elif c[2, 2] > c[0, 0]:\\n sqdip1 = math.sqrt(c[2, 2] - c[0, 0] - c[1, 1] + 1.0)\\n tmp[3] = 0.5*sqdip1\\n if sqdip1 != 0.0: #// if it equals 0, something is wrong\\n sqdip1 = 0.5/sqdip1\\n tmp[0] = (c[0, 1] - c[1, 0]) * sqdip1\\n tmp[1] = (c[2, 0] + c[0, 2]) * sqdip1\\n tmp[2] = (c[1, 2] + c[2, 1]) * sqdip1\\n else:\\n sqdip1 = math.sqrt(c[0, 0] - c[1, 1] - c[2, 2] + 1.0)\\n tmp[1] = 0.5*sqdip1\\n if sqdip1 != 0.0: #// if it equals 0, something is wrong\\n sqdip1 = 0.5/sqdip1\\n tmp[0] = (c[1, 2] - c[2, 1]) * sqdip1\\n tmp[2] = (c[0, 1] + c[1, 0]) * sqdip1\\n tmp[3] = (c[2, 0] + c[0, 2]) * sqdip1\\n # quaternion normalization, *** no need if dcm is really a dcm\\n #quatNormalize(tmp,q)\\n\\t# ensure q[0] is non-negative\\n if tmp[0] < 0:\\n q = -1.0 * tmp\\n else:\\n q = tmp\\n return q\",\n \"def structure(self):\\n if self.abelian:\\n return self.abelian\\n\\n # step 1. find order E/F_p.\\n simplified = self.simple()\\n N = simplified.order()\\n if prime.primeq(N):\\n return (1, N)\\n\\n # step 2. decompose N.\\n r = gcd.gcd(simplified.ch - 1, N)\\n _log.debug(\\\"r = %d, N = %d\\\" % (r, N))\\n r_factor = factor_methods.factor(r)\\n N0 = r\\n N1, N2 = 1, N\\n for p, _ in r_factor:\\n k, N2 = arith1.vp(N2, p=p)\\n N1 *= p**k\\n \\n while 1:\\n P1 = self.infpoint\\n while P1 == self.infpoint:\\n P1 = simplified.point()\\n P2 = self.infpoint\\n while P2 == self.infpoint:\\n P2 = simplified.point()\\n P1, P2 = simplified.mul(N2, P1), simplified.mul(N2, P2)\\n s = simplified.pointorder(P1, r, r_factor)\\n t = simplified.pointorder(P2, r, r_factor)\\n m = gcd.lcm(s, t)\\n if m > 1:\\n e = simplified.WeilPairing(m, P1, P2)\\n if e != self.basefield.one:\\n d = e.order()\\n else:\\n d = 1\\n if m*d == N1:\\n _log.debug(\\\"N1 = %d\\\" % N1)\\n _log.debug(\\\"P1 = %s (pointorder=%d)\\\" % (P1, s))\\n _log.debug(\\\"P2 = %s (pointorder=%d)\\\" % (P2, t))\\n assert (not (N//d) % d), d\\n self.abelian = (d, N//d)\\n return self.abelian\",\n \"def _q_z(self):\\n D = self.latt_par['D'].value\\n lambda_r = self.latt_par['lambda_r'].value\\n gamma = self.latt_par['gamma'].value\\n return 2*np.pi*(self.h/D - self.k/lambda_r/np.tan(gamma))\",\n \"def q_div(self, PFC, MHD, q):\\n psi = PFC.psimin\\n xyz = PFC.centers\\n\\n R_div,Z_div,phi_div = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\\n\\n R_omp = self.map_R_psi(psi,PFC)\\n Z_omp = np.zeros(R_omp.shape)\\n # Dot product between surface normal and B field\\n #self.HFincidentAngle(PFC, MHD)\\n # Calculate Magnitude of B at Divertor\\n Bp_div = PFC.ep.BpFunc.ev(R_div,Z_div)\\n Bt_div = PFC.ep.BtFunc.ev(R_div,Z_div)\\n B_div = np.sqrt(Bp_div**2 + Bt_div**2)\\n # Evaluate B at outboard midplane\\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\\n\\n# Bt_omp = MHD.ep.BtFunc.ev(R_omp,Z_omp)\\n# BR_omp = MHD.ep.BRFunc.ev(R_omp,Z_omp)\\n# BZ_omp = MHD.ep.BZFunc.ev(R_omp,Z_omp)\\n# B_omp = np.sqrt(Bt_omp**2 + BR_omp**2 + BZ_omp**2)\\n#\\n# Bt_div = MHD.ep.BtFunc.ev(R_div,Z_div)\\n# BR_div = MHD.ep.BRFunc.ev(R_div,Z_div)\\n# BZ_div = MHD.ep.BZFunc.ev(R_div,Z_div)\\n# B_div = np.sqrt(Bt_div**2 + BR_div**2 + BZ_div**2)\\n\\n\\n #For Debugging, plot Bfield Ratio\\n #import matplotlib.pyplot as plt\\n #testB_div = B_div.reshape(self.grid['Nphi'],self.grid['Nswall']).T\\n #testB_omp = B_omp.reshape(self.grid['Nphi'],self.grid['Nswall']).T\\n #B_ratio = testB_div/testB_omp\\n #CS = plt.contourf(self.grid['phi'], self.grid['Swall'],B_ratio,levels=30,cmap=plt.cm.cool)\\n #plt.colorbar(CS, label=r'$B Ratio$')\\n #plt.show()\\n #Divertor heat flux\\n q_div = np.zeros((len(xyz)))\\n use = np.where(PFC.shadowed_mask == 0)[0]\\n\\n #Matt's method\\n# q_div[use] = q[use] * B_div[use]/B_omp * PFC.bdotn[use]\\n #Menard's Method\\n q_div[use] = q[use] * B_div[use] * PFC.bdotn[use]\\n\\n #for i in range(len(q_div)):\\n #\\tif q_div[i] > 8.0: q_div[i] = 0.0\\n #Plot q|| and qdiv\\n #import matplotlib.pyplot as plt\\n #plt.scatter(self.grid['Swall'][:,0], q_div[0:self.grid['Nswall']], label='qdiv')\\n #plt.scatter(self.grid['Swall'][:,0], q[0:self.grid['Nswall']], label='q||')\\n #plt.legend()\\n #plt.show()\\n return np.abs(q_div)\",\n \"def universal_cir(q: List[QRegStorage], i: int, para: List[float]):\\n\\n RZ(para[0])(q[i])\\n RY(para[1])(q[i])\\n RZ(para[2])(q[i])\\n\\n RZ(para[3])(q[i + 1])\\n RY(para[4])(q[i + 1])\\n RZ(para[5])(q[i + 1])\\n\\n CX(q[i + 1], q[i])\\n\\n RZ(para[6])(q[i])\\n RY(para[7])(q[i + 1])\\n\\n CX(q[i], q[i + 1])\\n\\n RY(para[8])(q[i + 1])\\n\\n CX(q[i + 1], q[i])\\n\\n RZ(para[9])(q[i])\\n RY(para[10])(q[i])\\n RZ(para[11])(q[i])\\n\\n RZ(para[12])(q[i + 1])\\n RY(para[13])(q[i + 1])\\n RZ(para[14])(q[i + 1])\",\n \"def get_structure_factor(\\n scalar_field: ScalarField,\\n smoothing: Union[None, float, str] = \\\"auto\\\",\\n wave_numbers: Union[Sequence[float], str] = \\\"auto\\\",\\n add_zero: bool = False,\\n) -> Tuple[np.ndarray, np.ndarray]:\\n logger = logging.getLogger(__name__)\\n\\n if not isinstance(scalar_field, ScalarField):\\n raise TypeError(\\n \\\"Length scales can only be calculated for scalar \\\"\\n f\\\"fields, not {scalar_field.__class__.__name__}\\\"\\n )\\n\\n grid = scalar_field.grid\\n if not isinstance(grid, CartesianGridBase):\\n raise NotImplementedError(\\n \\\"Structure factor can currently only be calculated for Cartesian grids\\\"\\n )\\n if not all(grid.periodic):\\n logger.warning(\\n \\\"Structure factor calculation assumes periodic boundary \\\"\\n \\\"conditions, but not all grid dimensions are periodic\\\"\\n )\\n\\n # do the n-dimensional Fourier transform and calculate the structure factor\\n f1 = np_fftn(scalar_field.data, norm=\\\"ortho\\\").flat[1:]\\n flat_data = scalar_field.data.flat\\n sf = np.abs(f1) ** 2 / np.dot(flat_data, flat_data)\\n\\n # an alternative calculation of the structure factor is\\n # f2 = np_ifftn(scalar_field.data, norm='ortho').flat[1:]\\n # sf = (f1 * f2).real\\n # sf /= (scalar_field.data**2).sum()\\n # but since this involves two FFT, it is probably slower\\n\\n # determine the (squared) components of the wave vectors\\n k2s = [\\n np.fft.fftfreq(grid.shape[i], d=grid.discretization[i]) ** 2\\n for i in range(grid.dim)\\n ]\\n # calculate the magnitude\\n k_mag = np.sqrt(reduce(np.add.outer, k2s)).flat[1:]\\n\\n no_wavenumbers = wave_numbers is None or (\\n isinstance(wave_numbers, str) and wave_numbers == \\\"auto\\\"\\n )\\n\\n if smoothing is not None and smoothing != \\\"none\\\":\\n # construct the smoothed function of the structure factor\\n if smoothing == \\\"auto\\\":\\n smoothing = k_mag.max() / 128\\n smoothing = float(smoothing) # type: ignore\\n sf_smooth = SmoothData1D(k_mag, sf, sigma=smoothing)\\n\\n if no_wavenumbers:\\n # determine the wave numbers at which to evaluate it\\n k_min = 2 / grid.cuboid.size.max()\\n k_max = k_mag.max()\\n k_mag = np.linspace(k_min, k_max, 128)\\n\\n else:\\n k_mag = np.array(wave_numbers)\\n\\n # obtain the smoothed values at these points\\n sf = sf_smooth(k_mag)\\n\\n elif not no_wavenumbers:\\n logger.warning(\\n \\\"Argument `wave_numbers` is only used when `smoothing` is enabled.\\\"\\n )\\n\\n if add_zero:\\n sf = np.r_[1, sf]\\n k_mag = np.r_[0, k_mag]\\n\\n return k_mag, sf\",\n \"def Build_quadrant(self) :\\n\\n self.omega = np.zeros((self.n_dir,3))\\n self.weight = np.zeros((self.n_dir))\\n\\n if self.sn==2 :\\n direction = 0.577350269189625764509149\\n weight = 1.\\n\\n self.omega[0,0] = direction\\n self.omega[0,1] = direction\\n self.omega[0,2] = direction\\n \\n self.weight[0] = weight\\n \\n elif self.sn==4 :\\n direction_1 = 0.350021174581540677777041\\n direction_2 = 0.868890300722201205229788\\n weight = 1./3.\\n\\n self.omega[0,0] = direction_2\\n self.omega[0,1] = direction_1\\n self.omega[0,2] = direction_1\\n \\n self.omega[1,0] = direction_1\\n self.omega[1,1] = direction_2\\n self.omega[1,2] = direction_1\\n\\n self.omega[2,0] = direction_1\\n self.omega[2,1] = direction_1\\n self.omega[2,2] = direction_2\\n\\n self.weight[0] = weight\\n self.weight[1] = weight\\n self.weight[2] = weight\\n\\n elif self.sn==6 :\\n direction_1 = 0.266635401516704720331535\\n direction_2 = 0.681507726536546927403750\\n direction_3 = 0.926180935517489107558380\\n weight_1 = 0.176126130863383433783565\\n weight_2 = 0.157207202469949899549768\\n\\n self.omega[0,0] = direction_3\\n self.omega[0,1] = direction_1\\n self.omega[0,2] = direction_1\\n\\n self.omega[1,0] = direction_2\\n self.omega[1,1] = direction_2\\n self.omega[1,2] = direction_1\\n\\n self.omega[2,0] = direction_1\\n self.omega[2,1] = direction_3\\n self.omega[2,2] = direction_1\\n\\n self.omega[3,0] = direction_2\\n self.omega[3,1] = direction_1\\n self.omega[3,2] = direction_2\\n \\n self.omega[4,0] = direction_1\\n self.omega[4,1] = direction_2\\n self.omega[4,2] = direction_2\\n\\n self.omega[5,0] = direction_1\\n self.omega[5,1] = direction_1\\n self.omega[5,2] = direction_3\\n\\n self.weight[0] = weight_1\\n self.weight[1] = weight_2\\n self.weight[2] = weight_1\\n self.weight[3] = weight_2\\n self.weight[4] = weight_2\\n self.weight[5] = weight_1\\n\\n elif self.sn==8 :\\n direction_1 = 0.218217890235992381266097\\n direction_2 = 0.577350269189625764509149\\n direction_3 = 0.786795792469443145800830\\n direction_4 = 0.951189731211341853132399\\n\\n weight_1 = 0.120987654320987654320988\\n weight_2 = 0.0907407407407407407407407\\n weight_3 = 0.0925925925925925925925926\\n\\n self.omega[0,0] = direction_4\\n self.omega[0,1] = direction_1\\n self.omega[0,2] = direction_1\\n\\n self.omega[1,0] = direction_3\\n self.omega[1,1] = direction_2\\n self.omega[1,2] = direction_1\\n \\n self.omega[2,0] = direction_2\\n self.omega[2,1] = direction_3\\n self.omega[2,2] = direction_1\\n\\n self.omega[3,0] = direction_1\\n self.omega[3,1] = direction_4\\n self.omega[3,2] = direction_1\\n\\n self.omega[4,0] = direction_3\\n self.omega[4,1] = direction_1\\n self.omega[4,2] = direction_2\\n\\n self.omega[5,0] = direction_2\\n self.omega[5,1] = direction_2\\n self.omega[5,2] = direction_2\\n\\n self.omega[6,0] = direction_1\\n self.omega[6,1] = direction_3\\n self.omega[6,2] = direction_2\\n\\n self.omega[7,0] = direction_2\\n self.omega[7,1] = direction_1\\n self.omega[7,2] = direction_3\\n\\n self.omega[8,0] = direction_1\\n self.omega[8,1] = direction_2\\n self.omega[8,2] = direction_3\\n\\n self.omega[9,0] = direction_1\\n self.omega[9,1] = direction_1\\n self.omega[9,2] = direction_4\\n\\n self.weight[0] = weight_1\\n self.weight[1] = weight_2\\n self.weight[2] = weight_2\\n self.weight[3] = weight_1\\n self.weight[4] = weight_2\\n self.weight[5] = weight_3\\n self.weight[6] = weight_2\\n self.weight[7] = weight_2\\n self.weight[8] = weight_2\\n self.weight[9] = weight_1\\n\\n elif self.sn==10 :\\n direction_1 = 0.189321326478010476671494\\n direction_2 = 0.508881755582618974382711\\n direction_3 = 0.694318887594384317279217\\n direction_4 = 0.839759962236684758403029\\n direction_5 = 0.963490981110468484701598\\n\\n weight_1 = 0.0893031479843567214704325\\n weight_2 = 0.0725291517123655242296233\\n weight_3 = 0.0450437674364086390490892\\n weight_4 = 0.0539281144878369243545650\\n\\n self.omega[0,0] = direction_5\\n self.omega[0,1] = direction_1\\n self.omega[0,2] = direction_1\\n \\n self.omega[1,0] = direction_4\\n self.omega[1,1] = direction_2\\n self.omega[1,2] = direction_1\\n \\n self.omega[2,0] = direction_3\\n self.omega[2,1] = direction_3\\n self.omega[2,2] = direction_1\\n \\n self.omega[3,0] = direction_2\\n self.omega[3,1] = direction_4\\n self.omega[3,2] = direction_1\\n\\n self.omega[4,0] = direction_1\\n self.omega[4,1] = direction_5\\n self.omega[4,2] = direction_1\\n\\n self.omega[5,0] = direction_4\\n self.omega[5,1] = direction_1\\n self.omega[5,2] = direction_2\\n\\n self.omega[6,0] = direction_3\\n self.omega[6,1] = direction_2\\n self.omega[6,2] = direction_2\\n\\n self.omega[7,0] = direction_2\\n self.omega[7,1] = direction_3\\n self.omega[7,2] = direction_2\\n\\n self.omega[8,0] = direction_1\\n self.omega[8,1] = direction_4\\n self.omega[8,2] = direction_2\\n\\n self.omega[9,0] = direction_3\\n self.omega[9,1] = direction_1\\n self.omega[9,2] = direction_3\\n\\n self.omega[10,0] = direction_2\\n self.omega[10,1] = direction_2\\n self.omega[10,2] = direction_3\\n\\n self.omega[11,0] = direction_1\\n self.omega[11,1] = direction_3\\n self.omega[11,2] = direction_3\\n\\n self.omega[12,0] = direction_2\\n self.omega[12,1] = direction_1\\n self.omega[12,2] = direction_4\\n\\n self.omega[13,0] = direction_1\\n self.omega[13,1] = direction_2\\n self.omega[13,2] = direction_4\\n\\n self.weight[0] = weight_1\\n self.weight[1] = weight_2\\n self.weight[2] = weight_3\\n self.weight[3] = weight_2\\n self.weight[4] = weight_1\\n self.weight[5] = weight_2\\n self.weight[6] = weight_4\\n self.weight[7] = weight_4\\n self.weight[8] = weight_2\\n self.weight[9] = weight_3\\n self.weight[10] = weight_4\\n self.weight[11] = weight_3\\n self.weight[12] = weight_2\\n self.weight[13] = weight_2\\n self.weight[14] = weight_1\\n\\n elif self.sn==12 :\\n direction = np.zeros((6,1))\\n\\n direction[0] = 0.167212652822713264084504\\n direction[1] = 0.459547634642594690016761\\n direction[2] = 0.628019096642130901034766\\n direction[3] = 0.760021014833664062877138\\n direction[4] = 0.872270543025721502340662\\n direction[5] = 0.971637719251358378302376\\n\\n weight_1 = 0.0707625899700910439766549\\n weight_2 = 0.0558811015648888075828962\\n weight_3 = 0.0373376737588285824652402\\n weight_4 = 0.0502819010600571181385765\\n weight_5 = 0.0258512916557503911218290\\n\\n for i in xrange(0,6) :\\n self.omega[i,0] = direction[5-i]\\n self.omega[i,1] = direction[i]\\n self.omega[i,2] = direction[0]\\n \\n offset = 6\\n for i in xrange(0,5) :\\n self.omega[offset+i,0] = direction[4-i]\\n self.omega[offset+i,1] = direction[i]\\n self.omega[offset+i,2] = direction[1]\\n\\n offset += 5\\n for i in xrange(0,4) :\\n self.omega[offset+i,0] = direction[3-i]\\n self.omega[offset+i,1] = direction[i]\\n self.omega[offset+i,2] = direction[2]\\n \\n offset += 4\\n for i in xrange(0,3) :\\n self.omega[offset+i,0] = direction[2-i]\\n self.omega[offset+i,1] = direction[i]\\n self.omega[offset+i,2] = direction[3]\\n\\n offset += 3\\n for i in xrange(0,2) :\\n self.omega[offset+i,0] = direction[1-i]\\n self.omega[offset+i,1] = direction[i]\\n self.omega[offset+i,2] = direction[4]\\n \\n offset += 2\\n self.omega[offset+i,0] = direction[0]\\n self.omega[offset+i,1] = direction[1]\\n self.omega[offset+i,2] = direction[5]\\n\\n self.weight[0] = weigth_1\\n self.weight[1] = weight_2\\n self.weight[2] = weight_3\\n self.weight[3] = weight_3\\n self.weight[4] = weight_2\\n self.weight[5] = weight_1\\n self.weight[6] = weight_2\\n self.weight[7] = weight_4\\n self.weight[8] = weight_5\\n self.weight[9] = weight_4\\n self.weight[10] = weight_2\\n self.weight[11] = weight_3\\n self.weight[12] = weight_5\\n self.weight[13] = weight_5\\n self.weight[14] = weight_3\\n self.weight[15] = weight_3\\n self.weight[16] = weight_4\\n self.weight[17] = weight_3\\n self.weight[18] = weight_2\\n self.weight[19] = weight_2\\n self.weight[20] = weight_1\",\n \"def get_element_density(mt):\\r\\n fraction_matrix = zeros(100)\\r\\n \\r\\n composition = Composition(mt['pretty_formula'])\\r\\n \\r\\n for element in composition:\\r\\n fraction = composition.get_atomic_fraction(element) # get the atomic fraction.\\r\\n fraction_matrix[element.Z] = fraction\\r\\n \\r\\n return fraction_matrix\",\n \"def compute_duty_factor():\\n [time,\\n ankle_l_trajectory,\\n ankle_r_trajectory,\\n foot_l_contact,\\n foot_r_contact,\\n muscle_lh_activations,\\n muscle_rh_activations,\\n muscle_lh_forces,\\n muscle_rh_forces,\\n joint_lh_positions,\\n joint_rh_positions] = load_data()\\n \\n print(np.sum(foot_l_contact)/len(foot_l_contact))\\n print(np.sum(foot_r_contact)/len(foot_r_contact))\\n\\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5\",\n \"def compute_rf_field(self, r):\\r\\n\\t\\tE = np.zeros((3))\\r\\n\\t\\tfor nam, e in self.rf_electrode_list:\\r\\n\\t\\t\\tE += e.compute_electric_field(r)\\r\\n\\t\\treturn E\",\n \"def cntd_qed_furry_class_coeff( L, rt2, m):\\n\\n if rt2 % 2 != 0:\\n return 0\\n \\n r = rt2/2\\n s = m + 2*r + 2*(L - 1)\\n\\n if s<0:\\n return 0\\n\\n A = [ [ [ qed_furry_cc(sp, mp, rp) for mp in range(m+1) ] for rp in range(r+1) ] for sp in range(s+1) ]\\n Alog = lLog( A )\\n \\n return Alog[s][r][m]\",\n \"def test_mag_form_fac_case1():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac()[0], ion.calc_mag_form_fac()[1:]\\n del _temp\\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)\",\n \"def annihilation_branching_fractions(self, Q):\\n CSs = self.cross_sections(Q)\\n\\n if CSs[\\\"total\\\"] == 0.0:\\n return {\\\"mu mu\\\": 0.0, \\\"e e\\\": 0.0, \\\"pi0 pi pi\\\": 0.0, \\\"a a\\\": 0.0}\\n else:\\n return {\\n \\\"mu mu\\\": CSs[\\\"mu mu\\\"] / CSs[\\\"total\\\"],\\n \\\"e e\\\": CSs[\\\"e e\\\"] / CSs[\\\"total\\\"],\\n \\\"pi0 pi pi\\\": CSs[\\\"pi0 pi pi\\\"] / CSs[\\\"total\\\"],\\n \\\"a a\\\": CSs[\\\"a a\\\"] / CSs[\\\"total\\\"],\\n }\",\n \"def compute_density_ari(cur, N):\\n ## arithmetic average cardinality\\n avg_card = 0\\n for n in range(N):\\n card = get_parameter(cur, par=(\\\"card_B%d\\\" % n))\\n avg_card += card / float(N)\\n\\n ## average mass\\n if avg_card == 0:\\n return (-1, 0)\\n else:\\n return (get_parameter(cur, par=\\\"B_mass\\\") / avg_card, avg_card)\",\n \"def msqrd_l_pi0_pi(\\n s, t, model: SingleRhNeutrinoModel, form_factor: VectorFormFactorPiPi\\n):\\n mx = model.mx\\n ff = form_factor.form_factor(q=np.sqrt(s), couplings=(GVUU, GVDD))\\n ml = _lepton_masses[model.gen]\\n ckm = abs(VUD) ** 2\\n u = 0.5 * np.tan(2 * model.theta)\\n\\n return (\\n 2\\n * ckm\\n * u**2\\n * GF**2\\n * (\\n 4 * MPI**4\\n + (ml**2 + mx**2) * (ml**2 + mx**2 - s)\\n - 4 * (ml**2 + mx**2 + 2 * MPI**2 - s) * t\\n + 4 * t**2\\n )\\n * np.abs(ff) ** 2\\n )\",\n \"def _reduced_mass(structure) -> float:\\n reduced_comp = structure.composition.reduced_composition\\n num_elems = len(reduced_comp.elements)\\n elem_dict = reduced_comp.get_el_amt_dict()\\n\\n denominator = (num_elems - 1) * reduced_comp.num_atoms\\n\\n all_pairs = combinations(elem_dict.items(), 2)\\n mass_sum = 0\\n\\n for pair in all_pairs:\\n m_i = Composition(pair[0][0]).weight\\n m_j = Composition(pair[1][0]).weight\\n alpha_i = pair[0][1]\\n alpha_j = pair[1][1]\\n\\n mass_sum += (alpha_i + alpha_j) * (m_i * m_j) / (m_i + m_j) # type: ignore\\n\\n reduced_mass = (1 / denominator) * mass_sum\\n\\n return reduced_mass\",\n \"def factor(P):\\n cd = P[-1]\\n if P.deg == 0:\\n return (cd, defaultdict(int))\\n P = P * (1 / cd)\\n return (cd, P.factor_unit())\",\n \"def radial4(self) -> float:\\n return self.distortion_coefficients[1]\",\n \"def multiplicity(q, N):\\n return int(_math.factorial(q + N - 1) /\\n (_math.factorial(q) * _math.factorial(N - 1)))\",\n \"def question_c():\\n 4*math.pi*(r**2)\",\n \"def d(J,Mp,M):\\n\\tdd=0.0\\n\\tif so3.multJ(J,M)==1 and so3.multJ(J,Mp)==1:\\n\\t\\t## defining the limits of k\\n\\t\\tkmax=max(J+M,J-M,J-Mp)\\n\\t\\t#kmin=max(Mp-M,0)\\n\\t\\t##suming over k\\n\\t\\tfor k in range(int(kmax)+1):\\n\\t\\t\\tdd=dd+parity(k)*choose(int(J+M),int(J-Mp-k))*choose(int(J-M),k)\\n\\t\\tdd=(parity(J-Mp)\\n\\t\\t\\t*math.sqrt(\\n\\t\\t\\t\\tmath.factorial(int(J+Mp))\\n\\t\\t\\t\\t*math.factorial(int(J-Mp))\\n\\t\\t\\t\\t/(\\n\\t\\t\\t\\t\\t2.**(2*J)\\n\\t\\t\\t\\t\\t*math.factorial(int(J+M))\\n\\t\\t\\t\\t\\t*math.factorial(int(J-M))\\n\\t\\t\\t\\t\\t)\\n\\t\\t\\t\\t)\\n\\t\\t\\t)*dd\\n\\t#print \\\"dd\\\",dd\\n\\treturn dd\",\n \"def sol549(design_parameters, phi_0, N):\\r\\n prt('Design governing by this mantras (in oder of importance): \\\\nsize, stall margin, cost, off-design', 'blue')\\r\\n n = 0\\r\\n m = 0\\r\\n phi_f = phi_0*1.2\\r\\n N_lineal_phi = int(0.4 * N)\\r\\n step = (phi_f-phi_0)/(N_lineal_phi-1)\\r\\n phi_dist = [float_f(phi_0+i*step, 4) for i in range(N_lineal_phi)] + [float_f(phi_f, 4) for i in range(N_lineal_phi, N)]\\r\\n phi_dist = Distribution(phi_dist)\\r\\n N_lineal_R = int(0.3 * N)\\r\\n R_0 = 0.7\\r\\n R_f = 0.65\\r\\n step = (R_f - R_0) / (N_lineal_R - 1)\\r\\n R_dist = [float_f(R_0+i*step, 4) for i in range(N_lineal_R)] + [float_f(R_f, 4) for i in range(N_lineal_R, N)]\\r\\n R_dist = Distribution(R_dist)\\r\\n\\r\\n Kc = 1-0.5*design_parameters[1]\\r\\n psi_dist = Distribution(psi_limit(phi_dist, R_dist, Kc))\\r\\n if inlet_angle_flow(phi_dist,psi_dist,R_dist):\\r\\n pass\\r\\n\\r\\n return phi_dist, psi_dist, R_dist, n,m\",\n \"def radio_lumfn(L, _params):\\n print _params\\n # Number density as a function of sfr, dn/dlog(sfr)\\n sfr = L * 5.52e-29 # erg/s/Hz, Bell (2003), Eq. 6\\n dndlogsfr_sfms, dndlogsfr_pass = g.sfr_fn(hm, sfr, z=0., params=_params)\\n #phi = dndlogsfr_sfms #+ dndlogsfr_pass\\n return dndlogsfr_sfms, dndlogsfr_pass\",\n \"def qFelder(h):\\n\\treturn (0.92 + 0.153 * h/1.01) * math.sqrt(9.8 * (2/3.0 * h)**3)\",\n \"def BeamDeflection(I, E, L, q):\\n w = q * L**4 / (8*E*I)\\n return w\",\n \"def quadratureDetector(d, fs):\\n\\n k = fs / (2 * numpy.pi)\\n\\n # lazy version\\n def g(d):\\n prev = None\\n for b in d:\\n if prev is not None:\\n x = numpy.concatenate((prev[1:], b[:1]))\\n yield numpy.angle(x * prev.conj()) * k\\n prev = b\\n yield numpy.angle(prev[1:] * prev[:-1].conj()) * k\\n\\n if isinstance(d, types.GeneratorType):\\n return g(d)\\n else:\\n return numpy.angle(d[1:] * d[:-1].conj()) * k\",\n \"def guess_baudrate_divisor(klass, config):\\n\\t\\t# build a list of all the millisecond time values to check\\n\\t\\ttimes_tuples_keys = ['header', 'three', 'two', 'one', 'zero',\\n\\t\\t 'foot', 'repeat', 'pre', 'post']\\n\\t\\ttimes_keys = ['ptrail', 'phead', 'gap', 'repeat_gap']\\n\\t\\ttimes = []\\n\\t\\ttimes.append(1000000)\\t# can't have a baudrate of less than 1\\n\\t\\tfor k in times_tuples_keys:\\n\\t\\t\\tif k in config:\\n\\t\\t\\t\\ttimes.append(config[k][0])\\n\\t\\t\\t\\ttimes.append(config[k][1])\\n\\t\\tfor k in times_keys:\\n\\t\\t\\tif k in config:\\n\\t\\t\\t\\ttimes.append(config[k])\\n\\t\\t# try finding a common factor among them all\\n\\t\\ttotal_factor = 1\\n\\t\\tfactored = True\\n\\t\\twhile factored:\\n\\t\\t\\tfactored = False\\n\\t\\t\\tfactor_errors = {}\\n\\t\\t\\tfor factor in [2,3,5,7,11,17,19,23]:\\n\\t\\t\\t\\tnew_factor = 1.0 * total_factor * factor\\n\\t\\t\\t\\tint_times = [int(t / new_factor) for t in times]\\n\\t\\t\\t\\trounded_times = [t * new_factor for t in int_times]\\n\\t\\t\\t\\terrors = [abs(o-n)*1.0/o for o,n in zip(times, rounded_times)]\\n\\t\\t\\t\\tfactor_errors[factor] = max(errors)\\n\\t\\t\\t# figure out which factor had the least error\\n\\t\\t\\tnew_factor = None\\n\\t\\t\\tmin_error = 0.05\\n\\t\\t\\tfor f,e in factor_errors.items():\\n\\t\\t\\t\\tif e < min_error:\\n\\t\\t\\t\\t\\tmin_error = e\\n\\t\\t\\t\\t\\tnew_factor = total_factor * f\\n\\t\\t\\tif new_factor:\\n\\t\\t\\t\\tfactored = True\\n\\t\\t\\t\\ttotal_factor = new_factor\\n\\t\\treturn total_factor\",\n \"def deriv_matrix_block(\\n atomic_number,\\n total_rad_recomb_coefficients,\\n total_coll_ion_coefficients,\\n total_coll_recomb_coefficients,\\n current_ion_number_densities,\\n current_electron_density,\\n ):\\n ion_numbers = np.arange(0, atomic_number)\\n radiative_rate_coeff_matrix = NLTERateEquationSolver.recomb_matrix(\\n total_rad_recomb_coefficients, atomic_number, ion_numbers\\n )\\n coll_recomb_matrix = (\\n NLTERateEquationSolver.recomb_matrix(\\n total_coll_recomb_coefficients, atomic_number, ion_numbers\\n )\\n * current_electron_density\\n * 2\\n )\\n coll_ion_coeff_matrix = NLTERateEquationSolver.ion_matrix(\\n total_coll_ion_coefficients, atomic_number, ion_numbers\\n )\\n deriv_matrix = (\\n radiative_rate_coeff_matrix\\n + coll_ion_coeff_matrix\\n + coll_recomb_matrix\\n )\\n return np.dot(deriv_matrix, current_ion_number_densities)\",\n \"def factor_unit(P):\\n assert all(isinstance(c, ModInt) for c in P)\\n assert len(set(c.n for c in P)) == 1\\n if P.deg == 1:\\n return defaultdict(int, {P: 1})\\n\\n p = P[0].n\\n\\n S = Polynomial.gcd(P, P.prime())\\n if S.deg == P.deg:\\n # P' = 0 so P = R^p\\n R = Polynomial(P.C[::p])\\n return defaultdict(int,\\n {D: p * v\\n for D, v in Polynomial.factor_unit(R).items()})\\n else:\\n factors = defaultdict(int)\\n if S.deg:\\n for D, v in S.factor_unit().items():\\n factors[D] += v\\n P //= S\\n # P is now square-free\\n # We look for Q in Ker(F-Id) \\\\ {1}\\n Q = Polynomial.computeQ(P)\\n if Q is None:\\n # P is irreducible\\n factors[P] += 1\\n else:\\n # P is the product of the gcd(P, Q-i)\\n # that are factored recursively\\n for i in range(p):\\n D = Polynomial.gcd(P, Q - Polynomial([ModInt(i, p)]))\\n if D.deg:\\n for DD, v in D.factor_unit().items():\\n factors[DD] += v\\n return factors\",\n \"def qcd_cc( s, m, r, u ):\\n\\n l2_min = r\\n l3_min = u\\n l1_min = (m+1)/2\\n l1_max = l2_max = l3_max = (3*s+m+2*r+2*u)/2\\n\\n S = 0\\n for l1 in range(l1_min, l2_max+1):\\n for l2 in range(l2_min, l2_max+1):\\n for l3 in range(l3_min, l3_max+1):\\n n1 = 2*l1 + l2 + l3 - 2*s - m - r - u\\n n2_t2 = -2*(l1+l2+l3) + 3*s + m + 2*r + 2*u\\n n3 = l2-r\\n n4 = l3-u\\n if n2_t2%2 != 0:\\n continue\\n n2 = n2_t2/2\\n if n1 < 0 or n2 < 0 or n3 < 0 or n4 < 0:\\n continue\\n\\n denom = factorial(n1)*factorial(n2)*factorial(n3)*factorial(n4)*factorial(3)**n1*factorial(4)**n2*factorial(m)*factorial(r)**2*factorial(u)**2\\n\\n nom = double_factorial(2*l1-1)*factorial(l2)*factorial(l3)\\n S+= Fraction(nom, denom)\\n\\n return S\",\n \"def test_mag_form_fac():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac(q=1.)[0], ion.calc_mag_form_fac(q=1.)[1:]\\n del _temp\\n assert (abs(formfac - 0.932565) < 1e-6)\",\n \"def gas_zfactor(T_pr, P_pr):\\n # T_pr : calculated pseudoreduced temperature\\n # P_pr : calculated pseudoreduced pressure \\n from scipy.optimize import fsolve # non-linear solver\\n import numpy as np\\n\\n a1 = 0.3265; a2 = -1.0700; a3 = -0.5339; a4 = 0.01569; a5 = -0.05165; a6 = 0.5475\\n a7 = -0.7361; a8 = 0.1844; a9 = 0.1056; a10 = 0.6134; a11 = 0.7210\\n\\n def f(y):\\n rho_pr, z = y\\n c1 = a1 + (a2/T_pr) + (a3/(T_pr**3))+ (a4/(T_pr**4))+ (a5/(T_pr**5))\\n c2 = a6 + (a7/T_pr) + (a8/(T_pr**2))\\n c3 = a9*((a7/T_pr) + (a8/(T_pr**2)))\\n c4 = (a10)*(1+(a11*(rho_pr**2)))*((rho_pr**2)/(T_pr**3))*(np.exp(-a11*(rho_pr**2)))\\n\\n f1 = z + (c3*(rho_pr**5)) - (c2*(rho_pr**2)) - (c1*(rho_pr**1)) - c4 - 1\\n f2 = rho_pr - ((0.27 * P_pr) / (z * T_pr))\\n return[f1, f2]\\n\\n solve = fsolve(f, [1, 1]) # initial guess\\n return(solve[0], solve[1]) # result is density, z-factor\",\n \"def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[ int(uD) ]\\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \\n \\n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\\n \\n dJ_a = self.jacobian_actuators_diff( q , dq )\\n \\n C = self.C( q , dq )\\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\\n \\n D = self.D( q , dq )\\n Da = np.dot( B , np.dot( self.Da , B.T ) )\\n \\n CD_all = C + D + Ca + Da\\n \\n G = self.G( q )\\n \\n # External forces\\n J_e = self.jacobian_endeffector( q )\\n f_e = self.F_ext( q , dq )\\n \\n # Disturbance force\\n f_d = self.F_dist( t )\\n \\n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\\n \\n return ddq\",\n \"def ddq_a(self, q = np.zeros(2) , dq = np.zeros(2) , T = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[ int(uD) ]\\n B = np.dot( self.jacobian_actuators( q ).T , R.T ) # Transfor to rotor space \\n \\n H_all = self.H( q ) + np.dot( B , np.dot( self.Ia , B.T ) )\\n \\n dJ_a = self.jacobian_actuators_diff( q , dq )\\n \\n C = self.C( q , dq )\\n Ca = np.dot( B , np.dot( self.Ia , np.dot( R , dJ_a ) ) )\\n \\n D = self.D( q , dq )\\n Da = np.dot( B , np.dot( self.Da , B.T ) )\\n \\n CD_all = C + D + Ca + Da\\n \\n G = self.G( q )\\n \\n # External forces\\n J_e = self.jacobian_endeffector( q )\\n f_e = self.F_ext( q , dq )\\n \\n # Disturbance force\\n f_d = self.F_dist( t )\\n \\n ddq = np.dot( np.linalg.inv( H_all ) , ( np.dot( B , T ) + np.dot( J_e.T , f_e ) - f_d - np.dot( CD_all , dq ) - G ) )\\n \\n return ddq\",\n \"def qed_furry_class_coeff( L, rt2, m ):\\n\\n if rt2 % 2 != 0:\\n return 0\\n \\n r = rt2/2\\n s = m + 2*r + 2*(L - 1)\\n \\n if s<0:\\n return 0\\n\\n return qed_furry_cc(s,m,r)\",\n \"def harmSpinorPrefactor(l, m):\\n sign = (-1)**(l-m)\\n prefactor = math.sqrt((2*l+1) / (4*math.pi))\\n lastfactornumer = math.factorial(l+m) * math.factorial(l-m)\\n lastfactordenom = math.factorial(l+1/2) * math.factorial(l-1/2)\\n lastfactorsq = lastfactornumer / lastfactordenom\\n factor = sign * prefactor * math.sqrt(lastfactorsq)\\n return factor\",\n \"def get_quad_dip(q):\\n N = get_quad_normal(q)\\n V = get_vertical_vector(q)\\n dip = np.degrees(np.arccos(Vector.dot(N, V)))\\n return dip\",\n \"def quatreal(q):\\n a = q[0,0]\\n b = q[0,1]\\n c = q[0,2]\\n d = q[0,3]\\n amat = a*np.identity(4)\\n bmat = b*np.array([[0,1,0,0],[-1,0,0,0],[0,0,0,-1],[0,0,1,0]])\\n cmat = c*np.array([[0,0,1,0],[0,0,0,1],[-1,0,0,0],[0,-1,0,0]])\\n dmat = d*np.array([[0,0,0,1],[0,0,-1,0],[0,1,0,0],[-1,0,0,0]])\\n return amat+bmat+cmat+dmat\",\n \"def _get_deform_field_dm(self):\\n self.deformationStrength = self.deformrandomstate.rand()\\n adr = [w // d + 4 for w, d in zip(self.w, self.deform)]\\n deformshape = [len(self.w)] + adr\\n tmp = np.zeros([4] * (len(self.w) - 1) + [len(self.w)] + self.w)\\n\\n if np.isscalar(self.deformSigma):\\n myDeformSigma = np.array(len(self.w), self.deformSigma)\\n else:\\n myDeformSigma = np.asarray(self.deformSigma)\\n\\n strngs = [self.deformrandomstate.normal(0, myDeformSigma[i], deformshape[1:]) * self.deformationStrength\\n for i in range(len(myDeformSigma))]\\n tdf = np.asarray(strngs, dtype=np.float32)\\n\\n if self.truncated_deform:\\n upperBound = 3 * myDeformSigma\\n for i in range(len(myDeformSigma)):\\n overshoot_coordinates = np.where(np.abs(tdf[i]) > upperBound[i])\\n while len(overshoot_coordinates[0]):\\n tdf[i][overshoot_coordinates] = np.float32(self.deformrandomstate.normal(0, myDeformSigma[i], len(\\n overshoot_coordinates[0])) * self.deformationStrength)\\n overshoot_coordinates = np.where(np.abs(tdf[i]) > upperBound[i])\\n\\n # logging.getLogger('data').info('truncated deformation field')\\n\\n def cint(x, pnm1, pn, pnp1, pnp2):\\n return 0.5 * (\\n x * ((2 - x) * x - 1) * pnm1 + (x * x * (3 * x - 5) + 2) * pn + x * ((4 - 3 * x) * x + 1) * pnp1 + (\\n x - 1) * x * x * pnp2)\\n\\n r = [np.asarray([x * 1.0 / self.deform[i] - x // self.deform[i] for x in range(self.w[i])]).reshape(\\n [self.w[i] if t == i + 1 else 1 for t in range(len(self.w) + 1)]) for i in range(len(self.w))]\\n d = [np.asarray([x // self.deform[i] for x in range(self.w[i])]).reshape(\\n [self.w[i] if t == i else 1 for t in range(len(self.w))]) for i in range(len(self.w))]\\n\\n if len(self.w) == 3:\\n for i in range(4):\\n for j in range(4):\\n xx = d[0] + i\\n yy = d[1] + j\\n zz = d[2] + 1\\n tmp[i, j] = cint(r[2], tdf[:, xx, yy, zz - 1], tdf[:, xx, yy, zz], tdf[:, xx, yy, zz + 1],\\n tdf[:, xx, yy, zz + 2])\\n for i in range(4):\\n tmp[i, 0] = cint(r[1], tmp[i, 0], tmp[i, 1], tmp[i, 2], tmp[i, 3])\\n return cint(r[0], tmp[0, 0], tmp[1, 0], tmp[2, 0], tmp[3, 0])\\n\\n elif len(self.w) == 2:\\n for j in range(4):\\n xx = d[0] + j\\n yy = d[1] + 1\\n tmp[j] = cint(r[1], tdf[:, xx, yy - 1], tdf[:, xx, yy], tdf[:, xx, yy + 1], tdf[:, xx, yy + 2])\\n return cint(r[0], tmp[0], tmp[1], tmp[2], tmp[3])\\n\\n else:\\n raise Exception('only implemented for 2d and 3d case. feel free to contribute')\",\n \"def __init__(self, coefficient, basefield=None):\\n\\n try:\\n character = basefield.getCharacteristic()\\n self.basefield = basefield\\n except:\\n # backward compatibility support\\n if isinstance(basefield, rational.RationalField) or (not basefield):\\n character = 0\\n self.basefield = rational.theRationalField\\n elif isinstance(basefield, int):\\n character = basefield\\n if character == 1 or character < 0:\\n raise ValueError(\\\"basefield characteristic must be 0 or prime.\\\")\\n self.basefield = finitefield.FinitePrimeField.getInstance(character)\\n else:\\n raise ValueError(\\\"basefield must be FiniteField.\\\")\\n\\n self.ch = character\\n self.infpoint = [self.basefield.zero]\\n if isinstance(coefficient, list):\\n self.coefficient = coefficient\\n if self.ch == 0:\\n if len(self) == 5:\\n self.a1 = self.coefficient[0]\\n self.a2 = self.coefficient[1]\\n self.a3 = self.coefficient[2]\\n self.a4 = self.coefficient[3]\\n self.a6 = self.coefficient[4]\\n self.b2 = self.a1**2+4*self.a2\\n self.b4 = self.a1*self.a3+2*self.a4\\n self.b6 = self.a3**2+4*self.a6\\n self.b8 = self.a1**2*self.a6+4*self.a2*self.a6-self.a1*self.a3*self.a4+self.a2*self.a3**2-self.a4**2\\n self.c4 = self.b2**2-24*self.b4\\n self.c6 = -self.b2**3+36*self.b2*self.b4-216*self.b6\\n self.disc = -self.b2**2*self.b8-8*self.b4**3-27*self.b6**2+9*self.b2*self.b4*self.b6\\n elif len(self) == 2:\\n self.a = self.coefficient[0]\\n self.b = self.coefficient[1]\\n self.a1 = 0\\n self.a2 = 0\\n self.a3 = 0\\n self.a4 = self.coefficient[0]\\n self.a6 = self.coefficient[1]\\n self.b2 = 0\\n self.b4 = 2*self.a\\n self.b6 = 4*self.b\\n self.b8 = -self.a**2\\n self.c4 = -48*self.a\\n self.c6 = -864*self.b\\n self.disc = (self.c4**3-self.c6**2)/1728\\n else:\\n raise ValueError(\\\"coefficient is less or more, can't defined EC.\\\")\\n if self.disc == 0:\\n raise ValueError(\\\"this curve is singular.\\\")\\n self.j = (self.c4**3)/self.disc\\n self.cubic = UniVarPolynomial({0:self.a6, 1:self.a4,\\n 3:self.basefield.one},\\n self.basefield)\\n else:\\n pass # support for subclass\\n else:\\n raise ValueError(\\\"parameters must be (coefficient, basefield)\\\")\",\n \"def Lq(self):\\n if not self.isVaild():\\n pass\\n temp = ((self.r()**self.C)*self.Rho()) / \\\\\\n (math.factorial(self.C)*((1 - self.Rho())**2))\\n return temp*self.P0()\",\n \"def calc_iqr(data: list) -> float:\\n return calc_q3(data) - calc_q1(data)\",\n \"def DQT(fp):\\n # length is 2 + sum(t=1, N) of (65 + 64 * Pq(t))\\n length = unpack('>H', fp.read(2))[0]\\n _remaining = length - 2\\n\\n _pq, _tq, _qk = [], [], []\\n while _remaining > 0:\\n precision, table_id = _split_byte(fp.read(1))\\n _remaining -= 1\\n _pq.append(precision)\\n _tq.append(table_id)\\n\\n # If Pq is 0, Qk is 8-bit, if Pq is 1, Qk is 16-bit\\n Q_k = []\\n for ii in range(64):\\n if precision == 0:\\n Q_k.append(unpack('>B', fp.read(1))[0])\\n _remaining -= 1\\n elif precision == 1:\\n Q_k.append(unpack('>H', fp.read(2))[0])\\n _remaining -= 2\\n\\n _qk.append(Q_k)\\n\\n info = {\\n 'Lq' : length,\\n 'Pq' : _pq,\\n 'Tq' : _tq,\\n 'Qk' : _qk\\n }\\n\\n return info\",\n \"def ADT_QCD_LEPTON():\\n\\n # As input for the quark-mass ratios, we use the quark masses at MZ and the lepton masses\\n ip = Num_input()\\n\\n mu = ip.mu_at_MZ\\n md = ip.md_at_MZ\\n ms = ip.ms_at_MZ\\n me = ip.me\\n mmu = ip.mmu\\n mtau = ip.mtau\\n\\n # Create the ADT:\\n\\n gamma_hat_P63eu_Q81u = np.hstack((-16 * me**2/mu**2, np.zeros(5)))\\n gamma_hat_P63muu_Q81u = np.hstack((np.zeros(1), -16 * mmu**2/mu**2, np.zeros(4)))\\n gamma_hat_P63tauu_Q81u = np.hstack((np.zeros(2), -16 * mtau**2/mu**2, np.zeros(3)))\\n\\n gamma_hat_P63ed_Q81d = np.hstack((-16 * me**2/md**2, np.zeros(5)))\\n gamma_hat_P63mud_Q81d = np.hstack((np.zeros(1), -16 * mmu**2/md**2, np.zeros(4)))\\n gamma_hat_P63taud_Q81d = np.hstack((np.zeros(2), -16 * mtau**2/md**2, np.zeros(3)))\\n\\n gamma_hat_P63es_Q81s = np.hstack((-16 * me**2/ms**2, np.zeros(5)))\\n gamma_hat_P63mus_Q81s = np.hstack((np.zeros(1), -16 * mmu**2/ms**2, np.zeros(4)))\\n gamma_hat_P63taus_Q81s = np.hstack((np.zeros(2), -16 * mtau**2/ms**2, np.zeros(3)))\\n\\n\\n\\n gamma_hat_P63eu_Q82u = np.hstack((np.zeros(3), -16 * me**2/mu**2, np.zeros(2)))\\n gamma_hat_P63muu_Q82u = np.hstack((np.zeros(4), -16 * mmu**2/mu**2, np.zeros(1)))\\n gamma_hat_P63tauu_Q82u = np.hstack((np.zeros(5), -16 * mtau**2/mu**2))\\n\\n gamma_hat_P63ed_Q82d = np.hstack((np.zeros(3), -16 * me**2/md**2, np.zeros(2)))\\n gamma_hat_P63mud_Q82d = np.hstack((np.zeros(4), -16 * mmu**2/md**2, np.zeros(1)))\\n gamma_hat_P63taud_Q82d = np.hstack((np.zeros(5), -16 * mtau**2/md**2))\\n\\n gamma_hat_P63es_Q82s = np.hstack((np.zeros(3), -16 * me**2/ms**2, np.zeros(2)))\\n gamma_hat_P63mus_Q82s = np.hstack((np.zeros(4), -16 * mmu**2/ms**2, np.zeros(1)))\\n gamma_hat_P63taus_Q82s = np.hstack((np.zeros(5), -16 * mtau**2/ms**2))\\n\\n\\n\\n gamma_hat_P62ue_Q83u = np.hstack((-16 * me**2/mu**2, np.zeros(5)))\\n gamma_hat_P62umu_Q83u = np.hstack((np.zeros(1), -16 * mmu**2/mu**2, np.zeros(4)))\\n gamma_hat_P62utau_Q83u = np.hstack((np.zeros(2), -16 * mtau**2/mu**2, np.zeros(3)))\\n\\n gamma_hat_P62de_Q83d = np.hstack((-16 * me**2/md**2, np.zeros(5)))\\n gamma_hat_P62dmu_Q83d = np.hstack((np.zeros(1), -16 * mmu**2/md**2, np.zeros(4)))\\n gamma_hat_P62dtau_Q83d = np.hstack((np.zeros(2), -16 * mtau**2/md**2, np.zeros(3)))\\n\\n gamma_hat_P62se_Q83s = np.hstack((-16 * me**2/ms**2, np.zeros(5)))\\n gamma_hat_P62smu_Q83s = np.hstack((np.zeros(1), -16 * mmu**2/ms**2, np.zeros(4)))\\n gamma_hat_P62stau_Q83s = np.hstack((np.zeros(2), -16 * mtau**2/ms**2, np.zeros(3)))\\n\\n\\n\\n gamma_hat_P62ue_Q84u = np.hstack((np.zeros(3), -16 * me**2/mu**2, np.zeros(2)))\\n gamma_hat_P62umu_Q84u = np.hstack((np.zeros(4), -16 * mmu**2/mu**2, np.zeros(1)))\\n gamma_hat_P62utau_Q84u = np.hstack((np.zeros(5), -16 * mtau**2/mu**2))\\n\\n gamma_hat_P62de_Q84d = np.hstack((np.zeros(3), -16 * me**2/md**2, np.zeros(2)))\\n gamma_hat_P62dmu_Q84d = np.hstack((np.zeros(4), -16 * mmu**2/md**2, np.zeros(1)))\\n gamma_hat_P62dtau_Q84d = np.hstack((np.zeros(5), -16 * mtau**2/md**2))\\n\\n gamma_hat_P62se_Q84s = np.hstack((np.zeros(3), -16 * me**2/ms**2, np.zeros(2)))\\n gamma_hat_P62smu_Q84s = np.hstack((np.zeros(4), -16 * mmu**2/ms**2, np.zeros(1)))\\n gamma_hat_P62stau_Q84s = np.hstack((np.zeros(5), -16 * mtau**2/ms**2))\\n\\n\\n\\n gamma_hat_Q81u = np.vstack((gamma_hat_P63eu_Q81u, gamma_hat_P63muu_Q81u, gamma_hat_P63tauu_Q81u, np.zeros((15,6))))\\n gamma_hat_Q81d = np.vstack((np.zeros((3,6)), gamma_hat_P63ed_Q81d, gamma_hat_P63mud_Q81d, gamma_hat_P63taud_Q81d, np.zeros((12,6))))\\n gamma_hat_Q81s = np.vstack((np.zeros((6,6)), gamma_hat_P63es_Q81s, gamma_hat_P63mus_Q81s, gamma_hat_P63taus_Q81s, np.zeros((9,6))))\\n\\n gamma_hat_Q82u = np.vstack((gamma_hat_P63eu_Q82u, gamma_hat_P63muu_Q82u, gamma_hat_P63tauu_Q82u, np.zeros((15,6))))\\n gamma_hat_Q82d = np.vstack((np.zeros((3,6)), gamma_hat_P63ed_Q82d, gamma_hat_P63mud_Q82d, gamma_hat_P63taud_Q82d, np.zeros((12,6))))\\n gamma_hat_Q82s = np.vstack((np.zeros((6,6)), gamma_hat_P63es_Q82s, gamma_hat_P63mus_Q82s, gamma_hat_P63taus_Q82s, np.zeros((9,6))))\\n\\n gamma_hat_Q83u = np.vstack((np.zeros((9,6)), gamma_hat_P62ue_Q83u, gamma_hat_P62umu_Q83u, gamma_hat_P62utau_Q83u, np.zeros((6,6))))\\n gamma_hat_Q83d = np.vstack((np.zeros((12,6)), gamma_hat_P62de_Q83d, gamma_hat_P62dmu_Q83d, gamma_hat_P62dtau_Q83d, np.zeros((3,6))))\\n gamma_hat_Q83s = np.vstack((np.zeros((15,6)), gamma_hat_P62se_Q83s, gamma_hat_P62smu_Q83s, gamma_hat_P62stau_Q83s))\\n\\n gamma_hat_Q84u = np.vstack((np.zeros((9,6)), gamma_hat_P62ue_Q84u, gamma_hat_P62umu_Q84u, gamma_hat_P62utau_Q84u, np.zeros((6,6))))\\n gamma_hat_Q84d = np.vstack((np.zeros((12,6)), gamma_hat_P62de_Q84d, gamma_hat_P62dmu_Q84d, gamma_hat_P62dtau_Q84d, np.zeros((3,6))))\\n gamma_hat_Q84s = np.vstack((np.zeros((15,6)), gamma_hat_P62se_Q84s, gamma_hat_P62smu_Q84s, gamma_hat_P62stau_Q84s))\\n\\n\\n\\n\\n gamma_hat = np.array([gamma_hat_Q81u, gamma_hat_Q81d, gamma_hat_Q81s, gamma_hat_Q82u, gamma_hat_Q82d, gamma_hat_Q82s,\\n gamma_hat_Q83u, gamma_hat_Q83d, gamma_hat_Q83s, gamma_hat_Q84u, gamma_hat_Q84d, gamma_hat_Q84s])\\n\\n\\n # Return the tensor\\n\\n # tensor, zeile, spalte\\n\\n return gamma_hat\",\n \"def calculation_time_analysis():\\n\\tfrom . import spectra as sp\\n\\tp_dict = {'Bfield':700,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':0*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\\n\\tchiL,chiR,chiZ = sp.calc_chi([-3500],p_dict)\\n\\t\\n\\tfor angle in [0, np.pi/32, np.pi/16, np.pi/8, np.pi/4, np.pi/2]:\\n\\t\\tprint(('Angle (degrees): ',angle*180/np.pi))\\n\\t\\tRotMat, n1, n2 = solve_diel(chiL,chiR,chiZ,angle)\",\n \"def estimate_pi():\\n total = 0\\n k = 0\\n factor = 2 * sqrt(2) / 9801\\n while True:\\n num = factorial(4 * k) * (1103 + 26390 * k)\\n den = factorial(k) ** 4 * 396 ** (4 * k)\\n term = factor * num / den\\n total += term\\n\\n if abs(term) < 1e-15:\\n break\\n k += 1\\n\\n return 1 / total\",\n \"def ADT_QCD(nf):\\n\\n # As input for the quark-mass ratios, we use the quark masses at MZ\\n ip = Num_input()\\n\\n mu = ip.mu_at_MZ\\n md = ip.md_at_MZ\\n ms = ip.ms_at_MZ\\n mc = ip.mc_at_MZ\\n mb = ip.mb_at_MZ\\n\\n # Create the ADT:\\n\\n gamma_hat_P63cu_Q81u = np.hstack((np.zeros(3), -48 * mc**2/mu**2, np.zeros(6)))\\n gamma_hat_P63bu_Q81u = np.hstack((np.zeros(4), -48 * mb**2/mu**2, np.zeros(5)))\\n\\n gamma_hat_P63cd_Q81d = np.hstack((np.zeros(3), -48 * mc**2/md**2, np.zeros(6)))\\n gamma_hat_P63bd_Q81d = np.hstack((np.zeros(4), -48 * mb**2/md**2, np.zeros(5)))\\n\\n gamma_hat_P63cs_Q81s = np.hstack((np.zeros(3), -48 * mc**2/ms**2, np.zeros(6)))\\n gamma_hat_P63bs_Q81s = np.hstack((np.zeros(4), -48 * mb**2/ms**2, np.zeros(5)))\\n\\n\\n\\n gamma_hat_P63cu_Q82u = np.hstack((np.zeros(8), -48 * mc**2/mu**2, np.zeros(1)))\\n gamma_hat_P63bu_Q82u = np.hstack((np.zeros(9), -48 * mb**2/mu**2))\\n\\n gamma_hat_P63cd_Q82d = np.hstack((np.zeros(8), -48 * mc**2/md**2, np.zeros(1)))\\n gamma_hat_P63bd_Q82d = np.hstack((np.zeros(9), -48 * mb**2/md**2))\\n\\n gamma_hat_P63cs_Q82s = np.hstack((np.zeros(8), -48 * mc**2/ms**2, np.zeros(1)))\\n gamma_hat_P63bs_Q82s = np.hstack((np.zeros(9), -48 * mb**2/ms**2))\\n\\n\\n\\n gamma_hat_P62uc_Q83u = np.hstack((np.zeros(3), -48 * mc**2/mu**2, np.zeros(6)))\\n gamma_hat_P62ub_Q83u = np.hstack((np.zeros(4), -48 * mb**2/mu**2, np.zeros(5)))\\n\\n gamma_hat_P62dc_Q83d = np.hstack((np.zeros(3), -48 * mc**2/md**2, np.zeros(6)))\\n gamma_hat_P62db_Q83d = np.hstack((np.zeros(4), -48 * mb**2/md**2, np.zeros(5)))\\n\\n gamma_hat_P62sc_Q83s = np.hstack((np.zeros(3), -48 * mc**2/ms**2, np.zeros(6)))\\n gamma_hat_P62sb_Q83s = np.hstack((np.zeros(4), -48 * mb**2/ms**2, np.zeros(5)))\\n\\n\\n\\n gamma_hat_P62uc_Q84u = np.hstack((np.zeros(8), -48 * mc**2/mu**2, np.zeros(1)))\\n gamma_hat_P62ub_Q84u = np.hstack((np.zeros(9), -48 * mb**2/mu**2))\\n\\n gamma_hat_P62dc_Q84d = np.hstack((np.zeros(8), -48 * mc**2/md**2, np.zeros(1)))\\n gamma_hat_P62db_Q84d = np.hstack((np.zeros(9), -48 * mb**2/md**2))\\n\\n gamma_hat_P62sc_Q84s = np.hstack((np.zeros(8), -48 * mc**2/ms**2, np.zeros(1)))\\n gamma_hat_P62sb_Q84s = np.hstack((np.zeros(9), -48 * mb**2/ms**2))\\n\\n\\n\\n gamma_hat_Q81u = np.vstack((np.zeros((19,10)), gamma_hat_P63cu_Q81u, np.zeros((7,10)), gamma_hat_P63bu_Q81u, np.zeros((52,10))))\\n gamma_hat_Q81d = np.vstack((np.zeros((43,10)), gamma_hat_P63cd_Q81d, np.zeros((7,10)), gamma_hat_P63bd_Q81d, np.zeros((28,10))))\\n gamma_hat_Q81s = np.vstack((np.zeros((59,10)), gamma_hat_P63cs_Q81s, np.zeros((7,10)), gamma_hat_P63bs_Q81s, np.zeros((12,10))))\\n\\n gamma_hat_Q82u = np.vstack((np.zeros((19,10)), gamma_hat_P63cu_Q82u, np.zeros((7,10)), gamma_hat_P63bu_Q82u, np.zeros((52,10))))\\n gamma_hat_Q82d = np.vstack((np.zeros((43,10)), gamma_hat_P63cd_Q82d, np.zeros((7,10)), gamma_hat_P63bd_Q82d, np.zeros((28,10))))\\n gamma_hat_Q82s = np.vstack((np.zeros((59,10)), gamma_hat_P63cs_Q82s, np.zeros((7,10)), gamma_hat_P63bs_Q82s, np.zeros((12,10))))\\n\\n gamma_hat_Q83u = np.vstack((np.zeros((17,10)), gamma_hat_P62uc_Q83u, np.zeros((7,10)), gamma_hat_P62ub_Q83u, np.zeros((54,10))))\\n gamma_hat_Q83d = np.vstack((np.zeros((41,10)), gamma_hat_P62dc_Q83d, np.zeros((7,10)), gamma_hat_P62db_Q83d, np.zeros((30,10))))\\n gamma_hat_Q83s = np.vstack((np.zeros((57,10)), gamma_hat_P62sc_Q83s, np.zeros((7,10)), gamma_hat_P62sb_Q83s, np.zeros((14,10))))\\n\\n gamma_hat_Q84u = np.vstack((np.zeros((17,10)), gamma_hat_P62uc_Q84u, np.zeros((7,10)), gamma_hat_P62ub_Q84u, np.zeros((54,10))))\\n gamma_hat_Q84d = np.vstack((np.zeros((41,10)), gamma_hat_P62dc_Q84d, np.zeros((7,10)), gamma_hat_P62db_Q84d, np.zeros((30,10))))\\n gamma_hat_Q84s = np.vstack((np.zeros((57,10)), gamma_hat_P62sc_Q84s, np.zeros((7,10)), gamma_hat_P62sb_Q84s, np.zeros((14,10))))\\n\\n\\n\\n gamma_hat = np.array([gamma_hat_Q81u, gamma_hat_Q81d, gamma_hat_Q81s, gamma_hat_Q82u, gamma_hat_Q82d, gamma_hat_Q82s,\\n gamma_hat_Q83u, gamma_hat_Q83d, gamma_hat_Q83s, gamma_hat_Q84u, gamma_hat_Q84d, gamma_hat_Q84s])\\n\\n\\n # Return the tensor for given number of active quark flavors\\n\\n # tensor, zeile, spalte\\n\\n if nf == 5:\\n return gamma_hat\\n elif nf == 4:\\n return np.delete(np.delete(gamma_hat, np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80]], 1), [4, 9], 2)\\n else:\\n raise Exception(\\\"nf has to be 4 or 5\\\")\",\n \"def test_mag_form_fac_case2():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac(qrange=[0, 2])[0], ion.calc_mag_form_fac(qrange=[0, 2])[1:]\\n del _temp\\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)\",\n \"def ddq_a(self, q = np.zeros(1) , dq = np.zeros(1) , T = np.zeros(1) , R = 1 , t = 0 ): \\n \\n \\n Ha = self.H( q ) + np.dot( R , np.dot( R , self.Ia ) )\\n \\n C = self.C( q , dq )\\n D = self.D( q , dq )\\n \\n Ca = C + D + np.dot( R , np.dot( R , self.Da ) )\\n \\n G = self.G( q )\\n \\n # Disturbance force\\n f_d = self.F_dist( t )\\n \\n ddq = np.dot( 1. / Ha , ( np.dot( R , T ) + self.F_ext( q , dq ) - f_d - np.dot( Ca , dq ) - G ) )\\n \\n return ddq\",\n \"def fourier_coeff(period,f):\\n if(period!=int(period) or period<1):\\n raise ValueError(\\n \\\"period must be positive integer\\\"\\n )\\n if(len(f)!=period):\\n raise ValueError(\\n \\\"f must contain exactly period number of values\\\"\\n )\\n g = []\\n for n in range(0,period):\\n sum = complex(0,0)\\n for m in range(0,period):\\n sum = sum + (f[m]*cmath.rect(1,-1*(2*(math.pi)*m*n)/period ) )\\n sum = sum/period\\n g.append(sum)\\n return g\",\n \"def _fd_matrix(step_ratio, parity, nterms):\\n _assert(0 <= parity <= 6,\\n 'Parity must be 0, 1, 2, 3, 4, 5 or 6! ({0:d})'.format(parity))\\n step = [1, 2, 2, 4, 4, 4, 4][parity]\\n inv_sr = 1.0 / step_ratio\\n offset = [1, 1, 2, 2, 4, 1, 3][parity]\\n c0 = [1.0, 1.0, 1.0, 2.0, 24.0, 1.0, 6.0][parity]\\n c = c0 / \\\\\\n special.factorial(np.arange(offset, step * nterms + offset, step))\\n [i, j] = np.ogrid[0:nterms, 0:nterms]\\n return np.atleast_2d(c[j] * inv_sr ** (i * (step * j + offset)))\",\n \"def Q(self):\\n return np.array(list(self.center_frequencies)) \\\\\\n / np.array(list(self.bandwidths))\",\n \"def dI_SZ(self, l):\\n # Valid in RJ limit, x << 1\\n \\n # Get dimensionless frequency\\n x = X_SCALE * NU_WMAP_W / ( T_CMB * (1. + self.z) )\\n \\n # Integrate pressure profile at fixed radius\\n xmax = 5. * self.r500; xmin = -xmax\\n pp, err = scipy.integrate.quad( lambda x: self.xP(np.sqrt(x**2. + l**2.)), \\n xmin, xmax )\\n y = Y_SCALE * pp * self._P500\\n dI = -2. * y * (1. + 0.5*x)\\n return dI\",\n \"def IDFT(fourier_signal):\\n n = fourier_signal.shape[0]\\n omega = np.exp((((2 * np.pi)*1j) / n))\\n\\n e_items = np.vander(omega**np.arange(n), n, True)\\n org_signal = np.dot(e_items, fourier_signal)/n\\n\\n return org_signal\",\n \"def focused_diameter(f, lambda0, d, M2=1):\\n return 4 * M2**2 * lambda0 * f / (np.pi * d)\",\n \"def _mbondi_radii(atom_list):\\n radii = [0.0 for atom in atom_list]\\n for i, atom in enumerate(atom_list):\\n # Radius of H atom depends on element it is bonded to\\n if atom.type.atomic_number == 1:\\n bondeds = list(atom.bond_partners)\\n if bondeds[0].type.atomic_number in (6, 7): # C or N\\n radii[i] = 1.3\\n elif bondeds[0].type.atomic_number in (8, 16): # O or S\\n radii[i] = 0.8\\n else:\\n radii[i] = 1.2\\n # Radius of C atom depends on what type it is\\n elif atom.type.atomic_number == 6:\\n radii[i] = 1.7\\n # All other elements have fixed radii for all types/partners\\n elif atom.type.atomic_number == 7:\\n radii[i] = 1.55\\n elif atom.type.atomic_number == 8:\\n radii[i] = 1.5\\n elif atom.type.atomic_number == 9:\\n radii[i] = 1.5\\n elif atom.type.atomic_number == 14:\\n radii[i] = 2.1\\n elif atom.type.atomic_number == 15:\\n radii[i] = 1.85\\n elif atom.type.atomic_number == 16:\\n radii[i] = 1.8\\n elif atom.type.atomic_number == 17:\\n radii[i] = 1.5\\n else:\\n radii[i] = 1.5\\n return radii # converted to nanometers above\",\n \"def boxcar(self, box_dm: float = 0.5, n: int = 4, el_included=None, m_uplim: float=np.inf, is_info: bool = False):\\n clone = self.clone()\\n abund = clone.abund()\\n # abun = np.zeros((clone.nzon, len(clone.Elements)))\\n if el_included is None:\\n el_included = clone.Elements\\n if m_uplim is None:\\n m_uplim = np.inf\\n m = clone.m / phys.M_sun\\n dmass = np.diff(m)\\n dmass = np.insert(dmass, -1, dmass[-1])\\n\\n # todo Check left boundary condition fo Fe, Si\\n for l in range(n): # the iteration number\\n logger.debug(f'Attempt # {l}')\\n for k in range(clone.nzon):\\n if m[k] > m_uplim:\\n logger.warn(f'Exit from zone cycle m[k] > m_uplim: k= {k} m= {m[k]:.4f} m_uplim= {m_uplim:.4f}')\\n break # stop because mass is over the limit\\n kk = k + 1\\n dm = dmass[k]\\n while dm < box_dm and kk <= clone.nzon:\\n kk += 1\\n dm = np.sum(dmass[k:kk])\\n\\n logger.debug(f'{k}: kk= {kk} dm= {dm:.4f} m= {m[k]:.4f}')\\n if dm > 1e-6:\\n for i, ename in enumerate(clone.Elements):\\n if ename in el_included:\\n dm_e = np.dot(abund[k:kk, i], dmass[k:kk])\\n abund[k, i] = dm_e / dm\\n # abun[k,i] = x[k]\\n for i, ename in enumerate(clone.Elements):\\n clone.set_chem(ename, abund[:, i]) \\n logger.debug(f\\\"{ename}: {clone.el(ename)}\\\")\\n\\n return clone\",\n \"def omega(self, i, rosetta_definitions = True):\\n res = self.all_residues[i]\\n\\n try:\\n n = res['N'].get_vector()\\n ca = res['CA'].get_vector()\\n c = res['C'].get_vector()\\n\\n\\n\\n if rosetta_definitions and i < len(self.all_residues) -1 and self.connected_to_next(i):\\n res_plus_one = self.all_residues[i + 1]\\n next_n = res_plus_one['N'].get_vector()\\n next_ca = res_plus_one['CA'].get_vector()\\n omega = calc_dihedral(ca, c, next_n, next_ca)\\n return omega\\n\\n elif not rosetta_definitions and i > 1 and self.connected_to_previous(i):\\n res_minus_one = self.all_residues[i - 1]\\n pre_c = res_minus_one['C'].get_vector()\\n pre_ca = res_minus_one['CA'].get_vector()\\n omega = calc_dihedral(pre_ca, pre_c, n, ca)\\n return omega\\n else:\\n return 0.0\\n\\n except BaseException:\\n print \\\"Could not get omega for \\\"+repr(i)\\n raise LookupError\",\n \"def getDistMat(structure, tol):\\n \\n if tol>1:\\n print('WARNING: Increase in radius is greater than 100%')\\n \\n # Find interatomic distances)\\n s = structure\\n distance_matrix = np.array(s.distance_matrix)\\n \\n \\n # Ensure diagonal will be identified as not bonded\\n np.fill_diagonal(distance_matrix,100)\\n\\n radii = [ELEMENT_RADII[site.species_string] for site in s.sites]\\n radiiS = []\\n for r in radii:\\n radiiS.append(r*(1+tol))\\n radii_transpose = np.array(radii)[np.newaxis].T\\n \\n \\n # Create matrix for sum of radii of each species, scaled by 'tol'\\n radii_matrix = radiiS + radii_transpose*(1+tol)\\n \\n \\n # Take difference between atomic distances and summed radii\\n temp = distance_matrix-radii_matrix\\n \\n \\n # Turn bonded indexes to '1' and non-bonded to '0'\\n binary_matrix = (temp < 0).astype(int)\\n return(binary_matrix)\",\n \"def computeA(diameter):\\n radius = diameter / 2.0\\n return np.pi * (radius**2)\",\n \"def test_units_normalized_fourier_transform():\\n fake_data = np.zeros((1, 13, 21)) * units.m\\n fake_data[0, 7, 11] += 1 * units.m\\n fake_corr = utils.normalized_fourier_transform(\\n fake_data, 1 * units.Hz, taper=windows.boxcar, axis=2\\n )\\n test_units = units.m * units.Hz\\n assert test_units == fake_corr.unit\",\n \"def DFT(signal):\\n n = signal.shape[0]\\n omega = np.exp(((((-2) * np.pi)*1j) / n))\\n\\n e_items = np.vander(omega**np.arange(n), n, True)\\n fourier_signal = np.dot(e_items, signal)\\n\\n return fourier_signal.astype(np.complex128)\",\n \"def generate_fiducial(seed=235, th=150, time=0.5):\\n \\n # impact parameters\\n M = 3e7*u.Msun\\n B = 19.95*u.kpc\\n B = 20.06*u.kpc\\n V = 190*u.km/u.s\\n phi = coord.Angle(0*u.deg)\\n th = 155\\n theta = coord.Angle(th*u.deg)\\n Tenc = 0.01*u.Gyr\\n T = time*u.Gyr\\n dt = 0.05*u.Myr\\n rs = 0*u.pc\\n \\n # potential parameters\\n potential = 3\\n Vh = 220*u.km/u.s\\n q = 1*u.Unit(1)\\n rhalo = 20*u.pc\\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\\n \\n # setup tube\\n Nstar = 4000\\n wx = 30*u.kpc\\n wy = 0*u.pc\\n wz = 0*u.pc\\n sx = 0*u.km/u.s\\n \\n np.random.seed(seed)\\n observer = {'z_sun': -2000.*u.pc, 'galcen_distance': 8.3*u.kpc, 'roll': 50*u.deg, 'galcen_coord': coord.SkyCoord(ra=300*u.deg, dec=-90*u.deg, frame='icrs')}\\n vobs = {'vcirc': 220*u.km/u.s, 'vlsr': [0, 0, 0]*u.km/u.s}\\n wangle = 180*u.deg\\n \\n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\\n #xphi0 = np.linspace(-0.1*np.pi, 0.1*np.pi, 2000)\\n #xphi1 = np.linspace(-0.28*np.pi, -0.1*np.pi, 400)\\n #xphi2 = np.linspace(0.1*np.pi, 0.32*np.pi, 400)\\n #xphi = np.concatenate([xphi1, xphi0, xphi2])\\n \\n xr = 20*u.kpc + np.random.randn(Nstar)*0.0*u.kpc\\n x = np.sin(xphi) * xr\\n y = np.cos(xphi) * xr\\n z = x * 0\\n vx = -np.cos(xphi) * Vh\\n vy = np.sin(xphi) * Vh\\n vz = vx * 0\\n # closest to impact\\n ienc = np.argmin(np.abs(x))\\n \\n # generate stream model\\n potential_perturb = 1\\n par_perturb = np.array([M.si.value, 0., 0., 0.])\\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal = coord.Galactocentric(stream['x'], **observer)\\n xeq = xgal.transform_to(coord.ICRS)\\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\\n veq = [None] * 3\\n veq[0] = veq_[0].to(u.mas/u.yr)\\n veq[1] = veq_[1].to(u.mas/u.yr)\\n veq[2] = veq_[2].to(u.km/u.s)\\n \\n # unperturbed stream\\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream0 = {}\\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\\n xeq0 = xgal0.transform_to(coord.ICRS)\\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\\n veq0 = [None] * 3\\n veq0[0] = veq0_[0].to(u.mas/u.yr)\\n veq0[1] = veq0_[1].to(u.mas/u.yr)\\n veq0[2] = veq0_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n R = find_greatcircle(xeq0.ra.deg[::10], xeq0.dec.deg[::10])\\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\\n xi0 = coord.Angle(xi0*u.deg)\\n \\n # place gap at xi~0\\n xioff = xi0[ienc]\\n xi0 -= xioff\\n \\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\\n xi = coord.Angle(xi*u.deg)\\n xi -= xioff\\n \\n # velocity differences\\n dv = []\\n for i in range(3):\\n # interpolate expected kinematics from an unperturbed stream\\n vexp = np.interp(xi.wrap_at(wangle), xi0.wrap_at(wangle), veq0[i].value) * veq0[i].unit\\n dv += [veq[i]-vexp]\\n \\n outdict = {'x': stream['x'], 'v': stream['v'], 'xi': xi, 'eta': eta, 'veq': veq, 'dv': dv, 'observer': observer, 'vobs': vobs, 'R': R, 'xioff': xioff, 'x0': stream0['x'], 'v0': stream0['v'], 'xi0': xi0, 'eta0': eta, 'veq0': veq0}\\n pickle.dump(outdict, open('../data/gd1_fiducial_t{:.4f}.pkl'.format(time), 'wb'))\",\n \"def __q2v_cf(self, w, rhom, q):\\n return float(q / (rhom + q / w))\",\n \"def homogeneousDirichlet(N, Nq, f):\\n A, F, edge, p, tri = createAandF(f, N, Nq)\\n nodes = np.unique(edge)\\n F[nodes] = 0\\n epsilon = 1e-16\\n A[nodes, nodes] = 1 / epsilon\\n u = np.linalg.solve(A, F)\\n return u, p\",\n \"def dipolePotential(x,y,q,d):\\n k = 8.99e9\\n V = (k * q) / (sqrt(x**2 + (y - d)**2)) - (k * q) / (sqrt(x**2 + (y + d)**2))\\n return V\",\n \"def lindivQ(sample, quantity, criteria=len):\\n sizes = [criteria(dna) for dna in sample]\\n return [size*quantity/sum(sizes) for size in sizes]\",\n \"def ADM_QED(nf):\\n Qu = 2/3\\n Qd = -1/3\\n Qe = -1\\n nc = 3\\n gamma_QED = np.array([[8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc],\\n [8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc],\\n [8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc],\\n [8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qu*nc, 8/3*Qu*Qd*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc, 8/3*Qu*Qe*nc],\\n [8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qu*nc, 8/3*Qd*Qd*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc, 8/3*Qd*Qe*nc],\\n [8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qd, 8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qe, 8/3*Qe*Qe, 8/3*Qe*Qe],\\n [8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qd, 8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qe, 8/3*Qe*Qe, 8/3*Qe*Qe],\\n [8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qd, 8/3*Qe*Qu, 8/3*Qe*Qd, 8/3*Qe*Qe, 8/3*Qe*Qe, 8/3*Qe*Qe]])\\n gamma_QED_1 = np.zeros((2,154))\\n gamma_QED_2 = np.hstack((np.zeros((8,2)),gamma_QED,np.zeros((8,144))))\\n gamma_QED_3 = np.hstack((np.zeros((8,10)),gamma_QED,np.zeros((8,136))))\\n gamma_QED_4 = np.zeros((136,154))\\n gamma_QED = np.vstack((gamma_QED_1, gamma_QED_2, gamma_QED_3, gamma_QED_4))\\n\\n if nf == 5:\\n return gamma_QED\\n elif nf == 4:\\n return np.delete(np.delete(gamma_QED, [6, 14, 22, 30, 42, 50, 58, 66, 74, 82, 94, 102, 110, 118, 126, 134, 142, 150], 0)\\\\\\n , [6, 14, 22, 30, 42, 50, 58, 66, 74, 82, 94, 102, 110, 118, 126, 134, 142, 150], 1)\\n elif nf == 3:\\n return np.delete(np.delete(gamma_QED, [5,6, 13,14, 21,22, 29,30, 41,42, 49,50, 57,58, 65,66, 73,74, 81,82,\\\\\\n 93,94, 101,102, 109,110, 117,118, 125,126, 133,134, 141,142, 149,150], 0)\\\\\\n , [5,6, 13,14, 21,22, 29,30, 41,42, 49,50, 57,58, 65,66, 73,74, 81,82,\\\\\\n 93,94, 101,102, 109,110, 117,118, 125,126, 133,134, 141,142, 149,150], 1)\\n else:\\n raise Exception(\\\"nf has to be 3, 4 or 5\\\")\",\n \"def EulerBucklingForce(I, E, L):\\n # http://en.wikipedia.org/wiki/Buckling\\n K = 2.0 # for a vertical cantilever\\n F = np.pi**2 * E*I / (K*L)**2\\n return F\",\n \"def _like4(init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoef, i):\\r\\n\\t\\r\\n\\tplx_mod, v, sigma_v = init_par[i], init_par[-4:-1], init_par[-1] \\r\\n\\tp, q, r = normalTriad(alpha, delta)\\r\\n\\tmualpha_mod = np.dot(np.transpose(p),v)*plx_mod/_A ### [mas/yr]\\r\\n\\tmudelta_mod = np.dot(np.transpose(q),v)*plx_mod/_A ### [mas/yr]\\r\\n\\t### Add the model vector for the radial velocities:\\r\\n\\tvrad_mod = np.dot(np.transpose(r),v) ### [km/s]\\r\\n \\t\\r\\n\\tsigma_plx, sigma_mualpha, sigma_mudelta = np.transpose(sigma_obs)\\r\\n\\tC = np.zeros((4,4),dtype=np.float64) ### This is a 4x4 matrix \\r\\n\\t### Diagonal terms:\\r\\n\\tC[0,0],C[1,1],C[2,2] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\\r\\n\\tC[3,3] = sigma_vrad**2.\\r\\n\\t\\r\\n\\tr_plx_muRa, r_plx_muDec, r_muRa_muDec = ccoef[0], ccoef[1], ccoef[2] \\r\\n \\r\\n\\t### Correlation terms:\\r\\n\\tC[0,1], C[0,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_plx_muDec*sigma_plx*sigma_mudelta\\r\\n\\tC[1,0], C[1,2] = r_plx_muRa*sigma_plx*sigma_mualpha, r_muRa_muDec*sigma_mualpha*sigma_mudelta\\r\\n\\tC[2,0], C[2,1] = r_plx_muDec*sigma_plx*sigma_mudelta, r_muRa_muDec*sigma_mualpha*sigma_mudelta\\r\\n\\r\\n\\tE = np.zeros((4,4),dtype=np.float64) ### 4x4 matrix \\r\\n\\tE[1,1],E[2,2] = (sigma_v**2.)*(plx_mod/_A)**2., (sigma_v**2.)*(plx_mod/_A)**2. ### [mas/yr]\\r\\n\\tE[3,3] = sigma_v**2.\\t\\t\\t\\t\\t\\t\\t\\t ### [km/s]\\r\\n\\r\\n\\t\\r\\n\\tD = np.add(E,C)\\r\\n\\tdetD = det(D) \\r\\n\\tinvD = inv(D)\\r\\n\\t\\t\\r\\n\\ta_c = np.array([plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod, vrad_obs - vrad_mod])\\r\\n\\tg_func = row_matrix_col_4d(a_c, a_c, invD) \\r\\n\\t\\r\\n\\t\\r\\n\\treturn detD, g_func\",\n \"def chi_c_real(params):\\n Qi = Q_i(params)\\n Qc = params['Q_e_real'].value\\n return ((4 * Qc * Qi) /\\n (Qc + Qi) ** 2)\",\n \"def _Q(self, chi, eta, L):\\n return self.r**2 * chi**2 * np.cos(eta)**2 + L**2 / np.tan(self.theta)**2\",\n \"def find_basis_normal(q):\\n n, T = q.shape\\n\\n f1 = zeros((n, T))\\n f2 = zeros((n, T))\\n for i in range(0, T):\\n f1[:, i] = q[0, i] * q[:, i] / norm(q[:, i]) + array([norm(q[:, i]),\\n 0])\\n f2[:, i] = q[1, i] * q[:, i] / norm(q[:, i]) + array([0,\\n norm(q[:, i])])\\n\\n h3 = f1\\n h4 = f2\\n integrandb3 = zeros(T)\\n integrandb4 = zeros(T)\\n for i in range(0, T):\\n a = q[:, i].T\\n integrandb3[i] = a.dot(h3[:, i])\\n integrandb4[i] = a.dot(h4[:, i])\\n\\n b3 = h3 - q * trapz(integrandb3, linspace(0, 1, T))\\n b4 = h4 - q * trapz(integrandb4, linspace(0, 1, T))\\n\\n basis = [b3, b4]\\n\\n return (basis)\",\n \"def conc_final(V, R, Q):\\n if Q > 0:\\n C = 0.21/(Q+R)*Q\\n elif abs(Q) <= abs(R):\\n C = 0\\n elif abs(Q) > abs(R):\\n C = 0.21*(1-R/abs(Q))\\n return C\",\n \"def qfunc(x):\\n # Error check inputs\\n if isinstance(x, np.ndarray):\\n if x.dtype == np.complex128:\\n raise TypeError(\\\"complex input not supported\\\")\\n else:\\n if isinstance(x, complex):\\n raise TypeError(\\\"complex input not supported\\\")\\n\\n Q = 0.5 * erfc(x / np.sqrt(2.0))\\n return Q\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61005145","0.5547126","0.5504173","0.54883736","0.53962797","0.5384088","0.5333023","0.5327243","0.52803975","0.52569383","0.5241156","0.52071124","0.51957417","0.5193955","0.5186578","0.51780033","0.51702636","0.51467496","0.51093566","0.5086104","0.50725675","0.50621057","0.5056273","0.50495124","0.504766","0.5039809","0.50355047","0.50254065","0.50111854","0.500289","0.49940237","0.49930176","0.4983788","0.498308","0.49780568","0.49663833","0.49652487","0.49584693","0.4957262","0.49472168","0.49440145","0.49413025","0.49390024","0.49308708","0.4926292","0.49231353","0.4912864","0.49080506","0.49007082","0.48916864","0.48865837","0.4883265","0.48730865","0.4870975","0.48655754","0.48499563","0.48487622","0.48408577","0.48408577","0.4832407","0.4820213","0.4817339","0.4816873","0.4810584","0.48073906","0.48070467","0.48059648","0.48049775","0.48046303","0.48022935","0.4800461","0.47934684","0.4785767","0.47807655","0.4780464","0.47798637","0.47768307","0.47737393","0.4766181","0.47654104","0.47647208","0.4749734","0.4749501","0.4748907","0.47445434","0.47405845","0.47403285","0.47296602","0.47293732","0.47284934","0.47269624","0.47267842","0.4725705","0.4724128","0.47231153","0.47189546","0.4715997","0.47086975","0.47086","0.47042173"],"string":"[\n \"0.61005145\",\n \"0.5547126\",\n \"0.5504173\",\n \"0.54883736\",\n \"0.53962797\",\n \"0.5384088\",\n \"0.5333023\",\n \"0.5327243\",\n \"0.52803975\",\n \"0.52569383\",\n \"0.5241156\",\n \"0.52071124\",\n \"0.51957417\",\n \"0.5193955\",\n \"0.5186578\",\n \"0.51780033\",\n \"0.51702636\",\n \"0.51467496\",\n \"0.51093566\",\n \"0.5086104\",\n \"0.50725675\",\n \"0.50621057\",\n \"0.5056273\",\n \"0.50495124\",\n \"0.504766\",\n \"0.5039809\",\n \"0.50355047\",\n \"0.50254065\",\n \"0.50111854\",\n \"0.500289\",\n \"0.49940237\",\n \"0.49930176\",\n \"0.4983788\",\n \"0.498308\",\n \"0.49780568\",\n \"0.49663833\",\n \"0.49652487\",\n \"0.49584693\",\n \"0.4957262\",\n \"0.49472168\",\n \"0.49440145\",\n \"0.49413025\",\n \"0.49390024\",\n \"0.49308708\",\n \"0.4926292\",\n \"0.49231353\",\n \"0.4912864\",\n \"0.49080506\",\n \"0.49007082\",\n \"0.48916864\",\n \"0.48865837\",\n \"0.4883265\",\n \"0.48730865\",\n \"0.4870975\",\n \"0.48655754\",\n \"0.48499563\",\n \"0.48487622\",\n \"0.48408577\",\n \"0.48408577\",\n \"0.4832407\",\n \"0.4820213\",\n \"0.4817339\",\n \"0.4816873\",\n \"0.4810584\",\n \"0.48073906\",\n \"0.48070467\",\n \"0.48059648\",\n \"0.48049775\",\n \"0.48046303\",\n \"0.48022935\",\n \"0.4800461\",\n \"0.47934684\",\n \"0.4785767\",\n \"0.47807655\",\n \"0.4780464\",\n \"0.47798637\",\n \"0.47768307\",\n \"0.47737393\",\n \"0.4766181\",\n \"0.47654104\",\n \"0.47647208\",\n \"0.4749734\",\n \"0.4749501\",\n \"0.4748907\",\n \"0.47445434\",\n \"0.47405845\",\n \"0.47403285\",\n \"0.47296602\",\n \"0.47293732\",\n \"0.47284934\",\n \"0.47269624\",\n \"0.47267842\",\n \"0.4725705\",\n \"0.4724128\",\n \"0.47231153\",\n \"0.47189546\",\n \"0.4715997\",\n \"0.47086975\",\n \"0.47086\",\n \"0.47042173\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62520516"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74283,"cells":{"query":{"kind":"string","value":"Compute r_ij(t), the distance between atom j at time t and atom i and time 0. Note that this alone is likely useless, but is an intermediate variable in the construction of a dynamic structure factor. See 10.1103/PhysRevE.59.623."},"document":{"kind":"string","value":"def compute_dynamic_rdf(trj):\n\n n_atoms = trj.n_atoms\n n_frames = trj.n_frames\n\n r_ij = np.ndarray(shape=(trj.n_atoms, trj.n_atoms, trj.n_frames))\n\n for n_frame, frame in enumerate(trj):\n for atom_i in range(trj.n_atoms):\n for atom_j in range(trj.n_atoms):\n r_ij[atom_i, atom_j, n_frame] = compute_distance(trj.xyz[n_frame, atom_j], trj.xyz[0, atom_i])\n\n return r_ij"},"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 distance(ri, rj):\n return abs(ri[0] - rj[0]) + abs(ri[1] - rj[1])","def r(self, t):\n from scipy.optimize import fsolve\n t = YEAR_TO_SEC * t\n t_coll = fsolve(lambda x: self.r_free(x) - self.snr.r_reverse(x), 4e3)\n # 4e3 years is a typical value that works for fsolve\n # Radius at time of collision\n r_coll = self.r_free(t_coll)\n return np.where(t < t_coll, self.r_free(t), r_coll)","def u_i(self, t_array, i):\n t_array = t_array.reshape(1,len(t_array)) # (1 , N_t)\n tmp = self._r_tau(t_array-self._s.reshape(self._num_gp,1))\n # (N_gp, N_t)\n # A # (N_gp, N_ev)\n # A_j,i = w_j / sqrt(lambda_i) u_i(s_j) \n return 1/self._sqrt_eig_val[i]*np.tensordot(tmp, self._A[:,i], axes=([0],[0]))","def evaluate_rijP(self, q):\n rP_i = self._parent._parent.bodies[self.body_id_i].evaluate_r(q, element_id=self.element_id, ksi=self.element_ksi)\n\n self.r_P_list[0] = rP_i\n\n # distance vector\n r_ij_P = rP_i - self.rP_j\n\n return r_ij_P","def R(self, (k,t), (j,x), **params):\n d = len(x)/2\n q,dq = x[:d],x[d:]\n g = self.G((k,t), (j,x), **params)\n I = (g < 0.).nonzero()[0] # constraint indices that are activating or deactivating\n J = deepcopy(j)\n J[I] = np.logical_not(J[I])\n Delta = self.Delta( (k,t), (J,q,dq), **params )\n dq_ = util.dot( Delta, dq )\n k_ = k+1\n t_ = t\n j_ = 1 * J\n x_ = np.hstack([q,dq_])\n return (k_,t_),(j_,x_)","def do_dt(r, t):\n return -o(r,t)/(2*t)","def compute_r_t(e_mat):\r\n e_hat = e_mat / np.sqrt(np.trace(e_mat.T @ e_mat) / 2)\r\n et_e_hat = e_hat.T @ e_hat\r\n\r\n # using 7.26 from the book\r\n t_hat = np.array([np.sqrt(1 - et_e_hat[0, 0]), np.sqrt(1 - et_e_hat[1, 1]), np.sqrt(1 - et_e_hat[2, 2])])\r\n\r\n w = np.array([np.cross(e_hat[i, :], t_hat) for i in range(3)]) # [w_i, w_j, w_k]\r\n r = np.array([w[0] + np.cross(w[1], w[2]), w[1] + np.cross(w[2], w[0]), w[2] + np.cross(w[0], w[1])])\r\n return r, t_hat","def prep_distance(self, t: str = 'float') -> np.ndarray:\n d = np.zeros([self.ic.shape[0]*self.ic.shape[1],\n self.ic.shape[1]*self.ic.shape[0]])\n\n u,v = np.meshgrid(np.arange(self.ic.shape[0]),\n np.arange(self.ic.shape[1]),\n sparse=False, indexing='xy')\n u = u.ravel()\n v = v.ravel()\n z = np.array([u,v]).T\n\n for (k,x) in enumerate(z):\n if not self.boundary:\n d[k,:] = np.array(np.sqrt((u - x[0])**2 + (v - x[1])**2),dtype=t)\n\n else:\n d[k,:] = self.torus(x[0],x[1],\n self.ic.shape[0],\n self.ic.shape[1]\n ).ravel()\n\n return d","def dij(self, i, j):\n if self.dipole is None:\n return 1 if i != j else 0\n\n # <s_j|D|s_i>\n return (self.s[j:j+1] @ self.dipole @ self.s[i:i+1].T.conj())[0, 0]","def _qij_0(i: int, j: int):\n ia = i * 2 + 0\n ib = i * 2 + 1\n ja = j * 2 + 0\n jb = j * 2 + 1\n term1 = FermionOperator(((ja, 0), (ib, 0)), 1.0)\n term2 = FermionOperator(((ia, 0), (jb, 0)), 1.0)\n return numpy.sqrt(0.5) * (term1 - term2)","def _calc_R_T_amp(self, polarization, n, delta):\n t_amp = np.zeros((len(self.structure), len(self.structure)), dtype=complex)\n r_amp = np.zeros((len(self.structure), len(self.structure)), dtype=complex)\n# # debugging statement\n# print(\"\\nr_amp is:\")\n# for i in range(len(self.structure)):\n# for j in range(len(self.structure)):\n# print(\"{}{} {}\".format(i,j,r_amp[i][j]))\n# # debugging statement\n# print(\"\\nt_amp is:\")\n# for i in range(len(self.structure)):\n# for j in range(len(self.structure)):\n# print(\"{}{} {}\".format(i,j,t_amp[i][j]))\n\n for i in range(len(self.structure)-1):\n t_amp[i,i+1] = self._t_at_interface(polarization, n[i], n[i+1])\n r_amp[i,i+1] = self._r_at_interface(polarization, n[i], n[i+1])\n# # debugging statement\n# print(\"\\nmod r_amp is:\")\n# for i in range(len(self.structure)):\n# for j in range(len(self.structure)):\n# print(\"{}{} {}\".format(i,j,r_amp[i][j]))\n# # debugging statement\n# print(\"\\nmod t_amp is:\")\n# for i in range(len(self.structure)):\n# for j in range(len(self.structure)):\n# print(\"{}{} {}\".format(i,j,t_amp[i][j]))\n\n M = np.zeros((len(self.structure),2,2),dtype=complex)\n# # debugging statement\n# print(\"\\nThe 'M' matrix is:\")\n# for i in range(len(self.structure)):\n# for j in range(2):\n# for k in range(2):\n# print(\"M{}{}{} ---> {}\".format(i,j,k,M[i][j][k]))\n\n m_r_amp = np.zeros((len(self.structure),2,2), dtype=complex)\n m_t_amp = np.zeros((len(self.structure),2,2), dtype=complex)\n for i in range(1,len(self.structure)-1):\n m_t_amp[i] = self._make_2x2(np.exp(-1j*delta[i]), 0., 0., np.exp(1j*delta[i]), dtype=complex)\n m_r_amp[i] = self._make_2x2(1., r_amp[i,i+1], r_amp[i,i+1], 1., dtype=complex)\n\n# # debugging statement\n# print(\"\\nThe temporary 'm_r_amp' matrix is:\")\n# for i in range(len(self.structure)):\n# for j in range(2):\n# for k in range(2):\n# print(\"m_r_amp{}{}{} ---> {}\".format(i,j,k,m_r_amp[i][j][k]))\n\n# # debugging statement\n# print(\"\\nThe temporary 'm_t_amp' matrix is:\")\n# for i in range(len(self.structure)):\n# for j in range(2):\n# for k in range(2):\n# print(\"m_t_amp{}{}{} ---> {}\".format(i,j,k,m_t_amp[i][j][k]))\n\n m_temp = np.dot(m_t_amp, m_r_amp)\n\n# # debugging statement\n# print(\"\\nThe 'm_temp' matrix is:\")\n# for i in m_temp:\n# print i\n# for i in range(len(self.structure)):\n# for j in range(2):\n# for k in range(2):\n# print(\"m_temp{}{}{} ---> {}\".format(i,j,k,m_temp[i][j][k]))\n\n for i in range(1,len(self.structure)-1):\n M[i] = 1/t_amp[i,i+1] * np.dot(self._make_2x2(np.exp(-1j*delta[i]),\n 0., 0., np.exp(1j*delta[i]),\n dtype=complex),\n self._make_2x2(1., r_amp[i,i+1], \\\n r_amp[i,i+1], 1., \\\n dtype=complex))\n# # debugging statement\n# print(\"\\nThe modified 'M' matrix is:\")\n# for i in range(len(self.structure)):\n# for j in range(2):\n# for k in range(2):\n# print(\"mod M{}{}{} ---> {}\".format(i,j,k,M[i][j][k]))\n\n M_prime = self._make_2x2(1., 0., 0., 1., dtype=complex)\n\n# # debugging statement\n# print(\"\\nThe first modified 'M_prime' matrix is:\")\n# for i in range(2):\n# for j in range(2):\n# print(\"1st mod M_prime{}{} ---> {}\".format(i,j,M_prime[i][j]))\n\n for i in range(1, len(self.structure)-1):\n# print(\"\\n'M_prime' #{} is:\\n{}\".format(i,M_prime))\n M_prime = np.dot(M_prime, M[i])\n\n# # debugging statement\n# print(\"\\nThe second modified 'M_prime' matrix is:\")\n# for i in range(2):\n# for j in range(2):\n# print(\"2nd mod M_prime{}{} ---> {}\".format(i,j,M_prime[i][j]))\n\n# print(\"\\nr_amp01 is ---> {}\".format(r_amp[0,1]))\n# print(\"t_amp01 is ---> {}\".format(t_amp[0,1]))\n\n mod_M_prime = self._make_2x2(1.,r_amp[0,1], r_amp[0,1], 1., dtype=complex)/t_amp[0,1]\n\n# # debugging statement\n# print(\"\\nThe third modified 'M_prime' matrix is:\")\n# for i in range(2):\n# for j in range(2):\n# print(\"3rd mod M_prime{}{} ---> {}\".format(i, j, mod_M_prime[i][j]))\n\n M_prime = np.dot(self._make_2x2(1., r_amp[0,1], r_amp[0,1], 1., \\\n dtype=complex)/t_amp[0,1], M_prime)\n\n# # debugging statement\n# print(\"\\nThe 'M_final' matrix is:\")\n# for i in range(2):\n# for j in range(2):\n# print(\"M_final{}{} ---> {}\".format(i, j, M_prime[i][j]))\n\n t = 1/M_prime[0,0]\n r = M_prime[0,1]/M_prime[0,0]\n\n# # debugging statement\n# print(\"\\n't' ---> {}\".format(t))\n# print(\"'r' ---> {}\".format(r))\n\n return (r, t)","def diff(t, y):\n origin = root.vectorize()\n root.tensorize(y)\n self.time = t if not imaginary else None\n self.eom()\n ans = root.vectorize(use_aux=True)\n root.tensorize(origin)\n return ans","def get_traj_length_rad(traj):\n return np.sum(np.abs(np.diff(traj, axis=0)))","def F_calcDMradius(i, t, st, dm, t1, tth):\n mr = st.mn*dm.mxkg_v[i]/(st.mn+dm.mxkg_v[i]) # reduced mass, kg\n # before thermalization (cooling), rx changes with time:\n rxco = np.array([ F_rxco2(tim,t1,mr,(st.nb*1.e+6),dm.sigx_m,st.Rs,dm.mxkg_v[i],pF) for tim in t.time ]) # cm\n print \"-- Radius: rxco at t1 = \",F_rxco2(t1+0.1,t1,mr,(st.nb*1.e+6),dm.sigx_m,st.Rs,dm.mxkg_v[i],pF)\n # after thermalization:\n rxth1 = F_rxth(dm.mx_v[i],st.rhoc,st.Temp) # cm (formula)\n rxth2 = np.interp(tth,t.time,rxco) \t# cm (rxco(tth))\n rxth = rxth1\n print \" rxth=%.2e , rxth1=%.2e , rxth2=%.2e\" % (rxth,rxth1,rxth2)\n for k in xrange(len(t.time)):\n if t.time[k]<t1:\n t.rxtag[k] = 'Rs '\n t.rx[k] = st.Rs*1.e+2\n elif t.time[k]<tth:\n t.rxtag[k] = 'rxco'\n t.rx[k] = rxco[k]\n elif t.time[k]>=tth:\n t.rxtag[k] = 'rxth'\n t.rx[k] = rxth\n return rxco, rxth","def SIR_timederivative(self, SIR, t): \n beta = self.beta(t)\n nu = self.nu(t)\n Sddt = - beta*SIR[0]*SIR[1]\n Iddt = beta*SIR[0]*SIR[1] - nu*SIR[1]\n Rddt = nu*SIR[1]\n return [Sddt, Iddt, Rddt]","def sum_i_neq_j(x):\n\tiw_size = x.size(0)\n\tbatch_size = x.size(1)\n\n\t# TODO: Would torch.expand instead of torch.repeat make this faster?\n\tinv_mask = (1. - torch.eye(iw_size)\n\t\t\t\t).unsqueeze(dim=2).repeat(1, 1, batch_size)\n\tx_masked = torch.mul(x.view(1, iw_size, batch_size), inv_mask)\n\treturn torch.sum(x_masked, dim=1)","def compute_rate(Tij, dt):\n nstates = Tij.shape[0]\n Kij = Tij - np.eye(nstates)\n Kij /= dt\n return Kij","def rtt_cost(s_vr, neighbor_vr, rtt_matrix):\n rtt = rtt_matrix[s_vr][neighbor_vr + 1]\n #print \"rtt_i_k\", rtt\n return float(rtt)","def diff(t, y):\n origin = tensor.array\n tensor.set_array(np.reshape(y, tensor.shape))\n ans = np.zeros_like(y)\n self.time = t if not imaginary else None\n for n in self.term_visitor(use_cache=True):\n ans += np.reshape(self._single_eom(tensor, n, cache=cache), -1)\n if self.init_energy is not None:\n ans -= self.init_energy * y\n ans /= self.coefficient()\n tensor.set_array(origin)\n return ans","def R(self, s, j, **params):\n s_,j_ = (deepcopy(s)+1,deepcopy(j))\n return s_,j_","def __init__(self,\n r_i: np.array,\n tau_ij,\n alpha_ij: np.ndarray,\n nu_i,\n delta_i,\n solver_verbose: int = 0,\n solver_method: str = 'dogbox'):\n self.kappa_ref = 0.034\n self.eps_ref = 1960.0\n\n self.r = r_i\n self.size = r_i.shape[0]\n self.temp_dep_tau = False\n if callable(tau_ij):\n self.temp_dep_tau = True\n self.tau_fun = tau_ij\n else:\n self.tau = tau_ij\n if tau_ij.shape != (self.size, self.size):\n raise Exception(f'tau_ij size {tau_ij.shape} is inconsistent with r_i size {self.size}')\n self.alpha = alpha_ij\n if alpha_ij.shape != (self.size, self.size):\n raise Exception(f'alpha_ij size {alpha_ij.shape} is inconsistent with r_i size {self.size}')\n self.nu = nu_i\n self.delta = delta_i\n if len(nu_i) != self.size or len(delta_i) != self.size:\n raise Exception(f'nu_i size {len(nu_i)} or delta_i size {len(delta_i)} '\n f'is inconsistent with r_i size {self.size}')\n\n self.delta_as, self.delta_ds = self.get_delta_arrays()\n self.delta_ad = np.zeros((len(self.delta_as), len(self.delta_ds)))\n self.solver_verbose = solver_verbose\n self.solver_method = solver_method","def get_distvec2(self, i, j,exclude_self=True):\n leni = True\n lenj = True\n try:\n l=len(i)\n if l > 1:\n ri = np.array(i)\n else:\n leni = False\n ri = self.xyz[i]\n except:\n ri = self.xyz[i]\n try:\n l=len(j)\n if l > 1:\n rj = np.array(j)\n else:\n rj = self.xyz[j]\n except:\n rj = self.xyz[j]\n lenj = False\n if 1:\n all_rj = rj + self.images_cellvec\n all_r = all_rj - ri\n all_d = np.sqrt(np.add.reduce(all_r*all_r,1))\n d_sort = np.argsort(all_d)\n if exclude_self and (np.linalg.norm(ri-rj) <= 0.001):\n d_sort = d_sort[1:]\n closest = d_sort[0]\n closest=[closest]\n if (abs(all_d[closest[0]]-all_d[d_sort[1]]) < SMALL_DIST):\n for k in d_sort[1:]:\n if (abs(all_d[d_sort[0]]-all_d[k]) < SMALL_DIST):\n closest.append(k)\n d = all_d[closest[0]]\n r = all_r[closest[0]]\n return d, r, closest","def R(self, (k,t), (j,x), **params):\n (k_,t_),(j_,x_) = (deepcopy(k)+1,deepcopy(t)),(deepcopy(j),deepcopy(x))\n return (k_,t_),(j_,x_)","def d_j(self,q):\n dj = np.roll(q,-1,axis=-2) - q\n return dj","def time_integrate(arr, times):\n times = times.flatten()\n dt = times[1] - times[0]\n zeros = np.zeros(arr.shape[1:])\n off1 = np.vstack((zeros, arr))\n off2 = np.vstack((arr, zeros))\n return dt * 0.5 * np.sum(off1 + off2, axis=0)","def ridge_cd_weight_update(\n x: FloatTensor,\n r: FloatTensor,\n j: int,\n w_j: Union[float, FloatTensor],\n col_l2: float,\n lmb: float,\n) -> float:\n if col_l2 == 0.0:\n return 0.0\n n, d = x.size()\n return w_j + (x[:, j].matmul(r) - n * lmb * w_j) / col_l2","def calc_dist(atom_R, env_R_arr):\n assert atom_R not in env_R_arr\n return np.linalg.norm(atom_R - env_R_arr, axis=1)","def naive_sum(z, n_times_atom):\n n_atoms, n_trials, n_times_valid = z.shape\n\n ztz = np.zeros(shape=(n_atoms, n_atoms, 2 * n_times_atom - 1))\n t0 = n_times_atom - 1\n for k0 in range(n_atoms):\n for k in range(n_atoms):\n for i in range(n_trials):\n for t in range(n_times_atom):\n if t == 0:\n ztz[k0, k, t0] += (z[k0, i] * z[k, i]).sum()\n else:\n ztz[k0, k, t0 + t] += (\n z[k0, i, :-t] * z[k, i, t:]).sum()\n ztz[k0, k, t0 - t] += (\n z[k0, i, t:] * z[k, i, :-t]).sum()\n return ztz","def compute_j(self, trajectory):\r\n J = 0\r\n for i, (_,_,r,_) in enumerate(trajectory):\r\n J += (self.domain.discount**i) * r\r\n return J","def get_rho_from_J(self, J):\n return J[self.iOmX]/J[0]","def _jplus(j, *, dtype=None):\n m = np.arange(j, -j - 1, -1, dtype=complex)\n data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]\n return _data.diag[dtype](data, 1)","def get_dist(dist, i, j):\n n = int(np.ceil(np.sqrt(2 * len(dist))))\n if i == j:\n return 0\n elif i > j:\n return dist[n * j - j * (j + 1) / 2 + i - 1 - j]\n else:\n return dist[n * i - i * (i + 1) / 2 + j - 1 - i]","def Temp2IApprox(T,T0,K,D,t=1.0/64.0):\n # get numpy fn to interpret temperature as matrix and get pi constant\n from numpy import asarray, pi, sqrt, abs\n # temperature difference\n Tdiff = (T-T0)\n # thermal conductivity matrix\n K = K(Tdiff)\n # thermal diffusivity matrix\n D = D(Tdiff)\n # 2*sqrt(Dt/pi)\n a = ((D*t)/np.pi)\n # result of sqrt can be +/-\n # power density cannot be negative \n b = (2.0*np.sqrt(a))\n temp = K*Tdiff\n # K*(T-T0)/(2*sqrt(Dt/pi))\n return abs(temp/b)","def rt_num(lam, T, I_0, tau):\n B_lam = planck_w(lam, T)\n exp_tau_i_n = np.zeros(len(tau)-2)\n for i in range(len(exp_tau_i_n)):\n exp_tau_i_n[i] = np.exp(-(np.sum(tau[i+1:])))\n\n I = I_0 * np.exp(-(np.sum(tau))) + B_lam * (1 - np.exp(-tau[-1]))\\\n + B_lam * np.sum( (1 - np.exp(-tau[1:-1])) * exp_tau_i_n)\n\n return I","def rank_trotterjohnson(self):\n if self.array_form == [] or self.is_Identity:\n return 0\n if self.array_form == [1, 0]:\n return 1\n perm = self.array_form\n n = self.size\n rank = 0\n for j in range(1, n):\n k = 1\n i = 0\n while perm[i] != j:\n if perm[i] < j:\n k += 1\n i += 1\n j1 = j + 1\n if rank % 2 == 0:\n rank = j1*rank + j1 - k\n else:\n rank = j1*rank + k - 1\n return rank","def rt_isothermal(lam, T, I_0, tau):\n B_lam = planck_w(lam, T)\n return I_0 * np.exp(-tau) + B_lam * (1 - np.exp(-tau))","def J_inside(self, r):\n\n return self.S * (1. - quad(self.J_integ_inside, 0, 1, args=(r,))[0])","def integrate(ii, r0, c0, r1, c1):\n # This line is modified\n S = np.zeros(ii.shape[-1]) \n\n S += ii[r1, c1]\n\n if (r0 - 1 >= 0) and (c0 - 1 >= 0):\n S += ii[r0 - 1, c0 - 1]\n\n if (r0 - 1 >= 0):\n S -= ii[r0 - 1, c1]\n\n if (c0 - 1 >= 0):\n S -= ii[r1, c0 - 1]\n\n return S","def radial_distance(x_i, y_i, z_i, x_j, y_j, z_j, box_length):\n delta_x = min(((x_i - x_j) % box_length), ((x_j - x_i) % box_length))\n delta_y = min(((y_i - y_j) % box_length), ((y_j - y_i) % box_length))\n delta_z = min(((z_i - z_j) % box_length), ((z_j - z_i) % box_length))\n return np.sqrt(delta_x ** 2 + delta_y ** 2 + delta_z ** 2)","def j(U, Q, mesh, T, num_steps, params):\n \n # Define parameters for cost functional\n alpha = params[\"alpha\"]\n u_d = params[\"u_d\"]\n \n # Compute integrals with time\n I1 = 0\n I3 = 0\n \n t = 0\n dt = T/num_steps\n for i in range(num_steps + 1):\n I1_int = assemble((U[i] - u_d[i])*(U[i] - u_d[i])*dx(mesh))\n I3_int = assemble(Q[i]*Q[i]*dx(mesh))\n \n if i == 0 or i == num_steps:\n I1_int *= 0.5\n I3_int *= 0.5\n \n I1 += I1_int\n I3 += I3_int\n \n t += dt\n \n \n I1 *= dt\n I3 *= dt*alpha/2\n \n # Compute end time integral\n \n print(\"Cost Functional Data\")\n print(\"I1: {}\".format(I1))\n print(\"I3: {}\".format(I3))\n print()\n \n return I1 + I3","def rule(model, d, i, j):\n off = d * 48\n num = np.arange(self.num_timeslots / 7)\n total = model.A[i + off, j] * num[i]\n return 0, model.T_end[d, j] - total, None","def dpsi_dt(self, psi, t):\n#\t#To avoid doing anything twice. (odeint tends to do that.)\n#\t#---------------------------------------------------------\n#\tnovel, result = self.check_novelty(t,psi)\n#\tif not novel:\n#\t if self.my_id == 0:\n#\t\tprint \"Time: %2.2f / %2.2f au. Runtime: %2.2f---\"%(\n#\t\t t, self.total_duration, (time.time() - self.t_0)/60.)\n#\t\tself.debug_norm(t, psi, result)\t\n#\t\t\n#\t return result\n#\t##########################################################\n\n\t#Making a complex array. \n\tpsi_complex = psi[:len(psi)/2] + 1j * psi[len(psi)/2:] \n\t\n\tdp_dt_complex = zeros(psi_complex.shape, dtype = complex)\n\tdp_dt_buffer= zeros(psi_complex.shape, dtype = complex)\n\t\n\n\t#Do operations.\n\tmat_vec = self.mat_vec_product(psi_complex, t)\n\n\tdp_dt_complex[self.my_slice] = self.solve_overlap(-1j * mat_vec)\n\t\n\n\n\t#Add and redistribute.\n\tdp_dt_complex = pypar.reduce(dp_dt_complex, pypar.SUM, 0, buffer = dp_dt_buffer)\n\tdp_dt_buffer = dp_dt_complex.copy()\n\tdp_dt_complex = pypar.broadcast(dp_dt_buffer, 0)\n\t\n\n\n\t#Making a float array.\n\tdp_dt = r_[real(dp_dt_buffer), imag(dp_dt_buffer)] \n\t\n\tif self.my_id == 0:\n\t print \"Time: %2.2f / %2.2f au. Runtime: %2.2f\"%(\n\t\tt, self.total_duration, (time.time() - self.t_0)/60.)\n\t self.debug_norm(t, psi, dp_dt)\t\n\t\n\t#Store latest result. ----------------------------------\n\tself.prev_out = dp_dt\n\t############################3###########################3\n\treturn dp_dt","def momentOfInertia(m_r_touple_list):\n I = sum([m*r**2 for m,r in m_r_touple_list])\n return I","def ols_cd_weight_update(\n x: FloatTensor,\n r: FloatTensor,\n j: int,\n w_j: Union[float, FloatTensor],\n col_l2: float,\n _: float,\n) -> float:\n return w_j + x[:, j].matmul(r) / col_l2 if col_l2 != 0.0 else 0.0","def center_of_mass_ij(self, time):\n if self.start_time <= time <= self.end_time:\n diff = time - self.start_time\n valid = np.flatnonzero(self.masks[diff] > 0)\n if valid.size > 0:\n com_i = 1.0 / self.timesteps[diff].ravel()[valid].sum() * np.sum(self.timesteps[diff].ravel()[valid] *\n self.i[diff].ravel()[valid])\n com_j = 1.0 / self.timesteps[diff].ravel()[valid].sum() * np.sum(self.timesteps[diff].ravel()[valid] *\n self.j[diff].ravel()[valid])\n else:\n com_i = np.mean(self.i[diff])\n com_j = np.mean(self.j[diff])\n com_i = int(np.round(com_i))\n com_j = int(np.round(com_j))\n else:\n com_i = None\n com_j = None\n return com_i, com_j","def omega(self, i, rosetta_definitions = True):\n res = self.all_residues[i]\n\n try:\n n = res['N'].get_vector()\n ca = res['CA'].get_vector()\n c = res['C'].get_vector()\n\n\n\n if rosetta_definitions and i < len(self.all_residues) -1 and self.connected_to_next(i):\n res_plus_one = self.all_residues[i + 1]\n next_n = res_plus_one['N'].get_vector()\n next_ca = res_plus_one['CA'].get_vector()\n omega = calc_dihedral(ca, c, next_n, next_ca)\n return omega\n\n elif not rosetta_definitions and i > 1 and self.connected_to_previous(i):\n res_minus_one = self.all_residues[i - 1]\n pre_c = res_minus_one['C'].get_vector()\n pre_ca = res_minus_one['CA'].get_vector()\n omega = calc_dihedral(pre_ca, pre_c, n, ca)\n return omega\n else:\n return 0.0\n\n except BaseException:\n print \"Could not get omega for \"+repr(i)\n raise LookupError","def _redfield(R, rho0, evecs=None, Nt=1, dt=0.005, t0=0, e_ops=[], return_result=True):\n\n N = rho0.shape[0]\n # initialize the density matrix\n if e_ops is None:\n e_ops = []\n\n # basis transformation\n if evecs is not None:\n rho0 = transform(rho0, evecs)\n e_ops = [transform(e, evecs) for e in e_ops]\n\n rho = rho0.copy()\n rho = dm2vec(rho).astype(complex)\n\n # tf = t0 + dt * Nt\n # result = solve_ivp(rhs, t_span=(t0, tf), y0=rho0, vectorized=True, args=(R, ))\n\n t = t0\n\n if return_result == False:\n\n f_obs = open('obs.dat', 'w')\n fmt = '{} '* (len(e_ops) + 1) + '\\n'\n\n for k in range(Nt):\n\n # compute observables\n # observables = np.zeros(len(e_ops), dtype=complex)\n # for i, obs_op in enumerate(e_ops):\n\n observables = [obs_dm(rho, e) for e in e_ops]\n\n t += dt\n rho = rk4(rho, rhs, dt, R)\n\n # dipole-dipole auto-corrlation function\n #cor = np.trace(np.matmul(d, rho))\n\n # take a partial trace to obtain the rho_el\n\n\n f_obs.write(fmt.format(t, *observables))\n\n\n f_obs.close()\n # f_dm.close()\n\n return rho\n\n else:\n\n rholist = [] # store density matries\n\n result = Result(dt=dt, Nt=Nt, rho0=rho0)\n\n observables = np.zeros((Nt, len(e_ops)), dtype=complex)\n\n for k in range(Nt):\n\n t += dt\n rho = rk4(rho, rhs, dt, R)\n\n tmp = np.reshape(rho, (N, N))\n rholist.append(transform(tmp, dag(evecs)))\n\n\n observables[k, :] = [obs_dm(tmp, e) for e in e_ops]\n\n\n result.observables = observables\n result.rholist = rholist\n\n return result","def euler_cromer_method(theta_0, omega_0, dt, T_i):\n theta=np.zeros(samples)\n omega=np.zeros(samples)\n t=np.zeros(samples)\n theta[0]=theta_0\n omega[0]=omega_0\n t[0]=T_i\n\n for n in range(1,samples):\n \"\"\"\n calculates new value for omega using old value of theta and omega\n \"\"\"\n omega[n]=omega[n-1]-g/l*np.sin(theta[n-1])*dt\n \n \"\"\"\n calculates new value of omega by new omega and old theta\n \"\"\"\n theta[n]=theta[n-1]+omega[n]*dt\n \n \"\"\"\n time erray of same dimenion as earlier arrays\n \"\"\"\n t[n]=t[n-1]+dt\n \n \n \"\"\"\n theta: array with values of angular displacement\n w: array with values of angular velocity\n t: array with time-values\n \"\"\"\n return theta,omega,t","def get_rotation_diversity(self, i, t):\n\n if self.rotation_type == 2:\n ith = self._get_check_i(self.diversity, i)\n rotations = self.pro.get_ordering(self.diversity, ith)\n t -= 1\n return rotations[t]\n else:\n return self.get_diversity(t)","def d_j(self,q):\n dj = q.shift(y=-1) - q # works with chunks too\n return dj","def u_i_all(self, t_array):\n t_array = t_array.reshape(1,len(t_array)) # (1 , N_t)\n tmp = self._r_tau(t_array-self._s.reshape(self._num_gp,1))\n # (N_gp, N_t)\n # A # (N_gp, N_ev)\n # A_j,i = w_j / sqrt(lambda_i) u_i(s_j)\n return np.tensordot(tmp, 1/self._sqrt_eig_val.reshape(1,self._num_ev) * self._A, axes=([0],[0]))","def C(self,t,K,c0):\n #ode(self.dc_dt,c0,t,args=(k,)).set_integrator('lsoda')\n #ode(self.dc_dt,c0,t,args=(k,)).set_integrator('vode', method='bdf', order=15)\n \n # if we have any negative times we assume they occur before the \n # reaction starts hence all negative times are assigned concentration \n # c0\n \n ## could switch to something like ode15s that the oiginal matlab code \n ## uses - can odeint cope with equations as stiff as we need?\n ## to use integrate.ode need order of arguments in dc_dt to switch\n \n #r = scipy.integrate.ode(self.dc_dt)\n #r = r.set_integrator('vode', method='bdf', order=15,nsteps=3000)\n #r = r.set_initial_value(c0)\n #r = r.set_f_params((K,))\n #r.integrate(t)\n \n static_times = t[t<0]\n dynamic_times = t[t>=0]\n\n static_C = np.array([c0 for _ in static_times])\n\n # odeint always takes the first time point as t0\n # our t0 is always 0 (removing t0 occures before we integrate)\n # so if the first time point is not 0 we add it \n \n if not dynamic_times.any() or dynamic_times[0]:\n #fancy indexing returns a copy so we can do this\n dynamic_times = np.hstack([[0],dynamic_times]) \n dynamic_C = odeint(self.dc_dt,c0,dynamic_times,args=(K,))[1:]\n else:\n dynamic_C = odeint(self.dc_dt,c0,dynamic_times,args=(K,))\n \n if static_C.any():\n return np.vstack([static_C,dynamic_C])\n else:\n return dynamic_C","def get_neighb_dist(self, i, ci):\n ri = self.xyz[i]\n j = self.conn[i][ci]\n rj = self.xyz[j].copy()\n if self.periodic:\n if self.use_pconn:\n img = self.pconn[i][ci]\n rj += np.dot(img, self.cell)\n else:\n all_rj = rj + self.images_cellvec\n all_r = all_rj - self.xyz[i]\n all_d = np.sqrt(np.add.reduce(all_r*all_r,1))\n closest = np.argsort(all_d)[0]\n return all_rj[closest]\n dr = ri-rj\n d = np.sqrt(np.sum(dr*dr))\n return d","def utlibr(time):\n\n if time.size == 1:\n return iers.utlibr(time.tt.mjd)\n else:\n # Only loop over unique epochs\n _, idx, r_idx = np.unique(np.asarray(time), return_index=True, return_inverse=True)\n return np.array([iers.utlibr(t.tt.mjd) for t in time[idx]])[r_idx]","def __getitem__(self, i):\n T0, S0 = get_surface_ts(self.nc, i)\n \n # average the variables if we got multiple time elements\n if isinstance(i, slice):\n T0, S0, = T0.mean(axis=0), S0.mean(axis=0)\n if self.p == 0.:\n rho, drhodT, drhodS = jmd95.eos.state_surface(T0, S0)\n else:\n rho, drhodT, drhodS = jmd95.eos.state(self.p, T0, S0)\n return rho","def J(self, r):\n\n if r <= self.R:\n return self.J_inside(r)\n else:\n return self.J_outside(r)","def sum_numba(z, n_times_atom):\n n_atoms, n_trials, n_times_valid = z.shape\n\n ztz = np.zeros(shape=(n_atoms, n_atoms, 2 * n_times_atom - 1))\n t0 = n_times_atom - 1\n for k0 in range(n_atoms):\n for k in range(n_atoms):\n for i in range(n_trials):\n for t in range(n_times_atom):\n if t == 0:\n ztz[k0, k, t0] += (z[k0, i] * z[k, i]).sum()\n else:\n ztz[k0, k, t0 + t] += (\n z[k0, i, :-t] * z[k, i, t:]).sum()\n ztz[k0, k, t0 - t] += (\n z[k0, i, t:] * z[k, i, :-t]).sum()\n return ztz","def diffusion_spherical_FV(c, t, r, R, D, j0):\n\n # Compute spacing\n dr = r[1]-r[0]\n\n # Evaluate j\n j = current(t, j0)\n\n # Set maximum concentration\n\n # Compute fluxes\n q = - D*r[1:-1] ** 2. * (c[1:] - c[0:-1]) / dr\n q_surf = -j*R**2\n\n # Append boundary conditions\n q = np.append(0, q)\n q = np.append(q, q_surf)\n\n # Compute discretised dc/dt\n dcdt_out = - (2. / (r[1:] + r[0:-1])) ** 2. \\\n * (q[1:] - q[0:-1]) / dr\n\n return dcdt_out","def r(o, t):\n return o*t**0.5","def __call__(self, SIR, t):\n return self.SIR_timederivative(SIR, t)","def node_equilibrium(t_vec, q_vec, rd_vec, ri_vec):\n tvec_in = -1.0 * t_vec\n\n return trail_vector_out(tvec_in, q_vec, rd_vec, ri_vec) # bottleneck","def comp_r(dert__, fig, root_fcr):\n\n i__ = dert__[0] # i is ig if fig else pixel\n '''\n sparse aligned i__center and i__rim arrays:\n '''\n i__center = i__[1:-1:2, 1:-1:2]\n i__topleft = i__[:-2:2, :-2:2]\n i__top = i__[:-2:2, 1:-1:2]\n i__topright = i__[:-2:2, 2::2]\n i__right = i__[1:-1:2, 2::2]\n i__bottomright = i__[2::2, 2::2]\n i__bottom = i__[2::2, 1:-1:2]\n i__bottomleft = i__[2::2, :-2:2]\n i__left = i__[1:-1:2, :-2:2]\n\n if root_fcr: # root fork is comp_r, all params are present in the input:\n\n idy__, idx__, m__ = dert__[[2, 3, 4]] # skip g: recomputed, output for Dert only\n dy__ = idy__[1:-1:2, 1:-1:2] # sparse to align with i__center\n dx__ = idx__[1:-1:2, 1:-1:2]\n m__ = m__[1:-1:2, 1:-1:2]\n\n else: # root fork is comp_g or comp_pixel, initialize sparse derivatives:\n\n dy__ = np.zeros((i__center.shape[0], i__center.shape[1])) # row, column\n dx__ = np.zeros((i__center.shape[0], i__center.shape[1]))\n m__ = np.zeros((i__center.shape[0], i__center.shape[1]))\n\n if not fig: # compare four diametrically opposed pairs of rim pixels:\n\n dt__ = np.stack((i__topleft - i__bottomright,\n i__top - i__bottom,\n i__topright - i__bottomleft,\n i__right - i__left\n ))\n for d__, YCOEF, XCOEF in zip(dt__, YCOEFs[:4], XCOEFs[:4]):\n dy__ += d__ * YCOEF # decompose differences into dy and dx,\n dx__ += d__ * XCOEF # accumulate with prior-rng dy, dx\n\n g__ = np.hypot(dy__, dx__) # gradient\n '''\n inverse match = SAD, more precise measure of variation than g, direction doesn't matter:\n (all diagonal derivatives can be imported from prior 2x2 comp)\n '''\n m__ += (abs(i__center - i__topleft)\n + abs(i__center - i__top)\n + abs(i__center - i__topright)\n + abs(i__center - i__right)\n + abs(i__center - i__bottomright)\n + abs(i__center - i__bottom)\n + abs(i__center - i__bottomleft)\n + abs(i__center - i__left)\n )\n\n else: # fig is TRUE, compare angle and then magnitude of 8 center-rim pairs\n if not root_fcr:\n idy__, idx__ = dert__[[-2, -1]] # root fork is comp_g, not sparse\n\n a__ = [idy__, idx__] / i__ # i = ig\n '''\n sparse aligned a__center and a__rim arrays:\n '''\n a__center = a__[:, 1:-1:2, 1:-1:2]\n a__topleft = a__[:, :-2:2, :-2:2]\n a__top = a__[:, :-2:2, 1:-1: 2]\n a__topright = a__[:, :-2:2, 2::2]\n a__right = a__[:, 1:-1:2, 2::2]\n a__bottomright = a__[:, 2::2, 2::2]\n a__bottom = a__[:, 2::2, 1:-1:2]\n a__bottomleft = a__[:, 2::2, :-2:2]\n a__left = a__[:, 1:-1:2, :-2:2]\n '''\n 8-tuple of differences between center dert angle and rim dert angle:\n '''\n dat__ = np.stack((angle_diff(a__center, a__topleft, 0),\n angle_diff(a__center, a__top, 0),\n angle_diff(a__center, a__topright, 0),\n angle_diff(a__center, a__right, 0),\n angle_diff(a__center, a__bottomright, 0),\n angle_diff(a__center, a__bottom, 0),\n angle_diff(a__center, a__bottomleft, 0),\n angle_diff(a__center, a__left, 0)\n ))\n if root_fcr:\n m__, day__, dax__ = dert__[[-4, -2, -1]] # skip ga: recomputed, output for summation only?\n m__ = m__[1:-1:2, 1:-1:2] # sparse to align with i__center\n day__ = day__[1:-1:2, 1:-1:2]\n dax__ = dax__[1:-1:2, 1:-1:2]\n else:\n m__ = np.zeros((i__center.shape[0], i__center.shape[1])) # row, column\n day__ = np.zeros((a__center.shape[0], a__center.shape[1], a__center.shape[2]))\n dax__ = np.zeros((a__center.shape[0], a__center.shape[1], a__center.shape[2]))\n\n for dat_, YCOEF, XCOEF in zip(dat__, YCOEFs, XCOEFs):\n '''\n accumulate in prior-rng (3x3 -> 5x5 -> 9x9) day, dax:\n '''\n day__ += dat_ * YCOEF # decomposed differences of angle,\n dax__ += dat_ * YCOEF # accumulate in prior-rng day, dax\n '''\n gradient of angle: not needed in comp_r?\n '''\n ga__ = np.hypot(np.arctan2(*day__), np.arctan2(*dax__))\n '''\n accumulate match (cosine similarity) in prior-rng (3x3 -> 5x5 -> 9x9) m:\n '''\n m__ += (np.minimum(i__center, (i__topleft * dat__[0][1]))\n + np.minimum(i__center, (i__top * dat__[1][1]))\n + np.minimum(i__center, (i__topright * dat__[2][1]))\n + np.minimum(i__center, (i__right * dat__[3][1]))\n + np.minimum(i__center, (i__bottomright * dat__[4][1]))\n + np.minimum(i__center, (i__bottom * dat__[5][1]))\n + np.minimum(i__center, (i__bottomleft * dat__[6][1]))\n + np.minimum(i__center, (i__left * dat__[7][1]))\n )\n '''\n 8-tuple of cosine differences per direction:\n '''\n dt__ = np.stack(((i__center - i__topleft * dat__[0][1]),\n (i__center - i__top * dat__[1][1]),\n (i__center - i__topright * dat__[2][1]),\n (i__center - i__right * dat__[3][1]),\n (i__center - i__bottomright * dat__[4][1]),\n (i__center - i__bottom * dat__[5][1]),\n (i__center - i__bottomleft * dat__[6][1]),\n (i__center - i__left * dat__[7][1])\n ))\n for d__, YCOEF, XCOEF in zip(dt__, YCOEFs, XCOEFs):\n dy__ += d__ * YCOEF # y-decomposed center-to-rim difference\n dx__ += d__ * XCOEF # x-decomposed center-to-rim difference\n '''\n accumulate in prior-rng (3x3 -> 5x5 -> 9x9) dy, dx\n '''\n g__ = np.hypot(dy__, dx__)\n\n if fig:\n rdert = ma.stack((i__center, g__, dy__, dx__, m__, ga__, *day__, *dax__))\n else:\n rdert = ma.stack((i__center, g__, dy__, dx__, m__))\n '''\n return input dert__ with accumulated derivatives,\n\n next comp_r will use full dert # comp_rr\n next comp_a will use g__, dy__, dx__ # comp_agr, preserve dy, dx as idy, idx\n '''\n return rdert","def aire(self, r):\r\n self.r_num(r)\r\n return self.r**2 * pi","def estimate_reaction_time(self, R):\n # Transferred to json\n # estimated reaction time in s\n e_time = 360.\n return e_time","def get_radial_distance_from(self, star):\n # T = (4pi^2r^3/(Gm1))^1/2\n # r = ((GmT^2)/(4pi^2))^1/3\n G = 6.67408e-11\n numerator = G*star.mass*pow(self.T, 2)\n denominator = 4*pow(math.pi, 2)\n return pow(numerator/denominator, 1/3)","def calculate_trajectory(args, time, y0):\n t0, t1, dt = time\n r = ode(equations).set_integrator('dopri5')\n r.set_initial_value(y0, t0).set_f_params(args)\n data = [[t0, y0[0], y0[1], y0[2], y0[3]]]\n while r.successful() and r.t < t1:\n r.integrate(r.t+dt)\n data.append([r.t, r.y[0], r.y[1], r.y[2], r.y[3]])\n return np.array(data)","def shortestpathij(self, i, j):\n pathlist = []\n self.pathij(i, j, pathlist)\n distance = []\n \n for i in range(len(pathlist)):\n Temp = 0\n for j in range(len(pathlist[i]) - 1):\n Temp += self.Dismatrix[pathlist[i][j], pathlist[i][j+1]]\n distance.append(Temp)\n \n if(len(distance) == 0):\n return None\n else:\n return min(distance)","def __get_distance(self, i, j):\n row_i = i // 5\n column_i = i % 5\n row_j = j // 5\n column_j = j % 5\n distance = abs(row_i-row_j) + abs(column_i-column_j)\n return distance","def t(o, r):\n return (r/o)**2","def p(self, i, j, time, observation):\n trans = self.transition_map\n em = self.emission_map\n states = self.states\n O = observation\n\n num = self.alpha(i,time,O)*trans[i][j]*em[i][O[time]]*self.beta(j,time,O)\n denom = sum(self.alpha(m,time,O)*trans[m][n]*em[m][O[time]]*self.beta(n,time+1,O) for n in states for m in states)\n return num / denom","def sq_drij_c(r_i,r_j,latticevec):\n\n dr_pbc = delta_r_c(r_i,r_j,latticevec)\n\n sq_dr = np.dot( dr_pbc,dr_pbc)\n\n return sq_dr","def calc_q_rad(n0, IAM_b, I_direct, IAM_d, I_diffuse, tilt):\n q_rad_Wperm2 = n0 * IAM_b * I_direct + n0 * IAM_d * I_diffuse * (1 + cos(tilt)) / 2\n return q_rad_Wperm2","def _get_distance(reindeer, race_time):\n interval = reindeer.flight_time + reindeer.rest_time\n cycles = race_time // interval\n flight_time = min(reindeer.flight_time, race_time - interval * cycles)\n total_flying_time = reindeer.flight_time * cycles + flight_time\n return total_flying_time * reindeer.flight_speed","def _index(self, i, j):\n assert self._isvalid(i), 'i term (%s) is out of bounds' % i\n assert self._isvalid(j), 'j term (%s) is out of bounds' % j\n\n return self.n * (i - 1) + (j - 1)","def sqrt_shifted_rate(self, t, i):\n return np.real(self._sqrt_shifted_rates[i](t))","def add_J(Jr_m0, Jr_m1,\r\n Jt_m0, Jt_m1,\r\n Jz_m0, Jz_m1,\r\n J0, J1,\r\n J2, J3):\r\n # Get the CUDA Grid in 2D\r\n i, j = cuda.grid(2)\r\n # Only for threads within (nz, nr)\r\n if (i < Jr_m0.shape[0] and j < Jr_m0.shape[1]):\r\n # Sum the four field arrays for the different deposition\r\n # directions and write them to the global field array\r\n Jr_m0[i, j] += J0[i, j, 0] + \\\r\n J1[i, j - 1, 0] + \\\r\n J2[i - 1, j, 0] + \\\r\n J3[i - 1, j - 1, 0]\r\n\r\n Jr_m1[i, j] += J0[i, j, 1] + \\\r\n J1[i, j - 1, 1] + \\\r\n J2[i - 1, j, 1] + \\\r\n J3[i - 1, j - 1, 1]\r\n\r\n Jt_m0[i, j] += J0[i, j, 2] + \\\r\n J1[i, j - 1, 2] + \\\r\n J2[i - 1, j, 2] + \\\r\n J3[i - 1, j - 1, 2]\r\n\r\n Jt_m1[i, j] += J0[i, j, 3] + \\\r\n J1[i, j - 1, 3] + \\\r\n J2[i - 1, j, 3] + \\\r\n J3[i - 1, j - 1, 3]\r\n\r\n Jz_m0[i, j] += J0[i, j, 4] + \\\r\n J1[i, j - 1, 4] + \\\r\n J2[i - 1, j, 4] + \\\r\n J3[i - 1, j - 1, 4]\r\n\r\n Jz_m1[i, j] += J0[i, j, 5] + \\\r\n J1[i, j - 1, 5] + \\\r\n J2[i - 1, j, 5] + \\\r\n J3[i - 1, j - 1, 5]","def solver(I, a, T, dt, theta):\n Nt = int(T/dt) # no of time intervals\n T = Nt*dt # adjust T to fit time step dt\n u = zeros(Nt+1) # array of u[n] values\n t = linspace(0, T, Nt+1) # time mesh\n\n u[0] = I # assign initial condition\n for n in range(0, Nt): # n=0,1,...,Nt-1\n factor1 = (1 - (1-theta)*a*dt)\n factor2 = (1 + theta*dt*a)\n factor3 = factor1/factor2\n print factor1, type(factor1), factor2, type(factor2),\n print factor3, type(factor3)\n u[n+1] = (1 - (1-theta)*a*dt)/(1 + theta*dt*a)*u[n]\n return u, t","def distance(v, t):\n rf = v.orbit.body.non_rotating_reference_frame\n vec = v3minus(v.position(rf), t.position(rf))\n a = vec[0] * vec[0]\n b = vec[1] * vec[1]\n c = vec[2] * vec[2]\n return math.sqrt(a + b + c)","def solar_time_index(self):\n return self.data.solar_time_index","def getGradient(self,j):\n i = int(self.indicator['term'][j])\n r = int(self.indicator['row'][j])\n c = int(self.indicator['col'][j])\n rv = -np.kron(self.Fstar()[i][:,[r]],self.Astar()[i][[c],:])\n return rv","def getaij(self,i_,j_):\n aij_ = ctypes.c_double()\n res = __library__.MSK_XX_getaij(self.__nativep,i_,j_,ctypes.byref(aij_))\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n aij_ = aij_.value\n _aij_return_value = aij_\n return (_aij_return_value)","def d_dt(self, r, t):\n return self.d_do(r,t) * do_dt(r,t)","def r(t, i, j):\n\n #when get to (i,j) position, minus the food with the zombie needs\n t -= grid[i][j]\n\n\n #the food is not enough for rabbit to get to the top left or \n #rabbit can't go left or top. \n if i < 0 or j < 0 or t < 0:\n return food+1\n\n #can get to the top left, t is the remainder.\n elif i == 0 and j == 0:\n return t\n\n #choose the less food grid.\n else:\n return min(r(t, i-1, j), r(t, i, j-1))","def tv(i, r=None):\n if r is None:\n return i[0]\n else:\n return Operation.tv(r[i])","def rule(model, i, j):\n active = 1-self.task_spread[j]\n den = sum(tril[i, :])\n ind = model.timeslots\n total = sum(tril[i, k] * (\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\n k, j]) for k in ind)\n total /= den\n total *= active\n return -1 + EPS, model.CTl[i, j] - total, EPS + self.slack_cont","def spin_adapted_t1(i, j):\n if not isinstance(i, int) or not isinstance(j, int):\n raise ValueError(\"Requires integers as orbital indices, \\\nbut get {} and {}.\".format(type(i), type(j)))\n\n ia = i * 2 + 0\n ib = i * 2 + 1\n ja = j * 2 + 0\n jb = j * 2 + 1\n term1 = FermionOperator(((ia, 1), (ja, 0)), 1.0)\n term2 = FermionOperator(((ib, 1), (jb, 0)), 1.0)\n tpq_list = [term1 + term2]\n return tpq_list","def solver(I, a, T, dt, theta):\n dt = float(dt) # avoid integer division\n Nt = int(round(T/dt)) # no of time intervals\n T = Nt*dt # adjust T to fit time step dt\n u = zeros(Nt+1) # array of u[n] values\n t = linspace(0, T, Nt+1) # time mesh\n\n u[0] = I # assign initial condition\n for n in range(0, Nt): # n=0,1,...,Nt-1\n u[n+1] = (1 - (1-theta)*a*dt)/(1 + theta*dt*a)*u[n]\n return u, t","def to_ri(self,system):\n # rotating wave approx\n for i in system:\n for j in i:\n j.RWA()\n #change system to number\n for i in range(self.N):\n for j in range(self.N):\n system[i][j] = system[i][j].mag()\n# print self.system\n #transform conjugate to real and imag\n for i in range(self.n):\n for j in range(i,self.n):\n id1 = self.index(i,j) \n if i == j:\n for k in range(self.n):\n for l in range(k,self.n):\n if k != l:\n id2 = self.index(k,l)\n tmp1 = (system[id1][id2]+system[id1][id2+1]).real\n tmp2 = (system[id1][id2]-system[id1][id2+1]).imag \n system[id1][id2],system[id1][id2+1] = tmp1,-1*tmp2\n else:\n for k in range(self.n):\n for l in range(k,self.n):\n id2 = self.index(k,l)\n if k==l:\n tmp = system[id1][id2]\n system[id1][id2],system[id1+1][id2]=tmp.real,tmp.imag\n else:\n tmp1 = system[id1][id2]+system[id1][id2+1]\n tmp2 = system[id1][id2]-system[id1][id2+1]\n system[id1][id2],system[id1][id2+1] = tmp1.real,-1*tmp2.imag\n system[id1+1][id2],system[id1+1][id2+1] = tmp1.imag,tmp2.real\n return system","def calculate_dvec_spin_fixed_j(self, jorb: int) -> 'Nparray':\n return self._calculate_dvec_spin_with_coeff_fixed_j(self.coeff, jorb)","def qrot(I,sym):\n T = s.Symbol(\"T\")\n if type(I) == list:\n return (((s.pi * I[0] * I[1] * I[2])**(1/2))/sym) * ((8 * s.pi**2 * k * T) / (h**2))**(3/2)\n else:\n return (((s.pi * I)**(1/2))/sym) * ((8 * s.pi**2 * k * T) / (h**2))**(3/2)","def rms2int(twt, rms):\r\n v_int = np.ones((len(twt), ))\r\n v_int[0] = rms[0]\r\n v_int[1:] = np.sqrt((rms[1:]**2 * twt[1:] - rms[:-1]**2 * twt[:-1]) /\r\n (twt[1:] - twt[:-1]))\r\n\r\n return v_int","def dtheta_du_elt(self, i):\n\n half_delta_shift = [0.0, 0.0, 0.0]\n half_delta_shift[i] = self._delta / 2.0\n half_delta_shift = matrix.col(half_delta_shift)\n\n u_fwd = self._vec_u + half_delta_shift\n u_rev = self._vec_u - half_delta_shift\n\n theta_fwd = math.acos(u_fwd.dot(self._vec_v) / (u_fwd.length() * self._v))\n theta_rev = math.acos(u_rev.dot(self._vec_v) / (u_rev.length() * self._v))\n\n return (theta_fwd - theta_rev) / self._delta","def numerically_integrate(\n self, state, u=0., T=1, time_steps=200, method='dopri5'):\n\n t = torch.linspace(0, T, time_steps).to(device)\n state = state.to(device)\n return odeint(\n lambda _, x: self.forward(x, u), state, t, method=method\n ).cpu()[: , 0, :]","def width(self):\n return self.i_node.distance(self.j_node)","def calculation_time_analysis():\n\tfrom . import spectra as sp\n\tp_dict = {'Bfield':700,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':0*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\n\tchiL,chiR,chiZ = sp.calc_chi([-3500],p_dict)\n\t\n\tfor angle in [0, np.pi/32, np.pi/16, np.pi/8, np.pi/4, np.pi/2]:\n\t\tprint(('Angle (degrees): ',angle*180/np.pi))\n\t\tRotMat, n1, n2 = solve_diel(chiL,chiR,chiZ,angle)","def f(r,t):\r\n x = r[0]\r\n y = r[2]\r\n z = r[4]\r\n vx = r[1]\r\n vy = r[3]\r\n vz = r[5]\r\n velocity = np.sqrt(vx**2+vy**2+vz**2)\r\n #if np.abs(z)>eps:\r\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\r\n \r\n # equations for a cricket ball in motion\r\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\r\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\r\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)","def compute_jerk(joint_trajectory):\r\n joint_vel = np.gradient(joint_trajectory, axis=1)\r\n joint_acc = np.gradient(joint_vel, axis=1)\r\n joint_jerk = np.gradient(joint_acc, axis=1)\r\n jerk = np.linalg.norm(joint_jerk)\r\n return jerk","def rt_general(lam, T, I_0, tau):\n\n B_lam = planck_w(lam, T)\n tau_total = tau[-1]\n delta_tau = tau[1:] - tau[0:-1]\n integrate_radiation = B_lam[1:] * np.exp(- (tau_total - tau[:])) * delta_tau\n return I_0 * np.exp(-tau) + B_lam * (1 - np.exp(-tau))","def gen_Jij(atom_list,jmats):\n N_atoms = len(atom_list)\n jij_values = []\n jij_columns = []\n jij_rowIndex = []\n zeroval = np.zeros((3,3))\n \n # Counts total number of interactions: needed for row indexing\n num_inters = 0\n # Scan through atom_list\n \n nbrs_ints = [] \n for i in range(N_atoms):\n nbrs_ints = atom_list[i].interactions\n nbrs_ints.sort()\n\n # Now we have a sorted list of (nbr,intr) tuples from lowest neighbor to highest neighbor\n # Scan through interactions\n if len(nbrs_ints)>0:\n for j in range(len(nbrs_ints)):\n nbr = nbrs_ints[j][0]\n intr = nbrs_ints[j][1]\n \n #Get an interaction matrix\n curr_mat = jmats[intr].tolist()\n curr_mat = np.array(curr_mat, dtype=np.float64)\n \n # Values = current matrix\n # Columns = the current neighbor\n # RowIndex = total number of interactions \n jij_values.append(curr_mat)\n jij_columns.append(nbr)\n if j == 0:\n jij_rowIndex.append(num_inters)\n \n # Increase number of total interactions\n num_inters = num_inters + 1\n else:\n jij_values.append(zeroval)\n jij_columns.append(0)\n jij_rowIndex.append(num_inters)\n num_inters = num_inters + 1\n # Add dummy index to rowIndex\n jij_rowIndex.append(len(jij_values))\n\n # Convert to numpy arrays\n jij_values = np.array(jij_values)\n jij_columns = np.array(jij_columns)\n jij_rowIndex = np.array(jij_rowIndex)\n \n print jij_values\n print jij_values.shape[1:]\n print N_atoms + 1\n print len(jij_rowIndex)\n print jij_columns\n print jij_rowIndex\n \n # Create Sparse Array\n jij = bsr_matrix( (jij_values,jij_columns,jij_rowIndex), shape=(3*N_atoms,3*N_atoms) ).todense()\n\n return jij","def get_j1(mol, atom, coord):\n\n omega = np.identity(2)\n spin_j = np.einsum(\"ij,kl->ikjl\", omega, omega)\n\n twoe = -mol.intor(\"int2e_ip1\")[coord] #minus sign due to pyscf definition\n\n j1_spatial = np.zeros((twoe.shape[0],twoe.shape[0],twoe.shape[0],\n twoe.shape[0]))\n\n for i in range(twoe.shape[0]):\n\n lambda_i = int(i in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n for j in range(twoe.shape[0]):\n\n lambda_j = int(j in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n for k in range(twoe.shape[0]):\n\n lambda_k = int(k in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n for l in range(twoe.shape[0]):\n\n lambda_l = int(l in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n j1_spatial[i][j][k][l] += (twoe[i][j][k][l] * lambda_i\n + twoe[j][i][k][l] * lambda_j\n + twoe[k][l][i][j] * lambda_k\n + twoe[l][k][i][j] * lambda_l)\n\n j1_spatial = np.einsum(\"abcd->acbd\", j1_spatial,\n optimize='optimal') #convert to physicists\n j1 = np.kron(spin_j, j1_spatial)\n\n return j1"],"string":"[\n \"def distance(ri, rj):\\n return abs(ri[0] - rj[0]) + abs(ri[1] - rj[1])\",\n \"def r(self, t):\\n from scipy.optimize import fsolve\\n t = YEAR_TO_SEC * t\\n t_coll = fsolve(lambda x: self.r_free(x) - self.snr.r_reverse(x), 4e3)\\n # 4e3 years is a typical value that works for fsolve\\n # Radius at time of collision\\n r_coll = self.r_free(t_coll)\\n return np.where(t < t_coll, self.r_free(t), r_coll)\",\n \"def u_i(self, t_array, i):\\n t_array = t_array.reshape(1,len(t_array)) # (1 , N_t)\\n tmp = self._r_tau(t_array-self._s.reshape(self._num_gp,1))\\n # (N_gp, N_t)\\n # A # (N_gp, N_ev)\\n # A_j,i = w_j / sqrt(lambda_i) u_i(s_j) \\n return 1/self._sqrt_eig_val[i]*np.tensordot(tmp, self._A[:,i], axes=([0],[0]))\",\n \"def evaluate_rijP(self, q):\\n rP_i = self._parent._parent.bodies[self.body_id_i].evaluate_r(q, element_id=self.element_id, ksi=self.element_ksi)\\n\\n self.r_P_list[0] = rP_i\\n\\n # distance vector\\n r_ij_P = rP_i - self.rP_j\\n\\n return r_ij_P\",\n \"def R(self, (k,t), (j,x), **params):\\n d = len(x)/2\\n q,dq = x[:d],x[d:]\\n g = self.G((k,t), (j,x), **params)\\n I = (g < 0.).nonzero()[0] # constraint indices that are activating or deactivating\\n J = deepcopy(j)\\n J[I] = np.logical_not(J[I])\\n Delta = self.Delta( (k,t), (J,q,dq), **params )\\n dq_ = util.dot( Delta, dq )\\n k_ = k+1\\n t_ = t\\n j_ = 1 * J\\n x_ = np.hstack([q,dq_])\\n return (k_,t_),(j_,x_)\",\n \"def do_dt(r, t):\\n return -o(r,t)/(2*t)\",\n \"def compute_r_t(e_mat):\\r\\n e_hat = e_mat / np.sqrt(np.trace(e_mat.T @ e_mat) / 2)\\r\\n et_e_hat = e_hat.T @ e_hat\\r\\n\\r\\n # using 7.26 from the book\\r\\n t_hat = np.array([np.sqrt(1 - et_e_hat[0, 0]), np.sqrt(1 - et_e_hat[1, 1]), np.sqrt(1 - et_e_hat[2, 2])])\\r\\n\\r\\n w = np.array([np.cross(e_hat[i, :], t_hat) for i in range(3)]) # [w_i, w_j, w_k]\\r\\n r = np.array([w[0] + np.cross(w[1], w[2]), w[1] + np.cross(w[2], w[0]), w[2] + np.cross(w[0], w[1])])\\r\\n return r, t_hat\",\n \"def prep_distance(self, t: str = 'float') -> np.ndarray:\\n d = np.zeros([self.ic.shape[0]*self.ic.shape[1],\\n self.ic.shape[1]*self.ic.shape[0]])\\n\\n u,v = np.meshgrid(np.arange(self.ic.shape[0]),\\n np.arange(self.ic.shape[1]),\\n sparse=False, indexing='xy')\\n u = u.ravel()\\n v = v.ravel()\\n z = np.array([u,v]).T\\n\\n for (k,x) in enumerate(z):\\n if not self.boundary:\\n d[k,:] = np.array(np.sqrt((u - x[0])**2 + (v - x[1])**2),dtype=t)\\n\\n else:\\n d[k,:] = self.torus(x[0],x[1],\\n self.ic.shape[0],\\n self.ic.shape[1]\\n ).ravel()\\n\\n return d\",\n \"def dij(self, i, j):\\n if self.dipole is None:\\n return 1 if i != j else 0\\n\\n # <s_j|D|s_i>\\n return (self.s[j:j+1] @ self.dipole @ self.s[i:i+1].T.conj())[0, 0]\",\n \"def _qij_0(i: int, j: int):\\n ia = i * 2 + 0\\n ib = i * 2 + 1\\n ja = j * 2 + 0\\n jb = j * 2 + 1\\n term1 = FermionOperator(((ja, 0), (ib, 0)), 1.0)\\n term2 = FermionOperator(((ia, 0), (jb, 0)), 1.0)\\n return numpy.sqrt(0.5) * (term1 - term2)\",\n \"def _calc_R_T_amp(self, polarization, n, delta):\\n t_amp = np.zeros((len(self.structure), len(self.structure)), dtype=complex)\\n r_amp = np.zeros((len(self.structure), len(self.structure)), dtype=complex)\\n# # debugging statement\\n# print(\\\"\\\\nr_amp is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(len(self.structure)):\\n# print(\\\"{}{} {}\\\".format(i,j,r_amp[i][j]))\\n# # debugging statement\\n# print(\\\"\\\\nt_amp is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(len(self.structure)):\\n# print(\\\"{}{} {}\\\".format(i,j,t_amp[i][j]))\\n\\n for i in range(len(self.structure)-1):\\n t_amp[i,i+1] = self._t_at_interface(polarization, n[i], n[i+1])\\n r_amp[i,i+1] = self._r_at_interface(polarization, n[i], n[i+1])\\n# # debugging statement\\n# print(\\\"\\\\nmod r_amp is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(len(self.structure)):\\n# print(\\\"{}{} {}\\\".format(i,j,r_amp[i][j]))\\n# # debugging statement\\n# print(\\\"\\\\nmod t_amp is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(len(self.structure)):\\n# print(\\\"{}{} {}\\\".format(i,j,t_amp[i][j]))\\n\\n M = np.zeros((len(self.structure),2,2),dtype=complex)\\n# # debugging statement\\n# print(\\\"\\\\nThe 'M' matrix is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(2):\\n# for k in range(2):\\n# print(\\\"M{}{}{} ---> {}\\\".format(i,j,k,M[i][j][k]))\\n\\n m_r_amp = np.zeros((len(self.structure),2,2), dtype=complex)\\n m_t_amp = np.zeros((len(self.structure),2,2), dtype=complex)\\n for i in range(1,len(self.structure)-1):\\n m_t_amp[i] = self._make_2x2(np.exp(-1j*delta[i]), 0., 0., np.exp(1j*delta[i]), dtype=complex)\\n m_r_amp[i] = self._make_2x2(1., r_amp[i,i+1], r_amp[i,i+1], 1., dtype=complex)\\n\\n# # debugging statement\\n# print(\\\"\\\\nThe temporary 'm_r_amp' matrix is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(2):\\n# for k in range(2):\\n# print(\\\"m_r_amp{}{}{} ---> {}\\\".format(i,j,k,m_r_amp[i][j][k]))\\n\\n# # debugging statement\\n# print(\\\"\\\\nThe temporary 'm_t_amp' matrix is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(2):\\n# for k in range(2):\\n# print(\\\"m_t_amp{}{}{} ---> {}\\\".format(i,j,k,m_t_amp[i][j][k]))\\n\\n m_temp = np.dot(m_t_amp, m_r_amp)\\n\\n# # debugging statement\\n# print(\\\"\\\\nThe 'm_temp' matrix is:\\\")\\n# for i in m_temp:\\n# print i\\n# for i in range(len(self.structure)):\\n# for j in range(2):\\n# for k in range(2):\\n# print(\\\"m_temp{}{}{} ---> {}\\\".format(i,j,k,m_temp[i][j][k]))\\n\\n for i in range(1,len(self.structure)-1):\\n M[i] = 1/t_amp[i,i+1] * np.dot(self._make_2x2(np.exp(-1j*delta[i]),\\n 0., 0., np.exp(1j*delta[i]),\\n dtype=complex),\\n self._make_2x2(1., r_amp[i,i+1], \\\\\\n r_amp[i,i+1], 1., \\\\\\n dtype=complex))\\n# # debugging statement\\n# print(\\\"\\\\nThe modified 'M' matrix is:\\\")\\n# for i in range(len(self.structure)):\\n# for j in range(2):\\n# for k in range(2):\\n# print(\\\"mod M{}{}{} ---> {}\\\".format(i,j,k,M[i][j][k]))\\n\\n M_prime = self._make_2x2(1., 0., 0., 1., dtype=complex)\\n\\n# # debugging statement\\n# print(\\\"\\\\nThe first modified 'M_prime' matrix is:\\\")\\n# for i in range(2):\\n# for j in range(2):\\n# print(\\\"1st mod M_prime{}{} ---> {}\\\".format(i,j,M_prime[i][j]))\\n\\n for i in range(1, len(self.structure)-1):\\n# print(\\\"\\\\n'M_prime' #{} is:\\\\n{}\\\".format(i,M_prime))\\n M_prime = np.dot(M_prime, M[i])\\n\\n# # debugging statement\\n# print(\\\"\\\\nThe second modified 'M_prime' matrix is:\\\")\\n# for i in range(2):\\n# for j in range(2):\\n# print(\\\"2nd mod M_prime{}{} ---> {}\\\".format(i,j,M_prime[i][j]))\\n\\n# print(\\\"\\\\nr_amp01 is ---> {}\\\".format(r_amp[0,1]))\\n# print(\\\"t_amp01 is ---> {}\\\".format(t_amp[0,1]))\\n\\n mod_M_prime = self._make_2x2(1.,r_amp[0,1], r_amp[0,1], 1., dtype=complex)/t_amp[0,1]\\n\\n# # debugging statement\\n# print(\\\"\\\\nThe third modified 'M_prime' matrix is:\\\")\\n# for i in range(2):\\n# for j in range(2):\\n# print(\\\"3rd mod M_prime{}{} ---> {}\\\".format(i, j, mod_M_prime[i][j]))\\n\\n M_prime = np.dot(self._make_2x2(1., r_amp[0,1], r_amp[0,1], 1., \\\\\\n dtype=complex)/t_amp[0,1], M_prime)\\n\\n# # debugging statement\\n# print(\\\"\\\\nThe 'M_final' matrix is:\\\")\\n# for i in range(2):\\n# for j in range(2):\\n# print(\\\"M_final{}{} ---> {}\\\".format(i, j, M_prime[i][j]))\\n\\n t = 1/M_prime[0,0]\\n r = M_prime[0,1]/M_prime[0,0]\\n\\n# # debugging statement\\n# print(\\\"\\\\n't' ---> {}\\\".format(t))\\n# print(\\\"'r' ---> {}\\\".format(r))\\n\\n return (r, t)\",\n \"def diff(t, y):\\n origin = root.vectorize()\\n root.tensorize(y)\\n self.time = t if not imaginary else None\\n self.eom()\\n ans = root.vectorize(use_aux=True)\\n root.tensorize(origin)\\n return ans\",\n \"def get_traj_length_rad(traj):\\n return np.sum(np.abs(np.diff(traj, axis=0)))\",\n \"def F_calcDMradius(i, t, st, dm, t1, tth):\\n mr = st.mn*dm.mxkg_v[i]/(st.mn+dm.mxkg_v[i]) # reduced mass, kg\\n # before thermalization (cooling), rx changes with time:\\n rxco = np.array([ F_rxco2(tim,t1,mr,(st.nb*1.e+6),dm.sigx_m,st.Rs,dm.mxkg_v[i],pF) for tim in t.time ]) # cm\\n print \\\"-- Radius: rxco at t1 = \\\",F_rxco2(t1+0.1,t1,mr,(st.nb*1.e+6),dm.sigx_m,st.Rs,dm.mxkg_v[i],pF)\\n # after thermalization:\\n rxth1 = F_rxth(dm.mx_v[i],st.rhoc,st.Temp) # cm (formula)\\n rxth2 = np.interp(tth,t.time,rxco) \\t# cm (rxco(tth))\\n rxth = rxth1\\n print \\\" rxth=%.2e , rxth1=%.2e , rxth2=%.2e\\\" % (rxth,rxth1,rxth2)\\n for k in xrange(len(t.time)):\\n if t.time[k]<t1:\\n t.rxtag[k] = 'Rs '\\n t.rx[k] = st.Rs*1.e+2\\n elif t.time[k]<tth:\\n t.rxtag[k] = 'rxco'\\n t.rx[k] = rxco[k]\\n elif t.time[k]>=tth:\\n t.rxtag[k] = 'rxth'\\n t.rx[k] = rxth\\n return rxco, rxth\",\n \"def SIR_timederivative(self, SIR, t): \\n beta = self.beta(t)\\n nu = self.nu(t)\\n Sddt = - beta*SIR[0]*SIR[1]\\n Iddt = beta*SIR[0]*SIR[1] - nu*SIR[1]\\n Rddt = nu*SIR[1]\\n return [Sddt, Iddt, Rddt]\",\n \"def sum_i_neq_j(x):\\n\\tiw_size = x.size(0)\\n\\tbatch_size = x.size(1)\\n\\n\\t# TODO: Would torch.expand instead of torch.repeat make this faster?\\n\\tinv_mask = (1. - torch.eye(iw_size)\\n\\t\\t\\t\\t).unsqueeze(dim=2).repeat(1, 1, batch_size)\\n\\tx_masked = torch.mul(x.view(1, iw_size, batch_size), inv_mask)\\n\\treturn torch.sum(x_masked, dim=1)\",\n \"def compute_rate(Tij, dt):\\n nstates = Tij.shape[0]\\n Kij = Tij - np.eye(nstates)\\n Kij /= dt\\n return Kij\",\n \"def rtt_cost(s_vr, neighbor_vr, rtt_matrix):\\n rtt = rtt_matrix[s_vr][neighbor_vr + 1]\\n #print \\\"rtt_i_k\\\", rtt\\n return float(rtt)\",\n \"def diff(t, y):\\n origin = tensor.array\\n tensor.set_array(np.reshape(y, tensor.shape))\\n ans = np.zeros_like(y)\\n self.time = t if not imaginary else None\\n for n in self.term_visitor(use_cache=True):\\n ans += np.reshape(self._single_eom(tensor, n, cache=cache), -1)\\n if self.init_energy is not None:\\n ans -= self.init_energy * y\\n ans /= self.coefficient()\\n tensor.set_array(origin)\\n return ans\",\n \"def R(self, s, j, **params):\\n s_,j_ = (deepcopy(s)+1,deepcopy(j))\\n return s_,j_\",\n \"def __init__(self,\\n r_i: np.array,\\n tau_ij,\\n alpha_ij: np.ndarray,\\n nu_i,\\n delta_i,\\n solver_verbose: int = 0,\\n solver_method: str = 'dogbox'):\\n self.kappa_ref = 0.034\\n self.eps_ref = 1960.0\\n\\n self.r = r_i\\n self.size = r_i.shape[0]\\n self.temp_dep_tau = False\\n if callable(tau_ij):\\n self.temp_dep_tau = True\\n self.tau_fun = tau_ij\\n else:\\n self.tau = tau_ij\\n if tau_ij.shape != (self.size, self.size):\\n raise Exception(f'tau_ij size {tau_ij.shape} is inconsistent with r_i size {self.size}')\\n self.alpha = alpha_ij\\n if alpha_ij.shape != (self.size, self.size):\\n raise Exception(f'alpha_ij size {alpha_ij.shape} is inconsistent with r_i size {self.size}')\\n self.nu = nu_i\\n self.delta = delta_i\\n if len(nu_i) != self.size or len(delta_i) != self.size:\\n raise Exception(f'nu_i size {len(nu_i)} or delta_i size {len(delta_i)} '\\n f'is inconsistent with r_i size {self.size}')\\n\\n self.delta_as, self.delta_ds = self.get_delta_arrays()\\n self.delta_ad = np.zeros((len(self.delta_as), len(self.delta_ds)))\\n self.solver_verbose = solver_verbose\\n self.solver_method = solver_method\",\n \"def get_distvec2(self, i, j,exclude_self=True):\\n leni = True\\n lenj = True\\n try:\\n l=len(i)\\n if l > 1:\\n ri = np.array(i)\\n else:\\n leni = False\\n ri = self.xyz[i]\\n except:\\n ri = self.xyz[i]\\n try:\\n l=len(j)\\n if l > 1:\\n rj = np.array(j)\\n else:\\n rj = self.xyz[j]\\n except:\\n rj = self.xyz[j]\\n lenj = False\\n if 1:\\n all_rj = rj + self.images_cellvec\\n all_r = all_rj - ri\\n all_d = np.sqrt(np.add.reduce(all_r*all_r,1))\\n d_sort = np.argsort(all_d)\\n if exclude_self and (np.linalg.norm(ri-rj) <= 0.001):\\n d_sort = d_sort[1:]\\n closest = d_sort[0]\\n closest=[closest]\\n if (abs(all_d[closest[0]]-all_d[d_sort[1]]) < SMALL_DIST):\\n for k in d_sort[1:]:\\n if (abs(all_d[d_sort[0]]-all_d[k]) < SMALL_DIST):\\n closest.append(k)\\n d = all_d[closest[0]]\\n r = all_r[closest[0]]\\n return d, r, closest\",\n \"def R(self, (k,t), (j,x), **params):\\n (k_,t_),(j_,x_) = (deepcopy(k)+1,deepcopy(t)),(deepcopy(j),deepcopy(x))\\n return (k_,t_),(j_,x_)\",\n \"def d_j(self,q):\\n dj = np.roll(q,-1,axis=-2) - q\\n return dj\",\n \"def time_integrate(arr, times):\\n times = times.flatten()\\n dt = times[1] - times[0]\\n zeros = np.zeros(arr.shape[1:])\\n off1 = np.vstack((zeros, arr))\\n off2 = np.vstack((arr, zeros))\\n return dt * 0.5 * np.sum(off1 + off2, axis=0)\",\n \"def ridge_cd_weight_update(\\n x: FloatTensor,\\n r: FloatTensor,\\n j: int,\\n w_j: Union[float, FloatTensor],\\n col_l2: float,\\n lmb: float,\\n) -> float:\\n if col_l2 == 0.0:\\n return 0.0\\n n, d = x.size()\\n return w_j + (x[:, j].matmul(r) - n * lmb * w_j) / col_l2\",\n \"def calc_dist(atom_R, env_R_arr):\\n assert atom_R not in env_R_arr\\n return np.linalg.norm(atom_R - env_R_arr, axis=1)\",\n \"def naive_sum(z, n_times_atom):\\n n_atoms, n_trials, n_times_valid = z.shape\\n\\n ztz = np.zeros(shape=(n_atoms, n_atoms, 2 * n_times_atom - 1))\\n t0 = n_times_atom - 1\\n for k0 in range(n_atoms):\\n for k in range(n_atoms):\\n for i in range(n_trials):\\n for t in range(n_times_atom):\\n if t == 0:\\n ztz[k0, k, t0] += (z[k0, i] * z[k, i]).sum()\\n else:\\n ztz[k0, k, t0 + t] += (\\n z[k0, i, :-t] * z[k, i, t:]).sum()\\n ztz[k0, k, t0 - t] += (\\n z[k0, i, t:] * z[k, i, :-t]).sum()\\n return ztz\",\n \"def compute_j(self, trajectory):\\r\\n J = 0\\r\\n for i, (_,_,r,_) in enumerate(trajectory):\\r\\n J += (self.domain.discount**i) * r\\r\\n return J\",\n \"def get_rho_from_J(self, J):\\n return J[self.iOmX]/J[0]\",\n \"def _jplus(j, *, dtype=None):\\n m = np.arange(j, -j - 1, -1, dtype=complex)\\n data = np.sqrt(j * (j + 1) - m * (m + 1))[1:]\\n return _data.diag[dtype](data, 1)\",\n \"def get_dist(dist, i, j):\\n n = int(np.ceil(np.sqrt(2 * len(dist))))\\n if i == j:\\n return 0\\n elif i > j:\\n return dist[n * j - j * (j + 1) / 2 + i - 1 - j]\\n else:\\n return dist[n * i - i * (i + 1) / 2 + j - 1 - i]\",\n \"def Temp2IApprox(T,T0,K,D,t=1.0/64.0):\\n # get numpy fn to interpret temperature as matrix and get pi constant\\n from numpy import asarray, pi, sqrt, abs\\n # temperature difference\\n Tdiff = (T-T0)\\n # thermal conductivity matrix\\n K = K(Tdiff)\\n # thermal diffusivity matrix\\n D = D(Tdiff)\\n # 2*sqrt(Dt/pi)\\n a = ((D*t)/np.pi)\\n # result of sqrt can be +/-\\n # power density cannot be negative \\n b = (2.0*np.sqrt(a))\\n temp = K*Tdiff\\n # K*(T-T0)/(2*sqrt(Dt/pi))\\n return abs(temp/b)\",\n \"def rt_num(lam, T, I_0, tau):\\n B_lam = planck_w(lam, T)\\n exp_tau_i_n = np.zeros(len(tau)-2)\\n for i in range(len(exp_tau_i_n)):\\n exp_tau_i_n[i] = np.exp(-(np.sum(tau[i+1:])))\\n\\n I = I_0 * np.exp(-(np.sum(tau))) + B_lam * (1 - np.exp(-tau[-1]))\\\\\\n + B_lam * np.sum( (1 - np.exp(-tau[1:-1])) * exp_tau_i_n)\\n\\n return I\",\n \"def rank_trotterjohnson(self):\\n if self.array_form == [] or self.is_Identity:\\n return 0\\n if self.array_form == [1, 0]:\\n return 1\\n perm = self.array_form\\n n = self.size\\n rank = 0\\n for j in range(1, n):\\n k = 1\\n i = 0\\n while perm[i] != j:\\n if perm[i] < j:\\n k += 1\\n i += 1\\n j1 = j + 1\\n if rank % 2 == 0:\\n rank = j1*rank + j1 - k\\n else:\\n rank = j1*rank + k - 1\\n return rank\",\n \"def rt_isothermal(lam, T, I_0, tau):\\n B_lam = planck_w(lam, T)\\n return I_0 * np.exp(-tau) + B_lam * (1 - np.exp(-tau))\",\n \"def J_inside(self, r):\\n\\n return self.S * (1. - quad(self.J_integ_inside, 0, 1, args=(r,))[0])\",\n \"def integrate(ii, r0, c0, r1, c1):\\n # This line is modified\\n S = np.zeros(ii.shape[-1]) \\n\\n S += ii[r1, c1]\\n\\n if (r0 - 1 >= 0) and (c0 - 1 >= 0):\\n S += ii[r0 - 1, c0 - 1]\\n\\n if (r0 - 1 >= 0):\\n S -= ii[r0 - 1, c1]\\n\\n if (c0 - 1 >= 0):\\n S -= ii[r1, c0 - 1]\\n\\n return S\",\n \"def radial_distance(x_i, y_i, z_i, x_j, y_j, z_j, box_length):\\n delta_x = min(((x_i - x_j) % box_length), ((x_j - x_i) % box_length))\\n delta_y = min(((y_i - y_j) % box_length), ((y_j - y_i) % box_length))\\n delta_z = min(((z_i - z_j) % box_length), ((z_j - z_i) % box_length))\\n return np.sqrt(delta_x ** 2 + delta_y ** 2 + delta_z ** 2)\",\n \"def j(U, Q, mesh, T, num_steps, params):\\n \\n # Define parameters for cost functional\\n alpha = params[\\\"alpha\\\"]\\n u_d = params[\\\"u_d\\\"]\\n \\n # Compute integrals with time\\n I1 = 0\\n I3 = 0\\n \\n t = 0\\n dt = T/num_steps\\n for i in range(num_steps + 1):\\n I1_int = assemble((U[i] - u_d[i])*(U[i] - u_d[i])*dx(mesh))\\n I3_int = assemble(Q[i]*Q[i]*dx(mesh))\\n \\n if i == 0 or i == num_steps:\\n I1_int *= 0.5\\n I3_int *= 0.5\\n \\n I1 += I1_int\\n I3 += I3_int\\n \\n t += dt\\n \\n \\n I1 *= dt\\n I3 *= dt*alpha/2\\n \\n # Compute end time integral\\n \\n print(\\\"Cost Functional Data\\\")\\n print(\\\"I1: {}\\\".format(I1))\\n print(\\\"I3: {}\\\".format(I3))\\n print()\\n \\n return I1 + I3\",\n \"def rule(model, d, i, j):\\n off = d * 48\\n num = np.arange(self.num_timeslots / 7)\\n total = model.A[i + off, j] * num[i]\\n return 0, model.T_end[d, j] - total, None\",\n \"def dpsi_dt(self, psi, t):\\n#\\t#To avoid doing anything twice. (odeint tends to do that.)\\n#\\t#---------------------------------------------------------\\n#\\tnovel, result = self.check_novelty(t,psi)\\n#\\tif not novel:\\n#\\t if self.my_id == 0:\\n#\\t\\tprint \\\"Time: %2.2f / %2.2f au. Runtime: %2.2f---\\\"%(\\n#\\t\\t t, self.total_duration, (time.time() - self.t_0)/60.)\\n#\\t\\tself.debug_norm(t, psi, result)\\t\\n#\\t\\t\\n#\\t return result\\n#\\t##########################################################\\n\\n\\t#Making a complex array. \\n\\tpsi_complex = psi[:len(psi)/2] + 1j * psi[len(psi)/2:] \\n\\t\\n\\tdp_dt_complex = zeros(psi_complex.shape, dtype = complex)\\n\\tdp_dt_buffer= zeros(psi_complex.shape, dtype = complex)\\n\\t\\n\\n\\t#Do operations.\\n\\tmat_vec = self.mat_vec_product(psi_complex, t)\\n\\n\\tdp_dt_complex[self.my_slice] = self.solve_overlap(-1j * mat_vec)\\n\\t\\n\\n\\n\\t#Add and redistribute.\\n\\tdp_dt_complex = pypar.reduce(dp_dt_complex, pypar.SUM, 0, buffer = dp_dt_buffer)\\n\\tdp_dt_buffer = dp_dt_complex.copy()\\n\\tdp_dt_complex = pypar.broadcast(dp_dt_buffer, 0)\\n\\t\\n\\n\\n\\t#Making a float array.\\n\\tdp_dt = r_[real(dp_dt_buffer), imag(dp_dt_buffer)] \\n\\t\\n\\tif self.my_id == 0:\\n\\t print \\\"Time: %2.2f / %2.2f au. Runtime: %2.2f\\\"%(\\n\\t\\tt, self.total_duration, (time.time() - self.t_0)/60.)\\n\\t self.debug_norm(t, psi, dp_dt)\\t\\n\\t\\n\\t#Store latest result. ----------------------------------\\n\\tself.prev_out = dp_dt\\n\\t############################3###########################3\\n\\treturn dp_dt\",\n \"def momentOfInertia(m_r_touple_list):\\n I = sum([m*r**2 for m,r in m_r_touple_list])\\n return I\",\n \"def ols_cd_weight_update(\\n x: FloatTensor,\\n r: FloatTensor,\\n j: int,\\n w_j: Union[float, FloatTensor],\\n col_l2: float,\\n _: float,\\n) -> float:\\n return w_j + x[:, j].matmul(r) / col_l2 if col_l2 != 0.0 else 0.0\",\n \"def center_of_mass_ij(self, time):\\n if self.start_time <= time <= self.end_time:\\n diff = time - self.start_time\\n valid = np.flatnonzero(self.masks[diff] > 0)\\n if valid.size > 0:\\n com_i = 1.0 / self.timesteps[diff].ravel()[valid].sum() * np.sum(self.timesteps[diff].ravel()[valid] *\\n self.i[diff].ravel()[valid])\\n com_j = 1.0 / self.timesteps[diff].ravel()[valid].sum() * np.sum(self.timesteps[diff].ravel()[valid] *\\n self.j[diff].ravel()[valid])\\n else:\\n com_i = np.mean(self.i[diff])\\n com_j = np.mean(self.j[diff])\\n com_i = int(np.round(com_i))\\n com_j = int(np.round(com_j))\\n else:\\n com_i = None\\n com_j = None\\n return com_i, com_j\",\n \"def omega(self, i, rosetta_definitions = True):\\n res = self.all_residues[i]\\n\\n try:\\n n = res['N'].get_vector()\\n ca = res['CA'].get_vector()\\n c = res['C'].get_vector()\\n\\n\\n\\n if rosetta_definitions and i < len(self.all_residues) -1 and self.connected_to_next(i):\\n res_plus_one = self.all_residues[i + 1]\\n next_n = res_plus_one['N'].get_vector()\\n next_ca = res_plus_one['CA'].get_vector()\\n omega = calc_dihedral(ca, c, next_n, next_ca)\\n return omega\\n\\n elif not rosetta_definitions and i > 1 and self.connected_to_previous(i):\\n res_minus_one = self.all_residues[i - 1]\\n pre_c = res_minus_one['C'].get_vector()\\n pre_ca = res_minus_one['CA'].get_vector()\\n omega = calc_dihedral(pre_ca, pre_c, n, ca)\\n return omega\\n else:\\n return 0.0\\n\\n except BaseException:\\n print \\\"Could not get omega for \\\"+repr(i)\\n raise LookupError\",\n \"def _redfield(R, rho0, evecs=None, Nt=1, dt=0.005, t0=0, e_ops=[], return_result=True):\\n\\n N = rho0.shape[0]\\n # initialize the density matrix\\n if e_ops is None:\\n e_ops = []\\n\\n # basis transformation\\n if evecs is not None:\\n rho0 = transform(rho0, evecs)\\n e_ops = [transform(e, evecs) for e in e_ops]\\n\\n rho = rho0.copy()\\n rho = dm2vec(rho).astype(complex)\\n\\n # tf = t0 + dt * Nt\\n # result = solve_ivp(rhs, t_span=(t0, tf), y0=rho0, vectorized=True, args=(R, ))\\n\\n t = t0\\n\\n if return_result == False:\\n\\n f_obs = open('obs.dat', 'w')\\n fmt = '{} '* (len(e_ops) + 1) + '\\\\n'\\n\\n for k in range(Nt):\\n\\n # compute observables\\n # observables = np.zeros(len(e_ops), dtype=complex)\\n # for i, obs_op in enumerate(e_ops):\\n\\n observables = [obs_dm(rho, e) for e in e_ops]\\n\\n t += dt\\n rho = rk4(rho, rhs, dt, R)\\n\\n # dipole-dipole auto-corrlation function\\n #cor = np.trace(np.matmul(d, rho))\\n\\n # take a partial trace to obtain the rho_el\\n\\n\\n f_obs.write(fmt.format(t, *observables))\\n\\n\\n f_obs.close()\\n # f_dm.close()\\n\\n return rho\\n\\n else:\\n\\n rholist = [] # store density matries\\n\\n result = Result(dt=dt, Nt=Nt, rho0=rho0)\\n\\n observables = np.zeros((Nt, len(e_ops)), dtype=complex)\\n\\n for k in range(Nt):\\n\\n t += dt\\n rho = rk4(rho, rhs, dt, R)\\n\\n tmp = np.reshape(rho, (N, N))\\n rholist.append(transform(tmp, dag(evecs)))\\n\\n\\n observables[k, :] = [obs_dm(tmp, e) for e in e_ops]\\n\\n\\n result.observables = observables\\n result.rholist = rholist\\n\\n return result\",\n \"def euler_cromer_method(theta_0, omega_0, dt, T_i):\\n theta=np.zeros(samples)\\n omega=np.zeros(samples)\\n t=np.zeros(samples)\\n theta[0]=theta_0\\n omega[0]=omega_0\\n t[0]=T_i\\n\\n for n in range(1,samples):\\n \\\"\\\"\\\"\\n calculates new value for omega using old value of theta and omega\\n \\\"\\\"\\\"\\n omega[n]=omega[n-1]-g/l*np.sin(theta[n-1])*dt\\n \\n \\\"\\\"\\\"\\n calculates new value of omega by new omega and old theta\\n \\\"\\\"\\\"\\n theta[n]=theta[n-1]+omega[n]*dt\\n \\n \\\"\\\"\\\"\\n time erray of same dimenion as earlier arrays\\n \\\"\\\"\\\"\\n t[n]=t[n-1]+dt\\n \\n \\n \\\"\\\"\\\"\\n theta: array with values of angular displacement\\n w: array with values of angular velocity\\n t: array with time-values\\n \\\"\\\"\\\"\\n return theta,omega,t\",\n \"def get_rotation_diversity(self, i, t):\\n\\n if self.rotation_type == 2:\\n ith = self._get_check_i(self.diversity, i)\\n rotations = self.pro.get_ordering(self.diversity, ith)\\n t -= 1\\n return rotations[t]\\n else:\\n return self.get_diversity(t)\",\n \"def d_j(self,q):\\n dj = q.shift(y=-1) - q # works with chunks too\\n return dj\",\n \"def u_i_all(self, t_array):\\n t_array = t_array.reshape(1,len(t_array)) # (1 , N_t)\\n tmp = self._r_tau(t_array-self._s.reshape(self._num_gp,1))\\n # (N_gp, N_t)\\n # A # (N_gp, N_ev)\\n # A_j,i = w_j / sqrt(lambda_i) u_i(s_j)\\n return np.tensordot(tmp, 1/self._sqrt_eig_val.reshape(1,self._num_ev) * self._A, axes=([0],[0]))\",\n \"def C(self,t,K,c0):\\n #ode(self.dc_dt,c0,t,args=(k,)).set_integrator('lsoda')\\n #ode(self.dc_dt,c0,t,args=(k,)).set_integrator('vode', method='bdf', order=15)\\n \\n # if we have any negative times we assume they occur before the \\n # reaction starts hence all negative times are assigned concentration \\n # c0\\n \\n ## could switch to something like ode15s that the oiginal matlab code \\n ## uses - can odeint cope with equations as stiff as we need?\\n ## to use integrate.ode need order of arguments in dc_dt to switch\\n \\n #r = scipy.integrate.ode(self.dc_dt)\\n #r = r.set_integrator('vode', method='bdf', order=15,nsteps=3000)\\n #r = r.set_initial_value(c0)\\n #r = r.set_f_params((K,))\\n #r.integrate(t)\\n \\n static_times = t[t<0]\\n dynamic_times = t[t>=0]\\n\\n static_C = np.array([c0 for _ in static_times])\\n\\n # odeint always takes the first time point as t0\\n # our t0 is always 0 (removing t0 occures before we integrate)\\n # so if the first time point is not 0 we add it \\n \\n if not dynamic_times.any() or dynamic_times[0]:\\n #fancy indexing returns a copy so we can do this\\n dynamic_times = np.hstack([[0],dynamic_times]) \\n dynamic_C = odeint(self.dc_dt,c0,dynamic_times,args=(K,))[1:]\\n else:\\n dynamic_C = odeint(self.dc_dt,c0,dynamic_times,args=(K,))\\n \\n if static_C.any():\\n return np.vstack([static_C,dynamic_C])\\n else:\\n return dynamic_C\",\n \"def get_neighb_dist(self, i, ci):\\n ri = self.xyz[i]\\n j = self.conn[i][ci]\\n rj = self.xyz[j].copy()\\n if self.periodic:\\n if self.use_pconn:\\n img = self.pconn[i][ci]\\n rj += np.dot(img, self.cell)\\n else:\\n all_rj = rj + self.images_cellvec\\n all_r = all_rj - self.xyz[i]\\n all_d = np.sqrt(np.add.reduce(all_r*all_r,1))\\n closest = np.argsort(all_d)[0]\\n return all_rj[closest]\\n dr = ri-rj\\n d = np.sqrt(np.sum(dr*dr))\\n return d\",\n \"def utlibr(time):\\n\\n if time.size == 1:\\n return iers.utlibr(time.tt.mjd)\\n else:\\n # Only loop over unique epochs\\n _, idx, r_idx = np.unique(np.asarray(time), return_index=True, return_inverse=True)\\n return np.array([iers.utlibr(t.tt.mjd) for t in time[idx]])[r_idx]\",\n \"def __getitem__(self, i):\\n T0, S0 = get_surface_ts(self.nc, i)\\n \\n # average the variables if we got multiple time elements\\n if isinstance(i, slice):\\n T0, S0, = T0.mean(axis=0), S0.mean(axis=0)\\n if self.p == 0.:\\n rho, drhodT, drhodS = jmd95.eos.state_surface(T0, S0)\\n else:\\n rho, drhodT, drhodS = jmd95.eos.state(self.p, T0, S0)\\n return rho\",\n \"def J(self, r):\\n\\n if r <= self.R:\\n return self.J_inside(r)\\n else:\\n return self.J_outside(r)\",\n \"def sum_numba(z, n_times_atom):\\n n_atoms, n_trials, n_times_valid = z.shape\\n\\n ztz = np.zeros(shape=(n_atoms, n_atoms, 2 * n_times_atom - 1))\\n t0 = n_times_atom - 1\\n for k0 in range(n_atoms):\\n for k in range(n_atoms):\\n for i in range(n_trials):\\n for t in range(n_times_atom):\\n if t == 0:\\n ztz[k0, k, t0] += (z[k0, i] * z[k, i]).sum()\\n else:\\n ztz[k0, k, t0 + t] += (\\n z[k0, i, :-t] * z[k, i, t:]).sum()\\n ztz[k0, k, t0 - t] += (\\n z[k0, i, t:] * z[k, i, :-t]).sum()\\n return ztz\",\n \"def diffusion_spherical_FV(c, t, r, R, D, j0):\\n\\n # Compute spacing\\n dr = r[1]-r[0]\\n\\n # Evaluate j\\n j = current(t, j0)\\n\\n # Set maximum concentration\\n\\n # Compute fluxes\\n q = - D*r[1:-1] ** 2. * (c[1:] - c[0:-1]) / dr\\n q_surf = -j*R**2\\n\\n # Append boundary conditions\\n q = np.append(0, q)\\n q = np.append(q, q_surf)\\n\\n # Compute discretised dc/dt\\n dcdt_out = - (2. / (r[1:] + r[0:-1])) ** 2. \\\\\\n * (q[1:] - q[0:-1]) / dr\\n\\n return dcdt_out\",\n \"def r(o, t):\\n return o*t**0.5\",\n \"def __call__(self, SIR, t):\\n return self.SIR_timederivative(SIR, t)\",\n \"def node_equilibrium(t_vec, q_vec, rd_vec, ri_vec):\\n tvec_in = -1.0 * t_vec\\n\\n return trail_vector_out(tvec_in, q_vec, rd_vec, ri_vec) # bottleneck\",\n \"def comp_r(dert__, fig, root_fcr):\\n\\n i__ = dert__[0] # i is ig if fig else pixel\\n '''\\n sparse aligned i__center and i__rim arrays:\\n '''\\n i__center = i__[1:-1:2, 1:-1:2]\\n i__topleft = i__[:-2:2, :-2:2]\\n i__top = i__[:-2:2, 1:-1:2]\\n i__topright = i__[:-2:2, 2::2]\\n i__right = i__[1:-1:2, 2::2]\\n i__bottomright = i__[2::2, 2::2]\\n i__bottom = i__[2::2, 1:-1:2]\\n i__bottomleft = i__[2::2, :-2:2]\\n i__left = i__[1:-1:2, :-2:2]\\n\\n if root_fcr: # root fork is comp_r, all params are present in the input:\\n\\n idy__, idx__, m__ = dert__[[2, 3, 4]] # skip g: recomputed, output for Dert only\\n dy__ = idy__[1:-1:2, 1:-1:2] # sparse to align with i__center\\n dx__ = idx__[1:-1:2, 1:-1:2]\\n m__ = m__[1:-1:2, 1:-1:2]\\n\\n else: # root fork is comp_g or comp_pixel, initialize sparse derivatives:\\n\\n dy__ = np.zeros((i__center.shape[0], i__center.shape[1])) # row, column\\n dx__ = np.zeros((i__center.shape[0], i__center.shape[1]))\\n m__ = np.zeros((i__center.shape[0], i__center.shape[1]))\\n\\n if not fig: # compare four diametrically opposed pairs of rim pixels:\\n\\n dt__ = np.stack((i__topleft - i__bottomright,\\n i__top - i__bottom,\\n i__topright - i__bottomleft,\\n i__right - i__left\\n ))\\n for d__, YCOEF, XCOEF in zip(dt__, YCOEFs[:4], XCOEFs[:4]):\\n dy__ += d__ * YCOEF # decompose differences into dy and dx,\\n dx__ += d__ * XCOEF # accumulate with prior-rng dy, dx\\n\\n g__ = np.hypot(dy__, dx__) # gradient\\n '''\\n inverse match = SAD, more precise measure of variation than g, direction doesn't matter:\\n (all diagonal derivatives can be imported from prior 2x2 comp)\\n '''\\n m__ += (abs(i__center - i__topleft)\\n + abs(i__center - i__top)\\n + abs(i__center - i__topright)\\n + abs(i__center - i__right)\\n + abs(i__center - i__bottomright)\\n + abs(i__center - i__bottom)\\n + abs(i__center - i__bottomleft)\\n + abs(i__center - i__left)\\n )\\n\\n else: # fig is TRUE, compare angle and then magnitude of 8 center-rim pairs\\n if not root_fcr:\\n idy__, idx__ = dert__[[-2, -1]] # root fork is comp_g, not sparse\\n\\n a__ = [idy__, idx__] / i__ # i = ig\\n '''\\n sparse aligned a__center and a__rim arrays:\\n '''\\n a__center = a__[:, 1:-1:2, 1:-1:2]\\n a__topleft = a__[:, :-2:2, :-2:2]\\n a__top = a__[:, :-2:2, 1:-1: 2]\\n a__topright = a__[:, :-2:2, 2::2]\\n a__right = a__[:, 1:-1:2, 2::2]\\n a__bottomright = a__[:, 2::2, 2::2]\\n a__bottom = a__[:, 2::2, 1:-1:2]\\n a__bottomleft = a__[:, 2::2, :-2:2]\\n a__left = a__[:, 1:-1:2, :-2:2]\\n '''\\n 8-tuple of differences between center dert angle and rim dert angle:\\n '''\\n dat__ = np.stack((angle_diff(a__center, a__topleft, 0),\\n angle_diff(a__center, a__top, 0),\\n angle_diff(a__center, a__topright, 0),\\n angle_diff(a__center, a__right, 0),\\n angle_diff(a__center, a__bottomright, 0),\\n angle_diff(a__center, a__bottom, 0),\\n angle_diff(a__center, a__bottomleft, 0),\\n angle_diff(a__center, a__left, 0)\\n ))\\n if root_fcr:\\n m__, day__, dax__ = dert__[[-4, -2, -1]] # skip ga: recomputed, output for summation only?\\n m__ = m__[1:-1:2, 1:-1:2] # sparse to align with i__center\\n day__ = day__[1:-1:2, 1:-1:2]\\n dax__ = dax__[1:-1:2, 1:-1:2]\\n else:\\n m__ = np.zeros((i__center.shape[0], i__center.shape[1])) # row, column\\n day__ = np.zeros((a__center.shape[0], a__center.shape[1], a__center.shape[2]))\\n dax__ = np.zeros((a__center.shape[0], a__center.shape[1], a__center.shape[2]))\\n\\n for dat_, YCOEF, XCOEF in zip(dat__, YCOEFs, XCOEFs):\\n '''\\n accumulate in prior-rng (3x3 -> 5x5 -> 9x9) day, dax:\\n '''\\n day__ += dat_ * YCOEF # decomposed differences of angle,\\n dax__ += dat_ * YCOEF # accumulate in prior-rng day, dax\\n '''\\n gradient of angle: not needed in comp_r?\\n '''\\n ga__ = np.hypot(np.arctan2(*day__), np.arctan2(*dax__))\\n '''\\n accumulate match (cosine similarity) in prior-rng (3x3 -> 5x5 -> 9x9) m:\\n '''\\n m__ += (np.minimum(i__center, (i__topleft * dat__[0][1]))\\n + np.minimum(i__center, (i__top * dat__[1][1]))\\n + np.minimum(i__center, (i__topright * dat__[2][1]))\\n + np.minimum(i__center, (i__right * dat__[3][1]))\\n + np.minimum(i__center, (i__bottomright * dat__[4][1]))\\n + np.minimum(i__center, (i__bottom * dat__[5][1]))\\n + np.minimum(i__center, (i__bottomleft * dat__[6][1]))\\n + np.minimum(i__center, (i__left * dat__[7][1]))\\n )\\n '''\\n 8-tuple of cosine differences per direction:\\n '''\\n dt__ = np.stack(((i__center - i__topleft * dat__[0][1]),\\n (i__center - i__top * dat__[1][1]),\\n (i__center - i__topright * dat__[2][1]),\\n (i__center - i__right * dat__[3][1]),\\n (i__center - i__bottomright * dat__[4][1]),\\n (i__center - i__bottom * dat__[5][1]),\\n (i__center - i__bottomleft * dat__[6][1]),\\n (i__center - i__left * dat__[7][1])\\n ))\\n for d__, YCOEF, XCOEF in zip(dt__, YCOEFs, XCOEFs):\\n dy__ += d__ * YCOEF # y-decomposed center-to-rim difference\\n dx__ += d__ * XCOEF # x-decomposed center-to-rim difference\\n '''\\n accumulate in prior-rng (3x3 -> 5x5 -> 9x9) dy, dx\\n '''\\n g__ = np.hypot(dy__, dx__)\\n\\n if fig:\\n rdert = ma.stack((i__center, g__, dy__, dx__, m__, ga__, *day__, *dax__))\\n else:\\n rdert = ma.stack((i__center, g__, dy__, dx__, m__))\\n '''\\n return input dert__ with accumulated derivatives,\\n\\n next comp_r will use full dert # comp_rr\\n next comp_a will use g__, dy__, dx__ # comp_agr, preserve dy, dx as idy, idx\\n '''\\n return rdert\",\n \"def aire(self, r):\\r\\n self.r_num(r)\\r\\n return self.r**2 * pi\",\n \"def estimate_reaction_time(self, R):\\n # Transferred to json\\n # estimated reaction time in s\\n e_time = 360.\\n return e_time\",\n \"def get_radial_distance_from(self, star):\\n # T = (4pi^2r^3/(Gm1))^1/2\\n # r = ((GmT^2)/(4pi^2))^1/3\\n G = 6.67408e-11\\n numerator = G*star.mass*pow(self.T, 2)\\n denominator = 4*pow(math.pi, 2)\\n return pow(numerator/denominator, 1/3)\",\n \"def calculate_trajectory(args, time, y0):\\n t0, t1, dt = time\\n r = ode(equations).set_integrator('dopri5')\\n r.set_initial_value(y0, t0).set_f_params(args)\\n data = [[t0, y0[0], y0[1], y0[2], y0[3]]]\\n while r.successful() and r.t < t1:\\n r.integrate(r.t+dt)\\n data.append([r.t, r.y[0], r.y[1], r.y[2], r.y[3]])\\n return np.array(data)\",\n \"def shortestpathij(self, i, j):\\n pathlist = []\\n self.pathij(i, j, pathlist)\\n distance = []\\n \\n for i in range(len(pathlist)):\\n Temp = 0\\n for j in range(len(pathlist[i]) - 1):\\n Temp += self.Dismatrix[pathlist[i][j], pathlist[i][j+1]]\\n distance.append(Temp)\\n \\n if(len(distance) == 0):\\n return None\\n else:\\n return min(distance)\",\n \"def __get_distance(self, i, j):\\n row_i = i // 5\\n column_i = i % 5\\n row_j = j // 5\\n column_j = j % 5\\n distance = abs(row_i-row_j) + abs(column_i-column_j)\\n return distance\",\n \"def t(o, r):\\n return (r/o)**2\",\n \"def p(self, i, j, time, observation):\\n trans = self.transition_map\\n em = self.emission_map\\n states = self.states\\n O = observation\\n\\n num = self.alpha(i,time,O)*trans[i][j]*em[i][O[time]]*self.beta(j,time,O)\\n denom = sum(self.alpha(m,time,O)*trans[m][n]*em[m][O[time]]*self.beta(n,time+1,O) for n in states for m in states)\\n return num / denom\",\n \"def sq_drij_c(r_i,r_j,latticevec):\\n\\n dr_pbc = delta_r_c(r_i,r_j,latticevec)\\n\\n sq_dr = np.dot( dr_pbc,dr_pbc)\\n\\n return sq_dr\",\n \"def calc_q_rad(n0, IAM_b, I_direct, IAM_d, I_diffuse, tilt):\\n q_rad_Wperm2 = n0 * IAM_b * I_direct + n0 * IAM_d * I_diffuse * (1 + cos(tilt)) / 2\\n return q_rad_Wperm2\",\n \"def _get_distance(reindeer, race_time):\\n interval = reindeer.flight_time + reindeer.rest_time\\n cycles = race_time // interval\\n flight_time = min(reindeer.flight_time, race_time - interval * cycles)\\n total_flying_time = reindeer.flight_time * cycles + flight_time\\n return total_flying_time * reindeer.flight_speed\",\n \"def _index(self, i, j):\\n assert self._isvalid(i), 'i term (%s) is out of bounds' % i\\n assert self._isvalid(j), 'j term (%s) is out of bounds' % j\\n\\n return self.n * (i - 1) + (j - 1)\",\n \"def sqrt_shifted_rate(self, t, i):\\n return np.real(self._sqrt_shifted_rates[i](t))\",\n \"def add_J(Jr_m0, Jr_m1,\\r\\n Jt_m0, Jt_m1,\\r\\n Jz_m0, Jz_m1,\\r\\n J0, J1,\\r\\n J2, J3):\\r\\n # Get the CUDA Grid in 2D\\r\\n i, j = cuda.grid(2)\\r\\n # Only for threads within (nz, nr)\\r\\n if (i < Jr_m0.shape[0] and j < Jr_m0.shape[1]):\\r\\n # Sum the four field arrays for the different deposition\\r\\n # directions and write them to the global field array\\r\\n Jr_m0[i, j] += J0[i, j, 0] + \\\\\\r\\n J1[i, j - 1, 0] + \\\\\\r\\n J2[i - 1, j, 0] + \\\\\\r\\n J3[i - 1, j - 1, 0]\\r\\n\\r\\n Jr_m1[i, j] += J0[i, j, 1] + \\\\\\r\\n J1[i, j - 1, 1] + \\\\\\r\\n J2[i - 1, j, 1] + \\\\\\r\\n J3[i - 1, j - 1, 1]\\r\\n\\r\\n Jt_m0[i, j] += J0[i, j, 2] + \\\\\\r\\n J1[i, j - 1, 2] + \\\\\\r\\n J2[i - 1, j, 2] + \\\\\\r\\n J3[i - 1, j - 1, 2]\\r\\n\\r\\n Jt_m1[i, j] += J0[i, j, 3] + \\\\\\r\\n J1[i, j - 1, 3] + \\\\\\r\\n J2[i - 1, j, 3] + \\\\\\r\\n J3[i - 1, j - 1, 3]\\r\\n\\r\\n Jz_m0[i, j] += J0[i, j, 4] + \\\\\\r\\n J1[i, j - 1, 4] + \\\\\\r\\n J2[i - 1, j, 4] + \\\\\\r\\n J3[i - 1, j - 1, 4]\\r\\n\\r\\n Jz_m1[i, j] += J0[i, j, 5] + \\\\\\r\\n J1[i, j - 1, 5] + \\\\\\r\\n J2[i - 1, j, 5] + \\\\\\r\\n J3[i - 1, j - 1, 5]\",\n \"def solver(I, a, T, dt, theta):\\n Nt = int(T/dt) # no of time intervals\\n T = Nt*dt # adjust T to fit time step dt\\n u = zeros(Nt+1) # array of u[n] values\\n t = linspace(0, T, Nt+1) # time mesh\\n\\n u[0] = I # assign initial condition\\n for n in range(0, Nt): # n=0,1,...,Nt-1\\n factor1 = (1 - (1-theta)*a*dt)\\n factor2 = (1 + theta*dt*a)\\n factor3 = factor1/factor2\\n print factor1, type(factor1), factor2, type(factor2),\\n print factor3, type(factor3)\\n u[n+1] = (1 - (1-theta)*a*dt)/(1 + theta*dt*a)*u[n]\\n return u, t\",\n \"def distance(v, t):\\n rf = v.orbit.body.non_rotating_reference_frame\\n vec = v3minus(v.position(rf), t.position(rf))\\n a = vec[0] * vec[0]\\n b = vec[1] * vec[1]\\n c = vec[2] * vec[2]\\n return math.sqrt(a + b + c)\",\n \"def solar_time_index(self):\\n return self.data.solar_time_index\",\n \"def getGradient(self,j):\\n i = int(self.indicator['term'][j])\\n r = int(self.indicator['row'][j])\\n c = int(self.indicator['col'][j])\\n rv = -np.kron(self.Fstar()[i][:,[r]],self.Astar()[i][[c],:])\\n return rv\",\n \"def getaij(self,i_,j_):\\n aij_ = ctypes.c_double()\\n res = __library__.MSK_XX_getaij(self.__nativep,i_,j_,ctypes.byref(aij_))\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n aij_ = aij_.value\\n _aij_return_value = aij_\\n return (_aij_return_value)\",\n \"def d_dt(self, r, t):\\n return self.d_do(r,t) * do_dt(r,t)\",\n \"def r(t, i, j):\\n\\n #when get to (i,j) position, minus the food with the zombie needs\\n t -= grid[i][j]\\n\\n\\n #the food is not enough for rabbit to get to the top left or \\n #rabbit can't go left or top. \\n if i < 0 or j < 0 or t < 0:\\n return food+1\\n\\n #can get to the top left, t is the remainder.\\n elif i == 0 and j == 0:\\n return t\\n\\n #choose the less food grid.\\n else:\\n return min(r(t, i-1, j), r(t, i, j-1))\",\n \"def tv(i, r=None):\\n if r is None:\\n return i[0]\\n else:\\n return Operation.tv(r[i])\",\n \"def rule(model, i, j):\\n active = 1-self.task_spread[j]\\n den = sum(tril[i, :])\\n ind = model.timeslots\\n total = sum(tril[i, k] * (\\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\\n k, j]) for k in ind)\\n total /= den\\n total *= active\\n return -1 + EPS, model.CTl[i, j] - total, EPS + self.slack_cont\",\n \"def spin_adapted_t1(i, j):\\n if not isinstance(i, int) or not isinstance(j, int):\\n raise ValueError(\\\"Requires integers as orbital indices, \\\\\\nbut get {} and {}.\\\".format(type(i), type(j)))\\n\\n ia = i * 2 + 0\\n ib = i * 2 + 1\\n ja = j * 2 + 0\\n jb = j * 2 + 1\\n term1 = FermionOperator(((ia, 1), (ja, 0)), 1.0)\\n term2 = FermionOperator(((ib, 1), (jb, 0)), 1.0)\\n tpq_list = [term1 + term2]\\n return tpq_list\",\n \"def solver(I, a, T, dt, theta):\\n dt = float(dt) # avoid integer division\\n Nt = int(round(T/dt)) # no of time intervals\\n T = Nt*dt # adjust T to fit time step dt\\n u = zeros(Nt+1) # array of u[n] values\\n t = linspace(0, T, Nt+1) # time mesh\\n\\n u[0] = I # assign initial condition\\n for n in range(0, Nt): # n=0,1,...,Nt-1\\n u[n+1] = (1 - (1-theta)*a*dt)/(1 + theta*dt*a)*u[n]\\n return u, t\",\n \"def to_ri(self,system):\\n # rotating wave approx\\n for i in system:\\n for j in i:\\n j.RWA()\\n #change system to number\\n for i in range(self.N):\\n for j in range(self.N):\\n system[i][j] = system[i][j].mag()\\n# print self.system\\n #transform conjugate to real and imag\\n for i in range(self.n):\\n for j in range(i,self.n):\\n id1 = self.index(i,j) \\n if i == j:\\n for k in range(self.n):\\n for l in range(k,self.n):\\n if k != l:\\n id2 = self.index(k,l)\\n tmp1 = (system[id1][id2]+system[id1][id2+1]).real\\n tmp2 = (system[id1][id2]-system[id1][id2+1]).imag \\n system[id1][id2],system[id1][id2+1] = tmp1,-1*tmp2\\n else:\\n for k in range(self.n):\\n for l in range(k,self.n):\\n id2 = self.index(k,l)\\n if k==l:\\n tmp = system[id1][id2]\\n system[id1][id2],system[id1+1][id2]=tmp.real,tmp.imag\\n else:\\n tmp1 = system[id1][id2]+system[id1][id2+1]\\n tmp2 = system[id1][id2]-system[id1][id2+1]\\n system[id1][id2],system[id1][id2+1] = tmp1.real,-1*tmp2.imag\\n system[id1+1][id2],system[id1+1][id2+1] = tmp1.imag,tmp2.real\\n return system\",\n \"def calculate_dvec_spin_fixed_j(self, jorb: int) -> 'Nparray':\\n return self._calculate_dvec_spin_with_coeff_fixed_j(self.coeff, jorb)\",\n \"def qrot(I,sym):\\n T = s.Symbol(\\\"T\\\")\\n if type(I) == list:\\n return (((s.pi * I[0] * I[1] * I[2])**(1/2))/sym) * ((8 * s.pi**2 * k * T) / (h**2))**(3/2)\\n else:\\n return (((s.pi * I)**(1/2))/sym) * ((8 * s.pi**2 * k * T) / (h**2))**(3/2)\",\n \"def rms2int(twt, rms):\\r\\n v_int = np.ones((len(twt), ))\\r\\n v_int[0] = rms[0]\\r\\n v_int[1:] = np.sqrt((rms[1:]**2 * twt[1:] - rms[:-1]**2 * twt[:-1]) /\\r\\n (twt[1:] - twt[:-1]))\\r\\n\\r\\n return v_int\",\n \"def dtheta_du_elt(self, i):\\n\\n half_delta_shift = [0.0, 0.0, 0.0]\\n half_delta_shift[i] = self._delta / 2.0\\n half_delta_shift = matrix.col(half_delta_shift)\\n\\n u_fwd = self._vec_u + half_delta_shift\\n u_rev = self._vec_u - half_delta_shift\\n\\n theta_fwd = math.acos(u_fwd.dot(self._vec_v) / (u_fwd.length() * self._v))\\n theta_rev = math.acos(u_rev.dot(self._vec_v) / (u_rev.length() * self._v))\\n\\n return (theta_fwd - theta_rev) / self._delta\",\n \"def numerically_integrate(\\n self, state, u=0., T=1, time_steps=200, method='dopri5'):\\n\\n t = torch.linspace(0, T, time_steps).to(device)\\n state = state.to(device)\\n return odeint(\\n lambda _, x: self.forward(x, u), state, t, method=method\\n ).cpu()[: , 0, :]\",\n \"def width(self):\\n return self.i_node.distance(self.j_node)\",\n \"def calculation_time_analysis():\\n\\tfrom . import spectra as sp\\n\\tp_dict = {'Bfield':700,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':0*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\\n\\tchiL,chiR,chiZ = sp.calc_chi([-3500],p_dict)\\n\\t\\n\\tfor angle in [0, np.pi/32, np.pi/16, np.pi/8, np.pi/4, np.pi/2]:\\n\\t\\tprint(('Angle (degrees): ',angle*180/np.pi))\\n\\t\\tRotMat, n1, n2 = solve_diel(chiL,chiR,chiZ,angle)\",\n \"def f(r,t):\\r\\n x = r[0]\\r\\n y = r[2]\\r\\n z = r[4]\\r\\n vx = r[1]\\r\\n vy = r[3]\\r\\n vz = r[5]\\r\\n velocity = np.sqrt(vx**2+vy**2+vz**2)\\r\\n #if np.abs(z)>eps:\\r\\n velocity = np.sqrt((vx+c*radius*wy)**2+(vy-c*radius*wx)**2+(-e*vz)**2)\\r\\n \\r\\n # equations for a cricket ball in motion\\r\\n return np.array([vx, (-k_d*velocity*vx+k_l*(wy*vz-wz*vy)),\\r\\n vy, (-k_d*velocity*vy+k_l*(wz*vx-wx*vz)),\\r\\n vz,(-k_d*velocity*vz+k_l*(wz*vy-wy*vx)-g)], float)\",\n \"def compute_jerk(joint_trajectory):\\r\\n joint_vel = np.gradient(joint_trajectory, axis=1)\\r\\n joint_acc = np.gradient(joint_vel, axis=1)\\r\\n joint_jerk = np.gradient(joint_acc, axis=1)\\r\\n jerk = np.linalg.norm(joint_jerk)\\r\\n return jerk\",\n \"def rt_general(lam, T, I_0, tau):\\n\\n B_lam = planck_w(lam, T)\\n tau_total = tau[-1]\\n delta_tau = tau[1:] - tau[0:-1]\\n integrate_radiation = B_lam[1:] * np.exp(- (tau_total - tau[:])) * delta_tau\\n return I_0 * np.exp(-tau) + B_lam * (1 - np.exp(-tau))\",\n \"def gen_Jij(atom_list,jmats):\\n N_atoms = len(atom_list)\\n jij_values = []\\n jij_columns = []\\n jij_rowIndex = []\\n zeroval = np.zeros((3,3))\\n \\n # Counts total number of interactions: needed for row indexing\\n num_inters = 0\\n # Scan through atom_list\\n \\n nbrs_ints = [] \\n for i in range(N_atoms):\\n nbrs_ints = atom_list[i].interactions\\n nbrs_ints.sort()\\n\\n # Now we have a sorted list of (nbr,intr) tuples from lowest neighbor to highest neighbor\\n # Scan through interactions\\n if len(nbrs_ints)>0:\\n for j in range(len(nbrs_ints)):\\n nbr = nbrs_ints[j][0]\\n intr = nbrs_ints[j][1]\\n \\n #Get an interaction matrix\\n curr_mat = jmats[intr].tolist()\\n curr_mat = np.array(curr_mat, dtype=np.float64)\\n \\n # Values = current matrix\\n # Columns = the current neighbor\\n # RowIndex = total number of interactions \\n jij_values.append(curr_mat)\\n jij_columns.append(nbr)\\n if j == 0:\\n jij_rowIndex.append(num_inters)\\n \\n # Increase number of total interactions\\n num_inters = num_inters + 1\\n else:\\n jij_values.append(zeroval)\\n jij_columns.append(0)\\n jij_rowIndex.append(num_inters)\\n num_inters = num_inters + 1\\n # Add dummy index to rowIndex\\n jij_rowIndex.append(len(jij_values))\\n\\n # Convert to numpy arrays\\n jij_values = np.array(jij_values)\\n jij_columns = np.array(jij_columns)\\n jij_rowIndex = np.array(jij_rowIndex)\\n \\n print jij_values\\n print jij_values.shape[1:]\\n print N_atoms + 1\\n print len(jij_rowIndex)\\n print jij_columns\\n print jij_rowIndex\\n \\n # Create Sparse Array\\n jij = bsr_matrix( (jij_values,jij_columns,jij_rowIndex), shape=(3*N_atoms,3*N_atoms) ).todense()\\n\\n return jij\",\n \"def get_j1(mol, atom, coord):\\n\\n omega = np.identity(2)\\n spin_j = np.einsum(\\\"ij,kl->ikjl\\\", omega, omega)\\n\\n twoe = -mol.intor(\\\"int2e_ip1\\\")[coord] #minus sign due to pyscf definition\\n\\n j1_spatial = np.zeros((twoe.shape[0],twoe.shape[0],twoe.shape[0],\\n twoe.shape[0]))\\n\\n for i in range(twoe.shape[0]):\\n\\n lambda_i = int(i in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n for j in range(twoe.shape[0]):\\n\\n lambda_j = int(j in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n for k in range(twoe.shape[0]):\\n\\n lambda_k = int(k in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n for l in range(twoe.shape[0]):\\n\\n lambda_l = int(l in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n j1_spatial[i][j][k][l] += (twoe[i][j][k][l] * lambda_i\\n + twoe[j][i][k][l] * lambda_j\\n + twoe[k][l][i][j] * lambda_k\\n + twoe[l][k][i][j] * lambda_l)\\n\\n j1_spatial = np.einsum(\\\"abcd->acbd\\\", j1_spatial,\\n optimize='optimal') #convert to physicists\\n j1 = np.kron(spin_j, j1_spatial)\\n\\n return j1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5410007","0.52558136","0.52129275","0.51934403","0.5120384","0.50158536","0.49003237","0.48539624","0.48512992","0.4837882","0.48160997","0.4813014","0.48086157","0.48014414","0.47951403","0.47862214","0.47764075","0.47283062","0.47244427","0.47240275","0.470889","0.4708479","0.4699587","0.4693895","0.46829942","0.46718615","0.4667066","0.46458772","0.46367332","0.46154815","0.46100178","0.4609691","0.4605473","0.45770922","0.45765162","0.45436385","0.45420757","0.45353457","0.45324966","0.45273176","0.45247635","0.45240536","0.4523798","0.45121092","0.45112705","0.45076323","0.45059362","0.45053","0.4498192","0.44865572","0.44728208","0.44716558","0.4461865","0.44434053","0.44427097","0.44318372","0.442073","0.44031596","0.44013909","0.44000056","0.43969017","0.43948635","0.43922782","0.43884596","0.43866563","0.43865785","0.43828645","0.43795425","0.43786806","0.43744504","0.43744272","0.43740758","0.4361852","0.4356371","0.4354522","0.4344329","0.43434343","0.43374684","0.43341097","0.43340626","0.43325257","0.43309262","0.43277282","0.4325597","0.43246204","0.4324253","0.43207684","0.43151575","0.43149495","0.4311835","0.43101823","0.43084192","0.43040162","0.42993522","0.42992488","0.42962137","0.42948815","0.4292855","0.42910516","0.428566"],"string":"[\n \"0.5410007\",\n \"0.52558136\",\n \"0.52129275\",\n \"0.51934403\",\n \"0.5120384\",\n \"0.50158536\",\n \"0.49003237\",\n \"0.48539624\",\n \"0.48512992\",\n \"0.4837882\",\n \"0.48160997\",\n \"0.4813014\",\n \"0.48086157\",\n \"0.48014414\",\n \"0.47951403\",\n \"0.47862214\",\n \"0.47764075\",\n \"0.47283062\",\n \"0.47244427\",\n \"0.47240275\",\n \"0.470889\",\n \"0.4708479\",\n \"0.4699587\",\n \"0.4693895\",\n \"0.46829942\",\n \"0.46718615\",\n \"0.4667066\",\n \"0.46458772\",\n \"0.46367332\",\n \"0.46154815\",\n \"0.46100178\",\n \"0.4609691\",\n \"0.4605473\",\n \"0.45770922\",\n \"0.45765162\",\n \"0.45436385\",\n \"0.45420757\",\n \"0.45353457\",\n \"0.45324966\",\n \"0.45273176\",\n \"0.45247635\",\n \"0.45240536\",\n \"0.4523798\",\n \"0.45121092\",\n \"0.45112705\",\n \"0.45076323\",\n \"0.45059362\",\n \"0.45053\",\n \"0.4498192\",\n \"0.44865572\",\n \"0.44728208\",\n \"0.44716558\",\n \"0.4461865\",\n \"0.44434053\",\n \"0.44427097\",\n \"0.44318372\",\n \"0.442073\",\n \"0.44031596\",\n \"0.44013909\",\n \"0.44000056\",\n \"0.43969017\",\n \"0.43948635\",\n \"0.43922782\",\n \"0.43884596\",\n \"0.43866563\",\n \"0.43865785\",\n \"0.43828645\",\n \"0.43795425\",\n \"0.43786806\",\n \"0.43744504\",\n \"0.43744272\",\n \"0.43740758\",\n \"0.4361852\",\n \"0.4356371\",\n \"0.4354522\",\n \"0.4344329\",\n \"0.43434343\",\n \"0.43374684\",\n \"0.43341097\",\n \"0.43340626\",\n \"0.43325257\",\n \"0.43309262\",\n \"0.43277282\",\n \"0.4325597\",\n \"0.43246204\",\n \"0.4324253\",\n \"0.43207684\",\n \"0.43151575\",\n \"0.43149495\",\n \"0.4311835\",\n \"0.43101823\",\n \"0.43084192\",\n \"0.43040162\",\n \"0.42993522\",\n \"0.42992488\",\n \"0.42962137\",\n \"0.42948815\",\n \"0.4292855\",\n \"0.42910516\",\n \"0.428566\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60190296"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74284,"cells":{"query":{"kind":"string","value":"This function is called to check if a username / password combination is valid."},"document":{"kind":"string","value":"def check_auth(username, password):\n ADMIN_USER = config.CONFIG_VARS['ADMIN_USER']\n ADMIN_PASS = config.CONFIG_VARS['ADMIN_PASS']\n return username == ADMIN_USER and password == ADMIN_PASS"},"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_auth(username, password, expected_user, expected_pw):\n return username == expected_user and password == expected_pw","def validate_authentication(self, username, password):\n return self.user_table[username]['pwd'] == password","def check_auth(username, password):\n return username == USERNAME and password == PASSWORD","def check_valid(self, username, password):\n con = self.connect()\n cursor = con.cursor()\n cursor.execute(\"SELECT username,password \\\n FROM users WHERE username = %s\", (username,))\n credentials = cursor.fetchone()\n cursor.close()\n con.commit()\n con.close()\n if credentials is None:\n return False\n if username != credentials[0]:\n return False\n if sha256_crypt.verify(password, credentials[1]):\n return True\n return False","def check_auth(username, password):\n return username == 'aweber' and password == 'aweber1100'","def check_auth(username, password):\n return username == 'nicholas' and password == ADMIN_PASS","def check_auth(username, password):\n return username == 'admin' and password == 'worcester'","def validate_login(self, username, password):\n user = User(self).get(username)\n return user and user['Password'] == password","def check_auth(username, password):\n return username == 'admin' and password == 'pebble'","def check_auth(username, password):\n return username == 'jeffkoons' and password == 'likesweirdbaloons'","def check_auth(username, password):\n return username == 'admin' and password == 'Passw0rd'","def check_auth(username, password):\n return username == 'asimov' and password == 'tagada72'","def check_auth(username, password):\n return username == 'sammy' and password == 'BasicPassword!'","def check_auth_password(self, username, password):\n return AUTH_FAILED","def is_valid_password(password, username):\n import string\n if len(password) < 4 or ' ' in password:\n return False\n if username:\n if string.lower(username) in string.lower(password):\n return False\n return True","def check_auth(username, password):\n return username == app.config['USERNAME'] and (\n password == app.config['PASSWORD'])","def check_auth(username, password):\n return username == 'admin' and password == 'password'","def _credentials_are_valid(self, username, password):\n LDAP_SERVER = 'ldap://xxx.xxx.xxx' # EDIT THIS\n LDAP_USERNAME = '%s@xxx.com' % username # EDIT THIS\n LDAP_PASSWORD = password\n\n try:\n # build a client\n ldap_client = ldap.initialize(LDAP_SERVER)\n # perform a synchronous bind\n ldap_client.set_option(ldap.OPT_REFERRALS, 0)\n ldap_client.simple_bind_s(LDAP_USERNAME, LDAP_PASSWORD)\n except ldap.INVALID_CREDENTIALS:\n ldap_client.unbind()\n # Wrong username or password\n return False\n except ldap.SERVER_DOWN:\n # AD server not available\n return False\n # all is well\n ldap_client.unbind()\n # Login successful\n return True","def username_is_valid(username):\n\n if len(username) < MINIMUM_PASSWORD_LENGTH:\n return False\n else:\n return True","def check_auth(username, password):\n return (username == app.config['USERNAME'] and\n password == app.config['PASSWORD'])","def check_auth(username, password):\n return username == c.id and password == c.pw","def check_auth(username, password):\n return username == 'admin' and password == 'root'","def check_auth(username, password):\n return username == 'admin' and password == 'secret'","def check_auth(username, password):\n return username == 'admin' and password == 'secret'","def password_validator(username, password):\n digits = re.search(r'\\d+', password)\n capital_letters = re.search(r'[A-Z]+', password)\n lenght = len(password) > PASSWORD_MIN_LENGTH\n special_symbol = re.search(r'[\\-\\/\\@\\?\\!\\,\\.\\#\\&\\*]+', password)\n\n statement = digits and capital_letters and lenght and special_symbol\n\n if statement:\n return True\n return False","def check_auth(username, password):\n return username == 'admin' and password == 'admin'","def check_auth(username, password):\n # return username == app.config['USER'] and password == app.config['PASS']\n\n return username == app.config['USER'] and password == app.config['PASS']","def check_auth(username, password):\r\n return username == current_app.config['ADMIN_USERNAME'] \\\r\n and password == current_app.config['ADMIN_PASSWORD']","def check_credentials(username, password):\n if not validate_username(username) or not validate_password(password):\n return False\n sql = \"SELECT password \" \\\n \"FROM users \" \\\n \"WHERE username=:username AND is_active=TRUE\"\n result = db.session.execute(sql, {\"username\": username})\n user = result.fetchone()\n if user is None:\n return False\n password_hash = user[0]\n if check_password_hash(password_hash, password):\n return True\n return False","def is_logged_in_user_valid(user_name, password):\n if user_name.upper() == \"HELLO\" and password == \"World\":\n return True # User input matches user name and password.\n else:\n return False # User input does not match user name and password.s","def check_auth(username, password):\n\n config = get_app_configurations()\n\n with open(config[\"credentials\"], \"r\") as fh:\n u, p = fh.readline().rstrip().split(\",\")\n\n return username == u and password == p","def verify_pw(username, password):\n credentials = HtpasswdFile(app.config[\"CREDENTIAL_FILE\"])\n if not credentials.check_password(username, password):\n logging.warning(\"%s tried to login with wrong password\", username)\n return False\n return True","def check_auth(username, password):\n return password == os.getenv('PASSWORD')","def validate_user(self, username, password, client, request, *args, **kwargs):\n log.debug('Validating username %r and its password', username)\n if self._usergetter is not None:\n user = self._usergetter(username, password, client, request, *args, **kwargs)\n if user:\n log.debug('Successfully validated username %r', username)\n request.user = user\n return True\n return False\n log.debug('Password credential authorization is disabled.')\n return False","def check_auth(username, password):\n return username == os.environ['USERNAME'] and password == os.environ['PASSWORD']","def _validate_password_works_with_username(password, username=None):\n if password == username:\n raise errors.AccountPasswordInvalid(accounts.PASSWORD_CANT_EQUAL_USERNAME_MSG) # lint-amnesty, pylint: disable=no-member","def is_valid_login(self, username, password):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)","def authenticate(self):\n rv = Form.validate(self)\n if not rv:\n return False\n\n user = self.username.data\n\n cur = get_cursor()\n if email_exists(cur, user):\n user = get_username(cur, user)\n\n if username_exists(cur, user):\n pw_hash = get_pw_hash(cur, user)\n\n if check_password(self.password.data, pw_hash):\n self.username.data = user\n return True\n\n return False","def is_valid_user(self, username, password): # WORKS\n done1 = self.cur.execute(\"SELECT password FROM users WHERE username=\\\"{}\\\"\".format(username))\n done2 = self.cur.execute(\"SELECT username FROM admins WHERE username=\\\"{}\\\"\".format(username))\n if done1 == 0 and done2 == 0: # If both queries are unsuccessful, username doesn't exist in both tables.\n return False\n else:\n if done1 == 1: # If username exists in USERS table.\n self.cur.execute(\"SELECT password FROM users WHERE username=\\\"{}\\\"\".format(username))\n stored_password = self.cur.fetchone()[0]\n return check_password_hash(stored_password, password) # Returns True if the hashes match.\n else: # If username exists in ADMINS table.\n self.cur.execute(\"SELECT password FROM admins WHERE username=\\\"{}\\\"\".format(username))\n stored_password = self.cur.fetchone()[0]\n return check_password_hash(stored_password, password) # Returns True if the hashes match.","def check_user(self,username, password):\n safe_input = (username, password)\n vals = self.cur.execute(\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\",safe_input).fetchone()\n if vals:\n logging.info('%s was authenticated', username)\n return True\n else:\n logging.info('Failed login for %s', username)\n return False","def valid_login(username, password):\n db = get_db()\n db.ping(True)\n cur = db.cursor()\n\n try:\n sql = \"SELECT password FROM users WHERE user_name = '{}';\".format(username)\n cur.execute(sql)\n for i in cur:\n return check_password_hash(i[0], password)\n return False\n except mysql.connector.Error as err:\n flash(err, \"set\")\n return False\n finally:\n cur.close()\n db.close()","def check_credentials(self, username, password):\n user = None\n if username != \"\":\n # Calling DB and fetching userdetails\n user = userdetails_API_query(username)\n print \"id \", user['_id']\n if user != None:\n #u = app.config['BASIC_AUTH_USERNAME'] = user['username']\n #pwd = app.config['BASIC_AUTH_PASSWORD'] = user['pw_hash']\n # print \" u & pwd\",username\n if user['username'] == username and check_password_hash(user['pw_hash'], password):\n g.user = user['_id'], username, user['email']\n return True\n print \"g.user\", g.user\n return False","def test_credentials(self):\r\n data = self._deep_clean('zekebarge@gmail.com')\r\n error = data.get(ERROR_CODE, None)\r\n if error in (1,2):\r\n raise InvalidCredentialsError(\"Credentials are invalid for user '{}'\".format(self._username))\r\n return True","def check_auth(username, password):\n return get_ct_object(username, password) is not None","def check_user(self):\n try:\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\n return True\n else:\n return False\n except:\n return False","def check_auth(username, password):\n return username == 'daniel' and password == config['redis_auth_key']","def validate_authentication(self, username, password, handler):\n hash = md5(password).hexdigest()\n msg = \"Authentication failed.\"\n if not self.has_user(username):\n if username == 'anonymous':\n msg = \"Anonymous access not allowed.\"\n raise AuthenticationFailed(msg)\n if username != 'anonymous':\n if self.user_table[username]['pwd'] != hash:\n raise AuthenticationFailed(msg)","def is_correct_user(self, login, password):\n pass","def check_auth(username, password):\n return username == get_env('UPLOAD_USER') and password == get_env('UPLOAD_PASSWORD')","def verify_password(self, username, password):\n\n try:\n self.c.execute('SELECT password FROM profiles WHERE name=(?)', (username,))\n\n db_pw = self.c.fetchone()[0]\n print(password)\n\n return db_pw == password\n\n except TypeError:\n return False","def check_auth(_, http_password):\n return (password is not None) and (password == http_password)","def check_credentials(username, password):\n\n return db.auth_user(username, password)","def check_user(self, username, password):\n user = [user for user in self.db if user['username'] == username]\n if user:\n if check_password_hash(user[0][\"password\"], password):\n return True\n return False\n return False","def validate(self) -> bool:\n if not super().validate():\n return False\n\n # Does the user exist\n user = User.query.filter_by(username=self.username.data).first()\n if not user:\n self.username.errors.append('Invalid username or password')\n return False\n\n # Does given password match user's password\n if not user.check_password(self.password.data):\n self.username.errors.append('Invalid username or password')\n return False\n\n return True","def check_credentials(username, password):\n\t\n\tconn = sqlite3.connect('db/user_task.db')\n\tcursor = conn.execute(\"SELECT password from user WHERE username == \\'%s\\'\" % (username))\n\tdata = cursor.fetchall()\n\tconn.close()\n\n\tif len(data) == 0:\n\t\treturn u\"Incorrect username\"\n\n\tfor row in data:\n\t\tencoded_password = hashlib.sha1(password.encode('utf-8')).hexdigest()\n\t\tif row[0] == encoded_password:\n\t\t\treturn None\n\n\treturn u\"Incorrect password\"\n\t\n\t# An example implementation which uses an ORM could be:\n\t# u = User.get(username)\n\t# if u is None:\n\t# return u\"Username %s is unknown to me.\" % username\n\t# if u.password != md5.new(password).hexdigest():\n\t# return u\"Incorrect password\"","def check_auth(username, password):\n try:\n locust_username = os.environ['LOCUST_USER_NAME']\n locust_password = os.environ['LOCUST_PASSWORD']\n return username == locust_username and password == locust_password\n except:\n return True","def validate_password(data):\n\n if \"password\" not in data:\n return False\n password = data[\"password\"]\n if len(password) < 4 or len(password) > 16:\n return False\n\n return True","def _check_user_pass(self):\n if not self.username:\n self.username = input(' 请输入手机号：')\n if self.username.isdigit() and '+86' not in self.username:\n self.username = '+86' + self.username\n\n if not self.password:\n self.password = input(' 请输入密码：')","def check_password(self, username, password): # tested\r\n conn = self.get_db()\r\n with conn:\r\n c = conn.cursor()\r\n sql = ('select password from gameuser where username=%s')\r\n c.execute(sql,(username,))\r\n hashedpass = md5.new(password).hexdigest()\r\n u = c.fetchone()\r\n if u == None:\r\n raise NoUserExistsException(username)\r\n # print 'database contains {}, entered password was {}'.format(u[0],hashedpass)\r\n return u[0] == hashedpass","def valid_login_password(username, password, pw_hash):\n salt = pw_hash.split(',')[1]\n return pw_hash == make_pw_hash(username, password, salt)","def check_auth(username, password):\n return username == 'admin' and password in app.config[\"CLAIM_SECRETS\"]","def validate_password(self, field):\n username = self.username.data\n if platform.system().lower() == 'linux':\n g.logger.debug('use pam for authenticate.')\n from pam import authenticate\n if authenticate(username, field.data):\n g.logger.info('session opened for user %s.' % username)\n return username\n else:\n raise ValueError('Authentication failure.')\n return username","def check_credentials_typo(credentials):\n regex_username = r'^[\\w\\.\\-]{2,}$'\n regex_password = r'[^.]{4,10}$'\n\n if not match(regex_username, credentials['username']):\n raise ValueError('invalid username typo')\n\n if not match(regex_password, credentials['password']):\n raise ValueError('invalid password typo')","def username_and_password_check(username: str, password: str) -> bool:\n table = metadata.tables['users']\n s = select(\n [\n func.count(table.c.id)\n ]).where(tuple_(table.c['username'], table.c['password'])\n .in_([(username, password)]))\n result = conn.execute(s).scalar()\n return bool(result)","def check_auth(username, password):\n user = User.query.filter(User.username == username).first()\n\n if user:\n return user.password == password\n else:\n return False","def authentication_validation(username, password, access_token):\n if bool(username) is not bool(password):\n raise Exception(\"Basic authentication requires a username AND\" \" password.\")\n if (username and access_token) or (password and access_token):\n raise Exception(\n \"Cannot use both Basic Authentication and\"\n \" OAuth2.0. Please use only one authentication\"\n \" method.\"\n )","def verify_password(username, password):\n if username in user_auth and check_password_hash(user_auth.get(username), password):\n return username","def is_password_valid(password):\n #TODO : This should also be handled by the front_end\n pass","def invalid_credentials( form , field ): \n\tusername_entered = form.username.data\n\tpassword_entered = field.data \n\tuser_object = User.query.filter_by(username = username_entered).first()\n\tif user_object is None : \n\t\traise ValidationError(\"Username or Password is incorrect !\")\n\telif not pbkdf2_sha256.verify(password_entered , user_object.password) : \n\t\traise ValidationError(\"Username or Password is incorrect !\")","def check_password(username, password, htpasswd_fn):\n entries = parse_htpasswd(htpasswd_fn, username)\n if not entries.has_key(username):\n raise NoSuchUser('No user: %r' % username)\n return check_entry_password(\n username, password, entries[username])","def auth(username, password):\n return username == password","def _check_password(self, password):\n if self.password_regex.search(password) is not None:\n print(\"Correct password\")\n return True\n else:\n print(\"Wrong password\")\n return False","def check_auth(username, password):\n return username == current_app.config['DOC_USERNAME'] and password == current_app.config['DOC_PASSWORD']","def _check_username(self, username):\n if self.username_regex.search(username) is not None:\n print(\"Correct username\")\n return True\n else: \n print(\"Wrong username\")\n return False","def check_auth_password(self, username, password):\n if username == self.username and password == self.password:\n return paramiko.AUTH_SUCCESSFUL\n return paramiko.AUTH_FAILED","def check_credentials(input_password, real_password):\n return pwd_context.verify(input_password, real_password)","def test_valid_username_invalid_password(self):\n response = self.client.post(reverse('users:login'), {'username': self.user['username'], 'password': '1sfsdf'})\n self.assertEqual(response.status_code, 200)\n self.assertFormError(response, 'form', None, ERROR_MSG)","def authorise_login(self, username, password):\n con = self.connect()\n cursor = con.cursor()\n cursor.execute(\"SELECT username,password \\\n FROM users WHERE password = %s\", (password,))\n credentials = cursor.fetchone()\n cursor.close()\n con.commit()\n con.close()\n if credentials is None:\n return False\n if username != credentials[0]:\n return False\n if password != credentials[1]:\n return False\n return True","def clean(self):\n cleaned_data = super().clean()\n username = cleaned_data['username']\n password = cleaned_data['password']\n\n if authenticate(username=username, password=password) is None:\n raise ValidationError('Your username or password is incorrect.')","def _check_password(self, password):\n rule = re.compile(constant.password_regex)\n if not rule.match(password):\n return False\n # disallow password from azure guide, yes, it's hard code.\n disallowed = constant.password_disallowed\n return password not in disallowed","def validate(username: str, password: str) -> dict:\n validation_check = {}\n \n # Check to see if the username was left blank\n if username.strip() == \"\":\n validation_check[\"success\"] = False\n validation_check[\"username\"] = \"Username cannot be left blank.\"\n\n # Check to see if the username is taken\n elif not sql.is_username_taken(username):\n validation_check[\"success\"] = False\n validation_check[\"username\"] = \"Username is incorrect\"\n\n # Check to see if the password was left blank\n if password.strip() == \"\":\n validation_check[\"success\"] = False\n validation_check[\"password\"] = \"Password cannot be left blank.\"\n\n\n if not validation_check.get(\"success\", True):\n return validation_check\n\n else:\n return sql.verify_credentials(username, password)","def check_friend(self, username):\n if (self.isBlank(username) or self.isValidLen(username)):\n return False\n\n safe_input = (username,)\n \n vals = self.cur.execute(\"SELECT Username, Password FROM Users WHERE Username=?\" ,safe_input).fetchone()\n if vals:\n return True\n else:\n return False","def test_check_password():\n assert check_password('Longpassword') == False\n assert check_password('123456') == False\n assert check_password('short') == False\n assert check_password('C0rect') == False\n assert check_password('Correct8') == True","def test_validate_credentials(self):\n pass","def check_password(self, password):\n return self.password == password","def check_my_users(user):\n user_data = my_users.get(user['username'])\n if not user_data:\n return False # <--- invalid credentials\n elif user_data.get('password') == user['password']:\n return True # <--- user is logged in!\n\n return False # <--- invalid credentials","def valid_login(username: str, password: str):\n\n try:\n LoginHandler.login(username, password)\n global validLogin\n validLogin = True\n except:\n validLogin = False","def checkLogin(username, password):\n\n # Query database for username\n cur = initialise(2)\n cur.execute(\"SELECT * FROM users WHERE username = ?\", [username])\n users = cur.fetchall()\n\n # Ensure username exists and password is correct\n if len(users) != 1 or not check_password_hash(users[0][\"hash\"], password):\n return False, username\n else:\n return True, users[0][\"id\"]","def validate_login(name,password):\n\t\n\t#Read the attendance excelsheet check if username and password matched\n\tdf_atten=pd.read_csv(\"datasrc/People.csv\")\n\t# 10006 ultbjxu\n\t\n\tif (df_atten.Username.astype(str).str.contains(name).any() and df_atten.Password.astype(str).str.contains(password).any()):\t\t\n\t\treturn True\n\telse: \n\t\treturn False","def isUSER(username, password):\n usr = UserData[\"username\"].to_dict()\n listofUsers = list(UserData[\"username\"])\n if username in listofUsers:\n # print('Is a User')\n getindex = listofUsers.index(username)\n listofPasswords = list(UserData[\"password\"])\n # print(getindex)\n if listofPasswords[getindex] == password:\n # print('Password Correct')\n return True, True\n return True, False\n return False, False","def _input(self):\n\t\tself.username = input(\"Username:\")\n\t\tself.password = input(\"password:\")\n\t\tret = re.match(r\"^\\w{1,20}$\", self.username)\n\t\tprint(\"------>input string\", self.username)\n\t\tprint(\"------>matched string\",ret)\t\n\t\ttime.sleep(1)\n\t\tif ret == None:\n\t\t\treturn True\n\t\telse:\n\t\t\tpass\n\n\t\tsql = f\"\"\"select name, password from users where name='{self.username}';\"\"\"\n\t\tprint(\"----------->\", sql)\n\t\ttime.sleep(1)\n\t\tcount = self.cs.execute(sql)\n\t\tprint(count)\n\t\tif (self.username, self.password) == self.cs.fetchone():\n\t\t\tprint(\"Login Successfully\")\n\t\t\ttime.sleep(1)\n\t\t\treturn False\n\t\telse:\n\t\t\tprint(\"Wrong username or password\")\n\t\t\ttime.sleep(1)\n\t\t\treturn True","def check_auth(username, password):\n session.pop('username', None)\n session.pop('password', None)\n session['username'] = username\n session['password'] = password\n # Test if we can connect to a region\n connect_to_region()\n return True","def is_valid_login(username, password):\n with open(PASSFILE, \"r\") as passfile:\n for record in passfile:\n try:\n valid_user, valid_password = False, False\n r_username, r_salt_hash = record.split()\n if username == r_username:\n valid_user = True\n if sha256_crypt.verify(password, r_salt_hash):\n valid_password = True\n if valid_user and valid_password:\n return True\n except ValueError:\n pass\n return False","def check_credentials_validation(credentials):\n spec = {'_id': credentials['username'], 'password': credentials['password']}\n if not current_app.mongo.observer.users.find_one(spec):\n raise Unauthorized('invalid credentials')","def username_check(username):\n\n try: \n pwd.getpwnam(username)\n print(\"User %s DOES EXIST. Try a different username.\" % (username)) \n return False\n\n except KeyError: \n print(\"User %s DOES NOT exist. Continuing...\" % (username)) \n return True","def test_invalid_username_valid_password(self):\n response = self.client.post(reverse('users:login'), {'username': 'xyzabe', 'password': self.user['password1']})\n self.assertEqual(response.status_code, 200)\n self.assertFormError(response, 'form', None, ERROR_MSG)","def test_valid_password(self):\n pass_field = Field(\"\".join(['x' * (int(self.app.config['MAX_PWD_LEN']))]))\n\n valid_password(None, pass_field)","def authenticate(username, password):\n test = User.load(username)\n test_password = test.password\n input_password = md5.new(\n password + config.get('security', 'salt')).digest()\n if input_password == test_password:\n return True\n else:\n return False","def test_authenticate_invalid_username(self):\r\n print(\"Authenticate user invalid username\")\r\n username = \"test9999user\"\r\n password = \"password\"\r\n\r\n self.assertEqual(self.system.authenticate(username, password), False)","def verify_pw(username, password):\n global password_store\n logger = logging.getLogger('verify_pw')\n if not password_store:\n logger.error(\"No password store specified\")\n return False\n logger.debug(\"Verifying password for %s\" % username)\n return password_store.verify(username, password)"],"string":"[\n \"def check_auth(username, password, expected_user, expected_pw):\\n return username == expected_user and password == expected_pw\",\n \"def validate_authentication(self, username, password):\\n return self.user_table[username]['pwd'] == password\",\n \"def check_auth(username, password):\\n return username == USERNAME and password == PASSWORD\",\n \"def check_valid(self, username, password):\\n con = self.connect()\\n cursor = con.cursor()\\n cursor.execute(\\\"SELECT username,password \\\\\\n FROM users WHERE username = %s\\\", (username,))\\n credentials = cursor.fetchone()\\n cursor.close()\\n con.commit()\\n con.close()\\n if credentials is None:\\n return False\\n if username != credentials[0]:\\n return False\\n if sha256_crypt.verify(password, credentials[1]):\\n return True\\n return False\",\n \"def check_auth(username, password):\\n return username == 'aweber' and password == 'aweber1100'\",\n \"def check_auth(username, password):\\n return username == 'nicholas' and password == ADMIN_PASS\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'worcester'\",\n \"def validate_login(self, username, password):\\n user = User(self).get(username)\\n return user and user['Password'] == password\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'pebble'\",\n \"def check_auth(username, password):\\n return username == 'jeffkoons' and password == 'likesweirdbaloons'\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'Passw0rd'\",\n \"def check_auth(username, password):\\n return username == 'asimov' and password == 'tagada72'\",\n \"def check_auth(username, password):\\n return username == 'sammy' and password == 'BasicPassword!'\",\n \"def check_auth_password(self, username, password):\\n return AUTH_FAILED\",\n \"def is_valid_password(password, username):\\n import string\\n if len(password) < 4 or ' ' in password:\\n return False\\n if username:\\n if string.lower(username) in string.lower(password):\\n return False\\n return True\",\n \"def check_auth(username, password):\\n return username == app.config['USERNAME'] and (\\n password == app.config['PASSWORD'])\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'password'\",\n \"def _credentials_are_valid(self, username, password):\\n LDAP_SERVER = 'ldap://xxx.xxx.xxx' # EDIT THIS\\n LDAP_USERNAME = '%s@xxx.com' % username # EDIT THIS\\n LDAP_PASSWORD = password\\n\\n try:\\n # build a client\\n ldap_client = ldap.initialize(LDAP_SERVER)\\n # perform a synchronous bind\\n ldap_client.set_option(ldap.OPT_REFERRALS, 0)\\n ldap_client.simple_bind_s(LDAP_USERNAME, LDAP_PASSWORD)\\n except ldap.INVALID_CREDENTIALS:\\n ldap_client.unbind()\\n # Wrong username or password\\n return False\\n except ldap.SERVER_DOWN:\\n # AD server not available\\n return False\\n # all is well\\n ldap_client.unbind()\\n # Login successful\\n return True\",\n \"def username_is_valid(username):\\n\\n if len(username) < MINIMUM_PASSWORD_LENGTH:\\n return False\\n else:\\n return True\",\n \"def check_auth(username, password):\\n return (username == app.config['USERNAME'] and\\n password == app.config['PASSWORD'])\",\n \"def check_auth(username, password):\\n return username == c.id and password == c.pw\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'root'\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'secret'\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'secret'\",\n \"def password_validator(username, password):\\n digits = re.search(r'\\\\d+', password)\\n capital_letters = re.search(r'[A-Z]+', password)\\n lenght = len(password) > PASSWORD_MIN_LENGTH\\n special_symbol = re.search(r'[\\\\-\\\\/\\\\@\\\\?\\\\!\\\\,\\\\.\\\\#\\\\&\\\\*]+', password)\\n\\n statement = digits and capital_letters and lenght and special_symbol\\n\\n if statement:\\n return True\\n return False\",\n \"def check_auth(username, password):\\n return username == 'admin' and password == 'admin'\",\n \"def check_auth(username, password):\\n # return username == app.config['USER'] and password == app.config['PASS']\\n\\n return username == app.config['USER'] and password == app.config['PASS']\",\n \"def check_auth(username, password):\\r\\n return username == current_app.config['ADMIN_USERNAME'] \\\\\\r\\n and password == current_app.config['ADMIN_PASSWORD']\",\n \"def check_credentials(username, password):\\n if not validate_username(username) or not validate_password(password):\\n return False\\n sql = \\\"SELECT password \\\" \\\\\\n \\\"FROM users \\\" \\\\\\n \\\"WHERE username=:username AND is_active=TRUE\\\"\\n result = db.session.execute(sql, {\\\"username\\\": username})\\n user = result.fetchone()\\n if user is None:\\n return False\\n password_hash = user[0]\\n if check_password_hash(password_hash, password):\\n return True\\n return False\",\n \"def is_logged_in_user_valid(user_name, password):\\n if user_name.upper() == \\\"HELLO\\\" and password == \\\"World\\\":\\n return True # User input matches user name and password.\\n else:\\n return False # User input does not match user name and password.s\",\n \"def check_auth(username, password):\\n\\n config = get_app_configurations()\\n\\n with open(config[\\\"credentials\\\"], \\\"r\\\") as fh:\\n u, p = fh.readline().rstrip().split(\\\",\\\")\\n\\n return username == u and password == p\",\n \"def verify_pw(username, password):\\n credentials = HtpasswdFile(app.config[\\\"CREDENTIAL_FILE\\\"])\\n if not credentials.check_password(username, password):\\n logging.warning(\\\"%s tried to login with wrong password\\\", username)\\n return False\\n return True\",\n \"def check_auth(username, password):\\n return password == os.getenv('PASSWORD')\",\n \"def validate_user(self, username, password, client, request, *args, **kwargs):\\n log.debug('Validating username %r and its password', username)\\n if self._usergetter is not None:\\n user = self._usergetter(username, password, client, request, *args, **kwargs)\\n if user:\\n log.debug('Successfully validated username %r', username)\\n request.user = user\\n return True\\n return False\\n log.debug('Password credential authorization is disabled.')\\n return False\",\n \"def check_auth(username, password):\\n return username == os.environ['USERNAME'] and password == os.environ['PASSWORD']\",\n \"def _validate_password_works_with_username(password, username=None):\\n if password == username:\\n raise errors.AccountPasswordInvalid(accounts.PASSWORD_CANT_EQUAL_USERNAME_MSG) # lint-amnesty, pylint: disable=no-member\",\n \"def is_valid_login(self, username, password):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_IS_LOGIN_INFORMATION_VALID, username + '|' + password)\",\n \"def authenticate(self):\\n rv = Form.validate(self)\\n if not rv:\\n return False\\n\\n user = self.username.data\\n\\n cur = get_cursor()\\n if email_exists(cur, user):\\n user = get_username(cur, user)\\n\\n if username_exists(cur, user):\\n pw_hash = get_pw_hash(cur, user)\\n\\n if check_password(self.password.data, pw_hash):\\n self.username.data = user\\n return True\\n\\n return False\",\n \"def is_valid_user(self, username, password): # WORKS\\n done1 = self.cur.execute(\\\"SELECT password FROM users WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n done2 = self.cur.execute(\\\"SELECT username FROM admins WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n if done1 == 0 and done2 == 0: # If both queries are unsuccessful, username doesn't exist in both tables.\\n return False\\n else:\\n if done1 == 1: # If username exists in USERS table.\\n self.cur.execute(\\\"SELECT password FROM users WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n stored_password = self.cur.fetchone()[0]\\n return check_password_hash(stored_password, password) # Returns True if the hashes match.\\n else: # If username exists in ADMINS table.\\n self.cur.execute(\\\"SELECT password FROM admins WHERE username=\\\\\\\"{}\\\\\\\"\\\".format(username))\\n stored_password = self.cur.fetchone()[0]\\n return check_password_hash(stored_password, password) # Returns True if the hashes match.\",\n \"def check_user(self,username, password):\\n safe_input = (username, password)\\n vals = self.cur.execute(\\\"SELECT Username, Password FROM Users WHERE Username=? AND Password=?\\\",safe_input).fetchone()\\n if vals:\\n logging.info('%s was authenticated', username)\\n return True\\n else:\\n logging.info('Failed login for %s', username)\\n return False\",\n \"def valid_login(username, password):\\n db = get_db()\\n db.ping(True)\\n cur = db.cursor()\\n\\n try:\\n sql = \\\"SELECT password FROM users WHERE user_name = '{}';\\\".format(username)\\n cur.execute(sql)\\n for i in cur:\\n return check_password_hash(i[0], password)\\n return False\\n except mysql.connector.Error as err:\\n flash(err, \\\"set\\\")\\n return False\\n finally:\\n cur.close()\\n db.close()\",\n \"def check_credentials(self, username, password):\\n user = None\\n if username != \\\"\\\":\\n # Calling DB and fetching userdetails\\n user = userdetails_API_query(username)\\n print \\\"id \\\", user['_id']\\n if user != None:\\n #u = app.config['BASIC_AUTH_USERNAME'] = user['username']\\n #pwd = app.config['BASIC_AUTH_PASSWORD'] = user['pw_hash']\\n # print \\\" u & pwd\\\",username\\n if user['username'] == username and check_password_hash(user['pw_hash'], password):\\n g.user = user['_id'], username, user['email']\\n return True\\n print \\\"g.user\\\", g.user\\n return False\",\n \"def test_credentials(self):\\r\\n data = self._deep_clean('zekebarge@gmail.com')\\r\\n error = data.get(ERROR_CODE, None)\\r\\n if error in (1,2):\\r\\n raise InvalidCredentialsError(\\\"Credentials are invalid for user '{}'\\\".format(self._username))\\r\\n return True\",\n \"def check_auth(username, password):\\n return get_ct_object(username, password) is not None\",\n \"def check_user(self):\\n try:\\n if (self.get_user()[0][0] == self.username) and (self.check_password(self.password)):\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def check_auth(username, password):\\n return username == 'daniel' and password == config['redis_auth_key']\",\n \"def validate_authentication(self, username, password, handler):\\n hash = md5(password).hexdigest()\\n msg = \\\"Authentication failed.\\\"\\n if not self.has_user(username):\\n if username == 'anonymous':\\n msg = \\\"Anonymous access not allowed.\\\"\\n raise AuthenticationFailed(msg)\\n if username != 'anonymous':\\n if self.user_table[username]['pwd'] != hash:\\n raise AuthenticationFailed(msg)\",\n \"def is_correct_user(self, login, password):\\n pass\",\n \"def check_auth(username, password):\\n return username == get_env('UPLOAD_USER') and password == get_env('UPLOAD_PASSWORD')\",\n \"def verify_password(self, username, password):\\n\\n try:\\n self.c.execute('SELECT password FROM profiles WHERE name=(?)', (username,))\\n\\n db_pw = self.c.fetchone()[0]\\n print(password)\\n\\n return db_pw == password\\n\\n except TypeError:\\n return False\",\n \"def check_auth(_, http_password):\\n return (password is not None) and (password == http_password)\",\n \"def check_credentials(username, password):\\n\\n return db.auth_user(username, password)\",\n \"def check_user(self, username, password):\\n user = [user for user in self.db if user['username'] == username]\\n if user:\\n if check_password_hash(user[0][\\\"password\\\"], password):\\n return True\\n return False\\n return False\",\n \"def validate(self) -> bool:\\n if not super().validate():\\n return False\\n\\n # Does the user exist\\n user = User.query.filter_by(username=self.username.data).first()\\n if not user:\\n self.username.errors.append('Invalid username or password')\\n return False\\n\\n # Does given password match user's password\\n if not user.check_password(self.password.data):\\n self.username.errors.append('Invalid username or password')\\n return False\\n\\n return True\",\n \"def check_credentials(username, password):\\n\\t\\n\\tconn = sqlite3.connect('db/user_task.db')\\n\\tcursor = conn.execute(\\\"SELECT password from user WHERE username == \\\\'%s\\\\'\\\" % (username))\\n\\tdata = cursor.fetchall()\\n\\tconn.close()\\n\\n\\tif len(data) == 0:\\n\\t\\treturn u\\\"Incorrect username\\\"\\n\\n\\tfor row in data:\\n\\t\\tencoded_password = hashlib.sha1(password.encode('utf-8')).hexdigest()\\n\\t\\tif row[0] == encoded_password:\\n\\t\\t\\treturn None\\n\\n\\treturn u\\\"Incorrect password\\\"\\n\\t\\n\\t# An example implementation which uses an ORM could be:\\n\\t# u = User.get(username)\\n\\t# if u is None:\\n\\t# return u\\\"Username %s is unknown to me.\\\" % username\\n\\t# if u.password != md5.new(password).hexdigest():\\n\\t# return u\\\"Incorrect password\\\"\",\n \"def check_auth(username, password):\\n try:\\n locust_username = os.environ['LOCUST_USER_NAME']\\n locust_password = os.environ['LOCUST_PASSWORD']\\n return username == locust_username and password == locust_password\\n except:\\n return True\",\n \"def validate_password(data):\\n\\n if \\\"password\\\" not in data:\\n return False\\n password = data[\\\"password\\\"]\\n if len(password) < 4 or len(password) > 16:\\n return False\\n\\n return True\",\n \"def _check_user_pass(self):\\n if not self.username:\\n self.username = input(' 请输入手机号：')\\n if self.username.isdigit() and '+86' not in self.username:\\n self.username = '+86' + self.username\\n\\n if not self.password:\\n self.password = input(' 请输入密码：')\",\n \"def check_password(self, username, password): # tested\\r\\n conn = self.get_db()\\r\\n with conn:\\r\\n c = conn.cursor()\\r\\n sql = ('select password from gameuser where username=%s')\\r\\n c.execute(sql,(username,))\\r\\n hashedpass = md5.new(password).hexdigest()\\r\\n u = c.fetchone()\\r\\n if u == None:\\r\\n raise NoUserExistsException(username)\\r\\n # print 'database contains {}, entered password was {}'.format(u[0],hashedpass)\\r\\n return u[0] == hashedpass\",\n \"def valid_login_password(username, password, pw_hash):\\n salt = pw_hash.split(',')[1]\\n return pw_hash == make_pw_hash(username, password, salt)\",\n \"def check_auth(username, password):\\n return username == 'admin' and password in app.config[\\\"CLAIM_SECRETS\\\"]\",\n \"def validate_password(self, field):\\n username = self.username.data\\n if platform.system().lower() == 'linux':\\n g.logger.debug('use pam for authenticate.')\\n from pam import authenticate\\n if authenticate(username, field.data):\\n g.logger.info('session opened for user %s.' % username)\\n return username\\n else:\\n raise ValueError('Authentication failure.')\\n return username\",\n \"def check_credentials_typo(credentials):\\n regex_username = r'^[\\\\w\\\\.\\\\-]{2,}$'\\n regex_password = r'[^.]{4,10}$'\\n\\n if not match(regex_username, credentials['username']):\\n raise ValueError('invalid username typo')\\n\\n if not match(regex_password, credentials['password']):\\n raise ValueError('invalid password typo')\",\n \"def username_and_password_check(username: str, password: str) -> bool:\\n table = metadata.tables['users']\\n s = select(\\n [\\n func.count(table.c.id)\\n ]).where(tuple_(table.c['username'], table.c['password'])\\n .in_([(username, password)]))\\n result = conn.execute(s).scalar()\\n return bool(result)\",\n \"def check_auth(username, password):\\n user = User.query.filter(User.username == username).first()\\n\\n if user:\\n return user.password == password\\n else:\\n return False\",\n \"def authentication_validation(username, password, access_token):\\n if bool(username) is not bool(password):\\n raise Exception(\\\"Basic authentication requires a username AND\\\" \\\" password.\\\")\\n if (username and access_token) or (password and access_token):\\n raise Exception(\\n \\\"Cannot use both Basic Authentication and\\\"\\n \\\" OAuth2.0. Please use only one authentication\\\"\\n \\\" method.\\\"\\n )\",\n \"def verify_password(username, password):\\n if username in user_auth and check_password_hash(user_auth.get(username), password):\\n return username\",\n \"def is_password_valid(password):\\n #TODO : This should also be handled by the front_end\\n pass\",\n \"def invalid_credentials( form , field ): \\n\\tusername_entered = form.username.data\\n\\tpassword_entered = field.data \\n\\tuser_object = User.query.filter_by(username = username_entered).first()\\n\\tif user_object is None : \\n\\t\\traise ValidationError(\\\"Username or Password is incorrect !\\\")\\n\\telif not pbkdf2_sha256.verify(password_entered , user_object.password) : \\n\\t\\traise ValidationError(\\\"Username or Password is incorrect !\\\")\",\n \"def check_password(username, password, htpasswd_fn):\\n entries = parse_htpasswd(htpasswd_fn, username)\\n if not entries.has_key(username):\\n raise NoSuchUser('No user: %r' % username)\\n return check_entry_password(\\n username, password, entries[username])\",\n \"def auth(username, password):\\n return username == password\",\n \"def _check_password(self, password):\\n if self.password_regex.search(password) is not None:\\n print(\\\"Correct password\\\")\\n return True\\n else:\\n print(\\\"Wrong password\\\")\\n return False\",\n \"def check_auth(username, password):\\n return username == current_app.config['DOC_USERNAME'] and password == current_app.config['DOC_PASSWORD']\",\n \"def _check_username(self, username):\\n if self.username_regex.search(username) is not None:\\n print(\\\"Correct username\\\")\\n return True\\n else: \\n print(\\\"Wrong username\\\")\\n return False\",\n \"def check_auth_password(self, username, password):\\n if username == self.username and password == self.password:\\n return paramiko.AUTH_SUCCESSFUL\\n return paramiko.AUTH_FAILED\",\n \"def check_credentials(input_password, real_password):\\n return pwd_context.verify(input_password, real_password)\",\n \"def test_valid_username_invalid_password(self):\\n response = self.client.post(reverse('users:login'), {'username': self.user['username'], 'password': '1sfsdf'})\\n self.assertEqual(response.status_code, 200)\\n self.assertFormError(response, 'form', None, ERROR_MSG)\",\n \"def authorise_login(self, username, password):\\n con = self.connect()\\n cursor = con.cursor()\\n cursor.execute(\\\"SELECT username,password \\\\\\n FROM users WHERE password = %s\\\", (password,))\\n credentials = cursor.fetchone()\\n cursor.close()\\n con.commit()\\n con.close()\\n if credentials is None:\\n return False\\n if username != credentials[0]:\\n return False\\n if password != credentials[1]:\\n return False\\n return True\",\n \"def clean(self):\\n cleaned_data = super().clean()\\n username = cleaned_data['username']\\n password = cleaned_data['password']\\n\\n if authenticate(username=username, password=password) is None:\\n raise ValidationError('Your username or password is incorrect.')\",\n \"def _check_password(self, password):\\n rule = re.compile(constant.password_regex)\\n if not rule.match(password):\\n return False\\n # disallow password from azure guide, yes, it's hard code.\\n disallowed = constant.password_disallowed\\n return password not in disallowed\",\n \"def validate(username: str, password: str) -> dict:\\n validation_check = {}\\n \\n # Check to see if the username was left blank\\n if username.strip() == \\\"\\\":\\n validation_check[\\\"success\\\"] = False\\n validation_check[\\\"username\\\"] = \\\"Username cannot be left blank.\\\"\\n\\n # Check to see if the username is taken\\n elif not sql.is_username_taken(username):\\n validation_check[\\\"success\\\"] = False\\n validation_check[\\\"username\\\"] = \\\"Username is incorrect\\\"\\n\\n # Check to see if the password was left blank\\n if password.strip() == \\\"\\\":\\n validation_check[\\\"success\\\"] = False\\n validation_check[\\\"password\\\"] = \\\"Password cannot be left blank.\\\"\\n\\n\\n if not validation_check.get(\\\"success\\\", True):\\n return validation_check\\n\\n else:\\n return sql.verify_credentials(username, password)\",\n \"def check_friend(self, username):\\n if (self.isBlank(username) or self.isValidLen(username)):\\n return False\\n\\n safe_input = (username,)\\n \\n vals = self.cur.execute(\\\"SELECT Username, Password FROM Users WHERE Username=?\\\" ,safe_input).fetchone()\\n if vals:\\n return True\\n else:\\n return False\",\n \"def test_check_password():\\n assert check_password('Longpassword') == False\\n assert check_password('123456') == False\\n assert check_password('short') == False\\n assert check_password('C0rect') == False\\n assert check_password('Correct8') == True\",\n \"def test_validate_credentials(self):\\n pass\",\n \"def check_password(self, password):\\n return self.password == password\",\n \"def check_my_users(user):\\n user_data = my_users.get(user['username'])\\n if not user_data:\\n return False # <--- invalid credentials\\n elif user_data.get('password') == user['password']:\\n return True # <--- user is logged in!\\n\\n return False # <--- invalid credentials\",\n \"def valid_login(username: str, password: str):\\n\\n try:\\n LoginHandler.login(username, password)\\n global validLogin\\n validLogin = True\\n except:\\n validLogin = False\",\n \"def checkLogin(username, password):\\n\\n # Query database for username\\n cur = initialise(2)\\n cur.execute(\\\"SELECT * FROM users WHERE username = ?\\\", [username])\\n users = cur.fetchall()\\n\\n # Ensure username exists and password is correct\\n if len(users) != 1 or not check_password_hash(users[0][\\\"hash\\\"], password):\\n return False, username\\n else:\\n return True, users[0][\\\"id\\\"]\",\n \"def validate_login(name,password):\\n\\t\\n\\t#Read the attendance excelsheet check if username and password matched\\n\\tdf_atten=pd.read_csv(\\\"datasrc/People.csv\\\")\\n\\t# 10006 ultbjxu\\n\\t\\n\\tif (df_atten.Username.astype(str).str.contains(name).any() and df_atten.Password.astype(str).str.contains(password).any()):\\t\\t\\n\\t\\treturn True\\n\\telse: \\n\\t\\treturn False\",\n \"def isUSER(username, password):\\n usr = UserData[\\\"username\\\"].to_dict()\\n listofUsers = list(UserData[\\\"username\\\"])\\n if username in listofUsers:\\n # print('Is a User')\\n getindex = listofUsers.index(username)\\n listofPasswords = list(UserData[\\\"password\\\"])\\n # print(getindex)\\n if listofPasswords[getindex] == password:\\n # print('Password Correct')\\n return True, True\\n return True, False\\n return False, False\",\n \"def _input(self):\\n\\t\\tself.username = input(\\\"Username:\\\")\\n\\t\\tself.password = input(\\\"password:\\\")\\n\\t\\tret = re.match(r\\\"^\\\\w{1,20}$\\\", self.username)\\n\\t\\tprint(\\\"------>input string\\\", self.username)\\n\\t\\tprint(\\\"------>matched string\\\",ret)\\t\\n\\t\\ttime.sleep(1)\\n\\t\\tif ret == None:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\tpass\\n\\n\\t\\tsql = f\\\"\\\"\\\"select name, password from users where name='{self.username}';\\\"\\\"\\\"\\n\\t\\tprint(\\\"----------->\\\", sql)\\n\\t\\ttime.sleep(1)\\n\\t\\tcount = self.cs.execute(sql)\\n\\t\\tprint(count)\\n\\t\\tif (self.username, self.password) == self.cs.fetchone():\\n\\t\\t\\tprint(\\\"Login Successfully\\\")\\n\\t\\t\\ttime.sleep(1)\\n\\t\\t\\treturn False\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"Wrong username or password\\\")\\n\\t\\t\\ttime.sleep(1)\\n\\t\\t\\treturn True\",\n \"def check_auth(username, password):\\n session.pop('username', None)\\n session.pop('password', None)\\n session['username'] = username\\n session['password'] = password\\n # Test if we can connect to a region\\n connect_to_region()\\n return True\",\n \"def is_valid_login(username, password):\\n with open(PASSFILE, \\\"r\\\") as passfile:\\n for record in passfile:\\n try:\\n valid_user, valid_password = False, False\\n r_username, r_salt_hash = record.split()\\n if username == r_username:\\n valid_user = True\\n if sha256_crypt.verify(password, r_salt_hash):\\n valid_password = True\\n if valid_user and valid_password:\\n return True\\n except ValueError:\\n pass\\n return False\",\n \"def check_credentials_validation(credentials):\\n spec = {'_id': credentials['username'], 'password': credentials['password']}\\n if not current_app.mongo.observer.users.find_one(spec):\\n raise Unauthorized('invalid credentials')\",\n \"def username_check(username):\\n\\n try: \\n pwd.getpwnam(username)\\n print(\\\"User %s DOES EXIST. Try a different username.\\\" % (username)) \\n return False\\n\\n except KeyError: \\n print(\\\"User %s DOES NOT exist. Continuing...\\\" % (username)) \\n return True\",\n \"def test_invalid_username_valid_password(self):\\n response = self.client.post(reverse('users:login'), {'username': 'xyzabe', 'password': self.user['password1']})\\n self.assertEqual(response.status_code, 200)\\n self.assertFormError(response, 'form', None, ERROR_MSG)\",\n \"def test_valid_password(self):\\n pass_field = Field(\\\"\\\".join(['x' * (int(self.app.config['MAX_PWD_LEN']))]))\\n\\n valid_password(None, pass_field)\",\n \"def authenticate(username, password):\\n test = User.load(username)\\n test_password = test.password\\n input_password = md5.new(\\n password + config.get('security', 'salt')).digest()\\n if input_password == test_password:\\n return True\\n else:\\n return False\",\n \"def test_authenticate_invalid_username(self):\\r\\n print(\\\"Authenticate user invalid username\\\")\\r\\n username = \\\"test9999user\\\"\\r\\n password = \\\"password\\\"\\r\\n\\r\\n self.assertEqual(self.system.authenticate(username, password), False)\",\n \"def verify_pw(username, password):\\n global password_store\\n logger = logging.getLogger('verify_pw')\\n if not password_store:\\n logger.error(\\\"No password store specified\\\")\\n return False\\n logger.debug(\\\"Verifying password for %s\\\" % username)\\n return password_store.verify(username, password)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8221681","0.81452113","0.79765403","0.79615504","0.788556","0.78595155","0.7838946","0.78279626","0.7815743","0.77989453","0.7786234","0.7770711","0.7761279","0.77546805","0.7753378","0.7752181","0.77496976","0.7731222","0.77148515","0.76884216","0.76860243","0.767445","0.7663914","0.7663914","0.76614743","0.76573133","0.7654227","0.76126474","0.7594224","0.75643575","0.75582457","0.75472075","0.75426203","0.7530678","0.7505672","0.7504345","0.7466914","0.7442446","0.7408071","0.7405168","0.739546","0.73944503","0.7389761","0.735116","0.7336699","0.73003674","0.727589","0.7246855","0.72319084","0.7204968","0.71994823","0.71991974","0.71924865","0.71886957","0.7183467","0.71703935","0.7169686","0.7157913","0.71394336","0.713397","0.7113123","0.7109863","0.71078813","0.70977527","0.709342","0.70305026","0.7030209","0.7026298","0.7026147","0.69898516","0.69895244","0.69892305","0.69856286","0.6968489","0.6965026","0.6963002","0.6938744","0.6929973","0.69140005","0.69025785","0.68948376","0.68897927","0.6886976","0.6884964","0.6883382","0.68800384","0.687691","0.6864743","0.68634146","0.68617487","0.68555593","0.6846795","0.6846398","0.6840773","0.68359303","0.6827823","0.68276244","0.68247885","0.6820965","0.68141955"],"string":"[\n \"0.8221681\",\n \"0.81452113\",\n \"0.79765403\",\n \"0.79615504\",\n \"0.788556\",\n \"0.78595155\",\n \"0.7838946\",\n \"0.78279626\",\n \"0.7815743\",\n \"0.77989453\",\n \"0.7786234\",\n \"0.7770711\",\n \"0.7761279\",\n \"0.77546805\",\n \"0.7753378\",\n \"0.7752181\",\n \"0.77496976\",\n \"0.7731222\",\n \"0.77148515\",\n \"0.76884216\",\n \"0.76860243\",\n \"0.767445\",\n \"0.7663914\",\n \"0.7663914\",\n \"0.76614743\",\n \"0.76573133\",\n \"0.7654227\",\n \"0.76126474\",\n \"0.7594224\",\n \"0.75643575\",\n \"0.75582457\",\n \"0.75472075\",\n \"0.75426203\",\n \"0.7530678\",\n \"0.7505672\",\n \"0.7504345\",\n \"0.7466914\",\n \"0.7442446\",\n \"0.7408071\",\n \"0.7405168\",\n \"0.739546\",\n \"0.73944503\",\n \"0.7389761\",\n \"0.735116\",\n \"0.7336699\",\n \"0.73003674\",\n \"0.727589\",\n \"0.7246855\",\n \"0.72319084\",\n \"0.7204968\",\n \"0.71994823\",\n \"0.71991974\",\n \"0.71924865\",\n \"0.71886957\",\n \"0.7183467\",\n \"0.71703935\",\n \"0.7169686\",\n \"0.7157913\",\n \"0.71394336\",\n \"0.713397\",\n \"0.7113123\",\n \"0.7109863\",\n \"0.71078813\",\n \"0.70977527\",\n \"0.709342\",\n \"0.70305026\",\n \"0.7030209\",\n \"0.7026298\",\n \"0.7026147\",\n \"0.69898516\",\n \"0.69895244\",\n \"0.69892305\",\n \"0.69856286\",\n \"0.6968489\",\n \"0.6965026\",\n \"0.6963002\",\n \"0.6938744\",\n \"0.6929973\",\n \"0.69140005\",\n \"0.69025785\",\n \"0.68948376\",\n \"0.68897927\",\n \"0.6886976\",\n \"0.6884964\",\n \"0.6883382\",\n \"0.68800384\",\n \"0.687691\",\n \"0.6864743\",\n \"0.68634146\",\n \"0.68617487\",\n \"0.68555593\",\n \"0.6846795\",\n \"0.6846398\",\n \"0.6840773\",\n \"0.68359303\",\n \"0.6827823\",\n \"0.68276244\",\n \"0.68247885\",\n \"0.6820965\",\n \"0.68141955\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7653261"},"document_rank":{"kind":"string","value":"27"}}},{"rowIdx":74285,"cells":{"query":{"kind":"string","value":"Sends a 401 response that enables basic auth"},"document":{"kind":"string","value":"def authenticate():\n return Response(\n 'Could not verify your credentials for that url', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})"},"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 authenticate():\n return Response('Not Authorized', 401, {'WWW-Authenticate': 'Basic realm=\"api\"'})","def authenticate():\n return Response(\n '', 401, {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def authenticate():\n return Response(\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate(self):\n abort(\n 401,\n description=self.exception,\n www_authenticate=(\"WWW-Authenticate\", 'Basic realm=\"%s\"' % __package__),\n )","def authenticate():\r\n return Response(\r\n 'Could not verify your access level for that URL.\\n'\r\n 'You have to login with proper credentials', 401,\r\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n\treturn Response(\n\t'Could not verify your access level for that URL.\\n'\n\t'You have to login with proper credentials', 401,\n\t{'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials.', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response('Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials',\n 401,\n {\n 'WWW-Authenticate': 'Basic realm=\"Login Required\"'\n }\n )","def authenticate():\n return send_msg(\n 401,\n 'Must be connected',\n headers={'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(render_template('index.html', auth=False), 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return flask.Response('Login required.', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL, need token.\\n', 403,\n {'WWW-Authenticate': 'Basic realm=\"token Required\"'})","def authenticate(self):\n return Response(\n 'Could not verify your access level for that URL.\\nYou have to login with proper credentials',\n 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )","def user_must_authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def authenticate():\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with Web Manager credentials', 401,\n {'WWW-Authenticate': 'Basic realm=\"Login Required\"'})","def unauthorized():\n return HttpError(401)","def basic_auth_error():\n logger.debug(\"Basic authentication failed.\")\n return unauthorized(\"Invalid credentials.\")","def response_unauthorised():\n\n response = {\n 'status': 'failed',\n 'error': 'Not Authorised'\n }\n\n return response_json(response, status=401)","def challenge(self, environ, status, app_headers=(), forget_headers=()):\n resp = Response()\n resp.status = 401\n resp.headers = self.forget(environ, {})\n for headers in (app_headers, forget_headers):\n for name, value in headers:\n resp.headers[name] = value\n resp.content_type = \"text/plain\"\n resp.body = \"Unauthorized\"\n return resp","def authenticate(self):\n resp = Response(None, 401)\n abort(401, description='Please provide proper credentials', response=resp)","def _login(self, environ, start_response):\n response = HTTPUnauthorized()\n response.www_authenticate = ('Basic', {'realm': self._realm})\n return response(environ, start_response)","def add_basic_auth(blueprint: Blueprint, username, password, realm='api'):\n\n @blueprint.before_request\n def basic_http_auth(*args, **kwargs):\n auth = request.authorization\n if auth is None or auth.password != password or auth.username != username:\n return Response('Please login', 401, {'WWW-Authenticate': f'Basic realm=\"{realm}\"'})","def authenticate():\n return abort(401)","def unauthorized():\n return {'errors': ['Unauthorized']}, 401","def forget(self, request):\n return [('WWW-Authenticate', 'Basic realm=\"%s\"' % self.realm)]","def _respond_unauthorized(self, request, message=\"Unauthorized\"):\n resp = Response()\n resp.status = 401\n resp.headers = self.forget(request.environ, {})\n resp.content_type = \"text/plain\"\n resp.body = message\n request.environ[\"repoze.who.application\"] = resp\n return None","def authenticate():\n resp = {\"status\": 401, \"message\": \"Could not verify your access level for that URL\"}\n return Response(dumps(resp), status=404, mimetype='application/json')","def hidden_basic_auth(user=\"user\", passwd=\"passwd\"):\n\n if not check_basic_auth(user, passwd):\n return status_code(404)\n return jsonify(authenticated=True, user=user)","def CR_authentication():\n \n # create a random 10 character string\n choices = string.letters + string.digits + string.punctuation;\n randomString = ''.join(random.choice(choices) for i in range(10))\n session['challenge'] = randomString\n \n return Response('Access failed.', 401, {'WWW-Authenticate': str.format('Basic realm=\\\"Protected iStreet event data; Challenge: {0}\\\"', randomString)})","def authenticate():\n return Response(\n '''Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or\n with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide\n a linkedin or twitter account showing as much)\n You have to login with proper credentials''', 401, {'WWW-Authenticate': 'Basic realm=\"Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide a linkedin or twitter account showing as much)\"'})","def auth_failure():\n return \"Request denied due to failed authorization\", 201, {'Content-Type': 'text/html'}","def unauthorized(self, error):\n return jsonify({'error': \"NOT AUTHORIZED\"}), 401","def _handle_authentication_error(self):\n response = make_response('Access Denied')\n response.headers['WWW-Authenticate'] = self.auth.get_authenticate_header()\n response.status_code = 401\n return response","def authenticate():\n\n return Response(\n 'Could not verify your access level for that URL.\\n'\n 'You have to login with proper credentials', 401,\n get_auth_headers())","def test_unauthorized_exception(exception_app):\n request, response = exception_app.test_client.get('/401')\n assert response.status == 401\n\n request, response = exception_app.test_client.get('/401/basic')\n assert response.status == 401\n assert response.headers.get('WWW-Authenticate') is not None\n assert response.headers.get('WWW-Authenticate') == \"Basic realm='Sanic'\"\n\n request, response = exception_app.test_client.get('/401/digest')\n assert response.status == 401\n\n auth_header = response.headers.get('WWW-Authenticate')\n assert auth_header is not None\n assert auth_header.startswith('Digest')\n assert \"qop='auth, auth-int'\" in auth_header\n assert \"algorithm='MD5'\" in auth_header\n assert \"nonce='abcdef'\" in auth_header\n assert \"opaque='zyxwvu'\" in auth_header\n\n request, response = exception_app.test_client.get('/401/bearer')\n assert response.status == 401\n assert response.headers.get('WWW-Authenticate') == \"Bearer\"","def display_401(error):\n return render_template('/error401.html'), 401","def test_unauthorized(self):\n self._error_test(fitbit_exceptions.HTTPUnauthorized)","def basic_auth(user=\"user\", passwd=\"passwd\"):\n\n if not check_basic_auth(user, passwd):\n return status_code(401)\n\n return jsonify(authenticated=True, user=user)","def test_unauthenticated_request(self):\n url = self.get_url(self.active_user.id)\n response = self.client.get(url)\n\n expected_status_code = 401\n self.assertEqual(response.status_code, expected_status_code)","def basic_http_auth(f):\n def wrap(request, *args, **kwargs):\n if request.META.get('HTTP_AUTHORIZATION', False):\n authtype, auth = request.META['HTTP_AUTHORIZATION'].split(' ')\n auth = base64.b64decode(auth)\n username, password = auth.split(':')\n user = authenticate(username=username, password=password)\n if user is not None:\n if user.is_active:\n login(request, user)\n return f(request, *args, **kwargs)\n else:\n r = HttpResponse(\"Auth Required\", status = 401)\n r['WWW-Authenticate'] = 'Basic realm=\"ThatPanda DDNS\"'\n return r\n r = HttpResponse(\"Auth Required\", status = 401)\n r['WWW-Authenticate'] = 'Basic realm=\"ThatPanda DDNS\"'\n return r\n \n return wrap","def auth_error():\n return unauthorized('Invalid credentials')","def require_http_auth(request):\n\n if http_auth_allowed(request) and not request.user.is_authenticated:\n site = get_current_site(request)\n response = HttpResponse(status=401)\n response['WWW-Authenticate'] = (\n 'Basic realm=\"{}\", charset=\"UTF-8\"'.format(site.name)\n )\n # Check whether the client supports cookies.\n response.set_cookie('testcookie', '1', secure=(not settings.DEBUG),\n httponly=True, samesite='Lax')\n return response\n else:\n raise PermissionDenied()","def response_401(description=None):\n resp_def = dict(util.RESPONSE_404)\n if description is not None:\n resp_def['description'] = description\n\n return response(401, resp_def)","def http_basic_auth():\n users = ['administrator', 'admin']\n passwords = ['administrator', 'admin']\n protectedResource = 'http://localhost/secured_path'\n foundPass = False\n for user in users:\n if foundPass:\n break\n for passwd in passwords:\n encoded = base64.encodestring(user + ':' + passwd)\n response = requests.get(protectedResource, auth=(user, passwd))\n if response.status_code != 401:\n print('User Found!')\n print('User: %s, Pass: %s' % (user, passwd))\n foundPass = True\n break","def assertHttpUnauthorized(self, resp):\r\n return self.assertEqual(resp.status_code, 401)","def basic_auth_required(view_func):\n # http://djangosnippets.org/snippets/448/\n def _auth(request, *args, **kwargs):\n if 'HTTP_AUTHORIZATION' in request.META:\n auth = request.META['HTTP_AUTHORIZATION'].split()\n if len(auth) == 2:\n if auth[0].lower() == \"basic\":\n uname, passwd = base64.b64decode(auth[1]).split(':')\n user = authenticate(username=uname, password=passwd)\n if user is not None:\n if user.is_active:\n return view_func(request, *args, **kwargs)\n response = HttpResponse(\"Authorization Required\", status=401)\n response['WWW-Authenticate'] = 'Basic realm=\"Secure Area\"'\n return response\n return _auth","def http_basic_auth(func):\r\n\t@wraps(func)\r\n\tdef _decorator(request, *args, **kwargs):\r\n\r\n\t\tif request.META.has_key('HTTP_AUTHORIZATION'):\r\n\t\t\ttry:\r\n\t\t\t\tauthmeth, auth = request.META['HTTP_AUTHORIZATION'].split(' ', 1)\r\n\t\t\t\tif authmeth.lower() == 'basic':\r\n\t\t\t\t\tauth = auth.strip().decode('base64')\r\n\t\t\t\t\tusername, password = auth.split(':', 1)\r\n\t\t\t\t\tuser = authenticate(username=username, password=password)\r\n\r\n\t\t\t\t\tif user:\r\n\r\n\t\t\t\t\t\tlogin(request, user)\r\n\t\t\t\t\t\r\n\t\t\t\t\telse:\r\n\r\n\t\t\t\t\t\treturn HttpResponseForbidden()\r\n\r\n\t\t\texcept ValueError:\r\n\t\t\t\t# Bad HTTP_AUTHORIZATION header\r\n\t\t\t\treturn HttpResponseForbidden()\r\n\t\t\t\t\r\n\t\treturn func(request, *args, **kwargs)\r\n\treturn _decorator","def unauthorized(self, message=None):\n return self.send_message(message, status=401)","def basic_auth_required(fn):\n @wraps(fn)\n def _wrapper(request, *args, **kwargs):\n authentication = request.headers.get('Authentication', None)\n\n if authentication:\n if not authentication.startswith(\"Basic \"):\n request.response.status = 401\n\n return {\n 'error': \"Authentication failed!\"\n }\n\n auth_data = authentication[6:]\n\n try:\n username, password = base64.urlsafe_b64decode(auth_data).decode(\"UTF8\").split(\":\")\n\n user = request.dbsession.query(User).filter(\n User.email == username\n ).one()\n\n if user.is_password(password.encode(\"UTF8\")):\n return fn(request, *args, **kwargs)\n except (ValueError, NoResultFound):\n pass\n\n request.response.status = 401\n\n return {\n 'error': 'Authentication failed!'\n }\n\n return _wrapper","def test_user_get_failure_using_basic_auth(self):\n # setup\n user = self.generate_username_password()\n resp = self.create_user(user)\n resp_body = resp.json()\n try:\n assert resp.status_code == 201\n assert resp.headers[\"Content-Type\"] == \"application/json; charset=utf-8\"\n assert resp_body[\"username\"] == user[\"userName\"]\n assert resp_body[\"userID\"] != \"\"\n except AssertionError:\n raise\n finally:\n self.pprint_request(resp.request)\n self.pprint_response(resp)\n uuid_ = str(uuid.uuid4())\n\n # test\n resp2 = self.get_user_basic_auth(uuid_, user)\n resp_body2 = resp2.json()\n assert resp2.status_code == 401\n assert resp2.headers[\"Content-Type\"] == \"application/json; charset=utf-8\"\n assert resp_body2[\"code\"] == \"1207\"\n assert resp_body2[\"message\"] == \"User not found!\"\n\n # teardown:\n resp3 = self.delete_user_basic_auth(resp_body[\"userID\"], user)\n try:\n assert resp3.status_code == 204\n except AssertionError:\n raise\n finally:\n self.pprint_request(resp3.request)\n self.pprint_response(resp3)","def test_unhappy_path_unauthorized(self):\n\n response = self.client.get(self.url)\n expected_data = {\"detail\": \"Authentication credentials were not provided.\"}\n\n self.assertDictEqual(response.data, expected_data)\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)","def test_no_auth(self):\n url = 'https://domain.com/project/objects.inv'\n expected = 'https://domain.com/project/objects.inv'\n actual = _strip_basic_auth(url)\n assert expected == actual","def test_unauthorized_access(flask_test_client, http_method, endpoint):\n response = flask_test_client.open(\n method=http_method, path=endpoint, headers=get_headers()\n )\n assert response.status == \"401 UNAUTHORIZED\"\n assert response.content_type == \"application/json\"\n assert response.json[\"message\"] == \"Access token is invalid or expired.\"","def test_get_unauthenticated(self):\n del self.client.request_kwargs['auth']\n self.verify_get_response(self.client.get(STATUS_PATH))","def get_authenticate_header(self):\n return f'Basic realm=\"{self.www_authenticate_realm}\"'","def test_retrieve_user_unauthorized(self):\r\n res = self.client.get(ME_URL)\r\n\r\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)","def basic_header(self):\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\n', '')\n return { \n #\"Authorization\" : \"Basic %s\" % self.auth, \n \"Content-type\": \"text/plain\" }","def test_retrieve_unauthorized_user(self):\n\n response = self.client.get(URL_ME)\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)","def test_retrieve_user_unauthorized(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)","def test_retrieve_user_unauthorized(self):\n res = self.client.get(ME_URL)\n\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)","def challenge_view(self, request):\n headerlist = [(\"Content-Type\", \"text/plain\")]\n headerlist.extend(self._get_challenge_headers(request))\n return Response(\"Unauthorized\", status=\"401 Unauthorized\",\n headerlist=headerlist)","def denied_response(self, req):\n if req.remote_user:\n return HTTPForbidden(request=req)\n else:\n return HTTPUnauthorized(request=req)","def test_401_unauthorized(app, client):\n\n @app.route(\"/401\")\n def unauthorized():\n abort(401)\n\n response = client.get(\"/401\")\n assert response.status_code == 401\n assert \"401 Unauthorized\" in str(response.data)","def test_status_unauthenticated(self):\n rv = self.client.post('/statusize/', data={'message': 'foo'},\n follow_redirects=True)\n eq_(rv.status_code, 403)","def test_call_unauthenticated(self):\n\n with Client('username', 'password') as client:\n self.setSessionResponse(401)\n with self.assertRaises(APIError):\n data = client.call(**self.build_parameters)","def test_unhappy_path_unauthorized(self):\n\n response = self.client.post(self.url)\n expected_data = {\"detail\": \"Authentication credentials were not provided.\"}\n\n self.assertDictEqual(response.data, expected_data)\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)","def test_retrieve_users_unauthorized(setup_client):\n client = setup_client\n res = client.get(ME_URL)\n assert res.status_code == status.HTTP_401_UNAUTHORIZED","def __call__(self, resp):\r\n if not self.auth_token:\r\n self.auth()\r\n resp.register_hook('response', self.handle_error)\r\n resp.headers['X-Auth-Token'] = self.auth_token\r\n return resp","def _handle_401(self, response, **kwargs):\n if not response.status_code == 401 and not response.status_code == 403:\n return response\n\n # Free the original connection\n response.content\n response.close()\n\n # copy the request to resend\n newreq = response.request.copy()\n\n self._access_token = None\n self._logger.debug(\"_handle_401, cleared _access_token, retrying with new token\")\n\n newreq.headers[\"Authorization\"] = self._get_auth_value()\n\n _response = response.connection.send(newreq, **kwargs)\n _response.history.append(response)\n _response.request = newreq\n\n return _response"],"string":"[\n \"def authenticate():\\n return Response('Not Authorized', 401, {'WWW-Authenticate': 'Basic realm=\\\"api\\\"'})\",\n \"def authenticate():\\n return Response(\\n '', 401, {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def authenticate():\\n return Response(\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate(self):\\n abort(\\n 401,\\n description=self.exception,\\n www_authenticate=(\\\"WWW-Authenticate\\\", 'Basic realm=\\\"%s\\\"' % __package__),\\n )\",\n \"def authenticate():\\r\\n return Response(\\r\\n 'Could not verify your access level for that URL.\\\\n'\\r\\n 'You have to login with proper credentials', 401,\\r\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n\\treturn Response(\\n\\t'Could not verify your access level for that URL.\\\\n'\\n\\t'You have to login with proper credentials', 401,\\n\\t{'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials.', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response('Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials',\\n 401,\\n {\\n 'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'\\n }\\n )\",\n \"def authenticate():\\n return send_msg(\\n 401,\\n 'Must be connected',\\n headers={'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(render_template('index.html', auth=False), 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return flask.Response('Login required.', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL, need token.\\\\n', 403,\\n {'WWW-Authenticate': 'Basic realm=\\\"token Required\\\"'})\",\n \"def authenticate(self):\\n return Response(\\n 'Could not verify your access level for that URL.\\\\nYou have to login with proper credentials',\\n 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'}\\n )\",\n \"def user_must_authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def authenticate():\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with Web Manager credentials', 401,\\n {'WWW-Authenticate': 'Basic realm=\\\"Login Required\\\"'})\",\n \"def unauthorized():\\n return HttpError(401)\",\n \"def basic_auth_error():\\n logger.debug(\\\"Basic authentication failed.\\\")\\n return unauthorized(\\\"Invalid credentials.\\\")\",\n \"def response_unauthorised():\\n\\n response = {\\n 'status': 'failed',\\n 'error': 'Not Authorised'\\n }\\n\\n return response_json(response, status=401)\",\n \"def challenge(self, environ, status, app_headers=(), forget_headers=()):\\n resp = Response()\\n resp.status = 401\\n resp.headers = self.forget(environ, {})\\n for headers in (app_headers, forget_headers):\\n for name, value in headers:\\n resp.headers[name] = value\\n resp.content_type = \\\"text/plain\\\"\\n resp.body = \\\"Unauthorized\\\"\\n return resp\",\n \"def authenticate(self):\\n resp = Response(None, 401)\\n abort(401, description='Please provide proper credentials', response=resp)\",\n \"def _login(self, environ, start_response):\\n response = HTTPUnauthorized()\\n response.www_authenticate = ('Basic', {'realm': self._realm})\\n return response(environ, start_response)\",\n \"def add_basic_auth(blueprint: Blueprint, username, password, realm='api'):\\n\\n @blueprint.before_request\\n def basic_http_auth(*args, **kwargs):\\n auth = request.authorization\\n if auth is None or auth.password != password or auth.username != username:\\n return Response('Please login', 401, {'WWW-Authenticate': f'Basic realm=\\\"{realm}\\\"'})\",\n \"def authenticate():\\n return abort(401)\",\n \"def unauthorized():\\n return {'errors': ['Unauthorized']}, 401\",\n \"def forget(self, request):\\n return [('WWW-Authenticate', 'Basic realm=\\\"%s\\\"' % self.realm)]\",\n \"def _respond_unauthorized(self, request, message=\\\"Unauthorized\\\"):\\n resp = Response()\\n resp.status = 401\\n resp.headers = self.forget(request.environ, {})\\n resp.content_type = \\\"text/plain\\\"\\n resp.body = message\\n request.environ[\\\"repoze.who.application\\\"] = resp\\n return None\",\n \"def authenticate():\\n resp = {\\\"status\\\": 401, \\\"message\\\": \\\"Could not verify your access level for that URL\\\"}\\n return Response(dumps(resp), status=404, mimetype='application/json')\",\n \"def hidden_basic_auth(user=\\\"user\\\", passwd=\\\"passwd\\\"):\\n\\n if not check_basic_auth(user, passwd):\\n return status_code(404)\\n return jsonify(authenticated=True, user=user)\",\n \"def CR_authentication():\\n \\n # create a random 10 character string\\n choices = string.letters + string.digits + string.punctuation;\\n randomString = ''.join(random.choice(choices) for i in range(10))\\n session['challenge'] = randomString\\n \\n return Response('Access failed.', 401, {'WWW-Authenticate': str.format('Basic realm=\\\\\\\"Protected iStreet event data; Challenge: {0}\\\\\\\"', randomString)})\",\n \"def authenticate():\\n return Response(\\n '''Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or\\n with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide\\n a linkedin or twitter account showing as much)\\n You have to login with proper credentials''', 401, {'WWW-Authenticate': 'Basic realm=\\\"Login Required - email acaceres@0-sec.net for access or DM him @_hyp3ri0n on Twitter. Please do so from a corporate email or with some kind of proof that you are a security engineer, academic, or need this data for research purposes (e.g. email from a corporate or .edu email or provide a linkedin or twitter account showing as much)\\\"'})\",\n \"def auth_failure():\\n return \\\"Request denied due to failed authorization\\\", 201, {'Content-Type': 'text/html'}\",\n \"def unauthorized(self, error):\\n return jsonify({'error': \\\"NOT AUTHORIZED\\\"}), 401\",\n \"def _handle_authentication_error(self):\\n response = make_response('Access Denied')\\n response.headers['WWW-Authenticate'] = self.auth.get_authenticate_header()\\n response.status_code = 401\\n return response\",\n \"def authenticate():\\n\\n return Response(\\n 'Could not verify your access level for that URL.\\\\n'\\n 'You have to login with proper credentials', 401,\\n get_auth_headers())\",\n \"def test_unauthorized_exception(exception_app):\\n request, response = exception_app.test_client.get('/401')\\n assert response.status == 401\\n\\n request, response = exception_app.test_client.get('/401/basic')\\n assert response.status == 401\\n assert response.headers.get('WWW-Authenticate') is not None\\n assert response.headers.get('WWW-Authenticate') == \\\"Basic realm='Sanic'\\\"\\n\\n request, response = exception_app.test_client.get('/401/digest')\\n assert response.status == 401\\n\\n auth_header = response.headers.get('WWW-Authenticate')\\n assert auth_header is not None\\n assert auth_header.startswith('Digest')\\n assert \\\"qop='auth, auth-int'\\\" in auth_header\\n assert \\\"algorithm='MD5'\\\" in auth_header\\n assert \\\"nonce='abcdef'\\\" in auth_header\\n assert \\\"opaque='zyxwvu'\\\" in auth_header\\n\\n request, response = exception_app.test_client.get('/401/bearer')\\n assert response.status == 401\\n assert response.headers.get('WWW-Authenticate') == \\\"Bearer\\\"\",\n \"def display_401(error):\\n return render_template('/error401.html'), 401\",\n \"def test_unauthorized(self):\\n self._error_test(fitbit_exceptions.HTTPUnauthorized)\",\n \"def basic_auth(user=\\\"user\\\", passwd=\\\"passwd\\\"):\\n\\n if not check_basic_auth(user, passwd):\\n return status_code(401)\\n\\n return jsonify(authenticated=True, user=user)\",\n \"def test_unauthenticated_request(self):\\n url = self.get_url(self.active_user.id)\\n response = self.client.get(url)\\n\\n expected_status_code = 401\\n self.assertEqual(response.status_code, expected_status_code)\",\n \"def basic_http_auth(f):\\n def wrap(request, *args, **kwargs):\\n if request.META.get('HTTP_AUTHORIZATION', False):\\n authtype, auth = request.META['HTTP_AUTHORIZATION'].split(' ')\\n auth = base64.b64decode(auth)\\n username, password = auth.split(':')\\n user = authenticate(username=username, password=password)\\n if user is not None:\\n if user.is_active:\\n login(request, user)\\n return f(request, *args, **kwargs)\\n else:\\n r = HttpResponse(\\\"Auth Required\\\", status = 401)\\n r['WWW-Authenticate'] = 'Basic realm=\\\"ThatPanda DDNS\\\"'\\n return r\\n r = HttpResponse(\\\"Auth Required\\\", status = 401)\\n r['WWW-Authenticate'] = 'Basic realm=\\\"ThatPanda DDNS\\\"'\\n return r\\n \\n return wrap\",\n \"def auth_error():\\n return unauthorized('Invalid credentials')\",\n \"def require_http_auth(request):\\n\\n if http_auth_allowed(request) and not request.user.is_authenticated:\\n site = get_current_site(request)\\n response = HttpResponse(status=401)\\n response['WWW-Authenticate'] = (\\n 'Basic realm=\\\"{}\\\", charset=\\\"UTF-8\\\"'.format(site.name)\\n )\\n # Check whether the client supports cookies.\\n response.set_cookie('testcookie', '1', secure=(not settings.DEBUG),\\n httponly=True, samesite='Lax')\\n return response\\n else:\\n raise PermissionDenied()\",\n \"def response_401(description=None):\\n resp_def = dict(util.RESPONSE_404)\\n if description is not None:\\n resp_def['description'] = description\\n\\n return response(401, resp_def)\",\n \"def http_basic_auth():\\n users = ['administrator', 'admin']\\n passwords = ['administrator', 'admin']\\n protectedResource = 'http://localhost/secured_path'\\n foundPass = False\\n for user in users:\\n if foundPass:\\n break\\n for passwd in passwords:\\n encoded = base64.encodestring(user + ':' + passwd)\\n response = requests.get(protectedResource, auth=(user, passwd))\\n if response.status_code != 401:\\n print('User Found!')\\n print('User: %s, Pass: %s' % (user, passwd))\\n foundPass = True\\n break\",\n \"def assertHttpUnauthorized(self, resp):\\r\\n return self.assertEqual(resp.status_code, 401)\",\n \"def basic_auth_required(view_func):\\n # http://djangosnippets.org/snippets/448/\\n def _auth(request, *args, **kwargs):\\n if 'HTTP_AUTHORIZATION' in request.META:\\n auth = request.META['HTTP_AUTHORIZATION'].split()\\n if len(auth) == 2:\\n if auth[0].lower() == \\\"basic\\\":\\n uname, passwd = base64.b64decode(auth[1]).split(':')\\n user = authenticate(username=uname, password=passwd)\\n if user is not None:\\n if user.is_active:\\n return view_func(request, *args, **kwargs)\\n response = HttpResponse(\\\"Authorization Required\\\", status=401)\\n response['WWW-Authenticate'] = 'Basic realm=\\\"Secure Area\\\"'\\n return response\\n return _auth\",\n \"def http_basic_auth(func):\\r\\n\\t@wraps(func)\\r\\n\\tdef _decorator(request, *args, **kwargs):\\r\\n\\r\\n\\t\\tif request.META.has_key('HTTP_AUTHORIZATION'):\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tauthmeth, auth = request.META['HTTP_AUTHORIZATION'].split(' ', 1)\\r\\n\\t\\t\\t\\tif authmeth.lower() == 'basic':\\r\\n\\t\\t\\t\\t\\tauth = auth.strip().decode('base64')\\r\\n\\t\\t\\t\\t\\tusername, password = auth.split(':', 1)\\r\\n\\t\\t\\t\\t\\tuser = authenticate(username=username, password=password)\\r\\n\\r\\n\\t\\t\\t\\t\\tif user:\\r\\n\\r\\n\\t\\t\\t\\t\\t\\tlogin(request, user)\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\r\\n\\t\\t\\t\\t\\t\\treturn HttpResponseForbidden()\\r\\n\\r\\n\\t\\t\\texcept ValueError:\\r\\n\\t\\t\\t\\t# Bad HTTP_AUTHORIZATION header\\r\\n\\t\\t\\t\\treturn HttpResponseForbidden()\\r\\n\\t\\t\\t\\t\\r\\n\\t\\treturn func(request, *args, **kwargs)\\r\\n\\treturn _decorator\",\n \"def unauthorized(self, message=None):\\n return self.send_message(message, status=401)\",\n \"def basic_auth_required(fn):\\n @wraps(fn)\\n def _wrapper(request, *args, **kwargs):\\n authentication = request.headers.get('Authentication', None)\\n\\n if authentication:\\n if not authentication.startswith(\\\"Basic \\\"):\\n request.response.status = 401\\n\\n return {\\n 'error': \\\"Authentication failed!\\\"\\n }\\n\\n auth_data = authentication[6:]\\n\\n try:\\n username, password = base64.urlsafe_b64decode(auth_data).decode(\\\"UTF8\\\").split(\\\":\\\")\\n\\n user = request.dbsession.query(User).filter(\\n User.email == username\\n ).one()\\n\\n if user.is_password(password.encode(\\\"UTF8\\\")):\\n return fn(request, *args, **kwargs)\\n except (ValueError, NoResultFound):\\n pass\\n\\n request.response.status = 401\\n\\n return {\\n 'error': 'Authentication failed!'\\n }\\n\\n return _wrapper\",\n \"def test_user_get_failure_using_basic_auth(self):\\n # setup\\n user = self.generate_username_password()\\n resp = self.create_user(user)\\n resp_body = resp.json()\\n try:\\n assert resp.status_code == 201\\n assert resp.headers[\\\"Content-Type\\\"] == \\\"application/json; charset=utf-8\\\"\\n assert resp_body[\\\"username\\\"] == user[\\\"userName\\\"]\\n assert resp_body[\\\"userID\\\"] != \\\"\\\"\\n except AssertionError:\\n raise\\n finally:\\n self.pprint_request(resp.request)\\n self.pprint_response(resp)\\n uuid_ = str(uuid.uuid4())\\n\\n # test\\n resp2 = self.get_user_basic_auth(uuid_, user)\\n resp_body2 = resp2.json()\\n assert resp2.status_code == 401\\n assert resp2.headers[\\\"Content-Type\\\"] == \\\"application/json; charset=utf-8\\\"\\n assert resp_body2[\\\"code\\\"] == \\\"1207\\\"\\n assert resp_body2[\\\"message\\\"] == \\\"User not found!\\\"\\n\\n # teardown:\\n resp3 = self.delete_user_basic_auth(resp_body[\\\"userID\\\"], user)\\n try:\\n assert resp3.status_code == 204\\n except AssertionError:\\n raise\\n finally:\\n self.pprint_request(resp3.request)\\n self.pprint_response(resp3)\",\n \"def test_unhappy_path_unauthorized(self):\\n\\n response = self.client.get(self.url)\\n expected_data = {\\\"detail\\\": \\\"Authentication credentials were not provided.\\\"}\\n\\n self.assertDictEqual(response.data, expected_data)\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_no_auth(self):\\n url = 'https://domain.com/project/objects.inv'\\n expected = 'https://domain.com/project/objects.inv'\\n actual = _strip_basic_auth(url)\\n assert expected == actual\",\n \"def test_unauthorized_access(flask_test_client, http_method, endpoint):\\n response = flask_test_client.open(\\n method=http_method, path=endpoint, headers=get_headers()\\n )\\n assert response.status == \\\"401 UNAUTHORIZED\\\"\\n assert response.content_type == \\\"application/json\\\"\\n assert response.json[\\\"message\\\"] == \\\"Access token is invalid or expired.\\\"\",\n \"def test_get_unauthenticated(self):\\n del self.client.request_kwargs['auth']\\n self.verify_get_response(self.client.get(STATUS_PATH))\",\n \"def get_authenticate_header(self):\\n return f'Basic realm=\\\"{self.www_authenticate_realm}\\\"'\",\n \"def test_retrieve_user_unauthorized(self):\\r\\n res = self.client.get(ME_URL)\\r\\n\\r\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def basic_header(self):\\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\\\n', '')\\n return { \\n #\\\"Authorization\\\" : \\\"Basic %s\\\" % self.auth, \\n \\\"Content-type\\\": \\\"text/plain\\\" }\",\n \"def test_retrieve_unauthorized_user(self):\\n\\n response = self.client.get(URL_ME)\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_retrieve_user_unauthorized(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_retrieve_user_unauthorized(self):\\n res = self.client.get(ME_URL)\\n\\n self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def challenge_view(self, request):\\n headerlist = [(\\\"Content-Type\\\", \\\"text/plain\\\")]\\n headerlist.extend(self._get_challenge_headers(request))\\n return Response(\\\"Unauthorized\\\", status=\\\"401 Unauthorized\\\",\\n headerlist=headerlist)\",\n \"def denied_response(self, req):\\n if req.remote_user:\\n return HTTPForbidden(request=req)\\n else:\\n return HTTPUnauthorized(request=req)\",\n \"def test_401_unauthorized(app, client):\\n\\n @app.route(\\\"/401\\\")\\n def unauthorized():\\n abort(401)\\n\\n response = client.get(\\\"/401\\\")\\n assert response.status_code == 401\\n assert \\\"401 Unauthorized\\\" in str(response.data)\",\n \"def test_status_unauthenticated(self):\\n rv = self.client.post('/statusize/', data={'message': 'foo'},\\n follow_redirects=True)\\n eq_(rv.status_code, 403)\",\n \"def test_call_unauthenticated(self):\\n\\n with Client('username', 'password') as client:\\n self.setSessionResponse(401)\\n with self.assertRaises(APIError):\\n data = client.call(**self.build_parameters)\",\n \"def test_unhappy_path_unauthorized(self):\\n\\n response = self.client.post(self.url)\\n expected_data = {\\\"detail\\\": \\\"Authentication credentials were not provided.\\\"}\\n\\n self.assertDictEqual(response.data, expected_data)\\n self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)\",\n \"def test_retrieve_users_unauthorized(setup_client):\\n client = setup_client\\n res = client.get(ME_URL)\\n assert res.status_code == status.HTTP_401_UNAUTHORIZED\",\n \"def __call__(self, resp):\\r\\n if not self.auth_token:\\r\\n self.auth()\\r\\n resp.register_hook('response', self.handle_error)\\r\\n resp.headers['X-Auth-Token'] = self.auth_token\\r\\n return resp\",\n \"def _handle_401(self, response, **kwargs):\\n if not response.status_code == 401 and not response.status_code == 403:\\n return response\\n\\n # Free the original connection\\n response.content\\n response.close()\\n\\n # copy the request to resend\\n newreq = response.request.copy()\\n\\n self._access_token = None\\n self._logger.debug(\\\"_handle_401, cleared _access_token, retrying with new token\\\")\\n\\n newreq.headers[\\\"Authorization\\\"] = self._get_auth_value()\\n\\n _response = response.connection.send(newreq, **kwargs)\\n _response.history.append(response)\\n _response.request = newreq\\n\\n return _response\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8093736","0.80926424","0.7958403","0.7852648","0.7824419","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.7810746","0.776624","0.7754693","0.774767","0.774767","0.774767","0.774767","0.774767","0.774767","0.774767","0.774767","0.771945","0.7667712","0.7664151","0.76493174","0.76140213","0.7613103","0.7591923","0.74499536","0.74152935","0.7389793","0.73102117","0.72994584","0.70069116","0.6989699","0.6985984","0.69489896","0.69403917","0.69043815","0.6843354","0.6842244","0.6816229","0.67638755","0.6701405","0.6700694","0.6666637","0.66607744","0.66428447","0.66164446","0.66088307","0.6551196","0.6548378","0.64217687","0.6410419","0.6393135","0.6381609","0.6327866","0.629943","0.6287014","0.62427884","0.6242011","0.6230159","0.62130815","0.6168915","0.61408406","0.6088527","0.60420007","0.6041198","0.6029272","0.6020013","0.601565","0.5991479","0.59679294","0.5945756","0.59284157","0.59284157","0.5922706","0.59027636","0.58849794","0.58700204","0.58687663","0.5866924","0.58479726","0.58452344","0.5829068"],"string":"[\n \"0.8093736\",\n \"0.80926424\",\n \"0.7958403\",\n \"0.7852648\",\n \"0.7824419\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.7810746\",\n \"0.776624\",\n \"0.7754693\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.774767\",\n \"0.771945\",\n \"0.7667712\",\n \"0.7664151\",\n \"0.76493174\",\n \"0.76140213\",\n \"0.7613103\",\n \"0.7591923\",\n \"0.74499536\",\n \"0.74152935\",\n \"0.7389793\",\n \"0.73102117\",\n \"0.72994584\",\n \"0.70069116\",\n \"0.6989699\",\n \"0.6985984\",\n \"0.69489896\",\n \"0.69403917\",\n \"0.69043815\",\n \"0.6843354\",\n \"0.6842244\",\n \"0.6816229\",\n \"0.67638755\",\n \"0.6701405\",\n \"0.6700694\",\n \"0.6666637\",\n \"0.66607744\",\n \"0.66428447\",\n \"0.66164446\",\n \"0.66088307\",\n \"0.6551196\",\n \"0.6548378\",\n \"0.64217687\",\n \"0.6410419\",\n \"0.6393135\",\n \"0.6381609\",\n \"0.6327866\",\n \"0.629943\",\n \"0.6287014\",\n \"0.62427884\",\n \"0.6242011\",\n \"0.6230159\",\n \"0.62130815\",\n \"0.6168915\",\n \"0.61408406\",\n \"0.6088527\",\n \"0.60420007\",\n \"0.6041198\",\n \"0.6029272\",\n \"0.6020013\",\n \"0.601565\",\n \"0.5991479\",\n \"0.59679294\",\n \"0.5945756\",\n \"0.59284157\",\n \"0.59284157\",\n \"0.5922706\",\n \"0.59027636\",\n \"0.58849794\",\n \"0.58700204\",\n \"0.58687663\",\n \"0.5866924\",\n \"0.58479726\",\n \"0.58452344\",\n \"0.5829068\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7843114"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":74286,"cells":{"query":{"kind":"string","value":"Moler class of Unix command mount."},"document":{"kind":"string","value":"def __init__(self, connection, options=None, device=None, directory=None, prompt=None, newline_chars=None,\n runner=None):\n super(Mount, self).__init__(connection=connection, prompt=prompt, newline_chars=newline_chars, runner=runner)\n\n # Parameters defined by calling the command\n self.options = options\n self.device = device\n self.directory = directory\n\n # Internal variables\n self.current_ret['RESULT'] = list()\n self.current_ret['ON'] = dict()"},"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 mount(self):\n return self._mount","def mount(self, mount):\n assert mount in (ComponentBase.MOUNTS)\n if mount==self.MOUNT_HYB:\n raise Exception(\"Unsupported mount.\")\n self._mount = mount\n self._check_mount()","def testMountCommand(self):\n with self.assertRaises(FilePathException):\n File().getGirderMountFilePath(self.file)\n self.assertIsNone(File().getGirderMountFilePath(self.file, validate=False))\n mountPath = tempfile.mkdtemp()\n subprocess.check_call(['girder', 'mount', mountPath, '-d', os.environ['GIRDER_TEST_DB']])\n endTime = time.time() + 10 # maximum time to wait\n while time.time() < endTime:\n if os.path.exists(os.path.join(mountPath, 'user')):\n break\n time.sleep(0.1)\n filePath = os.path.join(mountPath, 'user', 'admin', 'Public', 'test', 'file1a.txt')\n self.assertEqual(File().getGirderMountFilePath(self.file), filePath)\n self.assertNotEqual(File().getGirderMountFilePath(self.file),\n File().getLocalFilePath(self.file))\n self.assertTrue(os.path.exists(filePath))\n self.assertEqual(open(filePath).read().strip(), 'File 1A')\n subprocess.check_call(['girder', 'mount', mountPath, '-u'])\n endTime = time.time() + 10 # maximum time to wait\n while time.time() < endTime:\n if not os.path.exists(os.path.join(mountPath, 'user')):\n break\n time.sleep(0.1)\n self.assertFalse(os.path.exists(filePath))\n os.rmdir(mountPath)\n with self.assertRaises(FilePathException):\n File().getGirderMountFilePath(self.file)","def __init__(self, mount_point):\n self.mount = mount_point","def _mount(source, target):\n # type: (str, str) -> None\n\n mount_options = ['mount', source, target]\n\n process = subprocess.Popen(mount_options, stderr=subprocess.PIPE)\n out, err = process.communicate()\n if process.returncode > 0:\n raise OSError(err)","def path_mounts(self) -> Path:\n return self.path_supervisor / MOUNTS_FOLDER","def mount(fstype, export, vol_name, mountpoint, instance, options=None):\n with __manager__.get_state() as mount_state:\n mount_state.mount(fstype, export, vol_name, mountpoint, instance,\n options)","def _do_mount(self, cmd, ensure):\n try:\n self._execute(*cmd, run_as_root=True)\n except exception.ProcessExecutionError as exc:\n if ensure and 'already mounted' in exc.stderr:\n LOG.warn(_LW(\"%s is already mounted\"),\n self.gluster_manager.export)\n else:\n raise exception.GlusterfsException(\n 'Unable to mount Gluster volume'\n )","def _get_mount(self):\n if not self._mount.endswith(os.path.sep):\n return \"%s%s\" % (self._mount, os.path.sep)\n else:\n return self._mount","def __init__(self, win_server, share_folder, mount_point, user, password):\n \n share_folder = share_folder.replace(\"/\", \"\\\\\")\n network_folder = r'//%s/%s' %(win_server, share_folder)\n\n print('Mount_point - %s' %(mount_point))\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\n self.mount_point = mount_point\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\n self.success = []\n self.error = []\n\n mount_cmd = \"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\"\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\n mount_point=mount_point,\n user=user,\n password=password)\n self.umount_cmd = \"umount {mount_point}\".format(mount_point=mount_point)","def mount(self, dev, path, mount_options):\n # if directory is not a mount point, mount it\n if not os.path.ismount(path):\n # check to see if dev is LVM. If so, activate it's associated volume group\n vg = self.get_vg(dev)\n if len(vg) > 0:\n Helper._runOsCommand(\"sudo /sbin/pvscan && sudo /sbin/vgscan && sudo /sbin/lvscan && sudo /sbin/vgchange -ay %s\" % vg, self.tracer)\n # check / create mount point and mount device\n self._checkAndCreatePath(path)\n self._mount(dev, path, mount_options)\n else:\n self.tracer.info(\"device %s is already mounted to %s\" % (dev, path))","def mount(self, path=None, vm=None):\n os.system(f\"multipass mount {path} {vm}\")\n dict_result = self._get_mount_status(vm=vm)\n return dict_result","def do_mount(devpath, mountpoint, fstype):\n try:\n if check_already_mounted(devpath, mountpoint):\n return\n\n mounter = Mounter()\n mounter.mount(devpath, mountpoint, fstype)\n except exceptions.MountException:\n try:\n mounter.make_filesystem(devpath, fstype)\n mounter.mount(devpath, mountpoint, fstype)\n except exceptions.FuxiException as e:\n with excutils.save_and_reraise_exception():\n LOG.error(str(e))","def mount(githubdir, mntpoint, verbose=True, foreground=True):\n fuse.FUSE(GithubOperations(root=githubdir),\n mntpoint, nothreads=True, foreground=foreground)","def test_mountfile(self):\n quote = b\"\"\"If you wish to make an apple pie from scratch, you must first invent the universe.\"\"\"\n mem_fs = MemoryFS()\n mem_fs.makedir('foo')\n mem_fs.setcontents('foo/bar.txt', quote)\n foo_dir = mem_fs.opendir('foo')\n\n mount_fs = MountFS()\n mount_fs.mountfile('bar.txt', foo_dir.open, foo_dir.getinfo)\n\n self.assertTrue(mount_fs.isdir('/'))\n self.assertTrue(mount_fs.isdir('./'))\n self.assertTrue(mount_fs.isdir(''))\n\n # Check we can see the mounted file in the dir list\n self.assertEqual(mount_fs.listdir(), [\"bar.txt\"])\n self.assertTrue(not mount_fs.exists('nobodyhere.txt'))\n self.assertTrue(mount_fs.exists('bar.txt'))\n self.assertTrue(mount_fs.isfile('bar.txt'))\n self.assertTrue(not mount_fs.isdir('bar.txt'))\n\n # Check open and getinfo callables\n self.assertEqual(mount_fs.getcontents('bar.txt'), quote)\n self.assertEqual(mount_fs.getsize('bar.txt'), len(quote))\n\n # Check changes are written back\n mem_fs.setcontents('foo/bar.txt', 'baz')\n self.assertEqual(mount_fs.getcontents('bar.txt'), b'baz')\n self.assertEqual(mount_fs.getsize('bar.txt'), len('baz'))\n\n # Check changes are written to the original fs\n self.assertEqual(mem_fs.getcontents('foo/bar.txt'), b'baz')\n self.assertEqual(mem_fs.getsize('foo/bar.txt'), len('baz'))\n\n # Check unmount\n self.assertTrue(mount_fs.unmount(\"bar.txt\"))\n self.assertEqual(mount_fs.listdir(), [])\n self.assertTrue(not mount_fs.exists('bar.txt'))\n\n # Check unount a second time is a null op, and returns False\n self.assertFalse(mount_fs.unmount(\"bar.txt\"))","def testMakeMountCommands(self):\n self.maxDiff = None\n container_obj = self.explorer_object.GetContainer(\n '8e8b7f23eb7cbd4dfe7e91646ddd0e0f524218e25d50113559f078dfb2690206')\n commands = container_obj.storage_object.MakeMountCommands(\n container_obj, '/mnt')\n commands = [' '.join(cmd) for cmd in commands]\n expected_commands = [(\n '/bin/mount -t overlay overlay -o ro,lowerdir='\n 'test_data/docker/overlay2/'\n '92fd3b3e7d6101bb701743c9518c45b0d036b898c8a3d7cae84e1a06e6829b53/diff:'\n 'test_data/docker/overlay2/l/OTFSLJCXWCECIG6FVNGRTWUZ7D:'\n 'test_data/docker/overlay2/l/CH5A7XWSBP2DUPV7V47B7DOOGY /mnt')]\n self.assertEqual(expected_commands, commands)","def testMakeMountCommands(self):\n container_obj = self.explorer_object.GetContainer(\n '5dc287aa80b460652a5584e80a5c8c1233b0c0691972d75424cf5250b917600a')\n commands = container_obj.storage_object.MakeMountCommands(\n container_obj, '/mnt')\n commands = [' '.join(cmd) for cmd in commands]\n expected_commands = [(\n '/bin/mount -t overlay overlay -o ro,lowerdir='\n 'test_data/docker/overlay/974e2b994f9db74e1ddd6fc546843bc65920e786612'\n 'a388f25685acf84b3fed1/upper:'\n 'test_data/docker/overlay/a94d714512251b0d8a9bfaacb832e0c6cb70f71cb71'\n '976cca7a528a429336aae/root '\n '/mnt')]\n self.assertEqual(expected_commands, commands)","def Mount(self, mount_point, mount_options_by_format=\"\"):\n fstab = self.fstab\n if fstab:\n p = fstab[mount_point]\n mount_dict = {}\n if mount_options_by_format is not None:\n for option in mount_options_by_format.split(\"|\"):\n if \"=\" in option:\n key, value = option.split(\"=\", 1)\n mount_dict[key] = value\n mount_flags = mount_dict.get(p.fs_type, \"\")\n if p.context is not None:\n mount_flags = p.context + (\",\" + mount_flags if mount_flags else \"\")\n self.script.append('mount(\"%s\", \"%s\", %s, \"%s\", \"%s\");' % (\n p.fs_type, common.PARTITION_TYPES[p.fs_type],\n self._GetSlotSuffixDeviceForEntry(p),\n p.mount_point, mount_flags))\n self.mounts.add(p.mount_point)","def cgroup_mount_option(command: Callable[..., None]) -> Callable[..., None]:\n function = click.option(\n '--mount-sys-fs-cgroup/--no-mount-sys-fs-cgroup',\n default=True,\n show_default=True,\n help=(\n 'Mounting ``/sys/fs/cgroup`` from the host is required to run '\n 'applications which require ``cgroup`` isolation. '\n 'Choose to not mount ``/sys/fs/cgroup`` if it is not available on '\n 'the host.'\n ),\n )(command) # type: Callable[..., None]\n return function","def testMakeMountCommands(self):\n self.maxDiff = None\n container_obj = self.explorer_object.GetContainer(\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\n commands = container_obj.storage_object.MakeMountCommands(\n container_obj, '/mnt')\n commands = [' '.join(x) for x in commands]\n expected_commands = [\n (\n '/bin/mount -t aufs -o ro,br=test_data/docker/aufs/diff/test_data/'\n 'docker/aufs/diff/'\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\n '=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\n '-init=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'd1c54c46d331de21587a16397e8bd95bdbb1015e1a04797c76de128107da83ae'\n '=ro+wh none /mnt'),\n (\n '/bin/mount --bind -o ro test_data/docker/volumes/'\n '28297de547b5473a9aff90aaab45ed108ebf019981b40c3c35c226f54c13ac0d/'\n '_data /mnt/var/jenkins_home')\n ]\n self.assertEqual(expected_commands, commands)","def mount(\n self, path, mode, *, persistent=True, text_only=False\n ): # pylint: disable=arguments-differ\n if mode not in (\"r\", \"w\"):\n raise ValueError('Mode must be \"r\" or \"w\"')\n if mode == \"r\":\n hcell = self._get_hcell2()\n hcell.pop(\"checksum\", None)\n super().mount(path, mode, \"cell\", persistent=persistent)\n if text_only:\n hcell = self._get_hcell2()\n hcell[\"mount\"][\"directory_text_only\"] = True\n return self","def cli():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--mountpoint\", dest=\"mountpoint\", help=\"Mount point\")\n parser.add_argument(\"--githubdir\", dest=\"githubdir\", help=\"Github caching directory.\")\n parser.add_argument(\"--foreground\", dest=\"foreground\", action=\"store_true\", help=\"Show in foreground.\")\n\n args = parser.parse_args()\n mount(args.githubdir, mntpoint=args.mountpoint, foreground=args.foreground)","def _mount (self,blockDevice,mountingPoint,blockDeviceReadahead,timer):\n\n # pre-mount command\n preMountCmd = self._activeCommandsConfig.preMount\n preMountCmdExtras = self._activeCommandsConfig.preMountExtras\n preMountCmdString = self.__joinCmdStringWithExtras(preMountCmd,preMountCmdExtras)\n if (preMountCmdString != \"\"):\n stdout,stderr,rc = self._runCommand(preMountCmdString,timer)\n if (rc != 0):\n self._log(\"pre-mount-cmd-fail\").error(\"pre-mount command '%s' failed! stderr=%s\",preMountCmdString,stderr)\n return ReturnCodes.kGeneralError\n\n # mount command\n mountCmd = self._activeCommandsConfig.mount\n mountCmdExtras = self._activeCommandsConfig.mountExtras\n mountCmdString = mountCmd%{self.MOUNTING_POINT_COMMAND_ELEMENT:mountingPoint,self.BLOCK_DEVICE_COMMAND_ELEMENT:blockDevice}\n mountCmdString = self.__joinCmdStringWithExtras(mountCmdString,mountCmdExtras)\n stdout,stderr,rc = self._runCommand(mountCmdString,timer)\n if (rc != 0):\n self._log(\"mount-cmd-fail\").error(\"mount command '%s' failed! stderr=%s\",mountCmdString,stderr)\n # TODO: consider insertion os pre and post commands cancelation commands - since we don't know what they do...\n return ReturnCodes.kGeneralError\n\n # post-mount command\n postMountCmd = self._activeCommandsConfig.preMount\n postMountCmdExtras = self._activeCommandsConfig.preMountExtras\n postMountCmdString = postMountCmd%{self.BLOCK_DEVICE_COMMAND_ELEMENT:blockDevice,self.SECTORS_COMMAND_ELEMENT:blockDeviceReadahead}\n postMountCmdString = self.__joinCmdStringWithExtras(postMountCmdString,postMountCmdExtras)\n if (postMountCmdString != \"\"):\n stdout,stderr,rc = self._runCommand(postMountCmdString,timer)\n if (rc != 0):\n self._log(\"post-mount-cmd-fail\").error(\"post-mount command '%s' failed! stderr=%s\",postMountCmdString,stderr)\n return ReturnCodes.kGeneralError\n\n # full success\n self._log(\"mount-sequence-success\").debug2(\"full mount sequence was successful!\")\n return ReturnCodes.kOk","def mount(self, pathname):\n \n # Make sure we don't try to mount something twice.\n if pathname in self.mounts:\n raise ProcessorError(\"%s is already mounted\" % pathname)\n \n # Call hdiutil.\n try:\n p = subprocess.Popen((\"/usr/bin/hdiutil\",\n \"attach\",\n \"-plist\",\n \"-mountrandom\", \"/private/tmp\",\n \"-nobrowse\",\n pathname),\n stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n (out, err) = p.communicate()\n except OSError as e:\n raise ProcessorError(\"hdiutil execution failed with error code %d: %s\" % (\n e.errno, e.strerror))\n if p.returncode != 0:\n raise ProcessorError(\"mounting %s failed: %s\" % (pathname, err))\n \n # Read output plist.\n output = plistlib.readPlistFromString(out)\n \n # Find mount point.\n for part in output[\"system-entities\"]:\n if \"mount-point\" in part:\n # Add to mount list.\n self.mounts[pathname] = part[\"mount-point\"]\n self.output(\"Mounted disk image %s\" % (pathname))\n return self.mounts[pathname]","def mount(\n dev,\n fstype,\n options,\n ):\n # sanity check: none of the arguments are None\n if dev is None:\n raise ValueError('dev may not be None')\n if fstype is None:\n raise ValueError('fstype may not be None')\n\n # pick best-of-breed mount options based on fs type\n if options is None:\n options = MOUNT_OPTIONS.get(fstype, '')\n\n # mount\n path = tempfile.mkdtemp(\n prefix='mnt.',\n dir=STATEDIR + '/tmp',\n )\n try:\n LOG.debug('Mounting %s on %s with options %s', dev, path, options)\n command_check_call(\n [\n 'mount',\n '-t', fstype,\n '-o', options,\n '--',\n dev,\n path,\n ],\n )\n except subprocess.CalledProcessError as e:\n try:\n os.rmdir(path)\n except (OSError, IOError):\n pass\n raise MountError(e)\n\n return path","def testMakeMountCommands(self):\n container_obj = self.explorer_object.GetContainer(\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c')\n commands = container_obj.storage_object.MakeMountCommands(\n container_obj, '/mnt')\n commands = [' '.join(x) for x in commands]\n expected_commands = [\n (\n '/bin/mount -t aufs -o ro,br=test_data/'\n 'docker/aufs/diff/'\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c'\n '=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c'\n '-init=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n '1cee97b18f87b5fa91633db35f587e2c65c093facfa2cbbe83d5ebe06e1d9125'\n '=ro+wh none /mnt'),\n (\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\n 'df557f39d413a1408f5c28d8aab2892f927237ec22e903ef04b331305130ab38'\n '=ro+wh none /mnt')\n ]\n self.assertEqual(expected_commands, commands)","def mounts(self) -> list[str]:\n _args: list[Arg] = []\n _ctx = self._select(\"mounts\", _args)\n return _ctx.execute_sync(list[str])","def get_mount(self, pipette_id: str) -> MountType:\n return self.get(pipette_id).mount","def active_mountpoint(mount_point):\n execute('mount', mount_point, sudo=True)\n yield\n execute('umount', mount_point, sudo=True)","def get_mount_info(devname, label=None):\n mount_point = get_mount_target(devname, label)\n mounts = check_output('mount | grep \" %s \" || :' % mount_point, shell=True)\n if mounts:\n return Munch(zip(('device', 'mount_point', 'type', 'options'),\n MOUNTS_RE.match(mounts.decode()).groups()))","def mount_path(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"mount_path\")","def cat_cmd(server, client, line):\n if len(line.split(' ')) > 1 and line.split(' ')[1] == \"/proc/mounts\":\n path = os.path.dirname(os.path.realpath(__file__))\n path = path[:-7] # shaves off /engine\n with open(\"{}/fakefiles/proc%mounts\".format(path), \"r\") as f:\n response = f.read()\n client.exit_status = 0\n else:\n response = client.run_in_container(line)\n client.send(response)","def mount(self, name, path):\n if not os.path.exists(path):\n raise OSError('no mount path: '+ path)\n if name.startswith('/'):\n name = name[1:]\n self._top_paths[name] = path","def actually_mount(self, client):\n try:\n getattr(client, self.mount_fun)(self.backend,\n mount_point=self.path)\n except hvac.exceptions.InvalidRequest as exception:\n match = re.match('existing mount at (?P<path>.+)', str(exception))\n if match:\n e_msg = \"%s has a mountpoint conflict with %s\" % \\\n (self.path, match.group('path'))\n raise aomi.exceptions.VaultConstraint(e_msg)\n else:\n raise","def mount(f, mountpoint=DMG_MOUNT, read_only=False, dry_run=ARGS.dry_run):\n result = None\n cmd = ['/usr/bin/hdiutil', 'attach', '-mountpoint', str(mountpoint), '-plist', f]\n\n # Insert read only option in the correct spot\n if read_only:\n cmd.insert(2, '-readonly')\n\n if not dry_run:\n _p = subprocess.run(cmd, capture_output=True)\n LOG.debug('{cmd} ({returncode})'.format(cmd=' '.join([str(x) for x in cmd]), returncode=_p.returncode))\n\n if _p.returncode == 0:\n _entities = plist.read_string(_p.stdout).get('system-entities')\n\n if _entities:\n result = mount_device(_entities)\n LOG.warning('Mounted {dmg} to {mountpoint}'.format(dmg=f, mountpoint=mountpoint))\n else:\n LOG.info(_p.stderr.decode('utf-8').strip())\n else:\n LOG.warning('Mount {dmg} to {mountpoint}'.format(dmg=f, mountpoint=mountpoint))\n\n return result","def mounted(\n name,\n device,\n fstype,\n mkmnt=False,\n opts=\"defaults\",\n dump=0,\n pass_num=0,\n config=\"/etc/fstab\",\n persist=True,\n mount=True,\n user=None,\n match_on=\"auto\",\n device_name_regex=None,\n extra_mount_invisible_options=None,\n extra_mount_invisible_keys=None,\n extra_mount_ignore_fs_keys=None,\n extra_mount_translate_options=None,\n hidden_opts=None,\n bind_mount_copy_active_opts=True,\n **kwargs\n):\n ret = {\"name\": name, \"changes\": {}, \"result\": True, \"comment\": \"\"}\n\n update_mount_cache = False\n\n if not name:\n ret[\"result\"] = False\n ret[\"comment\"] = \"Must provide name to mount.mounted\"\n return ret\n\n if not device:\n ret[\"result\"] = False\n ret[\"comment\"] = \"Must provide device to mount.mounted\"\n return ret\n\n if not fstype:\n ret[\"result\"] = False\n ret[\"comment\"] = \"Must provide fstype to mount.mounted\"\n return ret\n\n if device_name_regex is None:\n device_name_regex = []\n\n # Defaults is not a valid option on Mac OS\n if __grains__[\"os\"] in [\"MacOS\", \"Darwin\"] and opts == \"defaults\":\n opts = \"noowners\"\n\n # Defaults is not a valid option on AIX\n if __grains__[\"os\"] in [\"AIX\"]:\n if opts == \"defaults\":\n opts = \"\"\n\n # Make sure that opts is correct, it can be a list or a comma delimited\n # string\n if isinstance(opts, str):\n opts = opts.split(\",\")\n\n if isinstance(hidden_opts, str):\n hidden_opts = hidden_opts.split(\",\")\n\n # remove possible trailing slash\n if not name == \"/\":\n name = name.rstrip(\"/\")\n\n device_list = []\n # Get the active data\n active = __salt__[\"mount.active\"](extended=True)\n real_name = os.path.realpath(name)\n # real_name for comparisons to the active mount list\n comp_real_name = real_name.replace(\" \", \"\\\\040\")\n if device.startswith(\"/\"):\n if \"bind\" in opts and comp_real_name in active:\n _device = device.replace(\" \", \"\\\\040\")\n if active[comp_real_name][\"device\"].startswith(\"/\"):\n # Find the device that the bind really points at.\n while True:\n if _device in active:\n _real_device = active[_device][\"device\"]\n if bind_mount_copy_active_opts:\n opts = sorted(\n set(\n opts\n + active[_device][\"opts\"]\n + active[_device][\"superopts\"]\n )\n )\n active[comp_real_name][\"opts\"].append(\"bind\")\n break\n _device = os.path.dirname(_device.replace(\"\\\\040\", \" \"))\n real_device = _real_device\n else:\n # Remote file systems act differently.\n if _device in active:\n if bind_mount_copy_active_opts:\n opts = sorted(\n set(\n opts\n + active[_device][\"opts\"]\n + active[_device][\"superopts\"]\n )\n )\n active[comp_real_name][\"opts\"].append(\"bind\")\n real_device = active[comp_real_name][\"device\"]\n else:\n real_device = os.path.realpath(device)\n elif device.upper().startswith(\"UUID=\"):\n real_device = device.split(\"=\")[1].strip('\"').lower()\n elif device.upper().startswith(\"LABEL=\"):\n _label = device.split(\"=\")[1]\n cmd = \"blkid -t LABEL={}\".format(_label)\n res = __salt__[\"cmd.run_all\"](\"{}\".format(cmd))\n if res[\"retcode\"] > 0:\n ret[\"comment\"] = \"Unable to find device with label {}.\".format(_label)\n ret[\"result\"] = False\n return ret\n else:\n # output is a list of entries like this:\n # /dev/sda: LABEL=\"<label>\" UUID=\"<uuid>\" UUID_SUB=\"<uuid>\" TYPE=\"btrfs\"\n # exact list of properties varies between filesystems, but we're\n # only interested in the device in the first column\n for line in res[\"stdout\"]:\n dev_with_label = line.split(\":\")[0]\n device_list.append(dev_with_label)\n real_device = device_list[0]\n else:\n real_device = device\n\n # LVS devices have 2 names under /dev:\n # /dev/mapper/vg--name-lv--name and /dev/vg-name/lv-name\n # No matter what name is used for mounting,\n # mount always displays the device as /dev/mapper/vg--name-lv--name\n # Note the double-dash escaping.\n # So, let's call that the canonical device name\n # We should normalize names of the /dev/vg-name/lv-name type to the canonical name\n lvs_match = re.match(r\"^/dev/(?P<vg_name>[^/]+)/(?P<lv_name>[^/]+$)\", device)\n if lvs_match:\n double_dash_escaped = {\n k: re.sub(r\"-\", \"--\", v) for k, v in lvs_match.groupdict().items()\n }\n mapper_device = \"/dev/mapper/{vg_name}-{lv_name}\".format(**double_dash_escaped)\n if os.path.exists(mapper_device):\n real_device = mapper_device\n\n # When included in a Salt state file, FUSE devices are prefaced by the\n # filesystem type and a hash, e.g. sshfs. In the mount list only the\n # hostname is included. So if we detect that the device is a FUSE device\n # then we remove the prefaced string so that the device in state matches\n # the device in the mount list.\n fuse_match = re.match(r\"^\\w+\\#(?P<device_name>.+)\", device)\n if fuse_match:\n if \"device_name\" in fuse_match.groupdict():\n real_device = fuse_match.group(\"device_name\")\n\n if comp_real_name in active:\n if \"superopts\" not in active[comp_real_name]:\n active[comp_real_name][\"superopts\"] = []\n if mount:\n device_list.append(active[comp_real_name][\"device\"])\n device_list.append(os.path.realpath(device_list[0]))\n alt_device = (\n active[comp_real_name][\"alt_device\"]\n if \"alt_device\" in active[comp_real_name]\n else None\n )\n uuid_device = (\n active[comp_real_name][\"device_uuid\"]\n if \"device_uuid\" in active[comp_real_name]\n else None\n )\n label_device = (\n active[comp_real_name][\"device_label\"]\n if \"device_label\" in active[comp_real_name]\n else None\n )\n if alt_device and alt_device not in device_list:\n device_list.append(alt_device)\n if uuid_device and uuid_device not in device_list:\n device_list.append(uuid_device)\n if label_device and label_device not in device_list:\n device_list.append(label_device)\n if opts:\n mount_invisible_options = [\n \"_netdev\",\n \"actimeo\",\n \"bg\",\n \"comment\",\n \"defaults\",\n \"delay_connect\",\n \"direct-io-mode\",\n \"intr\",\n \"loop\",\n \"nointr\",\n \"nobootwait\",\n \"nofail\",\n \"password\",\n \"reconnect\",\n \"retry\",\n \"soft\",\n \"auto\",\n \"users\",\n \"bind\",\n \"nonempty\",\n \"transform_symlinks\",\n \"port\",\n \"backup-volfile-servers\",\n ]\n\n if extra_mount_invisible_options:\n mount_invisible_options.extend(extra_mount_invisible_options)\n\n if hidden_opts:\n mount_invisible_options = list(\n set(mount_invisible_options) | set(hidden_opts)\n )\n\n # options which are provided as key=value (e.g. password=Zohp5ohb)\n mount_invisible_keys = [\n \"actimeo\",\n \"comment\",\n \"credentials\",\n \"direct-io-mode\",\n \"password\",\n \"port\",\n \"retry\",\n \"secretfile\",\n ]\n\n if extra_mount_invisible_keys:\n mount_invisible_keys.extend(extra_mount_invisible_keys)\n\n # Some filesystems have options which should not force a remount.\n mount_ignore_fs_keys = {\"ramfs\": [\"size\"]}\n\n if extra_mount_ignore_fs_keys:\n mount_ignore_fs_keys.update(extra_mount_ignore_fs_keys)\n\n # Some options are translated once mounted\n mount_translate_options = {\n \"tcp\": \"proto=tcp\",\n \"udp\": \"proto=udp\",\n }\n\n if extra_mount_translate_options:\n mount_translate_options.update(extra_mount_translate_options)\n\n trigger_remount = []\n for opt in opts:\n if opt in mount_translate_options:\n opt = mount_translate_options[opt]\n\n keyval_option = opt.split(\"=\")[0]\n if keyval_option in mount_invisible_keys:\n opt = keyval_option\n\n size_match = re.match(\n r\"size=(?P<size_value>[0-9]+)(?P<size_unit>k|m|g)\", opt\n )\n if size_match:\n converted_size = _size_convert(size_match)\n opt = \"size={}k\".format(converted_size)\n # make cifs option user synonym for option username which is reported by /proc/mounts\n if fstype in [\"cifs\"] and opt.split(\"=\")[0] == \"user\":\n opt = \"username={}\".format(opt.split(\"=\")[1])\n\n if opt.split(\"=\")[0] in mount_ignore_fs_keys.get(fstype, []):\n opt = opt.split(\"=\")[0]\n\n # convert uid/gid to numeric value from user/group name\n name_id_opts = {\"uid\": \"user.info\", \"gid\": \"group.info\"}\n if opt.split(\"=\")[0] in name_id_opts and len(opt.split(\"=\")) > 1:\n _givenid = opt.split(\"=\")[1]\n _param = opt.split(\"=\")[0]\n _id = _givenid\n if not re.match(\"[0-9]+$\", _givenid):\n _info = __salt__[name_id_opts[_param]](_givenid)\n if _info and _param in _info:\n _id = _info[_param]\n opt = _param + \"=\" + str(_id)\n\n _active_superopts = active[comp_real_name].get(\"superopts\", [])\n for _active_opt in _active_superopts:\n size_match = re.match(\n r\"size=(?P<size_value>[0-9]+)(?P<size_unit>k|m|g)\",\n _active_opt,\n )\n if size_match:\n converted_size = _size_convert(size_match)\n opt = \"size={}k\".format(converted_size)\n _active_superopts.remove(_active_opt)\n _active_opt = \"size={}k\".format(converted_size)\n _active_superopts.append(_active_opt)\n\n if (\n opt not in active[comp_real_name][\"opts\"]\n and opt not in _active_superopts\n and opt not in mount_invisible_options\n and opt not in mount_ignore_fs_keys.get(fstype, [])\n and opt not in mount_invisible_keys\n ):\n trigger_remount.append(opt)\n\n if trigger_remount:\n if __opts__[\"test\"]:\n ret[\"result\"] = None\n ret[\n \"comment\"\n ] = \"Remount would be forced because options ({}) changed\".format(\n \",\".join(sorted(trigger_remount))\n )\n return ret\n else:\n # Some file systems require umounting and mounting if options change\n # add others to list that require similiar functionality\n if fstype in [\"nfs\", \"cvfs\"] or fstype.startswith(\"fuse\"):\n ret[\"changes\"][\"umount\"] = (\n \"Forced unmount and mount because \"\n + \"options ({}) changed\".format(\n \",\".join(sorted(trigger_remount))\n )\n )\n unmount_result = __salt__[\"mount.umount\"](real_name)\n if unmount_result is True:\n mount_result = __salt__[\"mount.mount\"](\n real_name,\n device,\n mkmnt=mkmnt,\n fstype=fstype,\n opts=opts,\n )\n ret[\"result\"] = mount_result\n else:\n ret[\"result\"] = False\n ret[\"comment\"] = \"Unable to unmount {}: {}.\".format(\n real_name, unmount_result\n )\n return ret\n else:\n ret[\"changes\"][\"umount\"] = (\n \"Forced remount because \"\n + \"options ({}) changed\".format(\n \",\".join(sorted(trigger_remount))\n )\n )\n remount_result = __salt__[\"mount.remount\"](\n real_name,\n device,\n mkmnt=mkmnt,\n fstype=fstype,\n opts=opts,\n )\n ret[\"result\"] = remount_result\n # Cleanup after the remount, so we\n # don't write remount into fstab\n if \"remount\" in opts:\n opts.remove(\"remount\")\n\n # Update the cache\n update_mount_cache = True\n\n mount_cache = __salt__[\"mount.read_mount_cache\"](real_name)\n if \"opts\" in mount_cache:\n _missing = [opt for opt in mount_cache[\"opts\"] if opt not in opts]\n\n if _missing:\n if __opts__[\"test\"]:\n ret[\"result\"] = None\n ret[\"comment\"] = (\n \"Remount would be forced because\"\n \" options ({})\"\n \"changed\".format(\",\".join(_missing))\n )\n return ret\n else:\n # Some file systems require umounting and mounting if options change\n # add others to list that require similiar functionality\n if fstype in [\"nfs\", \"cvfs\"] or fstype.startswith(\"fuse\"):\n ret[\"changes\"][\"umount\"] = (\n \"Forced unmount and mount because \"\n + \"options ({}) changed\".format(opt)\n )\n unmount_result = __salt__[\"mount.umount\"](real_name)\n if unmount_result is True:\n mount_result = __salt__[\"mount.mount\"](\n real_name,\n device,\n mkmnt=mkmnt,\n fstype=fstype,\n opts=opts,\n )\n ret[\"result\"] = mount_result\n else:\n ret[\"result\"] = False\n ret[\"comment\"] = \"Unable to unmount {}: {}.\".format(\n real_name, unmount_result\n )\n return ret\n else:\n ret[\"changes\"][\"umount\"] = (\n \"Forced remount because \"\n + \"options ({}) changed\".format(opt)\n )\n remount_result = __salt__[\"mount.remount\"](\n real_name,\n device,\n mkmnt=mkmnt,\n fstype=fstype,\n opts=opts,\n )\n ret[\"result\"] = remount_result\n # Cleanup after the remount, so we\n # don't write remount into fstab\n if \"remount\" in opts:\n opts.remove(\"remount\")\n\n update_mount_cache = True\n else:\n update_mount_cache = True\n\n if real_device not in device_list:\n # name matches but device doesn't - need to umount\n _device_mismatch_is_ignored = None\n for regex in list(device_name_regex):\n for _device in device_list:\n if re.match(regex, _device):\n _device_mismatch_is_ignored = _device\n break\n if _device_mismatch_is_ignored:\n ret[\"result\"] = True\n ret[\"comment\"] = (\n \"An umount will not be forced \"\n + \"because device matched device_name_regex: \"\n + _device_mismatch_is_ignored\n )\n elif __opts__[\"test\"]:\n ret[\"result\"] = None\n ret[\"comment\"] = (\n \"An umount would have been forced \"\n + \"because devices do not match. Watched: \"\n + device\n )\n else:\n ret[\"changes\"][\"umount\"] = (\n \"Forced unmount because devices \"\n + \"don't match. Wanted: \"\n + device\n )\n if real_device != device:\n ret[\"changes\"][\"umount\"] += \" (\" + real_device + \")\"\n ret[\"changes\"][\"umount\"] += \", current: \" + \", \".join(device_list)\n out = __salt__[\"mount.umount\"](real_name, user=user)\n active = __salt__[\"mount.active\"](extended=True)\n if comp_real_name in active:\n ret[\"comment\"] = \"Unable to unmount\"\n ret[\"result\"] = False\n return ret\n update_mount_cache = True\n else:\n ret[\"comment\"] = \"Target was already mounted\"\n # using a duplicate check so I can catch the results of a umount\n if comp_real_name not in active:\n if mount:\n # The mount is not present! Mount it\n if __opts__[\"test\"]:\n ret[\"result\"] = None\n if os.path.exists(name):\n ret[\"comment\"] = \"{} would be mounted\".format(name)\n elif mkmnt:\n ret[\"comment\"] = \"{} would be created and mounted\".format(name)\n else:\n ret[\n \"comment\"\n ] = \"{} does not exist and would not be created\".format(name)\n return ret\n\n if not os.path.exists(name) and not mkmnt:\n ret[\"result\"] = False\n ret[\"comment\"] = \"Mount directory is not present\"\n return ret\n\n out = __salt__[\"mount.mount\"](name, device, mkmnt, fstype, opts, user=user)\n active = __salt__[\"mount.active\"](extended=True)\n update_mount_cache = True\n if isinstance(out, str):\n # Failed to (re)mount, the state has failed!\n ret[\"comment\"] = out\n ret[\"result\"] = False\n return ret\n elif comp_real_name in active:\n # (Re)mount worked!\n ret[\"comment\"] = \"Target was successfully mounted\"\n ret[\"changes\"][\"mount\"] = True\n elif not os.path.exists(name):\n if __opts__[\"test\"]:\n ret[\"result\"] = None\n if mkmnt:\n ret[\"comment\"] = \"{} would be created, but not mounted\".format(name)\n else:\n ret[\n \"comment\"\n ] = \"{} does not exist and would neither be created nor mounted\".format(\n name\n )\n elif mkmnt:\n __salt__[\"file.mkdir\"](name, user=user)\n ret[\"comment\"] = \"{} was created, not mounted\".format(name)\n else:\n ret[\"comment\"] = \"{} not present and not mounted\".format(name)\n else:\n if __opts__[\"test\"]:\n ret[\"comment\"] = \"{} would not be mounted\".format(name)\n else:\n ret[\"comment\"] = \"{} not mounted\".format(name)\n\n if persist:\n if \"/etc/fstab\" == config:\n # Override default for Mac OS\n if __grains__[\"os\"] in [\"MacOS\", \"Darwin\"]:\n config = \"/etc/auto_salt\"\n\n # Override default for AIX\n elif \"AIX\" in __grains__[\"os\"]:\n config = \"/etc/filesystems\"\n\n if __opts__[\"test\"]:\n if __grains__[\"os\"] in [\"MacOS\", \"Darwin\"]:\n out = __salt__[\"mount.set_automaster\"](\n name, device, fstype, opts, config, test=True\n )\n elif __grains__[\"os\"] in [\"AIX\"]:\n out = __salt__[\"mount.set_filesystems\"](\n name,\n device,\n fstype,\n opts,\n mount,\n config,\n test=True,\n match_on=match_on,\n )\n else:\n out = __salt__[\"mount.set_fstab\"](\n name,\n device,\n fstype,\n opts,\n dump,\n pass_num,\n config,\n test=True,\n match_on=match_on,\n )\n if out != \"present\":\n ret[\"result\"] = None\n if out == \"new\":\n if mount:\n comment = (\n \"{} is mounted, but needs to be \"\n \"written to the fstab in order to be \"\n \"made persistent.\".format(name)\n )\n else:\n comment = (\n \"{} needs to be \"\n \"written to the fstab in order to be \"\n \"made persistent.\".format(name)\n )\n elif out == \"change\":\n if mount:\n comment = \"{} is mounted, but its fstab entry must be updated.\".format(\n name\n )\n else:\n comment = \"The {} fstab entry must be updated.\".format(name)\n else:\n ret[\"result\"] = False\n comment = (\n \"Unable to detect fstab status for \"\n \"mount point {} due to unexpected \"\n \"output '{}' from call to \"\n \"mount.set_fstab. This is most likely \"\n \"a bug.\".format(name, out)\n )\n if \"comment\" in ret:\n ret[\"comment\"] = \"{}. {}\".format(ret[\"comment\"], comment)\n else:\n ret[\"comment\"] = comment\n return ret\n\n else:\n if __grains__[\"os\"] in [\"MacOS\", \"Darwin\"]:\n out = __salt__[\"mount.set_automaster\"](\n name, device, fstype, opts, config\n )\n elif __grains__[\"os\"] in [\"AIX\"]:\n out = __salt__[\"mount.set_filesystems\"](\n name, device, fstype, opts, mount, config, match_on=match_on\n )\n else:\n out = __salt__[\"mount.set_fstab\"](\n name,\n device,\n fstype,\n opts,\n dump,\n pass_num,\n config,\n match_on=match_on,\n )\n\n if update_mount_cache:\n cache_result = __salt__[\"mount.write_mount_cache\"](\n real_name, device, mkmnt=mkmnt, fstype=fstype, mount_opts=opts\n )\n\n if out == \"present\":\n ret[\"comment\"] += \". Entry already exists in the fstab.\"\n return ret\n if out == \"new\":\n ret[\"changes\"][\"persist\"] = \"new\"\n ret[\"comment\"] += \". Added new entry to the fstab.\"\n return ret\n if out == \"change\":\n ret[\"changes\"][\"persist\"] = \"update\"\n ret[\"comment\"] += \". Updated the entry in the fstab.\"\n return ret\n if out == \"bad config\":\n ret[\"result\"] = False\n ret[\"comment\"] += \". However, the fstab was not found.\"\n return ret\n\n return ret","def __init__(__self__, *,\n mount_path: pulumi.Input[str],\n type: pulumi.Input[str],\n enable_sub_path: Optional[pulumi.Input[bool]] = None,\n mount_options: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\n read_only: Optional[pulumi.Input[bool]] = None,\n share_name: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"mount_path\", mount_path)\n pulumi.set(__self__, \"type\", 'AzureFileVolume')\n if enable_sub_path is None:\n enable_sub_path = False\n if enable_sub_path is not None:\n pulumi.set(__self__, \"enable_sub_path\", enable_sub_path)\n if mount_options is not None:\n pulumi.set(__self__, \"mount_options\", mount_options)\n if read_only is not None:\n pulumi.set(__self__, \"read_only\", read_only)\n if share_name is not None:\n pulumi.set(__self__, \"share_name\", share_name)","def _mount_gluster_vol(self, mount_path, ensure=False):\n self._execute('mkdir', '-p', mount_path)\n command = ['mount', '-t', 'glusterfs', self.gluster_manager.export,\n mount_path]\n self._do_mount(command, ensure)","def mount(\n self,\n path: str,\n mode: str = \"rw\",\n authority: str = \"file\",\n *,\n persistent: bool = True\n ):\n if self.celltype == \"structured\" and not isinstance(self, FolderCell):\n raise Exception(\"Mounting is only supported for non-structured cells\")\n\n if \"r\" in mode and not self.independent:\n msg = \"\"\"Cannot mount {} in read mode.\nThis cell is not fully independent, i.e. it has incoming connections\"\"\"\n raise Exception(msg.format(self))\n\n # TODO, upon translation: check that there are no duplicate paths.\n hcell = self._get_hcell2()\n mount = {\n \"path\": path,\n \"mode\": mode,\n \"authority\": authority,\n \"persistent\": persistent,\n }\n hcell[\"mount\"] = mount\n hcell[\"UNTRANSLATED\"] = True\n if self._parent() is not None:\n self._parent()._translate()\n return self","def _mount_stick_shell(stick):\n out = subprocess.check_output(\"udisks --mount {0}\"\n .format(stick).split())\n path = re.match(r\"Mounted .* at (.*)\", out).group(1)\n try:\n yield path\n except Exception as e:\n raise e\n finally:\n subprocess.check_output(\"udisks --unmount {0}\"\n .format(stick).split())","def _pmount(self, action, args, error='exit'):\n args = ('p%s' % action,) + args + (self.devname,)\n if action == 'mount':\n if self.label:\n args += (self.label,)\n msg = 'Mounting %s on %s'\n else:\n msg = 'Unmounting %s from %s'\n print(msg % (self.devname, get_mount_target(self.devname, self.label)))\n result = call(args)\n if result and error == 'exit':\n exit(result)","def mount_volume(self, kwargs):\n\n exp_params = [('dev_name', is_string),\n ('vol_name', is_string)]\n try:\n dev_name, vol_name = check_arguments(exp_params, kwargs)\n dev_name = \"/dev/%s\" % dev_name\n self.check_volume_name(vol_name)\n except Exception as ex:\n return HttpErrorResponse(\"%s\" % ex)\n\n self.logger.info(\"Mount operation starting up for volume '%s' on '%s'\"\n % (vol_name, dev_name))\n\n try:\n mount_point = join(self.VOLUME_DIR, vol_name)\n self._mount(dev_name, mount_point, True)\n except Exception as e:\n self.logger.exception(\"Failed to mount volume '%s'\" % vol_name)\n return HttpErrorResponse('Failed to mount volume: ' + e.message)\n\n self.logger.info('Mount operation completed')\n return HttpJsonResponse()","def mount(self, fstype, export, vol_name, mountpoint, instance, options):\n\n # NOTE(mdbooth): mount() may currently be called multiple times for a\n # single attachment. Any operation which calls\n # LibvirtDriver._hard_reboot will re-attach volumes which are probably\n # already attached, resulting in multiple mount calls.\n\n LOG.debug('_HostMountState.mount(fstype=%(fstype)s, '\n 'export=%(export)s, vol_name=%(vol_name)s, %(mountpoint)s, '\n 'options=%(options)s) generation %(gen)s',\n {'fstype': fstype, 'export': export, 'vol_name': vol_name,\n 'mountpoint': mountpoint, 'options': options,\n 'gen': self.generation}, instance=instance)\n with self._get_locked(mountpoint) as mount:\n if os.path.ismount(mountpoint):\n LOG.debug(('Mounting %(mountpoint)s generation %(gen)s, '\n 'mountpoint already mounted'),\n {'mountpoint': mountpoint, 'gen': self.generation},\n instance=instance)\n else:\n LOG.debug('Mounting %(mountpoint)s generation %(gen)s',\n {'mountpoint': mountpoint, 'gen': self.generation},\n instance=instance)\n\n fileutils.ensure_tree(mountpoint)\n\n try:\n nova.privsep.fs.mount(fstype, export, mountpoint, options)\n except processutils.ProcessExecutionError:\n # Check to see if mountpoint is mounted despite the error\n # eg it was already mounted\n if os.path.ismount(mountpoint):\n # We're not going to raise the exception because we're\n # in the desired state anyway. However, this is still\n # unusual so we'll log it.\n LOG.exception(\n 'Error mounting %(fstypes export %(export)s on '\n '%(mountpoint)s. Continuing because mountpount is '\n 'mounted despite this.',\n {'fstype': fstype, 'export': export,\n 'mountpoint': mountpoint}, instance=instance)\n else:\n # If the mount failed there's no reason for us to keep\n # a record of it. It will be created again if the\n # caller retries.\n\n # Delete while holding lock\n del self.mountpoints[mountpoint]\n\n raise\n\n mount.add_attachment(vol_name, instance.uuid)\n\n LOG.debug('_HostMountState.mount() for %(mountpoint)s '\n 'generation %(gen)s completed successfully',\n {'mountpoint': mountpoint, 'gen': self.generation},\n instance=instance)","def mount_resource(self, name, factory, path, methods=(), method=None, add_slash=False,\n replace=False, _level=3):\n factory = load_object(factory, level=_level)\n mounted_resource = MountedResource(self, name, factory, path, methods, method, add_slash)\n self.register(abcs.AMountedResource, mounted_resource, mounted_resource.name, replace)\n return SubResourceMounter(self, mounted_resource)","def mount_path(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"mount_path\")","def mount_path(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"mount_path\")","def run(self, check=True, mount_callback=None):\n # pylint: disable=arguments-differ,arguments-renamed\n self.log.info('Starting dfuse at %s on %s', self.mount_dir.value, str(self.hosts))\n\n # A log file must be defined to ensure logs are captured\n if \"D_LOG_FILE\" not in self.env:\n raise CommandFailure(\"Dfuse missing environment variables for D_LOG_FILE\")\n\n if 'D_LOG_MASK' not in self.env:\n self.env['D_LOG_MASK'] = 'INFO'\n\n if 'COVFILE' not in self.env:\n self.env['COVFILE'] = '/tmp/test.cov'\n\n # Determine which fusermount command to use before mounting\n if not self._fusermount_cmd:\n self.log.info('Check which fusermount command to use')\n for fusermount in ('fusermount3', 'fusermount'):\n if run_remote(self.log, self.hosts, f'{fusermount} --version').passed:\n self._fusermount_cmd = fusermount\n break\n if not self._fusermount_cmd:\n raise CommandFailure(f'Failed to get fusermount command on: {self.hosts}')\n\n # mark the instance as needing cleanup before starting setup\n self.__need_cleanup = True\n\n # setup the mount point\n self._setup_mount_point()\n\n # run dfuse command\n result = run_remote(self.log, self.hosts, self.with_exports, timeout=30)\n self._running_hosts.add(result.passed_hosts)\n if mount_callback:\n mount_callback(result)\n elif not result.passed:\n raise CommandFailure(f\"dfuse command failed on hosts {result.failed_hosts}\")\n\n if check:\n # Dfuse will block in the command for the mount to complete, even\n # if run in background mode so it should be possible to start using\n # it immediately after the command returns.\n num_retries = 3\n for retry in range(1, num_retries + 1):\n if not self.check_running(fail_on_error=retry == num_retries):\n self.log.info('Waiting two seconds for dfuse to start')\n time.sleep(2)","def mount_factory(name, idn=0):\n # Import MOUNT_MAPPING at runtime so we avoid circular imports\n from robosuite.models.mounts import MOUNT_MAPPING\n\n return MOUNT_MAPPING.get(name, \"Unknown mount name: {}\".format(name))(idn=idn)","def volume_mounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VolumeMountArgs']]]]:\n return pulumi.get(self, \"volume_mounts\")","def _setup_mount_point(self):\n # Raise exception if mount point not specified\n if self.mount_dir.value is None:\n raise CommandFailure(\"Mount point not specified. Check test yaml file\")\n\n # Unmount dfuse if already running\n self.unmount()\n if self._running_hosts:\n raise CommandFailure(f\"Error stopping dfuse on {self._running_hosts}\")\n\n self.log.info(\"Creating dfuse mount directory\")\n if self._mount_state[\"nodirectory\"]:\n command = f\"mkdir -p {self.mount_dir.value}\"\n result = self._run_as_owner(self._mount_state[\"nodirectory\"], command, timeout=30)\n if not result.passed:\n raise CommandFailure(\n f\"Error creating the {self.mount_dir.value} dfuse mount point \"\n f\"on the following hosts: {result.failed_hosts}\")","def get_mounts(self):\n cmd = ['mount', '-t', 'btrfs', '-l']\n out, err, ret = self.justcall(cmd)\n if ret != 0:\n raise InitError(\"error running %s:\\n\"%' '.join(cmd)+err)\n mounts = {}\n for line in out.split(\"\\n\"):\n if len(line) == 0 or \" on \" not in line or \" type btrfs \" not in line:\n continue\n mntpt = line[line.index(\" on \")+4:line.index(\" type btrfs \")]\n if '[' in line:\n l = line.split('[')\n label = l[-1].strip(']')\n else:\n label = self.get_label(mntpt)\n mounts[mntpt] = label\n return mounts","def _mountMultifile(self, path: str) -> None:\n\n success = vfs.vfs_mount_multifile('.', path)\n if not success:\n self.showErrorDialog(message='Failed to mount %s' % path)\n sys.exit(2)","def mount_block(block):\n # type: (str) -> str\n\n dir_path = tempfile.mkdtemp(prefix='mount-')\n _mount(block, dir_path)\n\n return dir_path","def mount_fs_on_dir(vm_name, device_name, target_dir, fs_type, executor=None):\n if not executor:\n executor = get_vm_executor(vm_name)\n blkid_cmd = 'blkid %s' % device_name\n rc, out, error = executor.run_cmd(shlex.split(blkid_cmd))\n assert not rc, (\n \"Failed to get the UUID of device {0} {1}\".format(device_name, error)\n )\n uuid_regex = re.search(REGEX_UUID, out)\n assert uuid_regex, \"Failed to find UUUID in output {0}\".format(out)\n fstab_line = 'UUID=\"%s\" %s %s defaults 0 0' % (\n uuid_regex.group('uuid'), target_dir, fs_type\n )\n insert_to_fstab = 'echo \"{0}\" >> {1}'.format(fstab_line, '/etc/fstab')\n out = _run_cmd_on_remote_machine(vm_name, insert_to_fstab, executor)\n assert out, errors.MountError(\"Failed to add mount point to fstab\", out)\n mount_cmd = 'mount -a'\n out = _run_cmd_on_remote_machine(vm_name, mount_cmd, executor)\n assert out, errors.MountError(\"Failed to mount FS\", out)","def mounts():\n if not _mounts:\n raw = subprocess.check_output(['mount'])\n if sys.platform == 'darwin':\n _mounts.extend(_parse_darwin_mounts(raw))\n elif sys.platform.startswith('linux'):\n _mounts.extend(_parse_linux_mounts(raw))\n else:\n log.warning('cannot parse mounts for %s' % sys.platform)\n return list(_mounts)","def mounted(self):\n return os.path.ismount(self.get(\"~mountpoint\", \"/\"))","def mount_stick(stick):\n mount = stick.get_dbus_method(\n \"FilesystemMount\", dbus_interface=\"org.freedesktop.UDisks.Device\")\n path = mount('', [])\n try:\n yield path\n except Exception as e:\n raise e\n finally:\n unmount = stick.get_dbus_method(\n \"FilesystemUnmount\",\n dbus_interface=\"org.freedesktop.UDisks.Device\")\n unmount([], timeout=1e6) # dbus-python doesn't know an infinite\n # timeout... unmounting sometimes takes a\n # long time, since the device has to be\n # synced.","def path_extern_mounts(self) -> PurePath:\n return self.path_extern_supervisor / MOUNTS_FOLDER","def mount_single(partition_size, drives):\n for drive_list in drives:\n if are_equal(drive_list, partition_size):\n for drive_info, partition_info in zip(drive_list, partition_size):\n mount_pattern = \"mount -t ntfs -o uid=1000,gid=1000,umask=0002 /dev/{} {}\"\n mount_cmd = mount_pattern.format(drive_info[1], partition_info[1])\n print(mount_cmd)","def hadoop(self, command, *args, **kwargs):\n hadoop_cmd = \"-{}\".format(re.sub(\"^-*\", \"\", command))\n return self.exec(\"hadoop fs\", hadoop_cmd, *args, **kwargs)","def create_onedrive_mounting_point():\n return None","def mount(self):\n LOG.info(\"Mounting %s\", self.name)\n\n # read volume metadata\n self.read_volume_metadata()\n\n # calculate file allocation and file area offsets\n self.calculate_offsets()\n\n if self.debug_log_enabled:\n LOG.debug(\"Bytes Per Cluster: %08x\", self.bytes_per_cluster)\n LOG.debug(\"Max Clusters: %08x\", self.max_clusters)\n LOG.debug(\"FAT Byte Offset: %08x\", self.fat_byte_offset)\n LOG.debug(\"FILE Area Byte Offset: %08x\", self.file_area_byte_offset)\n\n # get file allocation table (int[])\n self.file_allocation_table = self.read_file_allocation_table()\n\n self._root = self.read_directory_stream(\n self.cluster_to_physical_offset(self.root_dir_first_cluster))\n\n # for each dirent in root, populate children\n self.populate_dirent_stream(self._root)","def is_mounted(volume):\n mounts = sudo(\"mount\", quiet=True).split(\"\\n\")\n for m in mounts:\n if m.startswith(volume + \" \"):\n return True\n return False","def command_mount(self, system_id, *system_ids):\n system_ids = (system_id,) + system_ids\n has_failed = False\n for system_id in system_ids:\n try:\n system = SystemModel.create_by_id(system_id, self.environment)\n controller = SystemControllerModel(system, self.environment)\n controller.mount()\n except SftpConfigException as e:\n sys.stderr.write('Cannot mount %s: %s\\n\\n' % (system_id, str(e)))\n has_failed = True\n except SftpMountException as e:\n sys.stderr.write('Cannot mount %s!\\n\\n' % system_id)\n sys.stderr.write('Mount command: \\n%s\\n\\n' % e.mount_cmd)\n sys.stderr.write('Command output: \\n%s\\n\\n' % e.mount_cmd_output)\n has_failed = True\n if has_failed:\n sys.exit(1)","def mount_nfs_share(self, share_config):\n remote_host = share_config.get('remote_host')\n remote_dir = share_config.get('remote_dir')\n mount_point = share_config.get('mount_point')\n if remote_host and remote_dir:\n if mount_point:\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\n self.cmd(command)","def match_mount(self, i, dev, mnt):\n if i.mnt != mnt:\n return False\n if i.dev == dev:\n return True\n return False","def _RemountRootAsReadWrite(self):\n self.RunCmdOnDevice(['mount', '-o', 'remount,rw', '/'])","def volume_mounts(self) -> Optional[Sequence['_core.v1.outputs.VolumeMount']]:\n return pulumi.get(self, \"volume_mounts\")","def get_mount_points():\n\n points = []\n t = subprocess.check_output(['mount'])\n t = t.decode()\n\n for line in t.splitlines():\n t = line.find('smbfs')\n if t < 0: continue\n b = line.find(' on ')\n points.append(line[b+4: t-2])\n # //share@win10.shared/storage on /Volumes/storage (smbfs, nodev, nosuid, mounted by ruan)\n return points","def __init__(self, type=\"uri_folder\", path=None, mode=\"rw_mount\", description=None):\n pass","def create_and_mount_brick(brick_device, brick_path, brickfs):\n\n # If brick device path is not starts with /dev then use\n # /brickdev prefix. Brick device directory passed by the user\n # is mounted as /brickdev to avoid mixing with any other\n # dirs inside container.\n if not brick_device.startswith(\"/dev/\"):\n brick_device = \"/brickdev/\" + os.path.basename(brick_device)\n\n mountdir = os.path.dirname(brick_path)\n os.makedirs(mountdir,\n mode=0o755,\n exist_ok=True)\n\n try:\n execute(\"mount\", brick_device, mountdir)\n logging.info(logf(\n \"Successfully mounted device on path\",\n fstype=brickfs,\n device=brick_device,\n mountdir=mountdir,\n ))\n except CommandException as err:\n logging.info(logf(\n \"Failed to mount device, continuing with mkfs\",\n err=err,\n fstype=brickfs,\n device=brick_device,\n mountdir=mountdir,\n ))\n if 'wrong fs type' in err.err:\n # This error pops up when we do mount on an empty device or wrong fs\n # Try doing a mkfs and try mount\n try:\n execute(MKFS_XFS_CMD, brick_device)\n logging.info(logf(\n \"Successfully created xfs file system on device\",\n fstype=brickfs,\n device=brick_device,\n ))\n except CommandException as err:\n if \"appears to contain an existing filesystem\" not in err.err:\n logging.error(logf(\n \"Failed to create file system\",\n fstype=brickfs,\n device=brick_device,\n error=err,\n ))\n sys.exit(1)\n else:\n logging.info(logf(\n \"Failed to perform mkfs on device. continuing with mount\",\n err=err,\n device=brick_device,\n mountdir=mountdir,\n ))\n try:\n execute(\"mount\", brick_device, mountdir)\n logging.info(logf(\n \"Successfully mounted device on path\",\n fstype=brickfs,\n device=brick_device,\n mountdir=mountdir,\n ))\n except CommandException as err:\n logging.error(logf(\n \"Failed to mount export brick (after mkfs)\",\n fstype=brickfs,\n device=brick_device,\n mountdir=mountdir,\n error=err,\n ))\n sys.exit(1)\n\n elif 'already mounted' not in err.err:\n logging.error(logf(\n \"Failed to mount export brick\",\n fstype=brickfs,\n device=brick_device,\n mountdir=mountdir,\n error=err,\n ))\n sys.exit(1)\n\n else:\n pass","def authenticated_mount(self, mount_obj):\n # Mount volume\n ret = mount_obj.mount()\n self.assertTrue(ret, (\"Failed to mount %s on client %s\" %\n (mount_obj.volname,\n mount_obj.client_system)))\n g.log.info(\"Successfully mounted %s on client %s\", mount_obj.volname,\n mount_obj.client_system)\n\n # Verify mount\n ret = mount_obj.is_mounted()\n self.assertTrue(ret, (\"%s is not mounted on client %s\"\n % (mount_obj.volname, mount_obj.client_system)))\n g.log.info(\"Verified: %s is mounted on client %s\",\n mount_obj.volname, mount_obj.client_system)","def testGenerateVolumesMountpoints(self):\n self.maxDiff = None\n de_object = de.DockerExplorerTool()\n de_object._explorer = self.explorer_object\n container_obj = de_object._explorer.GetContainer(\n '712909b5ab80d8785841f12e361c218a2faf5365f9ed525f2a0d6b6590ba89cb')\n\n commands = container_obj.storage_object._MakeVolumeMountCommands(\n container_obj, '/mnt')\n commands = [' '.join(x) for x in commands]\n expected_commands = [(\n '/bin/mount --bind -o ro '\n 'test_data/docker/volumes/f5479c534bbc6e2b9861973c2fbb4863ff5b7b5843c098d7fb1a027fe730a4dc/_data '\n '/mnt/opt/vols/volume')]\n self.assertEqual(expected_commands, commands)","def mount(class_, root):\n # XXX class_ - in successors own _ready (?)\n if class_._ready:\n return\n else:\n p = VRoot(root).hpath(SchModule.DIR)\n SchModule.DIR = VRoot(p)\n class_._ready = True","def get_mount_point(self):\n try:\n output = openmediavault.subprocess.check_output(\n [\n 'findmnt',\n '--canonicalize',\n '--first-only',\n '--noheadings',\n '--output=TARGET',\n '--raw',\n self.canonical_device_file,\n ]\n )\n # Examples:\n # /media/8c982ec2-8aa7-4fe2-a912-7478f0429e06\n # /srv/_dev_disk_by-id_dm-name-vg01-lv01\n # /srv/dev-disk-by-label-xx\\x20yy\n return openmediavault.string.unescape_blank(output.decode().strip())\n except subprocess.CalledProcessError:\n pass\n return None","def get_mounts(self):\n return [m.split()[0] for m in self.xlist(\"get-mounts\")[1]]","def generate_common_mount(self, working_file_name):\n\n # Reopenthe working file\n working_file = open(working_file_name, \"a\")\n\n # Check that the stack definition is in the configuration file\n if \"stack-definition\" not in self.project.firmware_definition[\"layout\"]:\n self.project.logging.critical(\"The stack definition is not in the configuration file\")\n exit(1)\n\n # Iterates the stack items\n for item in self.project.firmware_definition[\"layout\"][\"stack-definition\"]:\n # Generate the mount point creation code\n working_file.write(\"# Create the mount point for \" + item[\"stack-item\"][\"type\"] +\n \" '\" + item[\"stack-item\"][\"name\"] + \"'\\n\")\n working_file.write(\"mkdir -p /mnt/dft/\" + item[\"stack-item\"][\"name\"] + \"\\n\")\n working_file.write(\"\\n\")\n\n # Generate the mount commands\n working_file.write(\"# Mount item \" + item[\"stack-item\"][\"type\"] + \" '\" +\n item[\"stack-item\"][\"name\"] + \"'\\n\")\n\n # Generate the tmpfs specific mount command\n if item[\"stack-item\"][\"type\"] == \"tmpfs\":\n working_file.write(\"mount -t tmpfs \")\n\n # Is there some defined options ?\n if \"mount-options\" in item[\"stack-item\"]:\n # Yes, then append the options to the command\n working_file.write(\"-o \" + item[\"stack-item\"][\"mount-options\"] + \" \")\n\n # Complete the mount command\n working_file.write(\"tmpfs /mnt/dft/\" + item[\"stack-item\"][\"name\"] + \"\\n\")\n\n # Generate the tmpfs specific mount command\n if item[\"stack-item\"][\"type\"] == \"squashfs\":\n working_file.write(\"mount -t squashfs \")\n\n # Is there some defined options ?\n if \"mount-options\" in item[\"stack-item\"]:\n # Yes, then append the options to the command\n working_file.write(\"-o \" + item[\"stack-item\"][\"mount-options\"] + \" \")\n\n # Complete the mount command\n working_file.write(item[\"stack-item\"][\"squashfs-file\"] + \" /mnt/dft/\" +\n item[\"stack-item\"][\"name\"] + \" -o loop\\n\")\n\n # Generate the tmpfs specific mount command\n if item[\"stack-item\"][\"type\"] == \"partition\":\n working_file.write(\"mount \")\n\n # Is there some defined options ?\n if \"mount-options\" in item[\"stack-item\"]:\n # Yes, then append the options to the command\n working_file.write(\"-o \" + item[\"stack-item\"][\"mount-options\"] + \" \")\n\n # Complete the mount command\n working_file.write(item[\"stack-item\"][\"partition\"] + \" /mnt/dft/\" +\n item[\"stack-item\"][\"name\"] + \"\\n\")\n\n working_file.write(\"\\n\")\n\n # We are done here, now close the file\n working_file.close()","def umount_mdv():\n with open(\"/proc/self/mounts\", \"r\") as mounts:\n for line in mounts.readlines():\n if \"/stratis/.mdv-\" in line:\n mountpoint = line.split()[1]\n exec_command([\"umount\", mountpoint])","def __init__(self):\n current_app.logger.debug(\"Instantiating the Mount class\")","def mount_accessor(self, mount_accessor):\n\n self._mount_accessor = mount_accessor","def mount_device(entities):\n result = None\n reg = re.compile(r'/dev/disk\\d+')\n\n # When a DMG is mounted, the mount volume and device 'keys'\n # are in the same entity, so when both 'mount' and 'device'\n # exist, we have the right info.\n for ent in entities:\n _dev = ent.get('dev-entry', None)\n device = re.findall(reg, _dev)[0] if _dev else None\n mount = ent.get('mount-point', None)\n\n if mount and device:\n result = (mount, device)\n break\n\n return result","def test_mount_status_nas_share(self):\n pass","def fsmounted(mountpoint):\n ProcMounts.initialize()\n for mount in ProcMounts._mounts:\n if mount['fs_file'] == mountpoint:\n return mount\n return None","def get_mount_direction(self):\r\n return self._studio.get_mount_direction()","def get_mount_target(devname, label=None):\n return join(sep, 'media', label or basename(devname))","def shell(self, cmd):\n raise NotImplementedError","def create_filesystem_mounting_point(username, password, domainName, path, instanceId):\n createFileSystemMountingPointParams = {\n \"Username\": username,\n \"Password\": password,\n \"DomainName\": domainName,\n \"Path\": path,\n \"InstanceId\": instanceId\n }\n return createFileSystemMountingPointParams","def umount_cifs_share(self, **kwargs):\n mount_point = kwargs.get('mount_point')\n if mount_point:\n command = 'umount %s' % mount_point\n self.cmd(command)","def mount_root_vm(self):\n print \"montage de la partition root de %s\" % name_vm_dest\n self.exec_cmd(\"mount /dev/%s/root-%s %s\" % (vgname, name_vm_dest, self.rep_vhosts_vm))","def mount(mapping, loaded_data):\n for drive_size, partition_infos in mapping:\n mount_single(partition_infos, loaded_data[drive_size])","def volume_mounts(self) -> Optional[Sequence['_core.v1.outputs.VolumeMountPatch']]:\n return pulumi.get(self, \"volume_mounts\")","def build(kls, cmd, *, cls=subprocess.Popen, **kwargs):\n if not cmd:\n raise xt.XonshError(\"xonsh: subprocess mode: command is empty\")\n # modifications that do not alter cmds may come before creating instance\n spec = kls(cmd, cls=cls, **kwargs)\n # modifications that alter cmds must come after creating instance\n # perform initial redirects\n spec.redirect_leading()\n spec.redirect_trailing()\n # apply aliases\n spec.resolve_alias()\n spec.resolve_binary_loc()\n spec.resolve_auto_cd()\n spec.resolve_executable_commands()\n spec.resolve_alias_cls()\n spec.resolve_stack()\n return spec","def register_mount(self, app, path, variables, converters, required,\n get_converters, mount_name, app_factory):\n self.register_path(app, path, variables,\n converters, required, get_converters, False,\n app_factory)\n\n self.mounted[app] = app_factory\n mount_name = mount_name or path\n self.named_mounted[mount_name] = app_factory","def run(self):\n self.log.info(\"Start CMD>>> %s\", str(self.runner))\n\n # Temporary display debug mount information\n self.log.info(\"%s\", \"=\" * 80)\n pcmd(self._hosts, \"df -h -t tmpfs\", True, None, None)\n self.log.info(\"%s\", \"=\" * 80)\n\n return self.runner.run()","def mounts():\r\n ret = []\r\n with open('/proc/mounts') as f:\r\n lines = f.readlines()\r\n for line in lines:\r\n m = re.match(\r\n r'(?P<src>\\S+) (?P<dest>\\S+) (?P<type>\\S+)', line)\r\n if m:\r\n ret.append(m.groupdict())\r\n return ret","def _command_wrapper(self, cls):\n def command_send(func, args):\n self._con.send(func(*args))\n result = self._recv()\n if len(result) == 0: # Reconnect if no results were received\n self._con.connect()\n self._recv()\n return command_send(func, args)\n parsed_result = Parser.parse(result)\n if not parsed_result:\n raise MPDCommandError(\"Wrong command usage or insufficient permissions: {}\".format(result))\n return parsed_result\n\n class Wrapper(cls):\n \"\"\"\n The actual class that wraps Commands\n It generates new functions to each of Commands attributes, and all it does is to wrap\n Commands attributes with command_send.\n \"\"\"\n def __init__(self):\n pass\n\n def __getattr__(self, item):\n not_wrapped = cls.__getattr__(item)\n\n def f(*args):\n return command_send(not_wrapped, args)\n\n f.__doc__ = not_wrapped.__doc__\n f.__name__ = not_wrapped.__name__\n return f\n\n return Wrapper()","def delegator():\n import delegator\n\n def run(command):\n if \"|\" in command:\n res = delegator.chain(command)\n else:\n res = delegator.run(command)\n if res.return_code == 127:\n raise FileNotFoundError(res.err)\n if res.return_code != 0:\n raise RuntimeError(res.err)\n if res.err:\n sys.stderr.write(res.err)\n if not res.err.endswith(os.linesep):\n sys.stderr.write(os.linesep)\n\n return res.out.strip()\n\n return run","def _check_mount(self):\n if self.mount == ComponentBase.MOUNT_SMD:\n valid_shapes = [Con.SHAPE_PAD]\n default_shape = Con.SHAPE_PAD\n elif self.mount == ComponentBase.MOUNT_THT:\n valid_shapes = [Con.SHAPE_HOLE, Con.SHAPE_RHOLE]\n default_shape = Con.SHAPE_HOLE\n \n for con in self.connectors:\n if con.p_shape not in valid_shapes:\n con.p_shape = default_shape","def mountLXCPrivate(self,node,vmid):\n post_data = None\n data = self.connect('post','nodes/%s/lxc/%s/status/mount' % (node,vmid), post_data)\n return data","def getmount(mypath): # noqa\n\n path_ = os.path.realpath(os.path.abspath(mypath))\n while path_ != os.path.sep:\n if os.path.ismount(path_):\n return path_\n path_ = os.path.abspath(os.path.join(path_, os.pardir))\n return path_"],"string":"[\n \"def mount(self):\\n return self._mount\",\n \"def mount(self, mount):\\n assert mount in (ComponentBase.MOUNTS)\\n if mount==self.MOUNT_HYB:\\n raise Exception(\\\"Unsupported mount.\\\")\\n self._mount = mount\\n self._check_mount()\",\n \"def testMountCommand(self):\\n with self.assertRaises(FilePathException):\\n File().getGirderMountFilePath(self.file)\\n self.assertIsNone(File().getGirderMountFilePath(self.file, validate=False))\\n mountPath = tempfile.mkdtemp()\\n subprocess.check_call(['girder', 'mount', mountPath, '-d', os.environ['GIRDER_TEST_DB']])\\n endTime = time.time() + 10 # maximum time to wait\\n while time.time() < endTime:\\n if os.path.exists(os.path.join(mountPath, 'user')):\\n break\\n time.sleep(0.1)\\n filePath = os.path.join(mountPath, 'user', 'admin', 'Public', 'test', 'file1a.txt')\\n self.assertEqual(File().getGirderMountFilePath(self.file), filePath)\\n self.assertNotEqual(File().getGirderMountFilePath(self.file),\\n File().getLocalFilePath(self.file))\\n self.assertTrue(os.path.exists(filePath))\\n self.assertEqual(open(filePath).read().strip(), 'File 1A')\\n subprocess.check_call(['girder', 'mount', mountPath, '-u'])\\n endTime = time.time() + 10 # maximum time to wait\\n while time.time() < endTime:\\n if not os.path.exists(os.path.join(mountPath, 'user')):\\n break\\n time.sleep(0.1)\\n self.assertFalse(os.path.exists(filePath))\\n os.rmdir(mountPath)\\n with self.assertRaises(FilePathException):\\n File().getGirderMountFilePath(self.file)\",\n \"def __init__(self, mount_point):\\n self.mount = mount_point\",\n \"def _mount(source, target):\\n # type: (str, str) -> None\\n\\n mount_options = ['mount', source, target]\\n\\n process = subprocess.Popen(mount_options, stderr=subprocess.PIPE)\\n out, err = process.communicate()\\n if process.returncode > 0:\\n raise OSError(err)\",\n \"def path_mounts(self) -> Path:\\n return self.path_supervisor / MOUNTS_FOLDER\",\n \"def mount(fstype, export, vol_name, mountpoint, instance, options=None):\\n with __manager__.get_state() as mount_state:\\n mount_state.mount(fstype, export, vol_name, mountpoint, instance,\\n options)\",\n \"def _do_mount(self, cmd, ensure):\\n try:\\n self._execute(*cmd, run_as_root=True)\\n except exception.ProcessExecutionError as exc:\\n if ensure and 'already mounted' in exc.stderr:\\n LOG.warn(_LW(\\\"%s is already mounted\\\"),\\n self.gluster_manager.export)\\n else:\\n raise exception.GlusterfsException(\\n 'Unable to mount Gluster volume'\\n )\",\n \"def _get_mount(self):\\n if not self._mount.endswith(os.path.sep):\\n return \\\"%s%s\\\" % (self._mount, os.path.sep)\\n else:\\n return self._mount\",\n \"def __init__(self, win_server, share_folder, mount_point, user, password):\\n \\n share_folder = share_folder.replace(\\\"/\\\", \\\"\\\\\\\\\\\")\\n network_folder = r'//%s/%s' %(win_server, share_folder)\\n\\n print('Mount_point - %s' %(mount_point))\\n print('In the python code next use mount() function - to mount windows share folder, and use umount() function - to unmount')\\n self.mount_point = mount_point\\n self.options = {'network_folder':network_folder, 'mount_point':mount_point,'user':user}\\n self.success = []\\n self.error = []\\n\\n mount_cmd = \\\"mount_smbfs //{user}:{password}@{network_folder} {mount_point}\\\"\\n self.mount_cmd = mount_cmd.format(network_folder=network_folder,\\n mount_point=mount_point,\\n user=user,\\n password=password)\\n self.umount_cmd = \\\"umount {mount_point}\\\".format(mount_point=mount_point)\",\n \"def mount(self, dev, path, mount_options):\\n # if directory is not a mount point, mount it\\n if not os.path.ismount(path):\\n # check to see if dev is LVM. If so, activate it's associated volume group\\n vg = self.get_vg(dev)\\n if len(vg) > 0:\\n Helper._runOsCommand(\\\"sudo /sbin/pvscan && sudo /sbin/vgscan && sudo /sbin/lvscan && sudo /sbin/vgchange -ay %s\\\" % vg, self.tracer)\\n # check / create mount point and mount device\\n self._checkAndCreatePath(path)\\n self._mount(dev, path, mount_options)\\n else:\\n self.tracer.info(\\\"device %s is already mounted to %s\\\" % (dev, path))\",\n \"def mount(self, path=None, vm=None):\\n os.system(f\\\"multipass mount {path} {vm}\\\")\\n dict_result = self._get_mount_status(vm=vm)\\n return dict_result\",\n \"def do_mount(devpath, mountpoint, fstype):\\n try:\\n if check_already_mounted(devpath, mountpoint):\\n return\\n\\n mounter = Mounter()\\n mounter.mount(devpath, mountpoint, fstype)\\n except exceptions.MountException:\\n try:\\n mounter.make_filesystem(devpath, fstype)\\n mounter.mount(devpath, mountpoint, fstype)\\n except exceptions.FuxiException as e:\\n with excutils.save_and_reraise_exception():\\n LOG.error(str(e))\",\n \"def mount(githubdir, mntpoint, verbose=True, foreground=True):\\n fuse.FUSE(GithubOperations(root=githubdir),\\n mntpoint, nothreads=True, foreground=foreground)\",\n \"def test_mountfile(self):\\n quote = b\\\"\\\"\\\"If you wish to make an apple pie from scratch, you must first invent the universe.\\\"\\\"\\\"\\n mem_fs = MemoryFS()\\n mem_fs.makedir('foo')\\n mem_fs.setcontents('foo/bar.txt', quote)\\n foo_dir = mem_fs.opendir('foo')\\n\\n mount_fs = MountFS()\\n mount_fs.mountfile('bar.txt', foo_dir.open, foo_dir.getinfo)\\n\\n self.assertTrue(mount_fs.isdir('/'))\\n self.assertTrue(mount_fs.isdir('./'))\\n self.assertTrue(mount_fs.isdir(''))\\n\\n # Check we can see the mounted file in the dir list\\n self.assertEqual(mount_fs.listdir(), [\\\"bar.txt\\\"])\\n self.assertTrue(not mount_fs.exists('nobodyhere.txt'))\\n self.assertTrue(mount_fs.exists('bar.txt'))\\n self.assertTrue(mount_fs.isfile('bar.txt'))\\n self.assertTrue(not mount_fs.isdir('bar.txt'))\\n\\n # Check open and getinfo callables\\n self.assertEqual(mount_fs.getcontents('bar.txt'), quote)\\n self.assertEqual(mount_fs.getsize('bar.txt'), len(quote))\\n\\n # Check changes are written back\\n mem_fs.setcontents('foo/bar.txt', 'baz')\\n self.assertEqual(mount_fs.getcontents('bar.txt'), b'baz')\\n self.assertEqual(mount_fs.getsize('bar.txt'), len('baz'))\\n\\n # Check changes are written to the original fs\\n self.assertEqual(mem_fs.getcontents('foo/bar.txt'), b'baz')\\n self.assertEqual(mem_fs.getsize('foo/bar.txt'), len('baz'))\\n\\n # Check unmount\\n self.assertTrue(mount_fs.unmount(\\\"bar.txt\\\"))\\n self.assertEqual(mount_fs.listdir(), [])\\n self.assertTrue(not mount_fs.exists('bar.txt'))\\n\\n # Check unount a second time is a null op, and returns False\\n self.assertFalse(mount_fs.unmount(\\\"bar.txt\\\"))\",\n \"def testMakeMountCommands(self):\\n self.maxDiff = None\\n container_obj = self.explorer_object.GetContainer(\\n '8e8b7f23eb7cbd4dfe7e91646ddd0e0f524218e25d50113559f078dfb2690206')\\n commands = container_obj.storage_object.MakeMountCommands(\\n container_obj, '/mnt')\\n commands = [' '.join(cmd) for cmd in commands]\\n expected_commands = [(\\n '/bin/mount -t overlay overlay -o ro,lowerdir='\\n 'test_data/docker/overlay2/'\\n '92fd3b3e7d6101bb701743c9518c45b0d036b898c8a3d7cae84e1a06e6829b53/diff:'\\n 'test_data/docker/overlay2/l/OTFSLJCXWCECIG6FVNGRTWUZ7D:'\\n 'test_data/docker/overlay2/l/CH5A7XWSBP2DUPV7V47B7DOOGY /mnt')]\\n self.assertEqual(expected_commands, commands)\",\n \"def testMakeMountCommands(self):\\n container_obj = self.explorer_object.GetContainer(\\n '5dc287aa80b460652a5584e80a5c8c1233b0c0691972d75424cf5250b917600a')\\n commands = container_obj.storage_object.MakeMountCommands(\\n container_obj, '/mnt')\\n commands = [' '.join(cmd) for cmd in commands]\\n expected_commands = [(\\n '/bin/mount -t overlay overlay -o ro,lowerdir='\\n 'test_data/docker/overlay/974e2b994f9db74e1ddd6fc546843bc65920e786612'\\n 'a388f25685acf84b3fed1/upper:'\\n 'test_data/docker/overlay/a94d714512251b0d8a9bfaacb832e0c6cb70f71cb71'\\n '976cca7a528a429336aae/root '\\n '/mnt')]\\n self.assertEqual(expected_commands, commands)\",\n \"def Mount(self, mount_point, mount_options_by_format=\\\"\\\"):\\n fstab = self.fstab\\n if fstab:\\n p = fstab[mount_point]\\n mount_dict = {}\\n if mount_options_by_format is not None:\\n for option in mount_options_by_format.split(\\\"|\\\"):\\n if \\\"=\\\" in option:\\n key, value = option.split(\\\"=\\\", 1)\\n mount_dict[key] = value\\n mount_flags = mount_dict.get(p.fs_type, \\\"\\\")\\n if p.context is not None:\\n mount_flags = p.context + (\\\",\\\" + mount_flags if mount_flags else \\\"\\\")\\n self.script.append('mount(\\\"%s\\\", \\\"%s\\\", %s, \\\"%s\\\", \\\"%s\\\");' % (\\n p.fs_type, common.PARTITION_TYPES[p.fs_type],\\n self._GetSlotSuffixDeviceForEntry(p),\\n p.mount_point, mount_flags))\\n self.mounts.add(p.mount_point)\",\n \"def cgroup_mount_option(command: Callable[..., None]) -> Callable[..., None]:\\n function = click.option(\\n '--mount-sys-fs-cgroup/--no-mount-sys-fs-cgroup',\\n default=True,\\n show_default=True,\\n help=(\\n 'Mounting ``/sys/fs/cgroup`` from the host is required to run '\\n 'applications which require ``cgroup`` isolation. '\\n 'Choose to not mount ``/sys/fs/cgroup`` if it is not available on '\\n 'the host.'\\n ),\\n )(command) # type: Callable[..., None]\\n return function\",\n \"def testMakeMountCommands(self):\\n self.maxDiff = None\\n container_obj = self.explorer_object.GetContainer(\\n '7b02fb3e8a665a63e32b909af5babb7d6ba0b64e10003b2d9534c7d5f2af8966')\\n commands = container_obj.storage_object.MakeMountCommands(\\n container_obj, '/mnt')\\n commands = [' '.join(x) for x in commands]\\n expected_commands = [\\n (\\n '/bin/mount -t aufs -o ro,br=test_data/docker/aufs/diff/test_data/'\\n 'docker/aufs/diff/'\\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'b16a494082bba0091e572b58ff80af1b7b5d28737a3eedbe01e73cd7f4e01d23'\\n '-init=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'd1c54c46d331de21587a16397e8bd95bdbb1015e1a04797c76de128107da83ae'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount --bind -o ro test_data/docker/volumes/'\\n '28297de547b5473a9aff90aaab45ed108ebf019981b40c3c35c226f54c13ac0d/'\\n '_data /mnt/var/jenkins_home')\\n ]\\n self.assertEqual(expected_commands, commands)\",\n \"def mount(\\n self, path, mode, *, persistent=True, text_only=False\\n ): # pylint: disable=arguments-differ\\n if mode not in (\\\"r\\\", \\\"w\\\"):\\n raise ValueError('Mode must be \\\"r\\\" or \\\"w\\\"')\\n if mode == \\\"r\\\":\\n hcell = self._get_hcell2()\\n hcell.pop(\\\"checksum\\\", None)\\n super().mount(path, mode, \\\"cell\\\", persistent=persistent)\\n if text_only:\\n hcell = self._get_hcell2()\\n hcell[\\\"mount\\\"][\\\"directory_text_only\\\"] = True\\n return self\",\n \"def cli():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"--mountpoint\\\", dest=\\\"mountpoint\\\", help=\\\"Mount point\\\")\\n parser.add_argument(\\\"--githubdir\\\", dest=\\\"githubdir\\\", help=\\\"Github caching directory.\\\")\\n parser.add_argument(\\\"--foreground\\\", dest=\\\"foreground\\\", action=\\\"store_true\\\", help=\\\"Show in foreground.\\\")\\n\\n args = parser.parse_args()\\n mount(args.githubdir, mntpoint=args.mountpoint, foreground=args.foreground)\",\n \"def _mount (self,blockDevice,mountingPoint,blockDeviceReadahead,timer):\\n\\n # pre-mount command\\n preMountCmd = self._activeCommandsConfig.preMount\\n preMountCmdExtras = self._activeCommandsConfig.preMountExtras\\n preMountCmdString = self.__joinCmdStringWithExtras(preMountCmd,preMountCmdExtras)\\n if (preMountCmdString != \\\"\\\"):\\n stdout,stderr,rc = self._runCommand(preMountCmdString,timer)\\n if (rc != 0):\\n self._log(\\\"pre-mount-cmd-fail\\\").error(\\\"pre-mount command '%s' failed! stderr=%s\\\",preMountCmdString,stderr)\\n return ReturnCodes.kGeneralError\\n\\n # mount command\\n mountCmd = self._activeCommandsConfig.mount\\n mountCmdExtras = self._activeCommandsConfig.mountExtras\\n mountCmdString = mountCmd%{self.MOUNTING_POINT_COMMAND_ELEMENT:mountingPoint,self.BLOCK_DEVICE_COMMAND_ELEMENT:blockDevice}\\n mountCmdString = self.__joinCmdStringWithExtras(mountCmdString,mountCmdExtras)\\n stdout,stderr,rc = self._runCommand(mountCmdString,timer)\\n if (rc != 0):\\n self._log(\\\"mount-cmd-fail\\\").error(\\\"mount command '%s' failed! stderr=%s\\\",mountCmdString,stderr)\\n # TODO: consider insertion os pre and post commands cancelation commands - since we don't know what they do...\\n return ReturnCodes.kGeneralError\\n\\n # post-mount command\\n postMountCmd = self._activeCommandsConfig.preMount\\n postMountCmdExtras = self._activeCommandsConfig.preMountExtras\\n postMountCmdString = postMountCmd%{self.BLOCK_DEVICE_COMMAND_ELEMENT:blockDevice,self.SECTORS_COMMAND_ELEMENT:blockDeviceReadahead}\\n postMountCmdString = self.__joinCmdStringWithExtras(postMountCmdString,postMountCmdExtras)\\n if (postMountCmdString != \\\"\\\"):\\n stdout,stderr,rc = self._runCommand(postMountCmdString,timer)\\n if (rc != 0):\\n self._log(\\\"post-mount-cmd-fail\\\").error(\\\"post-mount command '%s' failed! stderr=%s\\\",postMountCmdString,stderr)\\n return ReturnCodes.kGeneralError\\n\\n # full success\\n self._log(\\\"mount-sequence-success\\\").debug2(\\\"full mount sequence was successful!\\\")\\n return ReturnCodes.kOk\",\n \"def mount(self, pathname):\\n \\n # Make sure we don't try to mount something twice.\\n if pathname in self.mounts:\\n raise ProcessorError(\\\"%s is already mounted\\\" % pathname)\\n \\n # Call hdiutil.\\n try:\\n p = subprocess.Popen((\\\"/usr/bin/hdiutil\\\",\\n \\\"attach\\\",\\n \\\"-plist\\\",\\n \\\"-mountrandom\\\", \\\"/private/tmp\\\",\\n \\\"-nobrowse\\\",\\n pathname),\\n stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n (out, err) = p.communicate()\\n except OSError as e:\\n raise ProcessorError(\\\"hdiutil execution failed with error code %d: %s\\\" % (\\n e.errno, e.strerror))\\n if p.returncode != 0:\\n raise ProcessorError(\\\"mounting %s failed: %s\\\" % (pathname, err))\\n \\n # Read output plist.\\n output = plistlib.readPlistFromString(out)\\n \\n # Find mount point.\\n for part in output[\\\"system-entities\\\"]:\\n if \\\"mount-point\\\" in part:\\n # Add to mount list.\\n self.mounts[pathname] = part[\\\"mount-point\\\"]\\n self.output(\\\"Mounted disk image %s\\\" % (pathname))\\n return self.mounts[pathname]\",\n \"def mount(\\n dev,\\n fstype,\\n options,\\n ):\\n # sanity check: none of the arguments are None\\n if dev is None:\\n raise ValueError('dev may not be None')\\n if fstype is None:\\n raise ValueError('fstype may not be None')\\n\\n # pick best-of-breed mount options based on fs type\\n if options is None:\\n options = MOUNT_OPTIONS.get(fstype, '')\\n\\n # mount\\n path = tempfile.mkdtemp(\\n prefix='mnt.',\\n dir=STATEDIR + '/tmp',\\n )\\n try:\\n LOG.debug('Mounting %s on %s with options %s', dev, path, options)\\n command_check_call(\\n [\\n 'mount',\\n '-t', fstype,\\n '-o', options,\\n '--',\\n dev,\\n path,\\n ],\\n )\\n except subprocess.CalledProcessError as e:\\n try:\\n os.rmdir(path)\\n except (OSError, IOError):\\n pass\\n raise MountError(e)\\n\\n return path\",\n \"def testMakeMountCommands(self):\\n container_obj = self.explorer_object.GetContainer(\\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c')\\n commands = container_obj.storage_object.MakeMountCommands(\\n container_obj, '/mnt')\\n commands = [' '.join(x) for x in commands]\\n expected_commands = [\\n (\\n '/bin/mount -t aufs -o ro,br=test_data/'\\n 'docker/aufs/diff/'\\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'de44dd97cfd1c8d1c1aad7f75a435603991a7a39fa4f6b20a69bf4458809209c'\\n '-init=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n '1cee97b18f87b5fa91633db35f587e2c65c093facfa2cbbe83d5ebe06e1d9125'\\n '=ro+wh none /mnt'),\\n (\\n '/bin/mount -t aufs -o ro,remount,append:test_data/docker/aufs/diff/'\\n 'df557f39d413a1408f5c28d8aab2892f927237ec22e903ef04b331305130ab38'\\n '=ro+wh none /mnt')\\n ]\\n self.assertEqual(expected_commands, commands)\",\n \"def mounts(self) -> list[str]:\\n _args: list[Arg] = []\\n _ctx = self._select(\\\"mounts\\\", _args)\\n return _ctx.execute_sync(list[str])\",\n \"def get_mount(self, pipette_id: str) -> MountType:\\n return self.get(pipette_id).mount\",\n \"def active_mountpoint(mount_point):\\n execute('mount', mount_point, sudo=True)\\n yield\\n execute('umount', mount_point, sudo=True)\",\n \"def get_mount_info(devname, label=None):\\n mount_point = get_mount_target(devname, label)\\n mounts = check_output('mount | grep \\\" %s \\\" || :' % mount_point, shell=True)\\n if mounts:\\n return Munch(zip(('device', 'mount_point', 'type', 'options'),\\n MOUNTS_RE.match(mounts.decode()).groups()))\",\n \"def mount_path(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"mount_path\\\")\",\n \"def cat_cmd(server, client, line):\\n if len(line.split(' ')) > 1 and line.split(' ')[1] == \\\"/proc/mounts\\\":\\n path = os.path.dirname(os.path.realpath(__file__))\\n path = path[:-7] # shaves off /engine\\n with open(\\\"{}/fakefiles/proc%mounts\\\".format(path), \\\"r\\\") as f:\\n response = f.read()\\n client.exit_status = 0\\n else:\\n response = client.run_in_container(line)\\n client.send(response)\",\n \"def mount(self, name, path):\\n if not os.path.exists(path):\\n raise OSError('no mount path: '+ path)\\n if name.startswith('/'):\\n name = name[1:]\\n self._top_paths[name] = path\",\n \"def actually_mount(self, client):\\n try:\\n getattr(client, self.mount_fun)(self.backend,\\n mount_point=self.path)\\n except hvac.exceptions.InvalidRequest as exception:\\n match = re.match('existing mount at (?P<path>.+)', str(exception))\\n if match:\\n e_msg = \\\"%s has a mountpoint conflict with %s\\\" % \\\\\\n (self.path, match.group('path'))\\n raise aomi.exceptions.VaultConstraint(e_msg)\\n else:\\n raise\",\n \"def mount(f, mountpoint=DMG_MOUNT, read_only=False, dry_run=ARGS.dry_run):\\n result = None\\n cmd = ['/usr/bin/hdiutil', 'attach', '-mountpoint', str(mountpoint), '-plist', f]\\n\\n # Insert read only option in the correct spot\\n if read_only:\\n cmd.insert(2, '-readonly')\\n\\n if not dry_run:\\n _p = subprocess.run(cmd, capture_output=True)\\n LOG.debug('{cmd} ({returncode})'.format(cmd=' '.join([str(x) for x in cmd]), returncode=_p.returncode))\\n\\n if _p.returncode == 0:\\n _entities = plist.read_string(_p.stdout).get('system-entities')\\n\\n if _entities:\\n result = mount_device(_entities)\\n LOG.warning('Mounted {dmg} to {mountpoint}'.format(dmg=f, mountpoint=mountpoint))\\n else:\\n LOG.info(_p.stderr.decode('utf-8').strip())\\n else:\\n LOG.warning('Mount {dmg} to {mountpoint}'.format(dmg=f, mountpoint=mountpoint))\\n\\n return result\",\n \"def mounted(\\n name,\\n device,\\n fstype,\\n mkmnt=False,\\n opts=\\\"defaults\\\",\\n dump=0,\\n pass_num=0,\\n config=\\\"/etc/fstab\\\",\\n persist=True,\\n mount=True,\\n user=None,\\n match_on=\\\"auto\\\",\\n device_name_regex=None,\\n extra_mount_invisible_options=None,\\n extra_mount_invisible_keys=None,\\n extra_mount_ignore_fs_keys=None,\\n extra_mount_translate_options=None,\\n hidden_opts=None,\\n bind_mount_copy_active_opts=True,\\n **kwargs\\n):\\n ret = {\\\"name\\\": name, \\\"changes\\\": {}, \\\"result\\\": True, \\\"comment\\\": \\\"\\\"}\\n\\n update_mount_cache = False\\n\\n if not name:\\n ret[\\\"result\\\"] = False\\n ret[\\\"comment\\\"] = \\\"Must provide name to mount.mounted\\\"\\n return ret\\n\\n if not device:\\n ret[\\\"result\\\"] = False\\n ret[\\\"comment\\\"] = \\\"Must provide device to mount.mounted\\\"\\n return ret\\n\\n if not fstype:\\n ret[\\\"result\\\"] = False\\n ret[\\\"comment\\\"] = \\\"Must provide fstype to mount.mounted\\\"\\n return ret\\n\\n if device_name_regex is None:\\n device_name_regex = []\\n\\n # Defaults is not a valid option on Mac OS\\n if __grains__[\\\"os\\\"] in [\\\"MacOS\\\", \\\"Darwin\\\"] and opts == \\\"defaults\\\":\\n opts = \\\"noowners\\\"\\n\\n # Defaults is not a valid option on AIX\\n if __grains__[\\\"os\\\"] in [\\\"AIX\\\"]:\\n if opts == \\\"defaults\\\":\\n opts = \\\"\\\"\\n\\n # Make sure that opts is correct, it can be a list or a comma delimited\\n # string\\n if isinstance(opts, str):\\n opts = opts.split(\\\",\\\")\\n\\n if isinstance(hidden_opts, str):\\n hidden_opts = hidden_opts.split(\\\",\\\")\\n\\n # remove possible trailing slash\\n if not name == \\\"/\\\":\\n name = name.rstrip(\\\"/\\\")\\n\\n device_list = []\\n # Get the active data\\n active = __salt__[\\\"mount.active\\\"](extended=True)\\n real_name = os.path.realpath(name)\\n # real_name for comparisons to the active mount list\\n comp_real_name = real_name.replace(\\\" \\\", \\\"\\\\\\\\040\\\")\\n if device.startswith(\\\"/\\\"):\\n if \\\"bind\\\" in opts and comp_real_name in active:\\n _device = device.replace(\\\" \\\", \\\"\\\\\\\\040\\\")\\n if active[comp_real_name][\\\"device\\\"].startswith(\\\"/\\\"):\\n # Find the device that the bind really points at.\\n while True:\\n if _device in active:\\n _real_device = active[_device][\\\"device\\\"]\\n if bind_mount_copy_active_opts:\\n opts = sorted(\\n set(\\n opts\\n + active[_device][\\\"opts\\\"]\\n + active[_device][\\\"superopts\\\"]\\n )\\n )\\n active[comp_real_name][\\\"opts\\\"].append(\\\"bind\\\")\\n break\\n _device = os.path.dirname(_device.replace(\\\"\\\\\\\\040\\\", \\\" \\\"))\\n real_device = _real_device\\n else:\\n # Remote file systems act differently.\\n if _device in active:\\n if bind_mount_copy_active_opts:\\n opts = sorted(\\n set(\\n opts\\n + active[_device][\\\"opts\\\"]\\n + active[_device][\\\"superopts\\\"]\\n )\\n )\\n active[comp_real_name][\\\"opts\\\"].append(\\\"bind\\\")\\n real_device = active[comp_real_name][\\\"device\\\"]\\n else:\\n real_device = os.path.realpath(device)\\n elif device.upper().startswith(\\\"UUID=\\\"):\\n real_device = device.split(\\\"=\\\")[1].strip('\\\"').lower()\\n elif device.upper().startswith(\\\"LABEL=\\\"):\\n _label = device.split(\\\"=\\\")[1]\\n cmd = \\\"blkid -t LABEL={}\\\".format(_label)\\n res = __salt__[\\\"cmd.run_all\\\"](\\\"{}\\\".format(cmd))\\n if res[\\\"retcode\\\"] > 0:\\n ret[\\\"comment\\\"] = \\\"Unable to find device with label {}.\\\".format(_label)\\n ret[\\\"result\\\"] = False\\n return ret\\n else:\\n # output is a list of entries like this:\\n # /dev/sda: LABEL=\\\"<label>\\\" UUID=\\\"<uuid>\\\" UUID_SUB=\\\"<uuid>\\\" TYPE=\\\"btrfs\\\"\\n # exact list of properties varies between filesystems, but we're\\n # only interested in the device in the first column\\n for line in res[\\\"stdout\\\"]:\\n dev_with_label = line.split(\\\":\\\")[0]\\n device_list.append(dev_with_label)\\n real_device = device_list[0]\\n else:\\n real_device = device\\n\\n # LVS devices have 2 names under /dev:\\n # /dev/mapper/vg--name-lv--name and /dev/vg-name/lv-name\\n # No matter what name is used for mounting,\\n # mount always displays the device as /dev/mapper/vg--name-lv--name\\n # Note the double-dash escaping.\\n # So, let's call that the canonical device name\\n # We should normalize names of the /dev/vg-name/lv-name type to the canonical name\\n lvs_match = re.match(r\\\"^/dev/(?P<vg_name>[^/]+)/(?P<lv_name>[^/]+$)\\\", device)\\n if lvs_match:\\n double_dash_escaped = {\\n k: re.sub(r\\\"-\\\", \\\"--\\\", v) for k, v in lvs_match.groupdict().items()\\n }\\n mapper_device = \\\"/dev/mapper/{vg_name}-{lv_name}\\\".format(**double_dash_escaped)\\n if os.path.exists(mapper_device):\\n real_device = mapper_device\\n\\n # When included in a Salt state file, FUSE devices are prefaced by the\\n # filesystem type and a hash, e.g. sshfs. In the mount list only the\\n # hostname is included. So if we detect that the device is a FUSE device\\n # then we remove the prefaced string so that the device in state matches\\n # the device in the mount list.\\n fuse_match = re.match(r\\\"^\\\\w+\\\\#(?P<device_name>.+)\\\", device)\\n if fuse_match:\\n if \\\"device_name\\\" in fuse_match.groupdict():\\n real_device = fuse_match.group(\\\"device_name\\\")\\n\\n if comp_real_name in active:\\n if \\\"superopts\\\" not in active[comp_real_name]:\\n active[comp_real_name][\\\"superopts\\\"] = []\\n if mount:\\n device_list.append(active[comp_real_name][\\\"device\\\"])\\n device_list.append(os.path.realpath(device_list[0]))\\n alt_device = (\\n active[comp_real_name][\\\"alt_device\\\"]\\n if \\\"alt_device\\\" in active[comp_real_name]\\n else None\\n )\\n uuid_device = (\\n active[comp_real_name][\\\"device_uuid\\\"]\\n if \\\"device_uuid\\\" in active[comp_real_name]\\n else None\\n )\\n label_device = (\\n active[comp_real_name][\\\"device_label\\\"]\\n if \\\"device_label\\\" in active[comp_real_name]\\n else None\\n )\\n if alt_device and alt_device not in device_list:\\n device_list.append(alt_device)\\n if uuid_device and uuid_device not in device_list:\\n device_list.append(uuid_device)\\n if label_device and label_device not in device_list:\\n device_list.append(label_device)\\n if opts:\\n mount_invisible_options = [\\n \\\"_netdev\\\",\\n \\\"actimeo\\\",\\n \\\"bg\\\",\\n \\\"comment\\\",\\n \\\"defaults\\\",\\n \\\"delay_connect\\\",\\n \\\"direct-io-mode\\\",\\n \\\"intr\\\",\\n \\\"loop\\\",\\n \\\"nointr\\\",\\n \\\"nobootwait\\\",\\n \\\"nofail\\\",\\n \\\"password\\\",\\n \\\"reconnect\\\",\\n \\\"retry\\\",\\n \\\"soft\\\",\\n \\\"auto\\\",\\n \\\"users\\\",\\n \\\"bind\\\",\\n \\\"nonempty\\\",\\n \\\"transform_symlinks\\\",\\n \\\"port\\\",\\n \\\"backup-volfile-servers\\\",\\n ]\\n\\n if extra_mount_invisible_options:\\n mount_invisible_options.extend(extra_mount_invisible_options)\\n\\n if hidden_opts:\\n mount_invisible_options = list(\\n set(mount_invisible_options) | set(hidden_opts)\\n )\\n\\n # options which are provided as key=value (e.g. password=Zohp5ohb)\\n mount_invisible_keys = [\\n \\\"actimeo\\\",\\n \\\"comment\\\",\\n \\\"credentials\\\",\\n \\\"direct-io-mode\\\",\\n \\\"password\\\",\\n \\\"port\\\",\\n \\\"retry\\\",\\n \\\"secretfile\\\",\\n ]\\n\\n if extra_mount_invisible_keys:\\n mount_invisible_keys.extend(extra_mount_invisible_keys)\\n\\n # Some filesystems have options which should not force a remount.\\n mount_ignore_fs_keys = {\\\"ramfs\\\": [\\\"size\\\"]}\\n\\n if extra_mount_ignore_fs_keys:\\n mount_ignore_fs_keys.update(extra_mount_ignore_fs_keys)\\n\\n # Some options are translated once mounted\\n mount_translate_options = {\\n \\\"tcp\\\": \\\"proto=tcp\\\",\\n \\\"udp\\\": \\\"proto=udp\\\",\\n }\\n\\n if extra_mount_translate_options:\\n mount_translate_options.update(extra_mount_translate_options)\\n\\n trigger_remount = []\\n for opt in opts:\\n if opt in mount_translate_options:\\n opt = mount_translate_options[opt]\\n\\n keyval_option = opt.split(\\\"=\\\")[0]\\n if keyval_option in mount_invisible_keys:\\n opt = keyval_option\\n\\n size_match = re.match(\\n r\\\"size=(?P<size_value>[0-9]+)(?P<size_unit>k|m|g)\\\", opt\\n )\\n if size_match:\\n converted_size = _size_convert(size_match)\\n opt = \\\"size={}k\\\".format(converted_size)\\n # make cifs option user synonym for option username which is reported by /proc/mounts\\n if fstype in [\\\"cifs\\\"] and opt.split(\\\"=\\\")[0] == \\\"user\\\":\\n opt = \\\"username={}\\\".format(opt.split(\\\"=\\\")[1])\\n\\n if opt.split(\\\"=\\\")[0] in mount_ignore_fs_keys.get(fstype, []):\\n opt = opt.split(\\\"=\\\")[0]\\n\\n # convert uid/gid to numeric value from user/group name\\n name_id_opts = {\\\"uid\\\": \\\"user.info\\\", \\\"gid\\\": \\\"group.info\\\"}\\n if opt.split(\\\"=\\\")[0] in name_id_opts and len(opt.split(\\\"=\\\")) > 1:\\n _givenid = opt.split(\\\"=\\\")[1]\\n _param = opt.split(\\\"=\\\")[0]\\n _id = _givenid\\n if not re.match(\\\"[0-9]+$\\\", _givenid):\\n _info = __salt__[name_id_opts[_param]](_givenid)\\n if _info and _param in _info:\\n _id = _info[_param]\\n opt = _param + \\\"=\\\" + str(_id)\\n\\n _active_superopts = active[comp_real_name].get(\\\"superopts\\\", [])\\n for _active_opt in _active_superopts:\\n size_match = re.match(\\n r\\\"size=(?P<size_value>[0-9]+)(?P<size_unit>k|m|g)\\\",\\n _active_opt,\\n )\\n if size_match:\\n converted_size = _size_convert(size_match)\\n opt = \\\"size={}k\\\".format(converted_size)\\n _active_superopts.remove(_active_opt)\\n _active_opt = \\\"size={}k\\\".format(converted_size)\\n _active_superopts.append(_active_opt)\\n\\n if (\\n opt not in active[comp_real_name][\\\"opts\\\"]\\n and opt not in _active_superopts\\n and opt not in mount_invisible_options\\n and opt not in mount_ignore_fs_keys.get(fstype, [])\\n and opt not in mount_invisible_keys\\n ):\\n trigger_remount.append(opt)\\n\\n if trigger_remount:\\n if __opts__[\\\"test\\\"]:\\n ret[\\\"result\\\"] = None\\n ret[\\n \\\"comment\\\"\\n ] = \\\"Remount would be forced because options ({}) changed\\\".format(\\n \\\",\\\".join(sorted(trigger_remount))\\n )\\n return ret\\n else:\\n # Some file systems require umounting and mounting if options change\\n # add others to list that require similiar functionality\\n if fstype in [\\\"nfs\\\", \\\"cvfs\\\"] or fstype.startswith(\\\"fuse\\\"):\\n ret[\\\"changes\\\"][\\\"umount\\\"] = (\\n \\\"Forced unmount and mount because \\\"\\n + \\\"options ({}) changed\\\".format(\\n \\\",\\\".join(sorted(trigger_remount))\\n )\\n )\\n unmount_result = __salt__[\\\"mount.umount\\\"](real_name)\\n if unmount_result is True:\\n mount_result = __salt__[\\\"mount.mount\\\"](\\n real_name,\\n device,\\n mkmnt=mkmnt,\\n fstype=fstype,\\n opts=opts,\\n )\\n ret[\\\"result\\\"] = mount_result\\n else:\\n ret[\\\"result\\\"] = False\\n ret[\\\"comment\\\"] = \\\"Unable to unmount {}: {}.\\\".format(\\n real_name, unmount_result\\n )\\n return ret\\n else:\\n ret[\\\"changes\\\"][\\\"umount\\\"] = (\\n \\\"Forced remount because \\\"\\n + \\\"options ({}) changed\\\".format(\\n \\\",\\\".join(sorted(trigger_remount))\\n )\\n )\\n remount_result = __salt__[\\\"mount.remount\\\"](\\n real_name,\\n device,\\n mkmnt=mkmnt,\\n fstype=fstype,\\n opts=opts,\\n )\\n ret[\\\"result\\\"] = remount_result\\n # Cleanup after the remount, so we\\n # don't write remount into fstab\\n if \\\"remount\\\" in opts:\\n opts.remove(\\\"remount\\\")\\n\\n # Update the cache\\n update_mount_cache = True\\n\\n mount_cache = __salt__[\\\"mount.read_mount_cache\\\"](real_name)\\n if \\\"opts\\\" in mount_cache:\\n _missing = [opt for opt in mount_cache[\\\"opts\\\"] if opt not in opts]\\n\\n if _missing:\\n if __opts__[\\\"test\\\"]:\\n ret[\\\"result\\\"] = None\\n ret[\\\"comment\\\"] = (\\n \\\"Remount would be forced because\\\"\\n \\\" options ({})\\\"\\n \\\"changed\\\".format(\\\",\\\".join(_missing))\\n )\\n return ret\\n else:\\n # Some file systems require umounting and mounting if options change\\n # add others to list that require similiar functionality\\n if fstype in [\\\"nfs\\\", \\\"cvfs\\\"] or fstype.startswith(\\\"fuse\\\"):\\n ret[\\\"changes\\\"][\\\"umount\\\"] = (\\n \\\"Forced unmount and mount because \\\"\\n + \\\"options ({}) changed\\\".format(opt)\\n )\\n unmount_result = __salt__[\\\"mount.umount\\\"](real_name)\\n if unmount_result is True:\\n mount_result = __salt__[\\\"mount.mount\\\"](\\n real_name,\\n device,\\n mkmnt=mkmnt,\\n fstype=fstype,\\n opts=opts,\\n )\\n ret[\\\"result\\\"] = mount_result\\n else:\\n ret[\\\"result\\\"] = False\\n ret[\\\"comment\\\"] = \\\"Unable to unmount {}: {}.\\\".format(\\n real_name, unmount_result\\n )\\n return ret\\n else:\\n ret[\\\"changes\\\"][\\\"umount\\\"] = (\\n \\\"Forced remount because \\\"\\n + \\\"options ({}) changed\\\".format(opt)\\n )\\n remount_result = __salt__[\\\"mount.remount\\\"](\\n real_name,\\n device,\\n mkmnt=mkmnt,\\n fstype=fstype,\\n opts=opts,\\n )\\n ret[\\\"result\\\"] = remount_result\\n # Cleanup after the remount, so we\\n # don't write remount into fstab\\n if \\\"remount\\\" in opts:\\n opts.remove(\\\"remount\\\")\\n\\n update_mount_cache = True\\n else:\\n update_mount_cache = True\\n\\n if real_device not in device_list:\\n # name matches but device doesn't - need to umount\\n _device_mismatch_is_ignored = None\\n for regex in list(device_name_regex):\\n for _device in device_list:\\n if re.match(regex, _device):\\n _device_mismatch_is_ignored = _device\\n break\\n if _device_mismatch_is_ignored:\\n ret[\\\"result\\\"] = True\\n ret[\\\"comment\\\"] = (\\n \\\"An umount will not be forced \\\"\\n + \\\"because device matched device_name_regex: \\\"\\n + _device_mismatch_is_ignored\\n )\\n elif __opts__[\\\"test\\\"]:\\n ret[\\\"result\\\"] = None\\n ret[\\\"comment\\\"] = (\\n \\\"An umount would have been forced \\\"\\n + \\\"because devices do not match. Watched: \\\"\\n + device\\n )\\n else:\\n ret[\\\"changes\\\"][\\\"umount\\\"] = (\\n \\\"Forced unmount because devices \\\"\\n + \\\"don't match. Wanted: \\\"\\n + device\\n )\\n if real_device != device:\\n ret[\\\"changes\\\"][\\\"umount\\\"] += \\\" (\\\" + real_device + \\\")\\\"\\n ret[\\\"changes\\\"][\\\"umount\\\"] += \\\", current: \\\" + \\\", \\\".join(device_list)\\n out = __salt__[\\\"mount.umount\\\"](real_name, user=user)\\n active = __salt__[\\\"mount.active\\\"](extended=True)\\n if comp_real_name in active:\\n ret[\\\"comment\\\"] = \\\"Unable to unmount\\\"\\n ret[\\\"result\\\"] = False\\n return ret\\n update_mount_cache = True\\n else:\\n ret[\\\"comment\\\"] = \\\"Target was already mounted\\\"\\n # using a duplicate check so I can catch the results of a umount\\n if comp_real_name not in active:\\n if mount:\\n # The mount is not present! Mount it\\n if __opts__[\\\"test\\\"]:\\n ret[\\\"result\\\"] = None\\n if os.path.exists(name):\\n ret[\\\"comment\\\"] = \\\"{} would be mounted\\\".format(name)\\n elif mkmnt:\\n ret[\\\"comment\\\"] = \\\"{} would be created and mounted\\\".format(name)\\n else:\\n ret[\\n \\\"comment\\\"\\n ] = \\\"{} does not exist and would not be created\\\".format(name)\\n return ret\\n\\n if not os.path.exists(name) and not mkmnt:\\n ret[\\\"result\\\"] = False\\n ret[\\\"comment\\\"] = \\\"Mount directory is not present\\\"\\n return ret\\n\\n out = __salt__[\\\"mount.mount\\\"](name, device, mkmnt, fstype, opts, user=user)\\n active = __salt__[\\\"mount.active\\\"](extended=True)\\n update_mount_cache = True\\n if isinstance(out, str):\\n # Failed to (re)mount, the state has failed!\\n ret[\\\"comment\\\"] = out\\n ret[\\\"result\\\"] = False\\n return ret\\n elif comp_real_name in active:\\n # (Re)mount worked!\\n ret[\\\"comment\\\"] = \\\"Target was successfully mounted\\\"\\n ret[\\\"changes\\\"][\\\"mount\\\"] = True\\n elif not os.path.exists(name):\\n if __opts__[\\\"test\\\"]:\\n ret[\\\"result\\\"] = None\\n if mkmnt:\\n ret[\\\"comment\\\"] = \\\"{} would be created, but not mounted\\\".format(name)\\n else:\\n ret[\\n \\\"comment\\\"\\n ] = \\\"{} does not exist and would neither be created nor mounted\\\".format(\\n name\\n )\\n elif mkmnt:\\n __salt__[\\\"file.mkdir\\\"](name, user=user)\\n ret[\\\"comment\\\"] = \\\"{} was created, not mounted\\\".format(name)\\n else:\\n ret[\\\"comment\\\"] = \\\"{} not present and not mounted\\\".format(name)\\n else:\\n if __opts__[\\\"test\\\"]:\\n ret[\\\"comment\\\"] = \\\"{} would not be mounted\\\".format(name)\\n else:\\n ret[\\\"comment\\\"] = \\\"{} not mounted\\\".format(name)\\n\\n if persist:\\n if \\\"/etc/fstab\\\" == config:\\n # Override default for Mac OS\\n if __grains__[\\\"os\\\"] in [\\\"MacOS\\\", \\\"Darwin\\\"]:\\n config = \\\"/etc/auto_salt\\\"\\n\\n # Override default for AIX\\n elif \\\"AIX\\\" in __grains__[\\\"os\\\"]:\\n config = \\\"/etc/filesystems\\\"\\n\\n if __opts__[\\\"test\\\"]:\\n if __grains__[\\\"os\\\"] in [\\\"MacOS\\\", \\\"Darwin\\\"]:\\n out = __salt__[\\\"mount.set_automaster\\\"](\\n name, device, fstype, opts, config, test=True\\n )\\n elif __grains__[\\\"os\\\"] in [\\\"AIX\\\"]:\\n out = __salt__[\\\"mount.set_filesystems\\\"](\\n name,\\n device,\\n fstype,\\n opts,\\n mount,\\n config,\\n test=True,\\n match_on=match_on,\\n )\\n else:\\n out = __salt__[\\\"mount.set_fstab\\\"](\\n name,\\n device,\\n fstype,\\n opts,\\n dump,\\n pass_num,\\n config,\\n test=True,\\n match_on=match_on,\\n )\\n if out != \\\"present\\\":\\n ret[\\\"result\\\"] = None\\n if out == \\\"new\\\":\\n if mount:\\n comment = (\\n \\\"{} is mounted, but needs to be \\\"\\n \\\"written to the fstab in order to be \\\"\\n \\\"made persistent.\\\".format(name)\\n )\\n else:\\n comment = (\\n \\\"{} needs to be \\\"\\n \\\"written to the fstab in order to be \\\"\\n \\\"made persistent.\\\".format(name)\\n )\\n elif out == \\\"change\\\":\\n if mount:\\n comment = \\\"{} is mounted, but its fstab entry must be updated.\\\".format(\\n name\\n )\\n else:\\n comment = \\\"The {} fstab entry must be updated.\\\".format(name)\\n else:\\n ret[\\\"result\\\"] = False\\n comment = (\\n \\\"Unable to detect fstab status for \\\"\\n \\\"mount point {} due to unexpected \\\"\\n \\\"output '{}' from call to \\\"\\n \\\"mount.set_fstab. This is most likely \\\"\\n \\\"a bug.\\\".format(name, out)\\n )\\n if \\\"comment\\\" in ret:\\n ret[\\\"comment\\\"] = \\\"{}. {}\\\".format(ret[\\\"comment\\\"], comment)\\n else:\\n ret[\\\"comment\\\"] = comment\\n return ret\\n\\n else:\\n if __grains__[\\\"os\\\"] in [\\\"MacOS\\\", \\\"Darwin\\\"]:\\n out = __salt__[\\\"mount.set_automaster\\\"](\\n name, device, fstype, opts, config\\n )\\n elif __grains__[\\\"os\\\"] in [\\\"AIX\\\"]:\\n out = __salt__[\\\"mount.set_filesystems\\\"](\\n name, device, fstype, opts, mount, config, match_on=match_on\\n )\\n else:\\n out = __salt__[\\\"mount.set_fstab\\\"](\\n name,\\n device,\\n fstype,\\n opts,\\n dump,\\n pass_num,\\n config,\\n match_on=match_on,\\n )\\n\\n if update_mount_cache:\\n cache_result = __salt__[\\\"mount.write_mount_cache\\\"](\\n real_name, device, mkmnt=mkmnt, fstype=fstype, mount_opts=opts\\n )\\n\\n if out == \\\"present\\\":\\n ret[\\\"comment\\\"] += \\\". Entry already exists in the fstab.\\\"\\n return ret\\n if out == \\\"new\\\":\\n ret[\\\"changes\\\"][\\\"persist\\\"] = \\\"new\\\"\\n ret[\\\"comment\\\"] += \\\". Added new entry to the fstab.\\\"\\n return ret\\n if out == \\\"change\\\":\\n ret[\\\"changes\\\"][\\\"persist\\\"] = \\\"update\\\"\\n ret[\\\"comment\\\"] += \\\". Updated the entry in the fstab.\\\"\\n return ret\\n if out == \\\"bad config\\\":\\n ret[\\\"result\\\"] = False\\n ret[\\\"comment\\\"] += \\\". However, the fstab was not found.\\\"\\n return ret\\n\\n return ret\",\n \"def __init__(__self__, *,\\n mount_path: pulumi.Input[str],\\n type: pulumi.Input[str],\\n enable_sub_path: Optional[pulumi.Input[bool]] = None,\\n mount_options: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,\\n read_only: Optional[pulumi.Input[bool]] = None,\\n share_name: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"mount_path\\\", mount_path)\\n pulumi.set(__self__, \\\"type\\\", 'AzureFileVolume')\\n if enable_sub_path is None:\\n enable_sub_path = False\\n if enable_sub_path is not None:\\n pulumi.set(__self__, \\\"enable_sub_path\\\", enable_sub_path)\\n if mount_options is not None:\\n pulumi.set(__self__, \\\"mount_options\\\", mount_options)\\n if read_only is not None:\\n pulumi.set(__self__, \\\"read_only\\\", read_only)\\n if share_name is not None:\\n pulumi.set(__self__, \\\"share_name\\\", share_name)\",\n \"def _mount_gluster_vol(self, mount_path, ensure=False):\\n self._execute('mkdir', '-p', mount_path)\\n command = ['mount', '-t', 'glusterfs', self.gluster_manager.export,\\n mount_path]\\n self._do_mount(command, ensure)\",\n \"def mount(\\n self,\\n path: str,\\n mode: str = \\\"rw\\\",\\n authority: str = \\\"file\\\",\\n *,\\n persistent: bool = True\\n ):\\n if self.celltype == \\\"structured\\\" and not isinstance(self, FolderCell):\\n raise Exception(\\\"Mounting is only supported for non-structured cells\\\")\\n\\n if \\\"r\\\" in mode and not self.independent:\\n msg = \\\"\\\"\\\"Cannot mount {} in read mode.\\nThis cell is not fully independent, i.e. it has incoming connections\\\"\\\"\\\"\\n raise Exception(msg.format(self))\\n\\n # TODO, upon translation: check that there are no duplicate paths.\\n hcell = self._get_hcell2()\\n mount = {\\n \\\"path\\\": path,\\n \\\"mode\\\": mode,\\n \\\"authority\\\": authority,\\n \\\"persistent\\\": persistent,\\n }\\n hcell[\\\"mount\\\"] = mount\\n hcell[\\\"UNTRANSLATED\\\"] = True\\n if self._parent() is not None:\\n self._parent()._translate()\\n return self\",\n \"def _mount_stick_shell(stick):\\n out = subprocess.check_output(\\\"udisks --mount {0}\\\"\\n .format(stick).split())\\n path = re.match(r\\\"Mounted .* at (.*)\\\", out).group(1)\\n try:\\n yield path\\n except Exception as e:\\n raise e\\n finally:\\n subprocess.check_output(\\\"udisks --unmount {0}\\\"\\n .format(stick).split())\",\n \"def _pmount(self, action, args, error='exit'):\\n args = ('p%s' % action,) + args + (self.devname,)\\n if action == 'mount':\\n if self.label:\\n args += (self.label,)\\n msg = 'Mounting %s on %s'\\n else:\\n msg = 'Unmounting %s from %s'\\n print(msg % (self.devname, get_mount_target(self.devname, self.label)))\\n result = call(args)\\n if result and error == 'exit':\\n exit(result)\",\n \"def mount_volume(self, kwargs):\\n\\n exp_params = [('dev_name', is_string),\\n ('vol_name', is_string)]\\n try:\\n dev_name, vol_name = check_arguments(exp_params, kwargs)\\n dev_name = \\\"/dev/%s\\\" % dev_name\\n self.check_volume_name(vol_name)\\n except Exception as ex:\\n return HttpErrorResponse(\\\"%s\\\" % ex)\\n\\n self.logger.info(\\\"Mount operation starting up for volume '%s' on '%s'\\\"\\n % (vol_name, dev_name))\\n\\n try:\\n mount_point = join(self.VOLUME_DIR, vol_name)\\n self._mount(dev_name, mount_point, True)\\n except Exception as e:\\n self.logger.exception(\\\"Failed to mount volume '%s'\\\" % vol_name)\\n return HttpErrorResponse('Failed to mount volume: ' + e.message)\\n\\n self.logger.info('Mount operation completed')\\n return HttpJsonResponse()\",\n \"def mount(self, fstype, export, vol_name, mountpoint, instance, options):\\n\\n # NOTE(mdbooth): mount() may currently be called multiple times for a\\n # single attachment. Any operation which calls\\n # LibvirtDriver._hard_reboot will re-attach volumes which are probably\\n # already attached, resulting in multiple mount calls.\\n\\n LOG.debug('_HostMountState.mount(fstype=%(fstype)s, '\\n 'export=%(export)s, vol_name=%(vol_name)s, %(mountpoint)s, '\\n 'options=%(options)s) generation %(gen)s',\\n {'fstype': fstype, 'export': export, 'vol_name': vol_name,\\n 'mountpoint': mountpoint, 'options': options,\\n 'gen': self.generation}, instance=instance)\\n with self._get_locked(mountpoint) as mount:\\n if os.path.ismount(mountpoint):\\n LOG.debug(('Mounting %(mountpoint)s generation %(gen)s, '\\n 'mountpoint already mounted'),\\n {'mountpoint': mountpoint, 'gen': self.generation},\\n instance=instance)\\n else:\\n LOG.debug('Mounting %(mountpoint)s generation %(gen)s',\\n {'mountpoint': mountpoint, 'gen': self.generation},\\n instance=instance)\\n\\n fileutils.ensure_tree(mountpoint)\\n\\n try:\\n nova.privsep.fs.mount(fstype, export, mountpoint, options)\\n except processutils.ProcessExecutionError:\\n # Check to see if mountpoint is mounted despite the error\\n # eg it was already mounted\\n if os.path.ismount(mountpoint):\\n # We're not going to raise the exception because we're\\n # in the desired state anyway. However, this is still\\n # unusual so we'll log it.\\n LOG.exception(\\n 'Error mounting %(fstypes export %(export)s on '\\n '%(mountpoint)s. Continuing because mountpount is '\\n 'mounted despite this.',\\n {'fstype': fstype, 'export': export,\\n 'mountpoint': mountpoint}, instance=instance)\\n else:\\n # If the mount failed there's no reason for us to keep\\n # a record of it. It will be created again if the\\n # caller retries.\\n\\n # Delete while holding lock\\n del self.mountpoints[mountpoint]\\n\\n raise\\n\\n mount.add_attachment(vol_name, instance.uuid)\\n\\n LOG.debug('_HostMountState.mount() for %(mountpoint)s '\\n 'generation %(gen)s completed successfully',\\n {'mountpoint': mountpoint, 'gen': self.generation},\\n instance=instance)\",\n \"def mount_resource(self, name, factory, path, methods=(), method=None, add_slash=False,\\n replace=False, _level=3):\\n factory = load_object(factory, level=_level)\\n mounted_resource = MountedResource(self, name, factory, path, methods, method, add_slash)\\n self.register(abcs.AMountedResource, mounted_resource, mounted_resource.name, replace)\\n return SubResourceMounter(self, mounted_resource)\",\n \"def mount_path(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"mount_path\\\")\",\n \"def mount_path(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"mount_path\\\")\",\n \"def run(self, check=True, mount_callback=None):\\n # pylint: disable=arguments-differ,arguments-renamed\\n self.log.info('Starting dfuse at %s on %s', self.mount_dir.value, str(self.hosts))\\n\\n # A log file must be defined to ensure logs are captured\\n if \\\"D_LOG_FILE\\\" not in self.env:\\n raise CommandFailure(\\\"Dfuse missing environment variables for D_LOG_FILE\\\")\\n\\n if 'D_LOG_MASK' not in self.env:\\n self.env['D_LOG_MASK'] = 'INFO'\\n\\n if 'COVFILE' not in self.env:\\n self.env['COVFILE'] = '/tmp/test.cov'\\n\\n # Determine which fusermount command to use before mounting\\n if not self._fusermount_cmd:\\n self.log.info('Check which fusermount command to use')\\n for fusermount in ('fusermount3', 'fusermount'):\\n if run_remote(self.log, self.hosts, f'{fusermount} --version').passed:\\n self._fusermount_cmd = fusermount\\n break\\n if not self._fusermount_cmd:\\n raise CommandFailure(f'Failed to get fusermount command on: {self.hosts}')\\n\\n # mark the instance as needing cleanup before starting setup\\n self.__need_cleanup = True\\n\\n # setup the mount point\\n self._setup_mount_point()\\n\\n # run dfuse command\\n result = run_remote(self.log, self.hosts, self.with_exports, timeout=30)\\n self._running_hosts.add(result.passed_hosts)\\n if mount_callback:\\n mount_callback(result)\\n elif not result.passed:\\n raise CommandFailure(f\\\"dfuse command failed on hosts {result.failed_hosts}\\\")\\n\\n if check:\\n # Dfuse will block in the command for the mount to complete, even\\n # if run in background mode so it should be possible to start using\\n # it immediately after the command returns.\\n num_retries = 3\\n for retry in range(1, num_retries + 1):\\n if not self.check_running(fail_on_error=retry == num_retries):\\n self.log.info('Waiting two seconds for dfuse to start')\\n time.sleep(2)\",\n \"def mount_factory(name, idn=0):\\n # Import MOUNT_MAPPING at runtime so we avoid circular imports\\n from robosuite.models.mounts import MOUNT_MAPPING\\n\\n return MOUNT_MAPPING.get(name, \\\"Unknown mount name: {}\\\".format(name))(idn=idn)\",\n \"def volume_mounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VolumeMountArgs']]]]:\\n return pulumi.get(self, \\\"volume_mounts\\\")\",\n \"def _setup_mount_point(self):\\n # Raise exception if mount point not specified\\n if self.mount_dir.value is None:\\n raise CommandFailure(\\\"Mount point not specified. Check test yaml file\\\")\\n\\n # Unmount dfuse if already running\\n self.unmount()\\n if self._running_hosts:\\n raise CommandFailure(f\\\"Error stopping dfuse on {self._running_hosts}\\\")\\n\\n self.log.info(\\\"Creating dfuse mount directory\\\")\\n if self._mount_state[\\\"nodirectory\\\"]:\\n command = f\\\"mkdir -p {self.mount_dir.value}\\\"\\n result = self._run_as_owner(self._mount_state[\\\"nodirectory\\\"], command, timeout=30)\\n if not result.passed:\\n raise CommandFailure(\\n f\\\"Error creating the {self.mount_dir.value} dfuse mount point \\\"\\n f\\\"on the following hosts: {result.failed_hosts}\\\")\",\n \"def get_mounts(self):\\n cmd = ['mount', '-t', 'btrfs', '-l']\\n out, err, ret = self.justcall(cmd)\\n if ret != 0:\\n raise InitError(\\\"error running %s:\\\\n\\\"%' '.join(cmd)+err)\\n mounts = {}\\n for line in out.split(\\\"\\\\n\\\"):\\n if len(line) == 0 or \\\" on \\\" not in line or \\\" type btrfs \\\" not in line:\\n continue\\n mntpt = line[line.index(\\\" on \\\")+4:line.index(\\\" type btrfs \\\")]\\n if '[' in line:\\n l = line.split('[')\\n label = l[-1].strip(']')\\n else:\\n label = self.get_label(mntpt)\\n mounts[mntpt] = label\\n return mounts\",\n \"def _mountMultifile(self, path: str) -> None:\\n\\n success = vfs.vfs_mount_multifile('.', path)\\n if not success:\\n self.showErrorDialog(message='Failed to mount %s' % path)\\n sys.exit(2)\",\n \"def mount_block(block):\\n # type: (str) -> str\\n\\n dir_path = tempfile.mkdtemp(prefix='mount-')\\n _mount(block, dir_path)\\n\\n return dir_path\",\n \"def mount_fs_on_dir(vm_name, device_name, target_dir, fs_type, executor=None):\\n if not executor:\\n executor = get_vm_executor(vm_name)\\n blkid_cmd = 'blkid %s' % device_name\\n rc, out, error = executor.run_cmd(shlex.split(blkid_cmd))\\n assert not rc, (\\n \\\"Failed to get the UUID of device {0} {1}\\\".format(device_name, error)\\n )\\n uuid_regex = re.search(REGEX_UUID, out)\\n assert uuid_regex, \\\"Failed to find UUUID in output {0}\\\".format(out)\\n fstab_line = 'UUID=\\\"%s\\\" %s %s defaults 0 0' % (\\n uuid_regex.group('uuid'), target_dir, fs_type\\n )\\n insert_to_fstab = 'echo \\\"{0}\\\" >> {1}'.format(fstab_line, '/etc/fstab')\\n out = _run_cmd_on_remote_machine(vm_name, insert_to_fstab, executor)\\n assert out, errors.MountError(\\\"Failed to add mount point to fstab\\\", out)\\n mount_cmd = 'mount -a'\\n out = _run_cmd_on_remote_machine(vm_name, mount_cmd, executor)\\n assert out, errors.MountError(\\\"Failed to mount FS\\\", out)\",\n \"def mounts():\\n if not _mounts:\\n raw = subprocess.check_output(['mount'])\\n if sys.platform == 'darwin':\\n _mounts.extend(_parse_darwin_mounts(raw))\\n elif sys.platform.startswith('linux'):\\n _mounts.extend(_parse_linux_mounts(raw))\\n else:\\n log.warning('cannot parse mounts for %s' % sys.platform)\\n return list(_mounts)\",\n \"def mounted(self):\\n return os.path.ismount(self.get(\\\"~mountpoint\\\", \\\"/\\\"))\",\n \"def mount_stick(stick):\\n mount = stick.get_dbus_method(\\n \\\"FilesystemMount\\\", dbus_interface=\\\"org.freedesktop.UDisks.Device\\\")\\n path = mount('', [])\\n try:\\n yield path\\n except Exception as e:\\n raise e\\n finally:\\n unmount = stick.get_dbus_method(\\n \\\"FilesystemUnmount\\\",\\n dbus_interface=\\\"org.freedesktop.UDisks.Device\\\")\\n unmount([], timeout=1e6) # dbus-python doesn't know an infinite\\n # timeout... unmounting sometimes takes a\\n # long time, since the device has to be\\n # synced.\",\n \"def path_extern_mounts(self) -> PurePath:\\n return self.path_extern_supervisor / MOUNTS_FOLDER\",\n \"def mount_single(partition_size, drives):\\n for drive_list in drives:\\n if are_equal(drive_list, partition_size):\\n for drive_info, partition_info in zip(drive_list, partition_size):\\n mount_pattern = \\\"mount -t ntfs -o uid=1000,gid=1000,umask=0002 /dev/{} {}\\\"\\n mount_cmd = mount_pattern.format(drive_info[1], partition_info[1])\\n print(mount_cmd)\",\n \"def hadoop(self, command, *args, **kwargs):\\n hadoop_cmd = \\\"-{}\\\".format(re.sub(\\\"^-*\\\", \\\"\\\", command))\\n return self.exec(\\\"hadoop fs\\\", hadoop_cmd, *args, **kwargs)\",\n \"def create_onedrive_mounting_point():\\n return None\",\n \"def mount(self):\\n LOG.info(\\\"Mounting %s\\\", self.name)\\n\\n # read volume metadata\\n self.read_volume_metadata()\\n\\n # calculate file allocation and file area offsets\\n self.calculate_offsets()\\n\\n if self.debug_log_enabled:\\n LOG.debug(\\\"Bytes Per Cluster: %08x\\\", self.bytes_per_cluster)\\n LOG.debug(\\\"Max Clusters: %08x\\\", self.max_clusters)\\n LOG.debug(\\\"FAT Byte Offset: %08x\\\", self.fat_byte_offset)\\n LOG.debug(\\\"FILE Area Byte Offset: %08x\\\", self.file_area_byte_offset)\\n\\n # get file allocation table (int[])\\n self.file_allocation_table = self.read_file_allocation_table()\\n\\n self._root = self.read_directory_stream(\\n self.cluster_to_physical_offset(self.root_dir_first_cluster))\\n\\n # for each dirent in root, populate children\\n self.populate_dirent_stream(self._root)\",\n \"def is_mounted(volume):\\n mounts = sudo(\\\"mount\\\", quiet=True).split(\\\"\\\\n\\\")\\n for m in mounts:\\n if m.startswith(volume + \\\" \\\"):\\n return True\\n return False\",\n \"def command_mount(self, system_id, *system_ids):\\n system_ids = (system_id,) + system_ids\\n has_failed = False\\n for system_id in system_ids:\\n try:\\n system = SystemModel.create_by_id(system_id, self.environment)\\n controller = SystemControllerModel(system, self.environment)\\n controller.mount()\\n except SftpConfigException as e:\\n sys.stderr.write('Cannot mount %s: %s\\\\n\\\\n' % (system_id, str(e)))\\n has_failed = True\\n except SftpMountException as e:\\n sys.stderr.write('Cannot mount %s!\\\\n\\\\n' % system_id)\\n sys.stderr.write('Mount command: \\\\n%s\\\\n\\\\n' % e.mount_cmd)\\n sys.stderr.write('Command output: \\\\n%s\\\\n\\\\n' % e.mount_cmd_output)\\n has_failed = True\\n if has_failed:\\n sys.exit(1)\",\n \"def mount_nfs_share(self, share_config):\\n remote_host = share_config.get('remote_host')\\n remote_dir = share_config.get('remote_dir')\\n mount_point = share_config.get('mount_point')\\n if remote_host and remote_dir:\\n if mount_point:\\n command = 'mount -t nfs %s:%s %s' % (remote_host, remote_dir, mount_point)\\n self.cmd(command)\",\n \"def match_mount(self, i, dev, mnt):\\n if i.mnt != mnt:\\n return False\\n if i.dev == dev:\\n return True\\n return False\",\n \"def _RemountRootAsReadWrite(self):\\n self.RunCmdOnDevice(['mount', '-o', 'remount,rw', '/'])\",\n \"def volume_mounts(self) -> Optional[Sequence['_core.v1.outputs.VolumeMount']]:\\n return pulumi.get(self, \\\"volume_mounts\\\")\",\n \"def get_mount_points():\\n\\n points = []\\n t = subprocess.check_output(['mount'])\\n t = t.decode()\\n\\n for line in t.splitlines():\\n t = line.find('smbfs')\\n if t < 0: continue\\n b = line.find(' on ')\\n points.append(line[b+4: t-2])\\n # //share@win10.shared/storage on /Volumes/storage (smbfs, nodev, nosuid, mounted by ruan)\\n return points\",\n \"def __init__(self, type=\\\"uri_folder\\\", path=None, mode=\\\"rw_mount\\\", description=None):\\n pass\",\n \"def create_and_mount_brick(brick_device, brick_path, brickfs):\\n\\n # If brick device path is not starts with /dev then use\\n # /brickdev prefix. Brick device directory passed by the user\\n # is mounted as /brickdev to avoid mixing with any other\\n # dirs inside container.\\n if not brick_device.startswith(\\\"/dev/\\\"):\\n brick_device = \\\"/brickdev/\\\" + os.path.basename(brick_device)\\n\\n mountdir = os.path.dirname(brick_path)\\n os.makedirs(mountdir,\\n mode=0o755,\\n exist_ok=True)\\n\\n try:\\n execute(\\\"mount\\\", brick_device, mountdir)\\n logging.info(logf(\\n \\\"Successfully mounted device on path\\\",\\n fstype=brickfs,\\n device=brick_device,\\n mountdir=mountdir,\\n ))\\n except CommandException as err:\\n logging.info(logf(\\n \\\"Failed to mount device, continuing with mkfs\\\",\\n err=err,\\n fstype=brickfs,\\n device=brick_device,\\n mountdir=mountdir,\\n ))\\n if 'wrong fs type' in err.err:\\n # This error pops up when we do mount on an empty device or wrong fs\\n # Try doing a mkfs and try mount\\n try:\\n execute(MKFS_XFS_CMD, brick_device)\\n logging.info(logf(\\n \\\"Successfully created xfs file system on device\\\",\\n fstype=brickfs,\\n device=brick_device,\\n ))\\n except CommandException as err:\\n if \\\"appears to contain an existing filesystem\\\" not in err.err:\\n logging.error(logf(\\n \\\"Failed to create file system\\\",\\n fstype=brickfs,\\n device=brick_device,\\n error=err,\\n ))\\n sys.exit(1)\\n else:\\n logging.info(logf(\\n \\\"Failed to perform mkfs on device. continuing with mount\\\",\\n err=err,\\n device=brick_device,\\n mountdir=mountdir,\\n ))\\n try:\\n execute(\\\"mount\\\", brick_device, mountdir)\\n logging.info(logf(\\n \\\"Successfully mounted device on path\\\",\\n fstype=brickfs,\\n device=brick_device,\\n mountdir=mountdir,\\n ))\\n except CommandException as err:\\n logging.error(logf(\\n \\\"Failed to mount export brick (after mkfs)\\\",\\n fstype=brickfs,\\n device=brick_device,\\n mountdir=mountdir,\\n error=err,\\n ))\\n sys.exit(1)\\n\\n elif 'already mounted' not in err.err:\\n logging.error(logf(\\n \\\"Failed to mount export brick\\\",\\n fstype=brickfs,\\n device=brick_device,\\n mountdir=mountdir,\\n error=err,\\n ))\\n sys.exit(1)\\n\\n else:\\n pass\",\n \"def authenticated_mount(self, mount_obj):\\n # Mount volume\\n ret = mount_obj.mount()\\n self.assertTrue(ret, (\\\"Failed to mount %s on client %s\\\" %\\n (mount_obj.volname,\\n mount_obj.client_system)))\\n g.log.info(\\\"Successfully mounted %s on client %s\\\", mount_obj.volname,\\n mount_obj.client_system)\\n\\n # Verify mount\\n ret = mount_obj.is_mounted()\\n self.assertTrue(ret, (\\\"%s is not mounted on client %s\\\"\\n % (mount_obj.volname, mount_obj.client_system)))\\n g.log.info(\\\"Verified: %s is mounted on client %s\\\",\\n mount_obj.volname, mount_obj.client_system)\",\n \"def testGenerateVolumesMountpoints(self):\\n self.maxDiff = None\\n de_object = de.DockerExplorerTool()\\n de_object._explorer = self.explorer_object\\n container_obj = de_object._explorer.GetContainer(\\n '712909b5ab80d8785841f12e361c218a2faf5365f9ed525f2a0d6b6590ba89cb')\\n\\n commands = container_obj.storage_object._MakeVolumeMountCommands(\\n container_obj, '/mnt')\\n commands = [' '.join(x) for x in commands]\\n expected_commands = [(\\n '/bin/mount --bind -o ro '\\n 'test_data/docker/volumes/f5479c534bbc6e2b9861973c2fbb4863ff5b7b5843c098d7fb1a027fe730a4dc/_data '\\n '/mnt/opt/vols/volume')]\\n self.assertEqual(expected_commands, commands)\",\n \"def mount(class_, root):\\n # XXX class_ - in successors own _ready (?)\\n if class_._ready:\\n return\\n else:\\n p = VRoot(root).hpath(SchModule.DIR)\\n SchModule.DIR = VRoot(p)\\n class_._ready = True\",\n \"def get_mount_point(self):\\n try:\\n output = openmediavault.subprocess.check_output(\\n [\\n 'findmnt',\\n '--canonicalize',\\n '--first-only',\\n '--noheadings',\\n '--output=TARGET',\\n '--raw',\\n self.canonical_device_file,\\n ]\\n )\\n # Examples:\\n # /media/8c982ec2-8aa7-4fe2-a912-7478f0429e06\\n # /srv/_dev_disk_by-id_dm-name-vg01-lv01\\n # /srv/dev-disk-by-label-xx\\\\x20yy\\n return openmediavault.string.unescape_blank(output.decode().strip())\\n except subprocess.CalledProcessError:\\n pass\\n return None\",\n \"def get_mounts(self):\\n return [m.split()[0] for m in self.xlist(\\\"get-mounts\\\")[1]]\",\n \"def generate_common_mount(self, working_file_name):\\n\\n # Reopenthe working file\\n working_file = open(working_file_name, \\\"a\\\")\\n\\n # Check that the stack definition is in the configuration file\\n if \\\"stack-definition\\\" not in self.project.firmware_definition[\\\"layout\\\"]:\\n self.project.logging.critical(\\\"The stack definition is not in the configuration file\\\")\\n exit(1)\\n\\n # Iterates the stack items\\n for item in self.project.firmware_definition[\\\"layout\\\"][\\\"stack-definition\\\"]:\\n # Generate the mount point creation code\\n working_file.write(\\\"# Create the mount point for \\\" + item[\\\"stack-item\\\"][\\\"type\\\"] +\\n \\\" '\\\" + item[\\\"stack-item\\\"][\\\"name\\\"] + \\\"'\\\\n\\\")\\n working_file.write(\\\"mkdir -p /mnt/dft/\\\" + item[\\\"stack-item\\\"][\\\"name\\\"] + \\\"\\\\n\\\")\\n working_file.write(\\\"\\\\n\\\")\\n\\n # Generate the mount commands\\n working_file.write(\\\"# Mount item \\\" + item[\\\"stack-item\\\"][\\\"type\\\"] + \\\" '\\\" +\\n item[\\\"stack-item\\\"][\\\"name\\\"] + \\\"'\\\\n\\\")\\n\\n # Generate the tmpfs specific mount command\\n if item[\\\"stack-item\\\"][\\\"type\\\"] == \\\"tmpfs\\\":\\n working_file.write(\\\"mount -t tmpfs \\\")\\n\\n # Is there some defined options ?\\n if \\\"mount-options\\\" in item[\\\"stack-item\\\"]:\\n # Yes, then append the options to the command\\n working_file.write(\\\"-o \\\" + item[\\\"stack-item\\\"][\\\"mount-options\\\"] + \\\" \\\")\\n\\n # Complete the mount command\\n working_file.write(\\\"tmpfs /mnt/dft/\\\" + item[\\\"stack-item\\\"][\\\"name\\\"] + \\\"\\\\n\\\")\\n\\n # Generate the tmpfs specific mount command\\n if item[\\\"stack-item\\\"][\\\"type\\\"] == \\\"squashfs\\\":\\n working_file.write(\\\"mount -t squashfs \\\")\\n\\n # Is there some defined options ?\\n if \\\"mount-options\\\" in item[\\\"stack-item\\\"]:\\n # Yes, then append the options to the command\\n working_file.write(\\\"-o \\\" + item[\\\"stack-item\\\"][\\\"mount-options\\\"] + \\\" \\\")\\n\\n # Complete the mount command\\n working_file.write(item[\\\"stack-item\\\"][\\\"squashfs-file\\\"] + \\\" /mnt/dft/\\\" +\\n item[\\\"stack-item\\\"][\\\"name\\\"] + \\\" -o loop\\\\n\\\")\\n\\n # Generate the tmpfs specific mount command\\n if item[\\\"stack-item\\\"][\\\"type\\\"] == \\\"partition\\\":\\n working_file.write(\\\"mount \\\")\\n\\n # Is there some defined options ?\\n if \\\"mount-options\\\" in item[\\\"stack-item\\\"]:\\n # Yes, then append the options to the command\\n working_file.write(\\\"-o \\\" + item[\\\"stack-item\\\"][\\\"mount-options\\\"] + \\\" \\\")\\n\\n # Complete the mount command\\n working_file.write(item[\\\"stack-item\\\"][\\\"partition\\\"] + \\\" /mnt/dft/\\\" +\\n item[\\\"stack-item\\\"][\\\"name\\\"] + \\\"\\\\n\\\")\\n\\n working_file.write(\\\"\\\\n\\\")\\n\\n # We are done here, now close the file\\n working_file.close()\",\n \"def umount_mdv():\\n with open(\\\"/proc/self/mounts\\\", \\\"r\\\") as mounts:\\n for line in mounts.readlines():\\n if \\\"/stratis/.mdv-\\\" in line:\\n mountpoint = line.split()[1]\\n exec_command([\\\"umount\\\", mountpoint])\",\n \"def __init__(self):\\n current_app.logger.debug(\\\"Instantiating the Mount class\\\")\",\n \"def mount_accessor(self, mount_accessor):\\n\\n self._mount_accessor = mount_accessor\",\n \"def mount_device(entities):\\n result = None\\n reg = re.compile(r'/dev/disk\\\\d+')\\n\\n # When a DMG is mounted, the mount volume and device 'keys'\\n # are in the same entity, so when both 'mount' and 'device'\\n # exist, we have the right info.\\n for ent in entities:\\n _dev = ent.get('dev-entry', None)\\n device = re.findall(reg, _dev)[0] if _dev else None\\n mount = ent.get('mount-point', None)\\n\\n if mount and device:\\n result = (mount, device)\\n break\\n\\n return result\",\n \"def test_mount_status_nas_share(self):\\n pass\",\n \"def fsmounted(mountpoint):\\n ProcMounts.initialize()\\n for mount in ProcMounts._mounts:\\n if mount['fs_file'] == mountpoint:\\n return mount\\n return None\",\n \"def get_mount_direction(self):\\r\\n return self._studio.get_mount_direction()\",\n \"def get_mount_target(devname, label=None):\\n return join(sep, 'media', label or basename(devname))\",\n \"def shell(self, cmd):\\n raise NotImplementedError\",\n \"def create_filesystem_mounting_point(username, password, domainName, path, instanceId):\\n createFileSystemMountingPointParams = {\\n \\\"Username\\\": username,\\n \\\"Password\\\": password,\\n \\\"DomainName\\\": domainName,\\n \\\"Path\\\": path,\\n \\\"InstanceId\\\": instanceId\\n }\\n return createFileSystemMountingPointParams\",\n \"def umount_cifs_share(self, **kwargs):\\n mount_point = kwargs.get('mount_point')\\n if mount_point:\\n command = 'umount %s' % mount_point\\n self.cmd(command)\",\n \"def mount_root_vm(self):\\n print \\\"montage de la partition root de %s\\\" % name_vm_dest\\n self.exec_cmd(\\\"mount /dev/%s/root-%s %s\\\" % (vgname, name_vm_dest, self.rep_vhosts_vm))\",\n \"def mount(mapping, loaded_data):\\n for drive_size, partition_infos in mapping:\\n mount_single(partition_infos, loaded_data[drive_size])\",\n \"def volume_mounts(self) -> Optional[Sequence['_core.v1.outputs.VolumeMountPatch']]:\\n return pulumi.get(self, \\\"volume_mounts\\\")\",\n \"def build(kls, cmd, *, cls=subprocess.Popen, **kwargs):\\n if not cmd:\\n raise xt.XonshError(\\\"xonsh: subprocess mode: command is empty\\\")\\n # modifications that do not alter cmds may come before creating instance\\n spec = kls(cmd, cls=cls, **kwargs)\\n # modifications that alter cmds must come after creating instance\\n # perform initial redirects\\n spec.redirect_leading()\\n spec.redirect_trailing()\\n # apply aliases\\n spec.resolve_alias()\\n spec.resolve_binary_loc()\\n spec.resolve_auto_cd()\\n spec.resolve_executable_commands()\\n spec.resolve_alias_cls()\\n spec.resolve_stack()\\n return spec\",\n \"def register_mount(self, app, path, variables, converters, required,\\n get_converters, mount_name, app_factory):\\n self.register_path(app, path, variables,\\n converters, required, get_converters, False,\\n app_factory)\\n\\n self.mounted[app] = app_factory\\n mount_name = mount_name or path\\n self.named_mounted[mount_name] = app_factory\",\n \"def run(self):\\n self.log.info(\\\"Start CMD>>> %s\\\", str(self.runner))\\n\\n # Temporary display debug mount information\\n self.log.info(\\\"%s\\\", \\\"=\\\" * 80)\\n pcmd(self._hosts, \\\"df -h -t tmpfs\\\", True, None, None)\\n self.log.info(\\\"%s\\\", \\\"=\\\" * 80)\\n\\n return self.runner.run()\",\n \"def mounts():\\r\\n ret = []\\r\\n with open('/proc/mounts') as f:\\r\\n lines = f.readlines()\\r\\n for line in lines:\\r\\n m = re.match(\\r\\n r'(?P<src>\\\\S+) (?P<dest>\\\\S+) (?P<type>\\\\S+)', line)\\r\\n if m:\\r\\n ret.append(m.groupdict())\\r\\n return ret\",\n \"def _command_wrapper(self, cls):\\n def command_send(func, args):\\n self._con.send(func(*args))\\n result = self._recv()\\n if len(result) == 0: # Reconnect if no results were received\\n self._con.connect()\\n self._recv()\\n return command_send(func, args)\\n parsed_result = Parser.parse(result)\\n if not parsed_result:\\n raise MPDCommandError(\\\"Wrong command usage or insufficient permissions: {}\\\".format(result))\\n return parsed_result\\n\\n class Wrapper(cls):\\n \\\"\\\"\\\"\\n The actual class that wraps Commands\\n It generates new functions to each of Commands attributes, and all it does is to wrap\\n Commands attributes with command_send.\\n \\\"\\\"\\\"\\n def __init__(self):\\n pass\\n\\n def __getattr__(self, item):\\n not_wrapped = cls.__getattr__(item)\\n\\n def f(*args):\\n return command_send(not_wrapped, args)\\n\\n f.__doc__ = not_wrapped.__doc__\\n f.__name__ = not_wrapped.__name__\\n return f\\n\\n return Wrapper()\",\n \"def delegator():\\n import delegator\\n\\n def run(command):\\n if \\\"|\\\" in command:\\n res = delegator.chain(command)\\n else:\\n res = delegator.run(command)\\n if res.return_code == 127:\\n raise FileNotFoundError(res.err)\\n if res.return_code != 0:\\n raise RuntimeError(res.err)\\n if res.err:\\n sys.stderr.write(res.err)\\n if not res.err.endswith(os.linesep):\\n sys.stderr.write(os.linesep)\\n\\n return res.out.strip()\\n\\n return run\",\n \"def _check_mount(self):\\n if self.mount == ComponentBase.MOUNT_SMD:\\n valid_shapes = [Con.SHAPE_PAD]\\n default_shape = Con.SHAPE_PAD\\n elif self.mount == ComponentBase.MOUNT_THT:\\n valid_shapes = [Con.SHAPE_HOLE, Con.SHAPE_RHOLE]\\n default_shape = Con.SHAPE_HOLE\\n \\n for con in self.connectors:\\n if con.p_shape not in valid_shapes:\\n con.p_shape = default_shape\",\n \"def mountLXCPrivate(self,node,vmid):\\n post_data = None\\n data = self.connect('post','nodes/%s/lxc/%s/status/mount' % (node,vmid), post_data)\\n return data\",\n \"def getmount(mypath): # noqa\\n\\n path_ = os.path.realpath(os.path.abspath(mypath))\\n while path_ != os.path.sep:\\n if os.path.ismount(path_):\\n return path_\\n path_ = os.path.abspath(os.path.join(path_, os.pardir))\\n return path_\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68459976","0.6746837","0.66094476","0.65165293","0.6478037","0.63636965","0.63398814","0.6326575","0.6229015","0.61068434","0.6089923","0.6050603","0.60273486","0.60215586","0.601697","0.6004157","0.5968393","0.59526014","0.59160775","0.59134746","0.5872324","0.58562547","0.5847534","0.58254325","0.5762882","0.57278013","0.5697151","0.5679594","0.56767213","0.56757116","0.5672935","0.5641257","0.5634728","0.56185913","0.5615919","0.55924004","0.55746305","0.5574128","0.5558618","0.5540162","0.55335575","0.5516888","0.5473865","0.54666114","0.545203","0.545203","0.54425204","0.542382","0.54199463","0.54129034","0.5405656","0.53991294","0.53850526","0.53820395","0.53777677","0.5377688","0.5369373","0.5325247","0.5323322","0.5266776","0.52447987","0.52398103","0.52307695","0.520469","0.5198672","0.5197644","0.51697314","0.51665616","0.51658463","0.51599896","0.5156561","0.5147802","0.51391023","0.5138936","0.5129439","0.5128313","0.51170427","0.5112249","0.5108049","0.5103671","0.5101725","0.50731367","0.5063645","0.5062742","0.5060923","0.5054085","0.5045187","0.50397384","0.5024727","0.50185996","0.50156903","0.50053436","0.50034237","0.4995328","0.4992702","0.49901283","0.4985944","0.4983175","0.49740583","0.49662307"],"string":"[\n \"0.68459976\",\n \"0.6746837\",\n \"0.66094476\",\n \"0.65165293\",\n \"0.6478037\",\n \"0.63636965\",\n \"0.63398814\",\n \"0.6326575\",\n \"0.6229015\",\n \"0.61068434\",\n \"0.6089923\",\n \"0.6050603\",\n \"0.60273486\",\n \"0.60215586\",\n \"0.601697\",\n \"0.6004157\",\n \"0.5968393\",\n \"0.59526014\",\n \"0.59160775\",\n \"0.59134746\",\n \"0.5872324\",\n \"0.58562547\",\n \"0.5847534\",\n \"0.58254325\",\n \"0.5762882\",\n \"0.57278013\",\n \"0.5697151\",\n \"0.5679594\",\n \"0.56767213\",\n \"0.56757116\",\n \"0.5672935\",\n \"0.5641257\",\n \"0.5634728\",\n \"0.56185913\",\n \"0.5615919\",\n \"0.55924004\",\n \"0.55746305\",\n \"0.5574128\",\n \"0.5558618\",\n \"0.5540162\",\n \"0.55335575\",\n \"0.5516888\",\n \"0.5473865\",\n \"0.54666114\",\n \"0.545203\",\n \"0.545203\",\n \"0.54425204\",\n \"0.542382\",\n \"0.54199463\",\n \"0.54129034\",\n \"0.5405656\",\n \"0.53991294\",\n \"0.53850526\",\n \"0.53820395\",\n \"0.53777677\",\n \"0.5377688\",\n \"0.5369373\",\n \"0.5325247\",\n \"0.5323322\",\n \"0.5266776\",\n \"0.52447987\",\n \"0.52398103\",\n \"0.52307695\",\n \"0.520469\",\n \"0.5198672\",\n \"0.5197644\",\n \"0.51697314\",\n \"0.51665616\",\n \"0.51658463\",\n \"0.51599896\",\n \"0.5156561\",\n \"0.5147802\",\n \"0.51391023\",\n \"0.5138936\",\n \"0.5129439\",\n \"0.5128313\",\n \"0.51170427\",\n \"0.5112249\",\n \"0.5108049\",\n \"0.5103671\",\n \"0.5101725\",\n \"0.50731367\",\n \"0.5063645\",\n \"0.5062742\",\n \"0.5060923\",\n \"0.5054085\",\n \"0.5045187\",\n \"0.50397384\",\n \"0.5024727\",\n \"0.50185996\",\n \"0.50156903\",\n \"0.50053436\",\n \"0.50034237\",\n \"0.4995328\",\n \"0.4992702\",\n \"0.49901283\",\n \"0.4985944\",\n \"0.4983175\",\n \"0.49740583\",\n \"0.49662307\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.667246"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":74287,"cells":{"query":{"kind":"string","value":"Read examples from path."},"document":{"kind":"string","value":"def _read_examples(self, train_test_val_split, path):\n train_examples = []\n eval_examples = []\n test_examples = []\n with genomics_reader.TFRecordReader(\n ngs_errors.get_train_filename(path), proto=example_pb2.Example) as fin:\n train_examples = list(fin)\n with genomics_reader.TFRecordReader(\n ngs_errors.get_eval_filename(path), proto=example_pb2.Example) as fin:\n eval_examples = list(fin)\n with genomics_reader.TFRecordReader(\n ngs_errors.get_test_filename(path), proto=example_pb2.Example) as fin:\n test_examples = list(fin)\n\n n_examples = len(train_examples) + len(eval_examples) + len(test_examples)\n return train_examples + eval_examples + test_examples"},"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 load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)","def load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)","def load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)","def examples_from_file(path):\n examples = []\n\n # count total lines before loading\n total_lines = int(local('wc -l {}'.format(path), capture=True).split()[0])\n\n with codecs.open(path, 'r', encoding='utf-8') as f:\n for line in verboserate(f, desc='Reading data file.', total=total_lines):\n src, trg = line.strip().lower().split('\\t')\n src_words = src.split(' ')\n trg_words = trg.split(' ')\n assert len(src_words) > 0\n assert len(trg_words) > 0\n\n if use_diff:\n ex = EditExample.salient_diff(src_words, trg_words, free_set)\n else:\n ex = EditExample.whitelist_blacklist(src_words, trg_words)\n examples.append(ex)\n return examples","def read(path):","def read(path, label2int):\n\n labels = [] # int labels\n samples = [] # examples as strings\n\n for label_dir in os.listdir(path):\n label_dir_path = os.path.join(path, label_dir)\n\n for file in os.listdir(label_dir_path):\n file_path = os.path.join(label_dir_path, file)\n file_text = open(file_path).read().rstrip()\n int_label = label2int[label_dir.lower()]\n samples.append(file_text)\n labels.append(int_label)\n\n return samples, labels","def discover_examples():\n root = './examples'\n for filename in os.listdir(root):\n if os.path.splitext(filename)[1] == '.py':\n yield os.path.join(root, filename)","def example(*paths):\n\n return normpath(join(dirname(__file__), '..', 'examples', *paths))","def read_examples(data_dir, data_sign):\n examples = []\n # read src data\n with open(data_dir / f'{data_sign}/sentences.txt', \"r\", encoding='utf-8') as f_sen, \\\n open(data_dir / f'{data_sign}/tags.txt', 'r', encoding='utf-8') as f_tag:\n for sen, tag in zip(f_sen, f_tag):\n example = InputExample(sentence=sen.strip().split(' '), tags=tag.strip().split(' '))\n examples.append(example)\n print(\"InputExamples:\", len(examples))\n return examples","def get_test_examples(self, data_path):\r\n return self.create_examples(self.read_data(data_path), 'test')","def examplereader(path, lower=False):\n for line in filereader(path):\n line = line.lower() if lower else line\n tokens = tokens_from_treestring(line)\n tree = Tree.fromstring(line) # use NLTK's Tree\n label = int(line[1])\n trans = transitions_from_treestring(line)\n yield Example(tokens=tokens, tree=tree, label=label, transitions=trans)","def _read(self, path: str):\n num_samples, length = [int(x) for x in path.split(\":\")]\n random.seed(self.seed)\n for _ in range(num_samples):\n tokens, tags = self._sample(length)\n yield self.text_to_instance(tokens, tags)","def find_examples_in_schema(path):\n with open(path, 'rb') as fd:\n schema_tree = yaml.load(fd)\n\n for node in treeutil.iter_tree(schema_tree):\n if (isinstance(node, dict) and\n 'examples' in node and\n isinstance(node['examples'], list)):\n for desc, example in node['examples']:\n yield example","def read_path():\n global path\n if len(sys.argv) >= 2:\n path = sys.argv[1]\n else:\n path = \"train\"","def read(*paths):\n with open(os.path.join(*paths), 'r') as f:\n return f.read()","def read(*paths):\n with open(os.path.join(*paths), 'r') as f:\n return f.read()","def read(*paths):\n with open(os.path.join(*paths), 'r') as f:\n return f.read()","def read(*paths):\n with open(os.path.join(*paths), 'r') as f:\n return f.read()","def read(*paths):\n with open(os.path.join(*paths), 'r') as f:\n return f.read()","def read(*paths):\n with open(os.path.join(*paths), 'r') as f:\n return f.read()","def read(*paths):\n with open(os.path.join(*paths), 'r') as f:\n return f.read()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def samples_path():\n dir = os.path.dirname(os.path.abspath(__file__))\n samples = os.path.join(dir, 'samples')\n return samples","def read_test_file(path):\n #TODO Handle multiple test sets in a given doc\n teststruct = yaml.safe_load(os.path.expandvars(read_file(path)))\n return teststruct","def read(*paths):\n fullpath = join(dirname(__file__), *paths)\n return io.open(fullpath, encoding='utf-8').read().strip()","def read_examples(source_file, target_file):\n sources = []\n targets = []\n\n with gfile.GFile(source_file, \"r\") as txt_file:\n for line in txt_file:\n sources.append(line.rstrip(\"\\n\"))\n\n with gfile.GFile(target_file, \"r\") as txt_file:\n for line in txt_file:\n targets.append(line.rstrip(\"\\n\"))\n\n examples = list(zip(sources, targets))\n return examples","def _example_loader(self, prefix):\n return self._base_loader(prefix, 'examples')","def get_example(name):\n this = os.path.abspath(os.path.dirname(__file__))\n full = os.path.join(this, name)\n if not os.path.exists(full):\n raise FileNotFoundError(\"Unable to find example '{0}'\".format(name))\n return full","def test_load_path(parser):\n doc = parser.load(pathlib.Path('jsonexamples') / 'small' / 'demo.json')\n doc.at_pointer('/Image/Width')","def generate_examples(file_name):\n for line in read_file(file_name):\n yield json.loads(line)","def demonstration_examples(kind):\n\n DIR = './data/demos/'\n RNN_DEMO = \"-demo_rnn_examples\"\n EXT = '.pkl'\n\n if kind == 'rnn':\n return pd.read_pickle(DIR+RNN_DEMO+EXT)","def get_dev_examples(self, data_path):\r\n return self.create_examples(self.read_data(data_path), 'dev')","def load_data(path):\n with open(path) as f:\n return f.readlines()","def read(*paths):\n with open(os.path.join(*paths), 'r', 'utf-8') as f:\n return f.read()","def read_examples(input_file):\n examples = []\n unique_id = 0\n with tf.gfile.GFile(input_file, \"r\") as reader:\n while True:\n line = tokenization.convert_to_unicode(reader.readline())\n if not line:\n break\n \n line = line.strip()\n text_a = None\n text_b = None\n m = re.match(r\"^(.*) \\|\\|\\| (.*)$\", line)\n \n if m is None:\n text_a = line\n else:\n text_a = m.group(1)\n text_b = m.group(2)\n examples.append(InputExample(unique_id=unique_id,\n text_a=text_a, \n text_b=text_b))\n unique_id += 1\n return examples","def get_test_examples(self, data_dir):\n \n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def get_test_examples(self, data_dir):\n raise NotImplementedError()","def load_for_sklearn(self):\n\n labels = [] # string labels\n examples = [] # examples as strings\n\n # document number -> label mapping\n doc2label = n2b2.map_patients_to_labels(\n self.xml_dir,\n self.category)\n\n for f in os.listdir(self.cui_dir):\n doc_id = f.split('.')[0]\n file_path = os.path.join(self.cui_dir, f)\n file_as_string = open(file_path).read()\n\n string_label = doc2label[doc_id]\n int_label = LABEL2INT[string_label]\n labels.append(int_label)\n examples.append(file_as_string)\n\n return examples, labels","def test__read_scenario_files(self):\n test_str = '<sequence_demo><adaptivenumericinput />'\n test_result = _read_scenario_files()\n self.assertEqual(test_str, test_result[0:len(test_str)])","def load_sample(self):\n\n self.load_images(self.folder + \"/sampleSet.txt\")\n self.load_traces(self.folder + \"/sampleLabel.txt\")","def load(path):\n pass","def read(self, path: str) -> str:\n raise NotImplementedError","def test_examples(fname):\n app = use_app()\n app.start_timer(0, app.quit)\n if \"OLD\" in fname:\n with pytest.warns(FutureWarning):\n runpy.run_path(fname)\n else:\n try:\n runpy.run_path(fname)\n except ImportError as e:\n if \"Numpy required to use images\" in str(e):\n pytest.skip(\"numpy unavailable: skipping image example\")","def test_pep8_conformance_example(self):\n\n print(\"\\r\\n\")\n\n # Get the path to current directory\n path = os.path.dirname(os.path.realpath(__file__))\n path += \"/../docs/examples/\"\n\n # Find all the examples files\n file_paths = []\n for root, dirnames, filenames in os.walk(path):\n for file_path in fnmatch.filter(filenames, '*.py'):\n file_paths.append(os.path.join(root, file_path))\n\n for path in file_paths:\n self.run_check(path)","def _get_examples_from_json(self):\n results = []\n found = glob.glob(\n os.path.join(_TEST_DEFS_DIR, \"**\", f\"{self.expectation_type}.json\"),\n recursive=True,\n )\n if found:\n with open(found[0]) as fp:\n data = json.load(fp)\n results = data[\"datasets\"]\n return results","def read_data_samples(fp):\n if(path.isdir(fp)):\n fps = glob.glob(fp + '\\\\*.txt')\n return list(map(lambda x: read_file(x), fps))","def ReadRecipesFromDirectory(self, path: str) -> None:\n for file_path in glob.glob(os.path.join(path, '*.json')):\n self.ReadRecipeFromFile(file_path)","def _generate_examples_from_log_path(\n log_path: str,\n) -> Generator[Tuple[str, Dict[str, Any]], None, None]:\n envlogger = tfds.core.lazy_imports.envlogger\n logging.info('Processing directory %s.', log_path)\n counter = 0\n # TFDS suggests using the basename to avoid having the user path in the key.\n key_prefix = os.path.basename(log_path)\n with envlogger.Reader(log_path) as reader:\n for episode_dict in envlogger_reader.generate_episodes(reader):\n # The example ID should be unique.\n episode_id = counter\n if 'episode_id' in episode_dict:\n episode_id = episode_dict['episode_id']\n yield f'{key_prefix}/{episode_id}', episode_dict\n counter += 1","def get_dev_examples(self, input_file):\r\n raise NotImplementedError()","def get_examples(data_dir, mode, task_id, shard_id):\n file_path = get_full_filename(data_dir, mode, task_id, shard_id)\n relative_path = \"/\".join(file_path.split(\"/\")[3:])\n tf.logging.info(\"Reading file: %s\" % (file_path))\n print(relative_path)\n #client = storage.Client(projectname, credentials=credentials)\n #bucket = client.get_bucket(bucket_name)\n blob = storage_bucket.blob(relative_path)\n if not blob.exists():\n tf.logging.info(\"Path doesn't exist\")\n return None\n nq_data = extract_nq_data(file_path)\n tf.logging.info(\"NQ data Size: \" + str(len(nq_data.keys())))\n\n tf.logging.info(\"Performing entity extraction\")\n fact_extracted_data = entity_link_nq(nq_data)\n return fact_extracted_data","def test_darknet_txt_paths(path_to_samples_list: str):\n with open(path_to_samples_list, \"r\") as f:\n data = f.readlines()\n for img_path in [path[:-1] for path in data]:\n assert os.path.isfile(img_path)\n assert os.path.isfile(img_path.replace(\"/images/\", \"/labels/\").replace(\".jpg\", \".txt\"))\n print(f\"All files listed in '{path_to_samples_list}' exists.\")","def load_file(name):\n path = os.path.abspath(os.path.dirname(__file__))\n filename = os.path.join(path, \"tests/input\", name)\n with open(filename, \"r\") as f:\n data = f.read()\n return data","def generate_beam_examples(path):\n beam = tfds.core.lazy_imports.apache_beam\n\n tag_dirs = get_log_paths(path.resolve())\n return beam.Create(tag_dirs) | beam.FlatMap(_generate_examples_from_log_path)","def test_examples():\n import airconics\n # pytest runs test files in ./__pycache__: need to go up two levels\n example_dir = os.path.abspath(\n os.path.join(__file__, '..', '..', 'examples', 'core'))\n example_scripts = os.listdir(example_dir)\n for script in example_scripts:\n if script.endswith('.py'):\n fname = os.path.join(example_dir, script)\n try:\n subprocess.check_call(['python', fname])\n except subprocess.CalledProcessError:\n raise AssertionError('Example {} failed'.format(fname))","def _read_file(self, input_file):\n with io.open(input_file, \"r\", encoding=\"UTF-8\") as file:\n examples = []\n for line in file:\n data = line.strip().split(\"_!_\")\n example = InputExample(\n guid=data[0], label=data[1], text_a=data[3])\n examples.append(example)\n\n return examples","def read_exercise(env, label):\n # checks whether the exercise location is set by the user\n sl_ex_directory = env.config.sp_exercise_directory\n if sl_ex_directory is None:\n raise RuntimeError('The sp_exercise_directory sphinx config '\n 'value must be set.')\n # localise the directory if given as an absolute path\n if sl_ex_directory.startswith('/'):\n localised_directory = '.' + sl_ex_directory\n else:\n localised_directory = sl_ex_directory\n # check whether the directory exists\n if not os.path.exists(localised_directory):\n raise RuntimeError('The sp_exercise_directory ({}) does not '\n 'exist.'.format(localised_directory))\n\n # format the filename\n assert not label.endswith('.md')\n if label.startswith('ex:'):\n exercise_id = label[3:]\n elif label.startswith('sol:'):\n exercise_id = label[4:]\n else:\n raise RuntimeError('The label either has to start with \"ex:\" or '\n '\"sol:\".')\n\n filename = '{}.md'.format(exercise_id)\n exercise_path = os.path.join(localised_directory, filename)\n\n # ensure that the file exists\n sphinx_prolog.file_exists(exercise_path)\n\n # read the file\n with open(exercise_path, 'r') as f:\n exercise_content = f.read()\n\n # add this file to watch list for rebuilding this document\n env.note_dependency(exercise_path)\n\n return exercise_content","def load_sample(filename):\n return open(os.path.join(SAMPLES, filename)).read()","def read_input_file(path: str):\n with open(path, \"r\") as f:\n return f.readlines()","def read_file(path, source):\n if source == 'srim':\n return read_srim(path)\n elif source == 'astar':\n return read_astar(path)\n else:\n raise ValueError('Unknown data source {}'.format(source))","def test_examples():\n tests = [d for d in listdir(ex) if path.isdir(path.join(ex, d))]\n for d in tests:\n yield check_examples, d","def open_file(path):\n input_file = os.path.join(path)\n with open(input_file) as f:\n dataset = f.read()\n return dataset","def test_readfile(self):\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\n HEN_FILE_EXTENSION\n command = \"{0}\".format(fname)\n\n hen.io.main(command.split())","def _load(examples, f):\n\n for l in f:\n json_example = json.loads(l)\n if FLAGS.mode == 'long_answers' and not has_long_answer(json_example):\n continue\n\n elif FLAGS.mode == 'short_answers' and not has_short_answer(json_example):\n continue\n\n example = Example(json_example)\n examples[example.example_id] = example\n\n if len(examples) == FLAGS.max_examples:\n break","def get_examples(self, data_dir, file_key=\"train\"):\n raise NotImplementedError()","def read_data_test(path):\n with h5py.File(path, 'r') as hf:\n input_ = np.array(hf.get('data'))\n label_ = np.array(hf.get('label'))\n\t\n return input_, label_","def load(cls, path: str):\n with open(path, \"r\") as f:\n run_data = json.load(f)\n return Experiment.load_from_dict(run_data)","def read_samples(path: PathType) -> pd.DataFrame:\n df = pd.read_csv(path, sep=\" \", skiprows=[1], usecols=[0])\n df.columns = [\"sample_id\"]\n return df","def get_dev_examples(self, data_dir):\n raise NotImplementedError()","def get_dev_examples(self, data_dir):\n raise NotImplementedError()","def get_sample(self, path, prefix) -> List:\n pass","def get_dev_examples(self, data_dir):\r\n raise NotImplementedError()","def get_train_examples(self, data_path):\r\n return self.create_examples(self.read_data(data_path), 'train')","def demo_paths(self):\n base_path = os.path.join(self.module.__path__[0], 'demo')\n paths = []\n if os.path.isdir(base_path):\n for item in os.listdir(base_path):\n # TODO: support examples which is not auto-loaded\n if not os.path.isdir(os.path.join(base_path, 'examples')):\n paths.append(os.path.join(base_path, item))\n return paths","def load_demos():\n for index in range(len(feconf.DEMO_EXPLORATIONS)):\n load_demo(str(index))","def load_examples():\n X = []\n Y = []\n with open('examples.txt') as fin:\n for i, line in enumerate(fin):\n if line[0].isdigit():\n bias, pos, neg, label = map(float, line.strip().split(','))\n X.append([bias, pos, neg])\n Y.append(label)\n X = np.array(X)\n Y = np.array(Y).reshape(i, 1)\n return X, Y","def read_data_set(self, path):\n data = self._preprocessor.create_empty_input_target_data()\n\n for filename in glob.iglob(os.path.join(path, \"*\" + NoiseReader.file_extension())):\n exp_name = os.path.splitext(os.path.basename(filename))[0]\n\n experiment = self.read_experiment(path, exp_name)\n data = self._preprocessor.concat_input_target_data(data, experiment)\n\n return data","def read(self, path):\n if not os.path.exists(path):\n sys.stderr.write('Folder or file nonexist!\\nCheck the path!')\n return\n\n else:\n if os.path.isdir(path): # It should be DICOM folder\n self.read_dicom(path)\n\n else:\n # Get extension with dot, such as '.mha'\n ext = os.path.splitext(path)[1].lower()\n if '.mha' == ext or '.mhd' == ext:\n self.read_metaimage(path)","def read_files(dataroot, is_test=False, preprocess=False, aug_dataset_path=None):\n\tall_filenames = sorted(glob.glob(dataroot), key=alphanum_key)\n\tsamples_raw = []\n\tpreprocessed = 0\n\tskipped = 0\n\n\tfor fname in all_filenames:\n\t\twith open(fname, 'r') as fp:\n\t\t\ttry:\n\t\t\t\tproblem_data = json.load(fp)\n\t\t\t\t#print(fname)\n\t\t\texcept Exception as e:\n\t\t\t\tprint(f\"Error loading JSON from {fname}\", e)\n\t\t\t\traise e\n\n\t\tproblem = MATHProblem(\n\t\t\tfname,\n\t\t\tproblem_data['problem'],\n\t\t\tproblem_data['type'],\n\t\t\tproblem_data['level'],\n\t\t\texplanation=problem_data['explanation'] if not is_test else None,\n\t\t\tsolution=problem_data['solution'] if not is_test else None,\n\t\t\tequation=problem_data['equation'] if not is_test else None,\n\t\t\tjson_data=problem_data,\n\t\t\tpreprocess=preprocess,\n\t\t)\n\n\t\tif problem.no_expression:\n\t\t\tskipped += 1\n\t\tsamples_raw.append(problem)\n\n\tif not is_test and aug_dataset_path:\n\t\tprint('Adding another dataset to the samples...')\n\t\twith open(aug_dataset_path) as fp:\n\t\t\tdata = json.load(fp)\n\t\t\tfor data_item in data:\n\t\t\t\tproblem = MATHProblem(\n\t\t\t\t\t'augmented',\n\t\t\t\t\tdata_item['sQuestion'],\n\t\t\t\t\t'MWP',\n\t\t\t\t\t'NA',\n\t\t\t\t\tsolution=str(data_item['lSolutions'][0]),\n\t\t\t\t\tequation=data_item['new_equation'],\n\t\t\t\t)\n\n\t\t\t\tif problem.no_expression:\n\t\t\t\t\tskipped += 1\n\t\t\t\tsamples_raw.append(problem)\t\n\n\tprint('There are no expressions for {} in {} items'.format(skipped, len(samples_raw)))\n\treturn samples_raw","def examples_paths():\n data_dir = utils.get_data_filename(os.path.join('tests', 'data'))\n p_xylene_dir = os.path.join(data_dir, 'p-xylene-implicit')\n p_xylene_gro_dir = os.path.join(data_dir, 'p-xylene-gromacs-example')\n ben_tol_dir = os.path.join(data_dir, 'benzene-toluene-explicit')\n abl_imatinib_dir = os.path.join(data_dir, 'abl-imatinib-explicit')\n tol_dir = os.path.join(data_dir, 'toluene-explicit')\n benz_tol_dir = os.path.join(data_dir, 'benzene-toluene-standard-state')\n\n paths = dict()\n paths['lysozyme'] = os.path.join(p_xylene_dir, '181L-pdbfixer.pdb')\n paths['p-xylene'] = os.path.join(p_xylene_dir, 'p-xylene.mol2')\n paths['benzene'] = os.path.join(ben_tol_dir, 'benzene.tripos.mol2')\n paths['toluene'] = os.path.join(ben_tol_dir, 'toluene.tripos.mol2')\n paths['abl'] = os.path.join(abl_imatinib_dir, '2HYY-pdbfixer.pdb')\n paths['imatinib'] = os.path.join(abl_imatinib_dir, 'STI02.mol2')\n paths['bentol-complex'] = [os.path.join(ben_tol_dir, 'complex.prmtop'),\n os.path.join(ben_tol_dir, 'complex.inpcrd')]\n paths['bentol-solvent'] = [os.path.join(ben_tol_dir, 'solvent.prmtop'),\n os.path.join(ben_tol_dir, 'solvent.inpcrd')]\n paths['pxylene-complex'] = [os.path.join(p_xylene_gro_dir, 'complex.top'),\n os.path.join(p_xylene_gro_dir, 'complex.gro')]\n paths['pxylene-solvent'] = [os.path.join(p_xylene_gro_dir, 'solvent.top'),\n os.path.join(p_xylene_gro_dir, 'solvent.gro')]\n paths['pxylene-gro-include'] = os.path.join(p_xylene_gro_dir, 'top')\n paths['toluene-solvent'] = [os.path.join(tol_dir, 'solvent.pdb'),\n os.path.join(tol_dir, 'solvent.xml')]\n paths['toluene-vacuum'] = [os.path.join(tol_dir, 'vacuum.pdb'),\n os.path.join(tol_dir, 'vacuum.xml')]\n paths['benzene-toluene-boxless'] = [os.path.join(benz_tol_dir, 'standard_state_complex_boxless.inpcrd'),\n os.path.join(benz_tol_dir, 'standard_state_complex.prmtop')]\n paths['benzene-toluene-nan'] = [os.path.join(benz_tol_dir, 'standard_state_complex_nan.inpcrd'),\n os.path.join(benz_tol_dir, 'standard_state_complex.prmtop')]\n return paths","def load_data(path):\n input_file = os.path.join(path)\n with open(input_file, 'r', encoding='utf-8') as f:\n return f.read()","def read_fixture_file(*path, mode='rb'):\n with open(fixture_file(*path), mode) as f:\n return f.read()","def get_num_examples(path_in):\n i = 0\n with open(path_in, 'r', encoding='utf8') as f:\n for _ in f:\n i += 1\n return i","def read_file(path):\n # copied from straxen.common.open_resource\n # https://github.com/XENONnT/straxen/blob/a2e0e3abdbf278000cda70f7662a7d841c7223ef/straxen/common.py#L85\n name, fmt = os.path.splitext(path)\n\n if fmt in ['.npy', '.npy_pickle', '.npz']:\n result = np.load(path, allow_pickle=fmt == 'npy_pickle')\n if isinstance(result, np.lib.npyio.NpzFile):\n # Slurp the arrays in the file, so the result can be copied,\n # then close the file so its descriptors does not leak.\n result_slurped = {k: v[:] for k, v in result.items()}\n result.close()\n result = result_slurped\n elif fmt == '.pkl':\n with open(path, 'rb') as f:\n result = pickle.load(f)\n elif fmt == '.gz':\n subname, subfmt = os.path.splitext(name)\n if subfmt == '.pkl':\n with gzip.open(path, 'rb') as f:\n result = pickle.load(f)\n elif subfmt == '.json':\n with gzip.open(path, 'rb') as f:\n result = json.load(f)\n elif fmt == '.json':\n with open(path, mode='r') as f:\n result = commentjson.load(f)\n elif fmt == '.binary':\n with open(path, mode='rb') as f:\n result = f.read()\n elif fmt in ['.text', '.txt']:\n with open(path, mode='r') as f:\n result = f.read()\n elif fmt == '.csv':\n result = pd.read_csv(path)\n else:\n raise ValueError(f\"Unsupported format {fmt}!\")\n\n return result","def process_examples(self):\n input_dir = self.input_directory\n counter_example_dir = self.counter_example_input_directory\n if input_dir is None:\n input_dir = Path.cwd() / \"examples\"\n if counter_example_dir is None:\n counter_example_dir = Path.cwd() / \"counter_examples\"\n for fmt in self.input_formats:\n input_examples = glob.glob(os.path.join(str(input_dir), f\"*.{fmt}\"))\n input_counter_examples = glob.glob(os.path.join(str(counter_example_dir), f\"*.{fmt}\"))\n if not input_counter_examples:\n logging.warning(\n f\"No counter examples found in {self.counter_example_input_directory}\"\n )\n self.process_examples_from_list(input_examples, fmt, False)\n self.process_examples_from_list(input_counter_examples, fmt, True)","def load(self, path: str):\n pass","def readFile(path: str):\n print(\"\\n\" + path + \"\\n\")\n res = []\n with open(path, 'r') as reader:\n for line in reader.readlines():\n res.append(line)\n return res","def get_examples():\n # Get the tjson test cases from a url.\n examples = urlopen(TJSON_EXAMPLES_URL).read()\n\n # Strip comments from the lines.\n examples = re.sub(r\"^#.*\\n?\", \"\", examples.decode(), flags=re.MULTILINE)\n\n # Split a group of examples.\n delimiter = re.escape(EXAMPLES_DELIMITER)\n example_re = re.compile(delimiter + r'(.*?)' + delimiter, re.S)\n split = re.findall(example_re, examples)\n\n # Create the `Example` named tuples.\n return [\n parse_example(example)\n for example in split]","def read_file(path):\n # Mystery arguments:\n strictness = False\n # Read the string:\n return _iterate_bibtexsource(_bibtex.open_file(path, strictness))","def test_examples(self):\n with sphinx_build('pyexample'):\n with open('_build/text/docfx_yaml/example.nap.Base.yml') as yml_file:\n data = yaml.safe_load(yml_file)\n for item in data['items']:\n if item['uid'] == 'example.nap.Base.ref':\n self.assertEqual(\n item['example'].split('\\n')[2],\n \"\"\">>> print('docblock 1')\"\"\"\n )\n self.assertEqual(\n item['example'].split('\\n')[7],\n \"\"\">>> print('docblock 2')\"\"\"\n )","def load_examples(filename):\r\n data = np.load(filename)\r\n return data['examples'], int(data['srate'])","def load_examples(filename):\r\n data = np.load(filename)\r\n return data['examples'], int(data['srate'])","def load(self, path):\n pass","def load(self, path):\n pass","def read_examples(file_name):\n start = time.time()\n print 'Reading examples from tab separated file...'\n count = 0\n i = 0\n with open(file_name, 'r') as fp:\n relation_examples = []\n for i, line in enumerate(fp):\n line.strip()\n if len(line) == 0 or len(line.split()) == 0:\n raise IOError\n else:\n fields = line.split('\\t')\n assert len(fields) == 9, \"a problem with the file format (# fields is wrong) len is \" + str(len(fields)) + \"instead of 9\"\n relation_examples.append([str(count)] + fields)\n count += 1\n print ' File contained {} lines'.format(i + 1)\n print ' Datapoints with valid features encoded: {}'.format(count)\n print ' Done in {:.2f} sec'.format(time.time() - start)\n return relation_examples","def load(self):\n basePath = './examples/'\n file = \"print8.ls8\"\n # file = \"mult.ls8\"\n # file = \"stack.ls8\"\n # file = \"call.ls8\"\n file = \"sctest.ls8\"\n if len(sys.argv) > 1:\n file = sys.argv[1]\n address = 0\n\n with open(basePath + file, \"r\") as f:\n for line in f:\n line = line.split(\"#\")\n\n try:\n v = int(line[0], 2)\n except ValueError:\n continue\n # print(v)\n self.ram[address] = v\n address += 1"],"string":"[\n \"def load_examples(path: str) -> List['InputExample']:\\n with open(path, 'rb') as fh:\\n return pickle.load(fh)\",\n \"def load_examples(path: str) -> List['InputExample']:\\n with open(path, 'rb') as fh:\\n return pickle.load(fh)\",\n \"def load_examples(path: str) -> List['InputExample']:\\n with open(path, 'rb') as fh:\\n return pickle.load(fh)\",\n \"def examples_from_file(path):\\n examples = []\\n\\n # count total lines before loading\\n total_lines = int(local('wc -l {}'.format(path), capture=True).split()[0])\\n\\n with codecs.open(path, 'r', encoding='utf-8') as f:\\n for line in verboserate(f, desc='Reading data file.', total=total_lines):\\n src, trg = line.strip().lower().split('\\\\t')\\n src_words = src.split(' ')\\n trg_words = trg.split(' ')\\n assert len(src_words) > 0\\n assert len(trg_words) > 0\\n\\n if use_diff:\\n ex = EditExample.salient_diff(src_words, trg_words, free_set)\\n else:\\n ex = EditExample.whitelist_blacklist(src_words, trg_words)\\n examples.append(ex)\\n return examples\",\n \"def read(path):\",\n \"def read(path, label2int):\\n\\n labels = [] # int labels\\n samples = [] # examples as strings\\n\\n for label_dir in os.listdir(path):\\n label_dir_path = os.path.join(path, label_dir)\\n\\n for file in os.listdir(label_dir_path):\\n file_path = os.path.join(label_dir_path, file)\\n file_text = open(file_path).read().rstrip()\\n int_label = label2int[label_dir.lower()]\\n samples.append(file_text)\\n labels.append(int_label)\\n\\n return samples, labels\",\n \"def discover_examples():\\n root = './examples'\\n for filename in os.listdir(root):\\n if os.path.splitext(filename)[1] == '.py':\\n yield os.path.join(root, filename)\",\n \"def example(*paths):\\n\\n return normpath(join(dirname(__file__), '..', 'examples', *paths))\",\n \"def read_examples(data_dir, data_sign):\\n examples = []\\n # read src data\\n with open(data_dir / f'{data_sign}/sentences.txt', \\\"r\\\", encoding='utf-8') as f_sen, \\\\\\n open(data_dir / f'{data_sign}/tags.txt', 'r', encoding='utf-8') as f_tag:\\n for sen, tag in zip(f_sen, f_tag):\\n example = InputExample(sentence=sen.strip().split(' '), tags=tag.strip().split(' '))\\n examples.append(example)\\n print(\\\"InputExamples:\\\", len(examples))\\n return examples\",\n \"def get_test_examples(self, data_path):\\r\\n return self.create_examples(self.read_data(data_path), 'test')\",\n \"def examplereader(path, lower=False):\\n for line in filereader(path):\\n line = line.lower() if lower else line\\n tokens = tokens_from_treestring(line)\\n tree = Tree.fromstring(line) # use NLTK's Tree\\n label = int(line[1])\\n trans = transitions_from_treestring(line)\\n yield Example(tokens=tokens, tree=tree, label=label, transitions=trans)\",\n \"def _read(self, path: str):\\n num_samples, length = [int(x) for x in path.split(\\\":\\\")]\\n random.seed(self.seed)\\n for _ in range(num_samples):\\n tokens, tags = self._sample(length)\\n yield self.text_to_instance(tokens, tags)\",\n \"def find_examples_in_schema(path):\\n with open(path, 'rb') as fd:\\n schema_tree = yaml.load(fd)\\n\\n for node in treeutil.iter_tree(schema_tree):\\n if (isinstance(node, dict) and\\n 'examples' in node and\\n isinstance(node['examples'], list)):\\n for desc, example in node['examples']:\\n yield example\",\n \"def read_path():\\n global path\\n if len(sys.argv) >= 2:\\n path = sys.argv[1]\\n else:\\n path = \\\"train\\\"\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r') as f:\\n return f.read()\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r') as f:\\n return f.read()\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r') as f:\\n return f.read()\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r') as f:\\n return f.read()\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r') as f:\\n return f.read()\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r') as f:\\n return f.read()\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r') as f:\\n return f.read()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def samples_path():\\n dir = os.path.dirname(os.path.abspath(__file__))\\n samples = os.path.join(dir, 'samples')\\n return samples\",\n \"def read_test_file(path):\\n #TODO Handle multiple test sets in a given doc\\n teststruct = yaml.safe_load(os.path.expandvars(read_file(path)))\\n return teststruct\",\n \"def read(*paths):\\n fullpath = join(dirname(__file__), *paths)\\n return io.open(fullpath, encoding='utf-8').read().strip()\",\n \"def read_examples(source_file, target_file):\\n sources = []\\n targets = []\\n\\n with gfile.GFile(source_file, \\\"r\\\") as txt_file:\\n for line in txt_file:\\n sources.append(line.rstrip(\\\"\\\\n\\\"))\\n\\n with gfile.GFile(target_file, \\\"r\\\") as txt_file:\\n for line in txt_file:\\n targets.append(line.rstrip(\\\"\\\\n\\\"))\\n\\n examples = list(zip(sources, targets))\\n return examples\",\n \"def _example_loader(self, prefix):\\n return self._base_loader(prefix, 'examples')\",\n \"def get_example(name):\\n this = os.path.abspath(os.path.dirname(__file__))\\n full = os.path.join(this, name)\\n if not os.path.exists(full):\\n raise FileNotFoundError(\\\"Unable to find example '{0}'\\\".format(name))\\n return full\",\n \"def test_load_path(parser):\\n doc = parser.load(pathlib.Path('jsonexamples') / 'small' / 'demo.json')\\n doc.at_pointer('/Image/Width')\",\n \"def generate_examples(file_name):\\n for line in read_file(file_name):\\n yield json.loads(line)\",\n \"def demonstration_examples(kind):\\n\\n DIR = './data/demos/'\\n RNN_DEMO = \\\"-demo_rnn_examples\\\"\\n EXT = '.pkl'\\n\\n if kind == 'rnn':\\n return pd.read_pickle(DIR+RNN_DEMO+EXT)\",\n \"def get_dev_examples(self, data_path):\\r\\n return self.create_examples(self.read_data(data_path), 'dev')\",\n \"def load_data(path):\\n with open(path) as f:\\n return f.readlines()\",\n \"def read(*paths):\\n with open(os.path.join(*paths), 'r', 'utf-8') as f:\\n return f.read()\",\n \"def read_examples(input_file):\\n examples = []\\n unique_id = 0\\n with tf.gfile.GFile(input_file, \\\"r\\\") as reader:\\n while True:\\n line = tokenization.convert_to_unicode(reader.readline())\\n if not line:\\n break\\n \\n line = line.strip()\\n text_a = None\\n text_b = None\\n m = re.match(r\\\"^(.*) \\\\|\\\\|\\\\| (.*)$\\\", line)\\n \\n if m is None:\\n text_a = line\\n else:\\n text_a = m.group(1)\\n text_b = m.group(2)\\n examples.append(InputExample(unique_id=unique_id,\\n text_a=text_a, \\n text_b=text_b))\\n unique_id += 1\\n return examples\",\n \"def get_test_examples(self, data_dir):\\n \\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_test_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def load_for_sklearn(self):\\n\\n labels = [] # string labels\\n examples = [] # examples as strings\\n\\n # document number -> label mapping\\n doc2label = n2b2.map_patients_to_labels(\\n self.xml_dir,\\n self.category)\\n\\n for f in os.listdir(self.cui_dir):\\n doc_id = f.split('.')[0]\\n file_path = os.path.join(self.cui_dir, f)\\n file_as_string = open(file_path).read()\\n\\n string_label = doc2label[doc_id]\\n int_label = LABEL2INT[string_label]\\n labels.append(int_label)\\n examples.append(file_as_string)\\n\\n return examples, labels\",\n \"def test__read_scenario_files(self):\\n test_str = '<sequence_demo><adaptivenumericinput />'\\n test_result = _read_scenario_files()\\n self.assertEqual(test_str, test_result[0:len(test_str)])\",\n \"def load_sample(self):\\n\\n self.load_images(self.folder + \\\"/sampleSet.txt\\\")\\n self.load_traces(self.folder + \\\"/sampleLabel.txt\\\")\",\n \"def load(path):\\n pass\",\n \"def read(self, path: str) -> str:\\n raise NotImplementedError\",\n \"def test_examples(fname):\\n app = use_app()\\n app.start_timer(0, app.quit)\\n if \\\"OLD\\\" in fname:\\n with pytest.warns(FutureWarning):\\n runpy.run_path(fname)\\n else:\\n try:\\n runpy.run_path(fname)\\n except ImportError as e:\\n if \\\"Numpy required to use images\\\" in str(e):\\n pytest.skip(\\\"numpy unavailable: skipping image example\\\")\",\n \"def test_pep8_conformance_example(self):\\n\\n print(\\\"\\\\r\\\\n\\\")\\n\\n # Get the path to current directory\\n path = os.path.dirname(os.path.realpath(__file__))\\n path += \\\"/../docs/examples/\\\"\\n\\n # Find all the examples files\\n file_paths = []\\n for root, dirnames, filenames in os.walk(path):\\n for file_path in fnmatch.filter(filenames, '*.py'):\\n file_paths.append(os.path.join(root, file_path))\\n\\n for path in file_paths:\\n self.run_check(path)\",\n \"def _get_examples_from_json(self):\\n results = []\\n found = glob.glob(\\n os.path.join(_TEST_DEFS_DIR, \\\"**\\\", f\\\"{self.expectation_type}.json\\\"),\\n recursive=True,\\n )\\n if found:\\n with open(found[0]) as fp:\\n data = json.load(fp)\\n results = data[\\\"datasets\\\"]\\n return results\",\n \"def read_data_samples(fp):\\n if(path.isdir(fp)):\\n fps = glob.glob(fp + '\\\\\\\\*.txt')\\n return list(map(lambda x: read_file(x), fps))\",\n \"def ReadRecipesFromDirectory(self, path: str) -> None:\\n for file_path in glob.glob(os.path.join(path, '*.json')):\\n self.ReadRecipeFromFile(file_path)\",\n \"def _generate_examples_from_log_path(\\n log_path: str,\\n) -> Generator[Tuple[str, Dict[str, Any]], None, None]:\\n envlogger = tfds.core.lazy_imports.envlogger\\n logging.info('Processing directory %s.', log_path)\\n counter = 0\\n # TFDS suggests using the basename to avoid having the user path in the key.\\n key_prefix = os.path.basename(log_path)\\n with envlogger.Reader(log_path) as reader:\\n for episode_dict in envlogger_reader.generate_episodes(reader):\\n # The example ID should be unique.\\n episode_id = counter\\n if 'episode_id' in episode_dict:\\n episode_id = episode_dict['episode_id']\\n yield f'{key_prefix}/{episode_id}', episode_dict\\n counter += 1\",\n \"def get_dev_examples(self, input_file):\\r\\n raise NotImplementedError()\",\n \"def get_examples(data_dir, mode, task_id, shard_id):\\n file_path = get_full_filename(data_dir, mode, task_id, shard_id)\\n relative_path = \\\"/\\\".join(file_path.split(\\\"/\\\")[3:])\\n tf.logging.info(\\\"Reading file: %s\\\" % (file_path))\\n print(relative_path)\\n #client = storage.Client(projectname, credentials=credentials)\\n #bucket = client.get_bucket(bucket_name)\\n blob = storage_bucket.blob(relative_path)\\n if not blob.exists():\\n tf.logging.info(\\\"Path doesn't exist\\\")\\n return None\\n nq_data = extract_nq_data(file_path)\\n tf.logging.info(\\\"NQ data Size: \\\" + str(len(nq_data.keys())))\\n\\n tf.logging.info(\\\"Performing entity extraction\\\")\\n fact_extracted_data = entity_link_nq(nq_data)\\n return fact_extracted_data\",\n \"def test_darknet_txt_paths(path_to_samples_list: str):\\n with open(path_to_samples_list, \\\"r\\\") as f:\\n data = f.readlines()\\n for img_path in [path[:-1] for path in data]:\\n assert os.path.isfile(img_path)\\n assert os.path.isfile(img_path.replace(\\\"/images/\\\", \\\"/labels/\\\").replace(\\\".jpg\\\", \\\".txt\\\"))\\n print(f\\\"All files listed in '{path_to_samples_list}' exists.\\\")\",\n \"def load_file(name):\\n path = os.path.abspath(os.path.dirname(__file__))\\n filename = os.path.join(path, \\\"tests/input\\\", name)\\n with open(filename, \\\"r\\\") as f:\\n data = f.read()\\n return data\",\n \"def generate_beam_examples(path):\\n beam = tfds.core.lazy_imports.apache_beam\\n\\n tag_dirs = get_log_paths(path.resolve())\\n return beam.Create(tag_dirs) | beam.FlatMap(_generate_examples_from_log_path)\",\n \"def test_examples():\\n import airconics\\n # pytest runs test files in ./__pycache__: need to go up two levels\\n example_dir = os.path.abspath(\\n os.path.join(__file__, '..', '..', 'examples', 'core'))\\n example_scripts = os.listdir(example_dir)\\n for script in example_scripts:\\n if script.endswith('.py'):\\n fname = os.path.join(example_dir, script)\\n try:\\n subprocess.check_call(['python', fname])\\n except subprocess.CalledProcessError:\\n raise AssertionError('Example {} failed'.format(fname))\",\n \"def _read_file(self, input_file):\\n with io.open(input_file, \\\"r\\\", encoding=\\\"UTF-8\\\") as file:\\n examples = []\\n for line in file:\\n data = line.strip().split(\\\"_!_\\\")\\n example = InputExample(\\n guid=data[0], label=data[1], text_a=data[3])\\n examples.append(example)\\n\\n return examples\",\n \"def read_exercise(env, label):\\n # checks whether the exercise location is set by the user\\n sl_ex_directory = env.config.sp_exercise_directory\\n if sl_ex_directory is None:\\n raise RuntimeError('The sp_exercise_directory sphinx config '\\n 'value must be set.')\\n # localise the directory if given as an absolute path\\n if sl_ex_directory.startswith('/'):\\n localised_directory = '.' + sl_ex_directory\\n else:\\n localised_directory = sl_ex_directory\\n # check whether the directory exists\\n if not os.path.exists(localised_directory):\\n raise RuntimeError('The sp_exercise_directory ({}) does not '\\n 'exist.'.format(localised_directory))\\n\\n # format the filename\\n assert not label.endswith('.md')\\n if label.startswith('ex:'):\\n exercise_id = label[3:]\\n elif label.startswith('sol:'):\\n exercise_id = label[4:]\\n else:\\n raise RuntimeError('The label either has to start with \\\"ex:\\\" or '\\n '\\\"sol:\\\".')\\n\\n filename = '{}.md'.format(exercise_id)\\n exercise_path = os.path.join(localised_directory, filename)\\n\\n # ensure that the file exists\\n sphinx_prolog.file_exists(exercise_path)\\n\\n # read the file\\n with open(exercise_path, 'r') as f:\\n exercise_content = f.read()\\n\\n # add this file to watch list for rebuilding this document\\n env.note_dependency(exercise_path)\\n\\n return exercise_content\",\n \"def load_sample(filename):\\n return open(os.path.join(SAMPLES, filename)).read()\",\n \"def read_input_file(path: str):\\n with open(path, \\\"r\\\") as f:\\n return f.readlines()\",\n \"def read_file(path, source):\\n if source == 'srim':\\n return read_srim(path)\\n elif source == 'astar':\\n return read_astar(path)\\n else:\\n raise ValueError('Unknown data source {}'.format(source))\",\n \"def test_examples():\\n tests = [d for d in listdir(ex) if path.isdir(path.join(ex, d))]\\n for d in tests:\\n yield check_examples, d\",\n \"def open_file(path):\\n input_file = os.path.join(path)\\n with open(input_file) as f:\\n dataset = f.read()\\n return dataset\",\n \"def test_readfile(self):\\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\\\\n HEN_FILE_EXTENSION\\n command = \\\"{0}\\\".format(fname)\\n\\n hen.io.main(command.split())\",\n \"def _load(examples, f):\\n\\n for l in f:\\n json_example = json.loads(l)\\n if FLAGS.mode == 'long_answers' and not has_long_answer(json_example):\\n continue\\n\\n elif FLAGS.mode == 'short_answers' and not has_short_answer(json_example):\\n continue\\n\\n example = Example(json_example)\\n examples[example.example_id] = example\\n\\n if len(examples) == FLAGS.max_examples:\\n break\",\n \"def get_examples(self, data_dir, file_key=\\\"train\\\"):\\n raise NotImplementedError()\",\n \"def read_data_test(path):\\n with h5py.File(path, 'r') as hf:\\n input_ = np.array(hf.get('data'))\\n label_ = np.array(hf.get('label'))\\n\\t\\n return input_, label_\",\n \"def load(cls, path: str):\\n with open(path, \\\"r\\\") as f:\\n run_data = json.load(f)\\n return Experiment.load_from_dict(run_data)\",\n \"def read_samples(path: PathType) -> pd.DataFrame:\\n df = pd.read_csv(path, sep=\\\" \\\", skiprows=[1], usecols=[0])\\n df.columns = [\\\"sample_id\\\"]\\n return df\",\n \"def get_dev_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_dev_examples(self, data_dir):\\n raise NotImplementedError()\",\n \"def get_sample(self, path, prefix) -> List:\\n pass\",\n \"def get_dev_examples(self, data_dir):\\r\\n raise NotImplementedError()\",\n \"def get_train_examples(self, data_path):\\r\\n return self.create_examples(self.read_data(data_path), 'train')\",\n \"def demo_paths(self):\\n base_path = os.path.join(self.module.__path__[0], 'demo')\\n paths = []\\n if os.path.isdir(base_path):\\n for item in os.listdir(base_path):\\n # TODO: support examples which is not auto-loaded\\n if not os.path.isdir(os.path.join(base_path, 'examples')):\\n paths.append(os.path.join(base_path, item))\\n return paths\",\n \"def load_demos():\\n for index in range(len(feconf.DEMO_EXPLORATIONS)):\\n load_demo(str(index))\",\n \"def load_examples():\\n X = []\\n Y = []\\n with open('examples.txt') as fin:\\n for i, line in enumerate(fin):\\n if line[0].isdigit():\\n bias, pos, neg, label = map(float, line.strip().split(','))\\n X.append([bias, pos, neg])\\n Y.append(label)\\n X = np.array(X)\\n Y = np.array(Y).reshape(i, 1)\\n return X, Y\",\n \"def read_data_set(self, path):\\n data = self._preprocessor.create_empty_input_target_data()\\n\\n for filename in glob.iglob(os.path.join(path, \\\"*\\\" + NoiseReader.file_extension())):\\n exp_name = os.path.splitext(os.path.basename(filename))[0]\\n\\n experiment = self.read_experiment(path, exp_name)\\n data = self._preprocessor.concat_input_target_data(data, experiment)\\n\\n return data\",\n \"def read(self, path):\\n if not os.path.exists(path):\\n sys.stderr.write('Folder or file nonexist!\\\\nCheck the path!')\\n return\\n\\n else:\\n if os.path.isdir(path): # It should be DICOM folder\\n self.read_dicom(path)\\n\\n else:\\n # Get extension with dot, such as '.mha'\\n ext = os.path.splitext(path)[1].lower()\\n if '.mha' == ext or '.mhd' == ext:\\n self.read_metaimage(path)\",\n \"def read_files(dataroot, is_test=False, preprocess=False, aug_dataset_path=None):\\n\\tall_filenames = sorted(glob.glob(dataroot), key=alphanum_key)\\n\\tsamples_raw = []\\n\\tpreprocessed = 0\\n\\tskipped = 0\\n\\n\\tfor fname in all_filenames:\\n\\t\\twith open(fname, 'r') as fp:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tproblem_data = json.load(fp)\\n\\t\\t\\t\\t#print(fname)\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tprint(f\\\"Error loading JSON from {fname}\\\", e)\\n\\t\\t\\t\\traise e\\n\\n\\t\\tproblem = MATHProblem(\\n\\t\\t\\tfname,\\n\\t\\t\\tproblem_data['problem'],\\n\\t\\t\\tproblem_data['type'],\\n\\t\\t\\tproblem_data['level'],\\n\\t\\t\\texplanation=problem_data['explanation'] if not is_test else None,\\n\\t\\t\\tsolution=problem_data['solution'] if not is_test else None,\\n\\t\\t\\tequation=problem_data['equation'] if not is_test else None,\\n\\t\\t\\tjson_data=problem_data,\\n\\t\\t\\tpreprocess=preprocess,\\n\\t\\t)\\n\\n\\t\\tif problem.no_expression:\\n\\t\\t\\tskipped += 1\\n\\t\\tsamples_raw.append(problem)\\n\\n\\tif not is_test and aug_dataset_path:\\n\\t\\tprint('Adding another dataset to the samples...')\\n\\t\\twith open(aug_dataset_path) as fp:\\n\\t\\t\\tdata = json.load(fp)\\n\\t\\t\\tfor data_item in data:\\n\\t\\t\\t\\tproblem = MATHProblem(\\n\\t\\t\\t\\t\\t'augmented',\\n\\t\\t\\t\\t\\tdata_item['sQuestion'],\\n\\t\\t\\t\\t\\t'MWP',\\n\\t\\t\\t\\t\\t'NA',\\n\\t\\t\\t\\t\\tsolution=str(data_item['lSolutions'][0]),\\n\\t\\t\\t\\t\\tequation=data_item['new_equation'],\\n\\t\\t\\t\\t)\\n\\n\\t\\t\\t\\tif problem.no_expression:\\n\\t\\t\\t\\t\\tskipped += 1\\n\\t\\t\\t\\tsamples_raw.append(problem)\\t\\n\\n\\tprint('There are no expressions for {} in {} items'.format(skipped, len(samples_raw)))\\n\\treturn samples_raw\",\n \"def examples_paths():\\n data_dir = utils.get_data_filename(os.path.join('tests', 'data'))\\n p_xylene_dir = os.path.join(data_dir, 'p-xylene-implicit')\\n p_xylene_gro_dir = os.path.join(data_dir, 'p-xylene-gromacs-example')\\n ben_tol_dir = os.path.join(data_dir, 'benzene-toluene-explicit')\\n abl_imatinib_dir = os.path.join(data_dir, 'abl-imatinib-explicit')\\n tol_dir = os.path.join(data_dir, 'toluene-explicit')\\n benz_tol_dir = os.path.join(data_dir, 'benzene-toluene-standard-state')\\n\\n paths = dict()\\n paths['lysozyme'] = os.path.join(p_xylene_dir, '181L-pdbfixer.pdb')\\n paths['p-xylene'] = os.path.join(p_xylene_dir, 'p-xylene.mol2')\\n paths['benzene'] = os.path.join(ben_tol_dir, 'benzene.tripos.mol2')\\n paths['toluene'] = os.path.join(ben_tol_dir, 'toluene.tripos.mol2')\\n paths['abl'] = os.path.join(abl_imatinib_dir, '2HYY-pdbfixer.pdb')\\n paths['imatinib'] = os.path.join(abl_imatinib_dir, 'STI02.mol2')\\n paths['bentol-complex'] = [os.path.join(ben_tol_dir, 'complex.prmtop'),\\n os.path.join(ben_tol_dir, 'complex.inpcrd')]\\n paths['bentol-solvent'] = [os.path.join(ben_tol_dir, 'solvent.prmtop'),\\n os.path.join(ben_tol_dir, 'solvent.inpcrd')]\\n paths['pxylene-complex'] = [os.path.join(p_xylene_gro_dir, 'complex.top'),\\n os.path.join(p_xylene_gro_dir, 'complex.gro')]\\n paths['pxylene-solvent'] = [os.path.join(p_xylene_gro_dir, 'solvent.top'),\\n os.path.join(p_xylene_gro_dir, 'solvent.gro')]\\n paths['pxylene-gro-include'] = os.path.join(p_xylene_gro_dir, 'top')\\n paths['toluene-solvent'] = [os.path.join(tol_dir, 'solvent.pdb'),\\n os.path.join(tol_dir, 'solvent.xml')]\\n paths['toluene-vacuum'] = [os.path.join(tol_dir, 'vacuum.pdb'),\\n os.path.join(tol_dir, 'vacuum.xml')]\\n paths['benzene-toluene-boxless'] = [os.path.join(benz_tol_dir, 'standard_state_complex_boxless.inpcrd'),\\n os.path.join(benz_tol_dir, 'standard_state_complex.prmtop')]\\n paths['benzene-toluene-nan'] = [os.path.join(benz_tol_dir, 'standard_state_complex_nan.inpcrd'),\\n os.path.join(benz_tol_dir, 'standard_state_complex.prmtop')]\\n return paths\",\n \"def load_data(path):\\n input_file = os.path.join(path)\\n with open(input_file, 'r', encoding='utf-8') as f:\\n return f.read()\",\n \"def read_fixture_file(*path, mode='rb'):\\n with open(fixture_file(*path), mode) as f:\\n return f.read()\",\n \"def get_num_examples(path_in):\\n i = 0\\n with open(path_in, 'r', encoding='utf8') as f:\\n for _ in f:\\n i += 1\\n return i\",\n \"def read_file(path):\\n # copied from straxen.common.open_resource\\n # https://github.com/XENONnT/straxen/blob/a2e0e3abdbf278000cda70f7662a7d841c7223ef/straxen/common.py#L85\\n name, fmt = os.path.splitext(path)\\n\\n if fmt in ['.npy', '.npy_pickle', '.npz']:\\n result = np.load(path, allow_pickle=fmt == 'npy_pickle')\\n if isinstance(result, np.lib.npyio.NpzFile):\\n # Slurp the arrays in the file, so the result can be copied,\\n # then close the file so its descriptors does not leak.\\n result_slurped = {k: v[:] for k, v in result.items()}\\n result.close()\\n result = result_slurped\\n elif fmt == '.pkl':\\n with open(path, 'rb') as f:\\n result = pickle.load(f)\\n elif fmt == '.gz':\\n subname, subfmt = os.path.splitext(name)\\n if subfmt == '.pkl':\\n with gzip.open(path, 'rb') as f:\\n result = pickle.load(f)\\n elif subfmt == '.json':\\n with gzip.open(path, 'rb') as f:\\n result = json.load(f)\\n elif fmt == '.json':\\n with open(path, mode='r') as f:\\n result = commentjson.load(f)\\n elif fmt == '.binary':\\n with open(path, mode='rb') as f:\\n result = f.read()\\n elif fmt in ['.text', '.txt']:\\n with open(path, mode='r') as f:\\n result = f.read()\\n elif fmt == '.csv':\\n result = pd.read_csv(path)\\n else:\\n raise ValueError(f\\\"Unsupported format {fmt}!\\\")\\n\\n return result\",\n \"def process_examples(self):\\n input_dir = self.input_directory\\n counter_example_dir = self.counter_example_input_directory\\n if input_dir is None:\\n input_dir = Path.cwd() / \\\"examples\\\"\\n if counter_example_dir is None:\\n counter_example_dir = Path.cwd() / \\\"counter_examples\\\"\\n for fmt in self.input_formats:\\n input_examples = glob.glob(os.path.join(str(input_dir), f\\\"*.{fmt}\\\"))\\n input_counter_examples = glob.glob(os.path.join(str(counter_example_dir), f\\\"*.{fmt}\\\"))\\n if not input_counter_examples:\\n logging.warning(\\n f\\\"No counter examples found in {self.counter_example_input_directory}\\\"\\n )\\n self.process_examples_from_list(input_examples, fmt, False)\\n self.process_examples_from_list(input_counter_examples, fmt, True)\",\n \"def load(self, path: str):\\n pass\",\n \"def readFile(path: str):\\n print(\\\"\\\\n\\\" + path + \\\"\\\\n\\\")\\n res = []\\n with open(path, 'r') as reader:\\n for line in reader.readlines():\\n res.append(line)\\n return res\",\n \"def get_examples():\\n # Get the tjson test cases from a url.\\n examples = urlopen(TJSON_EXAMPLES_URL).read()\\n\\n # Strip comments from the lines.\\n examples = re.sub(r\\\"^#.*\\\\n?\\\", \\\"\\\", examples.decode(), flags=re.MULTILINE)\\n\\n # Split a group of examples.\\n delimiter = re.escape(EXAMPLES_DELIMITER)\\n example_re = re.compile(delimiter + r'(.*?)' + delimiter, re.S)\\n split = re.findall(example_re, examples)\\n\\n # Create the `Example` named tuples.\\n return [\\n parse_example(example)\\n for example in split]\",\n \"def read_file(path):\\n # Mystery arguments:\\n strictness = False\\n # Read the string:\\n return _iterate_bibtexsource(_bibtex.open_file(path, strictness))\",\n \"def test_examples(self):\\n with sphinx_build('pyexample'):\\n with open('_build/text/docfx_yaml/example.nap.Base.yml') as yml_file:\\n data = yaml.safe_load(yml_file)\\n for item in data['items']:\\n if item['uid'] == 'example.nap.Base.ref':\\n self.assertEqual(\\n item['example'].split('\\\\n')[2],\\n \\\"\\\"\\\">>> print('docblock 1')\\\"\\\"\\\"\\n )\\n self.assertEqual(\\n item['example'].split('\\\\n')[7],\\n \\\"\\\"\\\">>> print('docblock 2')\\\"\\\"\\\"\\n )\",\n \"def load_examples(filename):\\r\\n data = np.load(filename)\\r\\n return data['examples'], int(data['srate'])\",\n \"def load_examples(filename):\\r\\n data = np.load(filename)\\r\\n return data['examples'], int(data['srate'])\",\n \"def load(self, path):\\n pass\",\n \"def load(self, path):\\n pass\",\n \"def read_examples(file_name):\\n start = time.time()\\n print 'Reading examples from tab separated file...'\\n count = 0\\n i = 0\\n with open(file_name, 'r') as fp:\\n relation_examples = []\\n for i, line in enumerate(fp):\\n line.strip()\\n if len(line) == 0 or len(line.split()) == 0:\\n raise IOError\\n else:\\n fields = line.split('\\\\t')\\n assert len(fields) == 9, \\\"a problem with the file format (# fields is wrong) len is \\\" + str(len(fields)) + \\\"instead of 9\\\"\\n relation_examples.append([str(count)] + fields)\\n count += 1\\n print ' File contained {} lines'.format(i + 1)\\n print ' Datapoints with valid features encoded: {}'.format(count)\\n print ' Done in {:.2f} sec'.format(time.time() - start)\\n return relation_examples\",\n \"def load(self):\\n basePath = './examples/'\\n file = \\\"print8.ls8\\\"\\n # file = \\\"mult.ls8\\\"\\n # file = \\\"stack.ls8\\\"\\n # file = \\\"call.ls8\\\"\\n file = \\\"sctest.ls8\\\"\\n if len(sys.argv) > 1:\\n file = sys.argv[1]\\n address = 0\\n\\n with open(basePath + file, \\\"r\\\") as f:\\n for line in f:\\n line = line.split(\\\"#\\\")\\n\\n try:\\n v = int(line[0], 2)\\n except ValueError:\\n continue\\n # print(v)\\n self.ram[address] = v\\n address += 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7140732","0.7140732","0.7140732","0.70798475","0.7010377","0.6614629","0.6553155","0.65470684","0.6530755","0.65236205","0.6338437","0.6306377","0.6261953","0.6246576","0.61261564","0.61261564","0.61261564","0.61261564","0.61261564","0.61261564","0.61261564","0.608912","0.608912","0.60818106","0.60583794","0.6019848","0.6017665","0.598613","0.58726084","0.58669543","0.586587","0.5862623","0.5830651","0.5828823","0.581353","0.5811614","0.58045274","0.57796687","0.57796687","0.57796687","0.57796687","0.57796687","0.5779438","0.5778377","0.57769245","0.57756454","0.57693815","0.5731984","0.573016","0.5726496","0.57155406","0.5707527","0.56993335","0.5694833","0.56934994","0.56927806","0.5681408","0.56757903","0.5658794","0.5648741","0.56446886","0.564031","0.5639812","0.5634136","0.5630991","0.56301713","0.56246084","0.56231904","0.5616441","0.5616092","0.561465","0.5612909","0.56111056","0.56111056","0.5611017","0.56106406","0.5604308","0.55942625","0.5587157","0.55864775","0.5572801","0.55681115","0.5553662","0.5544987","0.55379945","0.55222034","0.55145556","0.5511477","0.5500515","0.5495171","0.5482485","0.54801613","0.5470179","0.5462673","0.5456163","0.5456163","0.5451132","0.5451132","0.5436901","0.54366213"],"string":"[\n \"0.7140732\",\n \"0.7140732\",\n \"0.7140732\",\n \"0.70798475\",\n \"0.7010377\",\n \"0.6614629\",\n \"0.6553155\",\n \"0.65470684\",\n \"0.6530755\",\n \"0.65236205\",\n \"0.6338437\",\n \"0.6306377\",\n \"0.6261953\",\n \"0.6246576\",\n \"0.61261564\",\n \"0.61261564\",\n \"0.61261564\",\n \"0.61261564\",\n \"0.61261564\",\n \"0.61261564\",\n \"0.61261564\",\n \"0.608912\",\n \"0.608912\",\n \"0.60818106\",\n \"0.60583794\",\n \"0.6019848\",\n \"0.6017665\",\n \"0.598613\",\n \"0.58726084\",\n \"0.58669543\",\n \"0.586587\",\n \"0.5862623\",\n \"0.5830651\",\n \"0.5828823\",\n \"0.581353\",\n \"0.5811614\",\n \"0.58045274\",\n \"0.57796687\",\n \"0.57796687\",\n \"0.57796687\",\n \"0.57796687\",\n \"0.57796687\",\n \"0.5779438\",\n \"0.5778377\",\n \"0.57769245\",\n \"0.57756454\",\n \"0.57693815\",\n \"0.5731984\",\n \"0.573016\",\n \"0.5726496\",\n \"0.57155406\",\n \"0.5707527\",\n \"0.56993335\",\n \"0.5694833\",\n \"0.56934994\",\n \"0.56927806\",\n \"0.5681408\",\n \"0.56757903\",\n \"0.5658794\",\n \"0.5648741\",\n \"0.56446886\",\n \"0.564031\",\n \"0.5639812\",\n \"0.5634136\",\n \"0.5630991\",\n \"0.56301713\",\n \"0.56246084\",\n \"0.56231904\",\n \"0.5616441\",\n \"0.5616092\",\n \"0.561465\",\n \"0.5612909\",\n \"0.56111056\",\n \"0.56111056\",\n \"0.5611017\",\n \"0.56106406\",\n \"0.5604308\",\n \"0.55942625\",\n \"0.5587157\",\n \"0.55864775\",\n \"0.5572801\",\n \"0.55681115\",\n \"0.5553662\",\n \"0.5544987\",\n \"0.55379945\",\n \"0.55222034\",\n \"0.55145556\",\n \"0.5511477\",\n \"0.5500515\",\n \"0.5495171\",\n \"0.5482485\",\n \"0.54801613\",\n \"0.5470179\",\n \"0.5462673\",\n \"0.5456163\",\n \"0.5456163\",\n \"0.5451132\",\n \"0.5451132\",\n \"0.5436901\",\n \"0.54366213\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62074655"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":74288,"cells":{"query":{"kind":"string","value":"render the content for the graph container"},"document":{"kind":"string","value":"def render_content(self, request, tag):\n if self.showreel_document is not None:\n graph_row_xml = XMLString(self.get_content_xml())\n return graph_row_xml.load()\n else:\n oops_container = self.get_bad_container()\n return oops_container.load()"},"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 graphs():\n return render_template(\"graphs.html\")","def get_content_render(fig, index: int, content: str = ''):\n # returns a html tag\n return html.Div([\n dcc.Graph(id=f'graph_{graph_nr[index]}', figure=fig),\n html.H3(content),\n ], style={'font-family': 'Helvetica',\n '#123456': 'red',\n 'marginBottom': 50,\n },\n className='container' # className='six columns'\n )","def graphing1():\n return render_template('graph1.html')","def graphing2():\n return render_template('graph2.html')","def show_custom_graph(self):\n pass","def render(self):\r\n super().render()\r\n layers, titles, lat, lon = self.make_layers()\r\n plots = []\r\n for i in range(len(layers)):\r\n p = figure(\r\n tools=self.tools, \r\n toolbar_location=self.toolbarLocation, \r\n plot_width=self.width, \r\n plot_height=self.height,\r\n x_range=(np.min(lon), np.max(lon)),\r\n y_range=(np.min(lat), np.max(lat)),\r\n title=titles[i]\r\n )\r\n p.xaxis.axis_label = self.xlabel\r\n p.yaxis.axis_label = self.ylabel\r\n colorMapper = LinearColorMapper(palette=self.cmap, low=self.vmin, high=self.vmax)\r\n p.image(\r\n image=[layers[i]], \r\n color_mapper=colorMapper, \r\n x=np.min(lon), \r\n y=np.min(lat), \r\n dw=np.max(lon)-np.min(lon), \r\n dh=np.max(lat)-np.min(lat)\r\n )\r\n\r\n p.add_tools(HoverTool(\r\n tooltips=[\r\n ('longitude', '$x'),\r\n ('latitude', '$y'),\r\n (self.variable + self.unit, '@image'),\r\n ],\r\n mode='mouse'\r\n )\r\n )\r\n\r\n colorBar = ColorBar(\r\n color_mapper=colorMapper, \r\n ticker=BasicTicker(),\r\n label_standoff=12, \r\n border_line_color=None, \r\n location=(0,0)\r\n )\r\n\r\n p.add_layout(colorBar, 'right')\r\n plots.append(p)\r\n \r\n \r\n if not inline(): output_file(get_figure_dir() + self.variable + \".html\", title=self.variable) \r\n show(column(plots))","def index():\n graphs = [\n message_genre_bar_chart(df),\n category_bar_chart(df),\n top_words_bar_chart(df)\n ]\n \n # encode plotly graphs in JSON\n ids = [\"graph-{}\".format(i) for i, _ in enumerate(graphs)]\n graphJSON = json.dumps(graphs, cls=plotly.utils.PlotlyJSONEncoder)\n \n # render web page with plotly graphs\n return render_template('master.html', ids=ids, graphJSON=graphJSON)","def render_graph(self, view=True):\n\n log.debug(\"Rendering Graph to image file [%s]\" % 'NOT_IMPLEMENTED')\n\n if view:\n self.graph.view()\n else:\n self.graph.render()","def render(self, axes=None):\n raise NotImplementedError()","def render(self):\n draw.filled_rect(self.x, self.y, self.w, self.h, (0.0,0.0,0.0,1.))\n self._render_scrollbar(self.x, self.y + 1, self.w, 8)\n\n # render oscilloscope window edge\n gl.glPushMatrix()\n gl.glTranslatef(.5,.5,0.)\n gl.glLineWidth(1.)\n draw.rect(self.x, self.y, self.w, self.h, (0.6,0.6,0.6,1.))\n gl.glPopMatrix()\n\n gl.glPushMatrix()\n x, y, w, h = self._raw_graph_window_dim()\n xx, yy = self.parent.gl_coordinates(x, y)\n gl.glScissor(int(xx), int(yy - h), int(w), int(h))\n gl.glEnable(gl.GL_SCISSOR_TEST)\n #print \"sy1 %.2f sy2 %.2f sy2 - sy1 %.2f\" % (self.sy1, self.sy2, self.sy2 - self.sy1)\n self.graph_renderer.render(x, y, w, h, self.sx1, self.sy1, self.sx2 - self.sx1, self.sy2 - self.sy1)\n gl.glDisable(gl.GL_SCISSOR_TEST)\n gl.glPopMatrix()\n\n if self.render_legend:\n x, y = self.render_legend_pos\n self._render_legend(self.x + x, self.y + y)","def render_graph(variable, payload):\n\n try:\n climate_data = pd.read_json(payload, orient=\"split\")\n except ValueError:\n climate_data = pd.DataFrame()\n\n log.info(\n f\"Rendering graph for variable={variable} from {frame_summary(climate_data)}\"\n )\n\n fig = default_figure(climate_data, variable)\n\n fig.update_layout(\n margin=go.layout.Margin(\n l=0, # left margin\n r=0, # right margin\n b=0, # bottom margin\n t=0, # top margin\n )\n )\n\n return fig","def plot_graph(self) -> None:","def graphs_kelly():\n return render_template(\"graphs-Kelly.html\")","def draw(self):\n draw(self.graph)","def _render_content(self):\r\n xmltree = etree.fromstring(self.content)\r\n xmltree.tag = 'div'\r\n if 'display_name' in xmltree.attrib:\r\n del xmltree.attrib['display_name']\r\n\r\n index = 0\r\n for el in xmltree.findall('.//annotation'):\r\n self._render_annotation(index, el)\r\n index += 1\r\n\r\n return etree.tostring(xmltree, encoding='unicode')","def graph_section():\n return html.Div(\n className = \"tab-container tab-two-section\",\n children = [\n html.Div(\n className = \"container-col\",\n children = [\n climate_profiles_title(), \n climate_profiles_graphs()\n ]\n )\n ]\n )","def layout(self, params=None):\n graphs = html.Div([])\n\n for i in range(1, self.totalButtons+1):\n if i <= 3:\n graphs.children.append(dbc.Row(\n dbc.Col(\n dcc.Loading(\n id=\"loading-icon-normal-plot\",\n children=[dcc.Graph(\n figure={'layout': { 'title': 'Graph {}'.format(i)}},\n id={'type': 'graph-content', 'index': i},\n config={\n 'autosizable': True,\n \"displaylogo\": False,\n \"showTips\": True,\n \"showAxisDragHandles\": True,\n \"scrollZoom\": True,\n 'edits': {'titleText': True}\n },\n style={\n 'display': 'block',\n 'width': '100%'\n }\n )],\n type='graph')\n )\n ))\n else:\n graphs.children.append(dbc.Row(\n dbc.Col(\n dcc.Loading(\n id=\"loading-icon-normal-plot\",\n children=[\n dcc.Graph(\n figure={'layout': {'title': 'Graph {}'.format(i)}},\n id={'type': 'graph-content', 'index': i},\n config={\n 'autosizable': True,\n \"displaylogo\": False,\n \"showTips\": True,\n \"showAxisDragHandles\": True,\n \"scrollZoom\": True,\n 'edits': {'titleText': True}\n },\n style={\n 'display': 'none',\n 'width': '100%'\n }\n )],\n type='graph')\n )\n ))\n\n page = dbc.Container([\n graphs,\n dbc.Row(\n dbc.Col(\n html.Div(self.Table.layout(params))\n )\n )\n\n ], fluid=True)\n return page","def render(self):\n self.data.update(self.axes.render()) \n encoder = Encoder(self._encoding) \n if not 'chs' in self.data:\n self.data['chs'] = '300x150'\n else: \n size = self.data['chs'].split('x')\n assert(len(size) == 2), 'Invalid size, must be in the format WxH'\n self.check_size(*map(int,size))\n assert('cht' in self.data), 'No chart type defined, use type method'\n self.data['cht'] = self.check_type(self.data['cht']) \n if self._dataset:\n self.data['chd'] = encoder.encode(self._dataset) \n # except: raise IndexError, 'Data encoding went screwy' \n else:\n assert('chd' in self.data), 'You must have a dataset, or use chd' \n if self.scales:\n assert(self.data['chd'].startswith('t:')), 'You must use text encoding with chds'\n self.data['chds'] = ','.join(self.scales)\n if self.bar_heights:\n self.data['chbh'] = self.bar_heights\n if self._geo and self._cc:\n self.data['chtm'] = self._geo\n self.data['chld'] = self._cc\n if self.lines:\n self.data['chls'] = '|'.join(self.lines) \n if self.markers:\n self.data['chm'] = '|'.join(self.markers) \n if self.fills:\n self.data['chf'] = '|'.join(self.fills)","def render(self):\r\n super().render()","def render(self, chart):\n chart.create_visualization_files(self.__outputpath)","def plot_graph():\n name = request.args.get('instance')\n name = str(name)\n distance = request.args.get('distance')\n path = request.args.get('path')\n if name == 'Custom':\n coords = request.args.get('coords')\n coords = str(coords)\n nodes = custom_nodes(coords)\n else:\n nodes = create_nodes(name)\n fig = Figure()\n axis = fig.add_subplot(1, 1, 1)\n\n axis.set_title(name + \" - Distance: \"+ str(distance))\n path = str(path).split(',')\n path = [int(i) for i in path]\n for i in range(len(path) - 1):\n\n start_node = nodes[path[i]]\n x1, y1 = start_node.x, start_node.y\n axis.scatter(x1, y1, c = 'b', label = str(path[i]))\n axis.text(x1,y1, str(path[i]))\n end_node = nodes[path[i+1]]\n x2, y2 = end_node.x, end_node.y\n axis.plot([x1,x2], [y1, y2])\n\n last_node = nodes[path[len(path)-1]]\n x1, y1 = last_node.x, last_node.y\n axis.text(x1,y1, str(path[len(path)-1]))\n\n begin_node = nodes[path[0]]\n x2, y2 = begin_node.x, begin_node.y\n axis.scatter(x1, y1, c = 'b', label = str(path[len(path)-1]))\n axis.plot([x1,x2], [y1, y2])\n\n output = io.BytesIO()\n FigureCanvas(fig).print_png(output)\n return Response(output.getvalue(), mimetype=\"image/png\")","def get_layout(self, songs: dict) -> html.Div:\n # Prepare the data that is to be shown.\n columns = [\"title\", \"artist\", \"album\", \"release_date\", \"genre\", \"publisher\", \"composer\", \"duration\", \"bit_rate\"]\n complete = 0\n years = []\n genre = {}\n for song in songs:\n if all(i in songs[song].keys() for i in columns):\n complete += 1\n if songs[song].get(\"genre\") not in genre:\n genre[songs[song].get(\"genre\")] = 1 \n else:\n genre[songs[song].get(\"genre\")] += 1\n if \"release_date\" in songs[song]:\n if songs[song].get(\"release_date\") not in years:\n years.append(songs[song].get(\"release_date\"))\n\n if len(genre) >= 10:\n for element in list(genre.keys()):\n if genre[element] <= 10:\n genre.pop(element)\n if None in genre:\n genre[\"Unknown\"] = genre.pop(None)\n\n # Create basic statistics.\n quick_stat = html.Div(\n children=[\n dbc.Alert(\"Music number : \" + str(len(songs)) , color=\"primary\"),\n dbc.Alert(\"Music number with complete data : \" + str(complete) , color=\"success\"),\n dbc.Alert(\"Music number with incomplete data : \" + str(len(songs) - complete) , color=\"danger\"),\n dbc.Alert(\"Music dates range from : \" + str(min(years)) + \" to \" + str(max(years)), color=\"dark\"),\n dbc.Alert(\"Music is from \" + str(len(years)) + \" different years\", color=\"dark\"),\n dbc.Alert(\"Music is from \" + str(len(genre)) + \" different genres\", color=\"dark\"),\n ]\n )\n\n # Create the \"Number of genres\" pie chart.\n pie = dcc.Graph(\n id=\"piechart\",\n figure={\n \"data\": [\n {\n \"labels\": list(genre.keys()),\n \"values\": list(genre.values()),\n \"type\": \"pie\",\n \"marker\": {\"line\": {\"color\": \"white\", \"width\": 1}},\n \"hoverinfo\": \"values\",\n \"textinfo\": \"label\",\n }\n ],\n \"layout\": {\n \"title\": \"Number of genres\",\n \"showlegend\": True,\n \"autosize\": True,\n },\n },\n )\n\n # Make the pie chart appear from a collapsable button.\n collapse = html.Div(\n [\n dbc.Button(\n \"Basic statistics\",\n id=\"collapse-button\",\n className=\"mb-3\",\n color=\"primary\",\n ),\n dbc.Collapse(\n quick_stat,\n id=\"collapse\",\n ),\n ], style={'marginTop': 50, 'textAlign': 'center',}\n )\n\n @app.callback(\n Output(\"collapse\", \"is_open\"),\n [Input(\"collapse-button\", \"n_clicks\")],\n [State(\"collapse\", \"is_open\")],\n )\n def toggle_collapse(n, is_open):\n if n:\n return not is_open\n return is_open\n\n # Group the whole layout in a single HTML division.\n layout_home = html.Div(\n children=[\n nav,\n collapse,\n pie,\n ]\n )\n\n return layout_home","def graph(graph_file):\n return render_template(graph_file)","def render(self, content=Render.NOTHING):\r\n self.__render = content\r\n\r\n if self.__render == Render.NOTHING:\r\n if self.__ax1:\r\n self.__ax1.get_figure().close()\r\n self.__ax1 = None\r\n if self.__ax2:\r\n self.__ax2.get_figure().close()\r\n self.__ax2 = None\r\n if self.__render == Render.TRAINING:\r\n if self.__ax2 is None:\r\n fig, self.__ax2 = plt.subplots(1, 1, tight_layout=True)\r\n fig.canvas.set_window_title(\"Best move\")\r\n self.__ax2.set_axis_off()\r\n self.render_q(None)\r\n if self.__render in (Render.MOVES, Render.TRAINING):\r\n if self.__ax1 is None:\r\n fig, self.__ax1 = plt.subplots(1, 1, tight_layout=True)\r\n fig.canvas.set_window_title(\"Maze\")\r\n\r\n plt.show(block=False)","def displayGraph(self):\n self.dto.displayVerticalGraph()\n print(\"Vertical Bar Graph displayed.\")","def get_ecg_graph():\n titles = ['ecg1', 'ecg2', 'ecg3']\n colors = ['rgb(240,0,0)', 'rgb(0,240,0)', 'rgb(0,0,240)']\n update()\n signames_ecg = queries['signames_ecg']\n signals = queries['signals']\n latesthr = queries['latesthr']\n return html.Div(className='ecg', children=[\n html.Div(style={'display': 'flex', 'height': '40vh'},\n children=[dcc.Graph(\n id=titles[i] + signame,\n style={'width': '100%'},\n figure={\n 'data': [\n {'x': signals[signame]['time'],\n 'y': signals[signame][titles[i]],\n 'mode': 'line', 'name': signame, 'line': {'color':colors[i]}}\n ],\n 'layout': {\n 'font': {'color':'#fff'},\n 'title': '{}-{}'.format(signame, titles[i]),\n 'xaxis': {'title': 'time', 'color': '#fff', 'showgrid': 'False'},\n 'yaxis': {'title': 'voltage (mv)', 'color': '#fff', 'showgrid': 'False', 'range': np.linspace(-2.5, 2.5, 10)},\n 'paper_bgcolor':'#000', 'plot_bgcolor':'#000'\n }\n }\n ) for i in range(len(titles))]\n +\n [html.Div(\n style={'justify-content': 'center', 'display': 'flex',\n 'align-items': 'center', 'width': '10vh', 'font-size': '30pt', 'color': 'white'},\n children=['{}'.format(latesthr[signame][0])])\n ]\n ) for signame in signames_ecg])","def home():\n return render_template(\"d3_graph.html\")","def makeGraph(self):\n self.graphFrame = Frame(height=400, width=400, bd=10, bg='black')\n self.graphFrame.grid(row=1, column=0)","def render(self):\r\n super().render()\r\n layers, titles, latVect, lonVect = self.make_layers()\r\n LON, LAT = np.meshgrid(lonVect, latVect)\r\n lon = LON.flatten()\r\n lat = LAT.flatten()\r\n for i in range(len(layers)):\r\n vals = layers[i].flatten()\r\n hovertext = []\r\n for k in range(len(vals)):\r\n hovertext.append('lon: {:.2f}<br>lat: {:.2f}<br>{}: {:.1e}'.format(lon[k], lat[k], self.variable + self.unit,vals[k]))\r\n if self.levels == 0:\r\n data = [\r\n go.Heatmap(\r\n x=lon,\r\n y=lat,\r\n z=vals,\r\n colorscale=self.cmap,\r\n zmin=self.vmin,\r\n zmax=self.vmax,\r\n hoverinfo='text',\r\n text=hovertext \r\n )\r\n ]\r\n elif self.levels > 0:\r\n data = [\r\n go.Contour(\r\n x=lon,\r\n y=lat,\r\n z=vals,\r\n colorscale=self.cmap,\r\n hoverinfo='text',\r\n text=hovertext, \r\n connectgaps=False,\r\n contours=dict(\r\n coloring='heatmap',\r\n showlabels=True,\r\n start=self.vmin,\r\n end=self.vmax,\r\n size=(self.vmax-self.vmin) / float(self.levels)\r\n )\r\n # line=dict(smoothing=0.85) \r\n )\r\n ] \r\n\r\n\r\n layout = go.Layout(\r\n autosize=False,\r\n title=titles[i],\r\n width=self.width,\r\n height=self.height,\r\n xaxis={'title': self.xlabel},\r\n yaxis={'title': self.ylabel}\r\n ) \r\n\r\n\r\n\r\n if self.surface3D:\r\n data = [\r\n go.Surface(\r\n x=lonVect,\r\n y=latVect,\r\n z=layers[i],\r\n colorscale=self.cmap,\r\n # hoverinfo='text',\r\n # text=hovertext \r\n )\r\n ]\r\n\r\n layout = go.Layout(\r\n autosize=False,\r\n title=titles[i],\r\n width=self.width,\r\n height=self.height,\r\n scene = dict(\r\n xaxis={'title': self.xlabel},\r\n yaxis={'title': self.ylabel},\r\n zaxis={'title': self.variable + self.unit}\r\n )\r\n ) \r\n\r\n\r\n self._save_plotly_(go, data, layout)","def graph():\n port_to_csv()\n\n source = ''\n if request.form.get('GraphType', '') == '':\n source = url_for('static', filename='frog no graph.png')\n else:\n source = s_modular(request.form.get('GraphType', ''), '')\n\n return render_template(\n 'tmpGraph.jade',\n title=\"Graph\",\n year=datetime.now().year,\n src=source\n )","def renderNode(self, node):\n self.html += '<div id=\\\"nodeDecoration\\\">'\n self.html += '<p id=\\\"nodeTitle\\\">'\n self.html += escape(node.titleLong)\n self.html += '</p></div>\\n'\n for idevice in node.idevices:\n block = g_blockFactory.createBlock(None, idevice)\n if not block:\n log.critical(\"Unable to render iDevice.\")\n raise Error(\"Unable to render iDevice.\")\n if hasattr(idevice, \"isQuiz\"):\n self.html += block.renderJavascriptForWeb()\n self.html += block.renderView(self.style)\n for child in node.children:\n self.renderNode(child)","def index():\n return render_template(\"charts.html\")","def render(self):\n\n self.desert_image.render()\n self.cannon_image.render()\n self.play_button.render()\n self.escape_label.render()","def render_tab_content(active_tab):\n if active_tab is not None:\n if active_tab == \"graph1\":\n return dcc.Graph(figure=example_graph1, id='graph')\n elif active_tab == \"graph2\":\n return dcc.Graph(figure=example_graph2, id='graph')\n elif active_tab == \"graph3\":\n return dcc.Graph(figure=example_graph3, id='graph')\n return \"No tab selected\"","def get(self):\n self.render_front()","def buildPage(self):\n args = {}\n args['valueCol'] = 'value'\n args['textCol'] = 'size'\n args['y'] = 'index'\n args['x'] = 'number'\n args['orientation'] = 'h'\n args['title'] = ''\n args['x_title'] = ''\n args['y_title'] = ''\n args['height'] = 900\n args['width'] = 900\n\n self.add_basic_layout()\n layout = hpstats.quick_numbers_panel()\n dfs = hpstats.get_db_stats_data()\n plots = []\n plots.append(hpstats.plot_store_size_components(dfs, title='DB Store Size', args=args))\n plots.append(hpstats.plot_node_rel_per_label(dfs, focus='nodes', title='Nodes per Label', args=args))\n plots.append(hpstats.plot_node_rel_per_label(dfs, focus='relationships', title='Relationships per Type', args=args))\n self.extend_layout(layout)\n self.extend_layout(plots)","def render(self):\n content = self._render_pre_content('div')\n for widget in self._child_widgets:\n content += widget.render()\n content += self._render_post_content('div')\n self._widget_content = content\n return self._widget_content","def draw(self, stats=[]):\n clear_output(wait=True)\n svg_html = self.to_html(stats)\n display(svg_html)","def render(self, **kwargs):\n self.color_domain = [\n self.vmin + (self.vmax - self.vmin) * k / 499.0 for k in range(500)\n ]\n self.color_range = [self.__call__(x) for x in self.color_domain]\n if self.tick_labels is None:\n self.tick_labels = legend_scaler(self.index, self.max_labels)\n\n super().render(**kwargs)\n\n figure = self.get_root()\n assert isinstance(figure, Figure), (\n \"You cannot render this Element \" \"if it is not in a Figure.\"\n )\n\n figure.header.add_child(\n JavascriptLink(\"https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.5/d3.min.js\"),\n name=\"d3\",\n ) # noqa","def visualize_graph(self):\n self._graph.GetVertexData().AddArray(self._labels)\n self._graph.GetEdgeData().AddArray(self._weights)\n colors = vtk.vtkUnsignedCharArray()\n colors.SetNumberOfComponents(1)\n colors.SetName('Colors')\n types = int(245 / len(self._color_dict))\n for c in self._colors:\n colors.InsertNextValue(int(c * types))\n self._graph.GetVertexData().AddArray(colors)\n graphLayoutView = vtk.vtkGraphLayoutView()\n graphLayoutView.AddRepresentationFromInput(self._graph)\n graphLayoutView.SetLayoutStrategy(vtk.vtkSpanTreeLayoutStrategy())\n graphLayoutView.GetLayoutStrategy().SetEdgeWeightField(\"Weights\")\n graphLayoutView.GetLayoutStrategy().SetWeightEdges(1)\n graphLayoutView.GetRenderer().GetActiveCamera().ParallelProjectionOff()\n graphLayoutView.SetEdgeLabelArrayName(\"Weights\")\n graphLayoutView.SetEdgeLabelVisibility(1)\n graphLayoutView.SetVertexLabelArrayName('labels')\n graphLayoutView.SetVertexLabelVisibility(1)\n graphLayoutView.SetVertexColorArrayName('Colors')\n graphLayoutView.SetColorVertices(1)\n graphLayoutView.SetInteractorStyle(MouseAndKeysInteractor(graphLayoutView))\n graphLayoutView.ResetCamera()\n graphLayoutView.Render()\n graphLayoutView.GetInteractor().Start()","def render(self):","def render(self):\n raise NotImplementedError","def render(self):\n content = self._attach_css() + \"\\n\"\n content += self._render_pre_content('div')\n content += \"<div id='\" + self._name + \"_handle' class='ui-slider-handle'></div>\"\n content += self._render_post_content('div')\n self._widget_content = content + \"\\n\" + self._attach_script() + \"\\n\" + self._attach_polling()\n return self._widget_content","def show_graphs(self):\n self.frequency_plot_graph.show()\n self.resistance_graph.show()\n self.temperature_plot_graph.show()\n self.pressure_plot_graph.show()\n self.humidity_plot_graph.show()\n self.overview_graph.show()\n self.overview_graph.setXRange(-1000, 5000)","def plot(self):\n attr = self.Graph[\"root\"]\n if (self.type == 0 or self.type == 1):\n self.subplot_1(attr, 0)\n else:\n self.subplot_2(attr, 0)","def render(self):\n canvas_id = 'zdog_{}'.format(self.CANVAS_INDEX)\n illo_id = 'illo_{}'.format(self.CANVAS_INDEX)\n Scene.CANVAS_INDEX += 1\n\n html_lines = []\n\n js_lines = []\n\n euler = -rowan.to_euler(\n self.rotation, convention='xyz', axis_type='intrinsic')\n translation = self.translation*(1, -1, 1)\n\n pan_cfg = self.get_feature_config('pan')\n pan = pan_cfg.get('value', True) if pan_cfg is not None else False\n\n js_lines.append(\"\"\"\n let {illo_id} = new Zdog.Illustration({{\n element: '#{canvas_id}',\n zoom: {zoom},\n dragRotate: {rotation_enabled},\n rotate: {{x: {angle[0]}, y: {angle[1]}, z: {angle[2]}}},\n translate: {{x: {pos[0]}, y: {pos[1]}, z: {pos[2]}}},\n }});\n \"\"\".format(\n illo_id=illo_id, canvas_id=canvas_id, zoom=self.zoom*self.pixel_scale,\n angle=euler, pos=translation,\n rotation_enabled=('false' if pan else 'true')))\n\n config = self.get_feature_config('ambient_light')\n ambient_light = 0 if config is None else config.get('value', .4)\n\n config = self.get_feature_config('directional_light')\n directional_light = ([(0, 0, 0)] if config is None else\n config.get('value', [(0, 0, 0)]))\n directional_light = np.atleast_2d(directional_light)\n\n shapeIndex = 0\n for i, prim in enumerate(self._primitives):\n js_lines.extend(prim.render(\n rotation=self.rotation, illo_id=illo_id,\n name_suffix=i, ambient_light=ambient_light,\n directional_light=directional_light))\n\n (width, height) = map(int, self.size_pixels)\n html_lines.append(\"\"\"\n <canvas id=\"{canvas_id}\" width=\"{width}\" height=\"{height}\"></canvas>\n \"\"\".format(canvas_id=canvas_id, width=width, height=height))\n\n html_lines.append(\"\"\"<script>\n var fill_{canvas_id} = function() {{\n \"\"\".format(canvas_id=canvas_id))\n html_lines.append(LOCAL_HELPER_SCRIPT)\n html_lines.extend(js_lines)\n\n pan_snippet = \"\"\"\n new Zdog.Dragger({{\n startElement: {illo_id}.element,\n onDragStart: function( pointer, moveX, moveY) {{\n this.lastX = 0;\n this.lastY = 0;\n }},\n onDragMove: function( pointer, moveX, moveY ) {{\n let deltax = moveX - this.lastX;\n let deltay = moveY - this.lastY;\n let scale = 1.0/{illo_id}.zoom;\n {illo_id}.translate.x += deltax*scale;\n {illo_id}.translate.y += deltay*scale;\n this.lastX = moveX;\n this.lastY = moveY;\n }}\n }});\"\"\".format(illo_id=illo_id)\n if pan:\n html_lines.append(pan_snippet)\n\n html_lines.append(\"\"\"\n let this_canvas = document.querySelector(\"#{canvas_id}\");\n \"\"\".format(canvas_id=canvas_id))\n html_lines.append(\"\"\"\n let animate_{canvas_id} = function() {{\n if(is_in_view(this_canvas))\n {{\n {illo_id}.updateRenderGraph();\n }}\n if(document.contains(this_canvas))\n {{\n requestAnimationFrame(animate_{canvas_id});\n }}\n }};\n animate_{canvas_id}();\"\"\".format(canvas_id=canvas_id, illo_id=illo_id))\n # remove the global reference to this function after using it\n html_lines.append('fill_{canvas_id} = null;'.format(canvas_id=canvas_id))\n html_lines.append('};') # end of fill_{canvas_id}\n # now call fill_{canvas_id}, possibly after loading zdog\n html_lines.append(\"\"\"\n if (typeof Zdog == 'undefined')\n {{\n var script = document.createElement('script');\n script.addEventListener('load', fill_{canvas_id}, false);\n script.src = 'https://unpkg.com/zdog@1/dist/zdog.dist.min.js';\n document.getElementsByTagName('head')[0].appendChild(script);\n }}\n else\n fill_{canvas_id}();\n \"\"\".format(canvas_id=canvas_id))\n html_lines.append('</script>')\n\n return '\\n'.join(html_lines)","def draw_nodes(self):\n pass","def render(self):\n self.axial.Render()\n self.coronal.Render()\n self.sagittal.Render()\n #self.isosurface.Render()\n #self.rwi_pcp.Render()","def render(self):\n pass","def render(self):\n pass","def render(self):\n pass","def render(self):\n pass","def render(self):\n pass","def render(self):\n pass","def layout():\n # Needs db connection! (Set up tunnel if testing app locally)\n _ids = get_doc_ids_from_db() \n dropdown_dates = {num2str_month(_id): _id for _id in _ids}\n\n children_list = [\n html.Div([\n html.H2('Top women and men quoted'),\n html.P('''\n In this section, we display the top women and men quoted as sources in a\n given month. First, select a month from the dropdown menu below.\n ''')],\n ),\n html.Br(),\n dcc.Dropdown(\n id='date-dropdown',\n options=[\n {'label': date_str, 'value': date_num}\n for date_str, date_num in dropdown_dates.items()\n ],\n value=_ids[-1],\n className='dropdown'\n ),\n html.Br(),\n html.Div(\n dcc.Loading(\n id='topic-load-progress',\n children=[\n dcc.Store(id='top-sources-topic-data'),\n dcc.Store(id='top-sources-stats'),\n ])\n ),\n html.Br(),\n html.H4('Topics and gender representation among sources'),\n dcc.Markdown('''\n First, we display the *gender prominence* for each topic discovered in the \n selected month. Gender prominence is a measure we use to study whether a\n given topic features quotes by men or women more prominently.\n '''),\n html.Div([\n dcc.Graph(id='top-sources-outlet-gender-heatmap'),\n ]),\n html.Br(),\n html.Div([\n html.H4('Top quoted sources by gender'),\n html.P(f'''\n Next, we display the top {NUM_SOURCES_TO_SHOW} sources per gender for the given month.\n Hover over the dots to display the total number of articles in which each source was \n quoted.\n '''),\n html.Div([\n dcc.Graph(id='top-sources-dotplot', className='chart'),\n ]),\n ]),\n html.H4('Observations'),\n dcc.Markdown(id='user-comment-display'),\n ]\n return children_list","def render(self):\n content = self._render_pre_content('div')\n for widget in self._child_widgets:\n content += \"\\n\" + widget.render()\n content += self._render_post_content('div')\n content += \"\"\"<script>\n $(function(){\n $(\"#%s\").accordion({\n collapsible: %s,\n icons: %s,\n heightStyle: \"%s\"\n });\n });\n </script>\n \"\"\" % (self._name, \"true\" if self._collapsible else \"false\",\n self._icons, \"fill\" if self._fill_space else \"\")\n self._widget_content = content\n return self._widget_content","def graphs(self, title: str, graph_name: str) -> NoReturn:\n self.add_page()\n self.set_text_color(0, 250, 154)\n self.cell(0, 0, title, align='C', ln=2)\n self.ln(self.line_height)\n img = Image.open(full_path(f'./output/{graph_name}'))\n image_width = self.w - (self.l_margin + self.r_margin)\n image_height = self.h - (self.t_margin + self.b_margin + self.get_y())\n self.image(img, self.get_x(), self.get_y(), w=image_width,\n h=image_height)","def on_draw(self):\n\t\tself.render()","def on_draw(self):\n\t\tself.render()","def draw_graph(self):\n\t\tif None in self.graph:\n\t\t\tdel self.graph[None]\n\n\t\tfor vs in self.graph.itervalues():\n\t\t\tto_delete = []\n\t\t\tfor i in xrange(len(vs)):\n\t\t\t\tif vs[i] is None:\n\t\t\t\t\tto_delete.append(i)\n\n\t\t\tfor i in reversed(to_delete):\n\t\t\t\tdel vs[i]\n\n\t\tself.G=nx.Graph(self.graph)\n\n\t\tfor k,v in self.labels.iteritems():\n\t\t\tif v[:6] == 'Module':\n\t\t\t\troot = k\n\t\t\t\tbreak\n\n\t\treturn self.__dfs_plot(root)","def render(self):\n print(self._get_grid_representations())","def render(self):\n raise NotImplementedError()","def dspyRender(self):\n pass","def gc_content_plot (self): \n if 'gc_content' not in self.fastqc_data or len(self.fastqc_data['gc_content']) == 0:\n log.debug('gc_content not found in FastQC reports')\n return None\n \n pconfig = {\n 'id': 'fastqc_gc_content_plot',\n 'title': 'Per Sequence GC Content',\n 'ylab': 'Count',\n 'xlab': '%GC',\n 'ymin': 0,\n 'xmax': 100,\n 'xmin': 0,\n 'yDecimals': False,\n 'tt_label': '<b>{point.x}% GC</b>: {point.y}',\n 'colors': self.get_status_cols('gc_content'),\n }\n self.sections.append({\n 'name': 'Per Sequence GC Content',\n 'anchor': 'fastqc_gc_content',\n 'content': '<p>The average GC content of reads. Normal random library typically have a roughly normal distribution of GC content. ' +\n 'See the <a href=\"http://www.bioinformatics.babraham.ac.uk/projects/fastqc/Help/3%20Analysis%20Modules/5%20Per%20Sequence%20GC%20Content.html\" target=\"_bkank\">FastQC help</a>.</p>' +\n self.plot_xy_data(self.fastqc_data['gc_content'], pconfig)\n })","def draw(self):\n\t\tnx_graph = self.parse_graph()\n\t\tpos = nx.spring_layout(nx_graph, k=0.15, iterations=20) # to spread out the nodes\n\n\t\tnx.draw(nx_graph, pos, edge_color=\"black\", width=1, linewidths=1, node_size=500, node_color=\"pink\", alpha=0.9, with_labels=True)\n\n\t\tedge_labels = {(edge[0], edge[1]):edge[2] for edge in self.edges}\n\t\tnx.draw_networkx_edge_labels(nx_graph, pos, edge_labels=edge_labels, font_color='red')\n\n\t\tplt.show()","def __render(self):\r\n scores = self.__score_repository.get_high_scores()\r\n self.__renderer.draw(\"high_scores\", scores=scores)","def plot(self):\n layout = self.graph.layout(\"kk\")\n bbox = igraph.BoundingBox(600, 600)\n figure = igraph.Plot(bbox=bbox, background=\"white\")\n bbox = bbox.contract(100)\n figure.add(self.graph, layout = layout, bbox=bbox)\n figure.show()","def visualize_dependency_graph(self):\n if self.graph is None:\n self.logger.error(\"Graph value none cannot be plotted\")\n return\n\n nx.draw(self.graph, cmap=plt.get_cmap('jet'), with_labels=True)\n plt.show()","def paint(self):\n x = []\n y = []\n plt.figure(figsize=(10, 5), facecolor=\"silver\")\n ax = plt.axes()\n for node in self.graph.nodes.values():\n x.append(node.get_pos()[0])\n y.append(node.get_pos()[1])\n ax.scatter(x, y, color=\"black\", s=50)\n xl = ax.get_xlim()[1] - ax.get_xlim()[0]\n yl = ax.get_ylim()[1] - ax.get_ylim()[0]\n for nd in self.graph.nodes.values():\n for ed in self.graph.all_out_edges_of_node(Node.get_key(nd)).keys():\n desti: Node = self.graph.get_node(ed)\n destx = desti.get_pos()[0] - nd.get_pos()[0]\n desty = desti.get_pos()[1] - nd.get_pos()[1]\n ax.arrow(nd.get_pos()[0], nd.get_pos()[1], destx, desty, head_width=xl * 0.007,\n length_includes_head=True,\n head_length=yl * 0.02, width=xl * 0.0001 * yl, color='grey')\n plt.title(\"Your graph!\")\n plt.show()","def _render(self) -> None:\n pass","def show_data(self):\n\n self.area_canvas.axes.cla()\n self.draw_scatterplot(self.scatter_canvas, 'x [µm]', 'y [µm]', self.p_inputs['flip y-axis'].isChecked())\n self.draw_hist(self.area_canvas, 'area', 'cluster area [µm²]', 'number of clusters')\n self.draw_hist(self.number_canvas, 'nclusters', 'number of cluster', 'number of regions')\n self.draw_hist(self.density_canvas, 'density', 'cluster density [µm⁻²]', 'number of clusters')\n self.draw_hist(self.percentage_canvas, 'pclustered', 'percentage clustered',\n 'number of regions')\n self.draw_hist(self.ratio_canvas, 'reldensity', 'relative density clusters/background',\n 'number of regions')","def render_sample(cls,\n nusc: 'NuScenes',\n radar_data_gp: 'RadarDataGroup',\n front_cam_data: 'CameraData',\n host_data:'HostData',\n fig_info:dict,\n box_vis_level: BoxVisibility = BoxVisibility.ANY,\n out_path: str = None) -> None:\n cls.colors=radar_data_gp.colors\n fig, axes = plt.subplots(1, 2, figsize=(16, 24))\n #left diagram to show front view\n ax1 = axes[0]\n cls.render_front_view(cls, nusc=nusc, radar_data_gp=radar_data_gp, front_cam_data=front_cam_data,\n ax =ax1, use_flat_vehicle_coordinates=False, with_anns=False, with_radar=True)\n #right diagram to show bird view\n ax2 = axes[1] \n \n cls.render_bird_view(cls, nusc=nusc, radar_data_gp=radar_data_gp, front_cam_data=front_cam_data, \n host_data=host_data, ax =ax2, use_flat_vehicle_coordinates=True)\n #figure information\n fig.text(0.01, 0.97, 'Figure information: ', weight='bold', color='green',fontsize = 15) \n fig.text(0.01, 0.93, 'package: '+nusc.version, fontsize = 12) \n fig.text(0.01, 0.9, 'scene name: '+fig_info['scene_name'], fontsize = 12) \n fig.text(0.01, 0.87, 'timestamp: '+str(front_cam_data.time_stamp*1e-6)+'(s)', fontsize = 12)\n fig.text(0.01, 0.84, 'elapse time: : '+str((fig_info['elapse_time'])*1e-3)+'(ms)', fontsize = 12)\n \n plt.tight_layout()\n fig.subplots_adjust(wspace=0, hspace=0)\n if out_path is not None:\n plt.savefig(out_path,dpi=200)\n if fig_info['verbose']: \n plt.show()","def data_graph():\n station_reference = request.args.get(\"stationReference\")\n station_name = request.args.get(\"stationName\")\n station_name = station_name.replace(\" \",\"+\")\n\n if station_name is not None:\n # station_data = station_data.replace(\" \", \"+\")\n station = station_data.loc[station_data.stationName == station_name]\n else:\n station = station_data.loc[station_data.stationReference == station_reference]\n result_station = station.iloc[0]\n\n # Get optional parameters\n time_from = request.args.get(\"from\")\n time_to = request.args.get(\"to\")\n if time_from:\n pass\n else:\n time_from = None\n if time_to:\n pass\n else:\n time_to = None\n # plot pic\n magic_trick= data.station_graph(result_station.stationName, time_from, time_to)\n # img_stream = io.BytesIO(img)\n # img = Image.open(img_stream)\n # imgByteArr = io.BytesIO()\n # img.save(imgByteArr,format='PNG')\n # imgByteArr = imgByteArr.getvalue()\n # return send_file(io.BytesIO(imgByteArr),\n # mimetype = 'image/png',\n # as_attachment = True,\n # attachment_filename = 'tmp.png')\n image_data = open(\"tmp.png\", \"rb\").read()\n response = make_response(image_data)\n response.headers['Content-Type'] = 'image/png'\n return response","def show_visualizations(self, number = -1):\n instance = self.instance\n if number > instance.view_num:\n print(\"In function show_visualizations: Error, input number greater than the view numbers.\")\n return Page()\n if self.rank_method == methods_of_ranking[3]: # diversified_ranking\n G = myGraph(instance.view_num)\n for i in range(instance.view_num):\n view = instance.tables[instance.views[i].table_pos].views[instance.views[i].view_pos]\n G.addNode(view)\n G.getSim()\n result = G.getTopK(instance.view_num)\n if number != -1:\n begin = number - 1\n end = number\n else:\n begin = 0\n end = instance.view_num\n page = Page()\n for order in range(begin, end):\n if self.rank_method == methods_of_ranking[3]: # diversified_ranking\n view = G.nodes[result[order]]\n else:\n view = instance.tables[instance.views[order].table_pos].views[instance.views[order].view_pos]\n data = {}\n data['order'] = order\n data['chartname'] = instance.table_name\n data['describe'] = view.table.describe\n data['x_name'] = view.fx.name\n data['y_name'] = view.fy.name\n data['chart'] = Chart.chart[view.chart]\n data['classify'] = [v[0] for v in view.table.classes]\n data['x_data'] = view.X\n data['y_data'] = view.Y\n data['title_top'] = 5\n \n # 以下代码与html_handle相似\n margin = str(data['title_top']) + '%'\n \n if data['chart'] == 'bar':\n chart = (Bar().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\n xaxis_opts=opts.AxisOpts(name=data['x_name']),\n yaxis_opts=opts.AxisOpts(name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\n elif data['chart'] == 'pie': \n chart = (Pie().set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin)))\n elif data['chart'] == 'line': \n chart = (Line().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\n xaxis_opts=opts.AxisOpts(name=data['x_name']),\n yaxis_opts=opts.AxisOpts(name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\n elif data['chart']== 'scatter': \n chart = (Scatter().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\n xaxis_opts=opts.AxisOpts(type_='value', name=data['x_name'], splitline_opts=opts.SplitLineOpts(is_show=True)),\n yaxis_opts=opts.AxisOpts(type_='value', name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\n else :\n print (\"not valid chart\")\n \n if not data[\"classify\"] :\n attr = data[\"x_data\"][0]\n val = data[\"y_data\"][0]\n if data['chart'] == 'bar': \n chart.add_xaxis(attr).add_yaxis(\"\", val, label_opts=opts.LabelOpts(is_show=False))\n elif data['chart'] == 'line': \n chart.add_xaxis(attr).add_yaxis(\"\", val, label_opts=opts.LabelOpts(is_show=False))\n elif data['chart'] == 'pie': \n chart.add(\"\", [list(z) for z in zip(attr, val)])\n elif data['chart'] == 'scatter': \n if isinstance(attr[0], str):\n attr = [x for x in attr if x != '']\n attr = list(map(float, attr))\n if isinstance(val[0], str):\n val = [x for x in val if x != '']\n val = list(map(float, val))\n chart.add_xaxis(attr).add_yaxis(\"\", val, label_opts=opts.LabelOpts(is_show=False))\n page.add(chart)\n else :\n attr = data[\"x_data\"][0]\n for i in range(len(data[\"classify\"])) :\n val = data[\"y_data\"][i]\n name = (data[\"classify\"][i][0] if type(data[\"classify\"][i]) == type(('a','b')) else data[\"classify\"][i])\n if i == 0:\n if data['chart'] != 'pie' and data['chart'] != 'scatter':\n chart.add_xaxis(attr)\n if data['chart'] == 'bar': \n chart.add_yaxis(name, val, stack=\"stack1\", label_opts=opts.LabelOpts(is_show=False))\n elif data['chart'] == 'line': \n chart.add_yaxis(name, val, label_opts=opts.LabelOpts(is_show=False))\n elif data['chart'] == 'pie': \n chart.add(\"\", [list(z) for z in zip(attr, val)])\n elif data['chart'] == 'scatter': \n attr_scatter = data[\"x_data\"][i]\n if isinstance(attr_scatter[0], str):\n attr_scatter = [x for x in attr_scatter if x != '']\n attr_scatter = list(map(float, attr_scatter))\n if isinstance(val[0], str):\n val = [x for x in val if x != '']\n val = list(map(float, val))\n chart.add_xaxis(attr_scatter).add_yaxis(name, val, label_opts=opts.LabelOpts(is_show=False))\n page.add(chart)\n return page","def _render(self):\n self._renderer.render_menu()\n pg.display.update()","def index():\n # create table for original dataset\n table_1 = data_table_low(filepath = \"sparkify_data.csv\", title='Raw Sparkify Data')\n\n table_2 = data_table_low(filepath = \"cleaned_data.csv\", title='Cleaned Sparkify Data')\n\n # create and append plotly visuals into an array to be passed later for graphJSON file\n graphs = [table_1, table_2]\n\n # encode plotly graphs in JSON\n ids = [\"graph-{}\".format(i) for i, _ in enumerate(graphs)]\n graphJSON = json.dumps(graphs, cls=plotly.utils.PlotlyJSONEncoder)\n\n # render web page with plotly graphs\n return render_template(\"master.html\", ids=ids, graphJSON=graphJSON)","def render(results, out_file):\n fig, (ax_backlog, ax_merges, ax_open, ax_health) = plt.subplots(\n 4, sharex=True, figsize=(16, 10), dpi=100)\n\n fig.autofmt_xdate()\n plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m/%d/%Y'))\n plt.gca().xaxis.set_major_locator(mdates.DayLocator())\n if results.dts:\n render_queue(results, ax_open)\n render_merges(results, ax_merges)\n render_backlog(results, ax_backlog)\n render_health(results, ax_health)\n fig.text(\n 0.1, 0.00,\n 'image: %s, sample: %s' % (\n datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M'),\n results.dts[-1].strftime('%Y-%m-%d %H:%M'),\n ),\n horizontalalignment='left',\n fontsize='x-small',\n color=fresh_color(results.dts[-1]),\n )\n\n plt.savefig(out_file, bbox_inches='tight', format='svg')\n plt.close()","def visualize(request, slug, handle_id):\n nh = get_object_or_404(NodeHandle, pk=handle_id)\n node = nh.get_node()\n return render(request, 'noclook/visualize/visualize.html', {'node_handle': nh, 'node': node, 'slug': slug})","def draw_graph(self,path):\n print(\"Drawing HashTag Graph!\")\n\n layout = self.graph.layout(\"kk\")\n\n self.graph.vs[\"label\"] = self.graph.vs[\"name\"]\n\n\n visual_style = {}\n visual_style[\"bbox\"] = (1600,1600)\n visual_style[\"vertex_size\"] = 10\n visual_style[\"edge_width\"] = 1\n visual_style[\"edge_color\"] = 'blue'\n visual_style[\"layout\"] = layout\n visual_style[\"margin\"] = 100\n\n graph_plot = plot(self.graph, **visual_style)\n graph_plot.save(fname=path)\n\n return 0","def render(self):\n content = self._render_pre_content('ul')\n for widget in self._child_widgets:\n content += widget.render()\n content += self._render_post_content('ul')\n self._widget_content = content + \"\\n\" + self._attach_script() + \"\\n\" + self._attach_css()\n return self._widget_content","def chart(request):\n assert isinstance(request, HttpRequest)\n filename = 'ppg_RawDataSheet13.mat'\n subtitle = 'VerityDB/' + filename\n return render(\n request,\n 'research/chart.html',\n {\n 'title':'Chart',\n 'message':'Highcharts Based',\n 'year':datetime.now().year,\n #'data': content['val'][0:11]\n 'temp': models.load_data(),\n 'test': models.load_data_filename(filename),\n 'subtitle_text': subtitle,\n }\n )","def simple_map_graph(id_, title):\n return html.Div(\n className=\"main-card mb-4\",\n children=[\n html.Div(title, className=\"title-centered title-bold\"),\n html.Hr(),\n dcc.Graph(id=id_),\n ],\n )","def jloggraph(self, codebase=\"\", width=400, height=300):\n\n # Wraps the show method\n jloggraph = (\n '<applet width=\"'\n + str(width)\n + '\" height=\"'\n + str(height)\n + '\" code=\"JLogGraph.class\"\\n'\n + 'codebase=\"'\n + str(codebase)\n + '\"><param name=\"table\" value=\"\\n'\n )\n jloggraph = jloggraph + self.show(loggraph=True)\n jloggraph = jloggraph + '\"><b>For inline graphs use a Java browser</b></applet>'\n return jloggraph","def render(self, filename):\n lines = []\n for name in self._name_to_graph:\n text_graph = self._name_to_graph[name].render()\n lines.append(text_graph)\n if filename is None:\n print(\"\\n\".join(lines))\n else:\n with open(filename, \"w\") as out_file:\n out_file.write(\"\\n\".join(lines))","def echarts_Timeline(graph,\r\n h,\r\n x='',\r\n y='',\r\n symbol_size=20,\r\n line_width=1,\r\n repulsion=500,\r\n is_draggable=True,\r\n width=\"800px\",\r\n height=\"500px\",\r\n path='timelineExample.html',\r\n title='Timeline_graph',\r\n subtitle='',\r\n pageLayout=Page.DraggablePageLayout,\r\n layout=\"circular\",\r\n show_node_value=True,\r\n render=True):\r\n\r\n # initialize nodes list\r\n nodes = []\r\n if layout == 'none':\r\n for i in range(len(graph.nodes.aslist())):\r\n # calculate reachability for each nodes\r\n reachability = ot.calculate_reachability(graph, graph.nodes.labels()[i])\r\n if reachability > h:\r\n # nodes with reachability more than h will be assigned category 0\r\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\r\n x=graph.nodes.aslist()[i].data[x],\r\n y=graph.nodes.aslist()[i].data[y],\r\n category=0,\r\n value=reachability))\r\n else:\r\n # nodes with reachability less than or equal to h will be assigned category 1\r\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\r\n x=graph.nodes.aslist()[i].data[x],\r\n y=graph.nodes.aslist()[i].data[y],\r\n category=1,\r\n value=reachability))\r\n else:\r\n for i in range(len(graph.nodes.aslist())):\r\n # calculate reachability for each nodes\r\n reachability = ot.calculate_reachability(graph, graph.nodes.labels()[i])\r\n if reachability > h:\r\n # nodes with reachability more than h will be assigned category 0\r\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\r\n category=0,\r\n value=reachability))\r\n else:\r\n # nodes with reachability less than or equal to h will be assigned category 1\r\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\r\n category=1,\r\n value=reachability))\r\n\r\n # initialize links list\r\n links = []\r\n for i in graph.edges.timespan():\r\n tmpLinks = []\r\n for j in range(len(graph.edges.labels())):\r\n\r\n if graph.edges.start_times()[j] == i:\r\n tmp = graph.edges.labels()[j].split('-')\r\n edgeval = '{start time: ' + str(graph.edges.start_times()[j]) + ', end time: ' + str(\r\n graph.edges.end_times()[j]) + '}'\r\n tmpLinks.append(opts.GraphLink(source=tmp[0], target=tmp[1], value=edgeval))\r\n links.append(tmpLinks)\r\n\r\n # initialize categories list\r\n categories = [\r\n opts.GraphCategory(name='nodes with reachability more than {}'.format(h)),\r\n opts.GraphCategory(name='nodes with reachability less than or equal to {}'.format(h))\r\n ]\r\n\r\n tl = Timeline()\r\n for i in graph.edges.timespan():\r\n c = (\r\n Graph(init_opts=opts.InitOpts(width=width, height=height))\r\n .add(\r\n \"\",\r\n nodes=nodes,\r\n links=links[i - graph.edges.start_times()[0]],\r\n categories=categories,\r\n layout=layout,\r\n is_draggable=is_draggable,\r\n is_rotate_label=True,\r\n symbol_size=symbol_size,\r\n linestyle_opts=opts.LineStyleOpts(is_show=True, curve=0.1, color=\"source\", width=line_width),\r\n label_opts=opts.LabelOpts(position=\"right\"),\r\n edge_symbol=['circle', 'arrow'],\r\n edge_symbol_size=10\r\n )\r\n .set_global_opts(\r\n title_opts=opts.TitleOpts(title=title, subtitle=subtitle,\r\n title_textstyle_opts=opts.TextStyleOpts(font_size=40),\r\n subtitle_textstyle_opts=opts.TextStyleOpts(font_size=20)),\r\n legend_opts=opts.LegendOpts(orient=\"vertical\", pos_left=\"2%\", pos_top=\"20%\",\r\n textstyle_opts=opts.TextStyleOpts(font_size=20)),\r\n )\r\n )\r\n tl.add(c, \"{}\".format(i))\r\n\r\n # if render is True, generate an html file\r\n if render:\r\n page = Page(layout=pageLayout)\r\n page.add(tl)\r\n page.render(path)\r\n\r\n return c","def render(self):\n mode = self.check_mode()\n if mode == MODE_DISPLAY_ALL:\n self.display_all()\n elif mode == MODE_DISPLAY_STATUS:\n self.display_status()\n else:\n self.display_active_sensor()","def student_view(self, context=None): # pylint: disable=unused-argument\n html = self.resource_string(\"static/html/chartsxblock.html\")\n frag = Fragment(html.format(self=self))\n frag.add_css(self.resource_string(\"static/css/chartsxblock.css\"))\n frag.add_javascript(self.resource_string(\"static/vendor/GCloader.js\"))\n frag.add_javascript(self.resource_string(\"static/js/src/chartsxblock.js\"))\n frag.initialize_js('ChartsXBlock', {'chartData': self.chart_data,\n 'chartType': self.chart_type,\n 'chartName': self.chart_name,\n 'chartTypes': self.chart_types})\n return frag","def plot(self):\n pass","def draw_edges(self):\n pass","def _PlotGraph(self, event):\n self._rcvLock.acquire()\n for j in event.data[0].keys():\n data = event.data[0][j]\n #print data\n line = []\n for k in data.keys():\n if k in COLORS.keys():\n c = COLORS[k]\n else:\n c = 'black'\n line.append(plot.PolyLine(data[k], colour=c, width=1,\n legend=\"Node %d\"%(k,)))\n # To draw markers: default colour = black, size = 2\n # shapes = 'circle', 'cross', 'square', 'dot', 'plus'\n #marker = plot.PolyMarker(event.data[1], marker='triangle')\n\n # set up text, axis and draw\n if j == ERRORPLOT:\n t = \"Synchronization Error\"\n xa = \"Time [s]\"\n ya = \"Error [ms]\"\n elif j == TEMPPLOT:\n t = \"Temperature Index\"\n xa = \"Time [s]\"\n ya = \"Index\"\n elif j == SKEWPLOT:\n t = \"Frequency Error\"\n xa = \"Time [s]\"\n ya = \"Frequency Error [ppm]\"\n gc = plot.PlotGraphics(line, t, xa, ya)\n # Draw graphs for each plot\n self.plotter[j].Draw(gc, xAxis=(self._x_lower,\n self._x_upper), yAxis=(float(self._y_lower[j]),\n float(self._y_upper[j])))\n self._rcvLock.release()","def graph():\n # Try to get params request\n params = extract_variables(['start_time', 'end_time', 'sensor_id'], request)\n # Fetch data from database\n results = query_climate_range(**params)\n\n # Turn it in to lists which can be graphed\n dates = []\n humids = []\n temps = []\n pressures = []\n for result in results:\n dates.append(datetime.datetime.fromtimestamp(result['time']))\n humids.append(result['humid'])\n temps.append(result['temp'])\n pressures.append(result['pressure'])\n\n # Graph it\n fig = Figure()\n # First y axis (temp and humid)\n axis = fig.add_subplot(1, 1, 1)\n # Plot humidity and temp on the same scale\n axis.plot_date(dates, humids, '-', color=COLORS['blue'])\n axis.plot_date(dates, temps, '-', color=COLORS['red'])\n axis.xaxis.set_major_formatter(DateFormatter('%d/%m/%y %H:%M'))\n axis.set_ylabel('Humidity in % & Temps in C')\n axis.set_xlabel('Time')\n # Second y axis (pressure)\n axis_pressure = axis.twinx()\n # Plot pressure\n axis_pressure.plot_date(dates, pressures, '-', color=COLORS['green'])\n axis_pressure.xaxis.set_major_formatter(DateFormatter('%d/%m/%y %H:%M'))\n axis_pressure.set_ylabel('Pressure in mbar')\n # Configure the figure\n fig.autofmt_xdate()\n fig.legend(['Humidity', 'Temperature', 'Pressure'], loc='lower right')\n fig.set_tight_layout(True)\n canvas = FigureCanvas(fig)\n # Save output\n png_output = BytesIO()\n canvas.print_png(png_output)\n\n # Create the response and send it\n response = make_response(png_output.getvalue())\n response.headers['Content-Type'] = 'image/png'\n return response","def plot_graph(self) -> None:\n\n nodes_on_graph = self.dw_graph.get_all_v()\n for k, v in nodes_on_graph.items():\n if v.position is None:\n x_rand = random.uniform(0.5, self.dw_graph.v_size())\n y_rand = random.uniform(0.5, self.dw_graph.v_size())\n v.position = (x_rand, y_rand)\n x_vals = []\n y_vals = []\n n = list(nodes_on_graph.keys())\n for k, v in nodes_on_graph.items(): # draw nodes\n x_vals.append(v.position[0])\n y_vals.append(v.position[1])\n\n fig, ax = plt.subplots()\n plt.plot(x_vals, y_vals, 'ro', markersize=5, data=\"d\")\n\n for p, txt in enumerate(n):\n ax.annotate(n[p], (x_vals[p]+0.00003, y_vals[p]), color='g')\n\n for n in nodes_on_graph:\n n1 = self.dw_graph.get_nodes(n)\n x = n1.position[0]\n y = n1.position[1]\n for r in self.dw_graph.all_out_edges_of_node(n):\n dx = self.dw_graph.get_nodes(r).position[0]\n dy = self.dw_graph.get_nodes(r).position[1]\n ax.quiver(x, y, dx-x, dy-y, angles='xy', scale_units='xy', scale=1)\n #plt.arrow(x, y, dx - x, dy - y, head_width=0.0009, width=0.00005, length_includes_head=True)\n\n\n plt.xlabel(\"x axis \")\n plt.ylabel(\"y axis \")\n plt.title(\"The title of the graph\")\n plt.show()","def showGraph(self, file_name = \"\"):\n \n # prepare edges and weights for visualization\n edges = self.graph.edges()\n weights = [self.graph_data[u]['pheromones'][v] for u,v in edges]\n weights_sum = sum(weights)\n weights = [ (w/weights_sum)*50 for w in weights]\n \n # prepare different shades of red to be used to optionally differentiate\n # between edges with different costs\n # to show more informatiion on the same graph\n colors = []\n max_cost = max([self.graph_data[u]['costs'][v] for u,v in edges])\n for u,v in edges:\n if self.graph_data[u]['costs'][v] <= max_cost/32:\n colors.append('#ff7f7f')\n continue\n if self.graph_data[u]['costs'][v] <= max_cost/16:\n colors.append('#ff6666')\n continue\n if self.graph_data[u]['costs'][v] <= max_cost/8:\n colors.append('#ff4c4c')\n continue\n if self.graph_data[u]['costs'][v] <= max_cost/4:\n colors.append('#ff3232')\n continue\n if self.graph_data[u]['costs'][v] <= max_cost/2:\n colors.append('#ff1919')\n continue\n if self.graph_data[u]['costs'][v] <= max_cost:\n colors.append('#ff0000')\n continue\n \n # print the graph \n pos=nx.circular_layout(self.graph)\n nx.draw( self.graph,pos=pos,node_size=200,node_color='#A8A8A8', with_labels=True,edges=edges, edge_color=colors,edge_cmap=plt.cm.Blues, width=weights)\n if file_name != \"\":\n path = \"img/\"+file_name\n plt.savefig(path, format=\"PNG\")\n plt.show()","def adapter_content_plot (self):\n if 'adapter_content' not in self.fastqc_data or len(self.fastqc_data['adapter_content']) == 0:\n log.debug('adapter_content not found in FastQC reports')\n return None\n \n pconfig = {\n 'id': 'fastqc_adapter_content_plot',\n 'title': 'Adapter Content',\n 'ylab': '% of Sequences',\n 'xlab': 'Position',\n 'yCeiling': 100,\n 'yMinRange': 5,\n 'ymin': 0,\n 'xDecimals': False,\n 'tt_label': '<b>Base {point.x}</b>: {point.y:.2f}%',\n 'hide_empty': True,\n 'yPlotBands': [\n {'from': 20, 'to': 100, 'color': '#e6c3c3'},\n {'from': 5, 'to': 20, 'color': '#e6dcc3'},\n {'from': 0, 'to': 5, 'color': '#c3e6c3'},\n ],\n }\n # Note - colours are messy as we've added adapter names here. Not\n # possible to break down pass / warn / fail for each adapter, which\n # could lead to misleading labelling (fails on adapter types with\n # little or no contamination)\n \n self.sections.append({\n 'name': 'Adapter Content',\n 'anchor': 'fastqc_adapter_content',\n 'content': '<p>The cumulative percentage count of the proportion of your library which has seen each of the adapter sequences at each position. ' +\n 'See the <a href=\"http://www.bioinformatics.babraham.ac.uk/projects/fastqc/Help/3%20Analysis%20Modules/10%20Adapter%20Content.html\" target=\"_bkank\">FastQC help</a>.</p>' +\n self.plot_xy_data(self.fastqc_data['adapter_content'], pconfig)\n })","def render(self):\n content = self._render_pre_content('li')\n if self._icon is None:\n content += \"<div>\" + self._title + \"</div>\"\n else:\n content += \"<div><span id='\" + (self._name + \"_icon\")\\\n + \"' class='ui-icon \" + self._icon + \"'></span>\"\\\n + self._title + \"</div>\"\n content += self._render_post_content('li')\n self._widget_content = content + \"\\n\" + self._attach_polling()\n return self._widget_content","def render(self):\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\n print(''.join(map[i] for i in self.grid[0:3]))\n print(''.join(map[i] for i in self.grid[3:6]))\n print(''.join(map[i] for i in self.grid[6:9]))\n print('====')","def render(self):\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\n print(''.join(map[i] for i in self.grid[0:3]))\n print(''.join(map[i] for i in self.grid[3:6]))\n print(''.join(map[i] for i in self.grid[6:9]))\n print('====')","def draw(self):\n g = self.to_networkx()\n pos = nx.spring_layout(g)\n nx.draw_networkx_edges(g, pos,\n edge_color=EDGE_COLOR,\n width=EDGE_WIDTH)\n obj = nx.draw_networkx_nodes(g, pos, nodelist=self.vs.values(),\n node_size=NODE_SIZE,\n node_color=NODE_COLOR_NORMAL)\n obj.set_linewidth(NODE_BORDER_WIDTH)\n obj.set_edgecolor(NODE_BORDER_COLOR)\n nx.draw_networkx_nodes(g, pos, nodelist=self.fs,\n node_size=FACTOR_NODE_SIZE,\n node_color=FACTOR_NODE_COLOR,\n node_shape=FACTOR_NODE_SHAPE)\n nx.draw_networkx_labels(g, pos, {v: v.name\n for v in self.vs.values()},\n font_color=LABEL_COLOR)","def display(self):\n options = {\"ent_only_plot\": True,\n \"rel_only_plot\": not self.config.plot_entity_only,\n \"ent_and_rel_plot\": not self.config.plot_entity_only}\n\n if self.config.plot_embedding:\n viz = Visualization(model=self.model, vis_opts = options)\n\n viz.plot_embedding(resultpath=self.config.figures, algos=self.model.model_name, show_label=False)\n\n if self.config.plot_training_result:\n viz = Visualization(model=self.model)\n viz.plot_train_result()\n\n if self.config.plot_testing_result:\n viz = Visualization(model=self.model)\n viz.plot_test_result()","def drawLayout(self):\r\n self.drawBorder()\r\n self.drawAxes()\r\n self.drawLabels()"],"string":"[\n \"def graphs():\\n return render_template(\\\"graphs.html\\\")\",\n \"def get_content_render(fig, index: int, content: str = ''):\\n # returns a html tag\\n return html.Div([\\n dcc.Graph(id=f'graph_{graph_nr[index]}', figure=fig),\\n html.H3(content),\\n ], style={'font-family': 'Helvetica',\\n '#123456': 'red',\\n 'marginBottom': 50,\\n },\\n className='container' # className='six columns'\\n )\",\n \"def graphing1():\\n return render_template('graph1.html')\",\n \"def graphing2():\\n return render_template('graph2.html')\",\n \"def show_custom_graph(self):\\n pass\",\n \"def render(self):\\r\\n super().render()\\r\\n layers, titles, lat, lon = self.make_layers()\\r\\n plots = []\\r\\n for i in range(len(layers)):\\r\\n p = figure(\\r\\n tools=self.tools, \\r\\n toolbar_location=self.toolbarLocation, \\r\\n plot_width=self.width, \\r\\n plot_height=self.height,\\r\\n x_range=(np.min(lon), np.max(lon)),\\r\\n y_range=(np.min(lat), np.max(lat)),\\r\\n title=titles[i]\\r\\n )\\r\\n p.xaxis.axis_label = self.xlabel\\r\\n p.yaxis.axis_label = self.ylabel\\r\\n colorMapper = LinearColorMapper(palette=self.cmap, low=self.vmin, high=self.vmax)\\r\\n p.image(\\r\\n image=[layers[i]], \\r\\n color_mapper=colorMapper, \\r\\n x=np.min(lon), \\r\\n y=np.min(lat), \\r\\n dw=np.max(lon)-np.min(lon), \\r\\n dh=np.max(lat)-np.min(lat)\\r\\n )\\r\\n\\r\\n p.add_tools(HoverTool(\\r\\n tooltips=[\\r\\n ('longitude', '$x'),\\r\\n ('latitude', '$y'),\\r\\n (self.variable + self.unit, '@image'),\\r\\n ],\\r\\n mode='mouse'\\r\\n )\\r\\n )\\r\\n\\r\\n colorBar = ColorBar(\\r\\n color_mapper=colorMapper, \\r\\n ticker=BasicTicker(),\\r\\n label_standoff=12, \\r\\n border_line_color=None, \\r\\n location=(0,0)\\r\\n )\\r\\n\\r\\n p.add_layout(colorBar, 'right')\\r\\n plots.append(p)\\r\\n \\r\\n \\r\\n if not inline(): output_file(get_figure_dir() + self.variable + \\\".html\\\", title=self.variable) \\r\\n show(column(plots))\",\n \"def index():\\n graphs = [\\n message_genre_bar_chart(df),\\n category_bar_chart(df),\\n top_words_bar_chart(df)\\n ]\\n \\n # encode plotly graphs in JSON\\n ids = [\\\"graph-{}\\\".format(i) for i, _ in enumerate(graphs)]\\n graphJSON = json.dumps(graphs, cls=plotly.utils.PlotlyJSONEncoder)\\n \\n # render web page with plotly graphs\\n return render_template('master.html', ids=ids, graphJSON=graphJSON)\",\n \"def render_graph(self, view=True):\\n\\n log.debug(\\\"Rendering Graph to image file [%s]\\\" % 'NOT_IMPLEMENTED')\\n\\n if view:\\n self.graph.view()\\n else:\\n self.graph.render()\",\n \"def render(self, axes=None):\\n raise NotImplementedError()\",\n \"def render(self):\\n draw.filled_rect(self.x, self.y, self.w, self.h, (0.0,0.0,0.0,1.))\\n self._render_scrollbar(self.x, self.y + 1, self.w, 8)\\n\\n # render oscilloscope window edge\\n gl.glPushMatrix()\\n gl.glTranslatef(.5,.5,0.)\\n gl.glLineWidth(1.)\\n draw.rect(self.x, self.y, self.w, self.h, (0.6,0.6,0.6,1.))\\n gl.glPopMatrix()\\n\\n gl.glPushMatrix()\\n x, y, w, h = self._raw_graph_window_dim()\\n xx, yy = self.parent.gl_coordinates(x, y)\\n gl.glScissor(int(xx), int(yy - h), int(w), int(h))\\n gl.glEnable(gl.GL_SCISSOR_TEST)\\n #print \\\"sy1 %.2f sy2 %.2f sy2 - sy1 %.2f\\\" % (self.sy1, self.sy2, self.sy2 - self.sy1)\\n self.graph_renderer.render(x, y, w, h, self.sx1, self.sy1, self.sx2 - self.sx1, self.sy2 - self.sy1)\\n gl.glDisable(gl.GL_SCISSOR_TEST)\\n gl.glPopMatrix()\\n\\n if self.render_legend:\\n x, y = self.render_legend_pos\\n self._render_legend(self.x + x, self.y + y)\",\n \"def render_graph(variable, payload):\\n\\n try:\\n climate_data = pd.read_json(payload, orient=\\\"split\\\")\\n except ValueError:\\n climate_data = pd.DataFrame()\\n\\n log.info(\\n f\\\"Rendering graph for variable={variable} from {frame_summary(climate_data)}\\\"\\n )\\n\\n fig = default_figure(climate_data, variable)\\n\\n fig.update_layout(\\n margin=go.layout.Margin(\\n l=0, # left margin\\n r=0, # right margin\\n b=0, # bottom margin\\n t=0, # top margin\\n )\\n )\\n\\n return fig\",\n \"def plot_graph(self) -> None:\",\n \"def graphs_kelly():\\n return render_template(\\\"graphs-Kelly.html\\\")\",\n \"def draw(self):\\n draw(self.graph)\",\n \"def _render_content(self):\\r\\n xmltree = etree.fromstring(self.content)\\r\\n xmltree.tag = 'div'\\r\\n if 'display_name' in xmltree.attrib:\\r\\n del xmltree.attrib['display_name']\\r\\n\\r\\n index = 0\\r\\n for el in xmltree.findall('.//annotation'):\\r\\n self._render_annotation(index, el)\\r\\n index += 1\\r\\n\\r\\n return etree.tostring(xmltree, encoding='unicode')\",\n \"def graph_section():\\n return html.Div(\\n className = \\\"tab-container tab-two-section\\\",\\n children = [\\n html.Div(\\n className = \\\"container-col\\\",\\n children = [\\n climate_profiles_title(), \\n climate_profiles_graphs()\\n ]\\n )\\n ]\\n )\",\n \"def layout(self, params=None):\\n graphs = html.Div([])\\n\\n for i in range(1, self.totalButtons+1):\\n if i <= 3:\\n graphs.children.append(dbc.Row(\\n dbc.Col(\\n dcc.Loading(\\n id=\\\"loading-icon-normal-plot\\\",\\n children=[dcc.Graph(\\n figure={'layout': { 'title': 'Graph {}'.format(i)}},\\n id={'type': 'graph-content', 'index': i},\\n config={\\n 'autosizable': True,\\n \\\"displaylogo\\\": False,\\n \\\"showTips\\\": True,\\n \\\"showAxisDragHandles\\\": True,\\n \\\"scrollZoom\\\": True,\\n 'edits': {'titleText': True}\\n },\\n style={\\n 'display': 'block',\\n 'width': '100%'\\n }\\n )],\\n type='graph')\\n )\\n ))\\n else:\\n graphs.children.append(dbc.Row(\\n dbc.Col(\\n dcc.Loading(\\n id=\\\"loading-icon-normal-plot\\\",\\n children=[\\n dcc.Graph(\\n figure={'layout': {'title': 'Graph {}'.format(i)}},\\n id={'type': 'graph-content', 'index': i},\\n config={\\n 'autosizable': True,\\n \\\"displaylogo\\\": False,\\n \\\"showTips\\\": True,\\n \\\"showAxisDragHandles\\\": True,\\n \\\"scrollZoom\\\": True,\\n 'edits': {'titleText': True}\\n },\\n style={\\n 'display': 'none',\\n 'width': '100%'\\n }\\n )],\\n type='graph')\\n )\\n ))\\n\\n page = dbc.Container([\\n graphs,\\n dbc.Row(\\n dbc.Col(\\n html.Div(self.Table.layout(params))\\n )\\n )\\n\\n ], fluid=True)\\n return page\",\n \"def render(self):\\n self.data.update(self.axes.render()) \\n encoder = Encoder(self._encoding) \\n if not 'chs' in self.data:\\n self.data['chs'] = '300x150'\\n else: \\n size = self.data['chs'].split('x')\\n assert(len(size) == 2), 'Invalid size, must be in the format WxH'\\n self.check_size(*map(int,size))\\n assert('cht' in self.data), 'No chart type defined, use type method'\\n self.data['cht'] = self.check_type(self.data['cht']) \\n if self._dataset:\\n self.data['chd'] = encoder.encode(self._dataset) \\n # except: raise IndexError, 'Data encoding went screwy' \\n else:\\n assert('chd' in self.data), 'You must have a dataset, or use chd' \\n if self.scales:\\n assert(self.data['chd'].startswith('t:')), 'You must use text encoding with chds'\\n self.data['chds'] = ','.join(self.scales)\\n if self.bar_heights:\\n self.data['chbh'] = self.bar_heights\\n if self._geo and self._cc:\\n self.data['chtm'] = self._geo\\n self.data['chld'] = self._cc\\n if self.lines:\\n self.data['chls'] = '|'.join(self.lines) \\n if self.markers:\\n self.data['chm'] = '|'.join(self.markers) \\n if self.fills:\\n self.data['chf'] = '|'.join(self.fills)\",\n \"def render(self):\\r\\n super().render()\",\n \"def render(self, chart):\\n chart.create_visualization_files(self.__outputpath)\",\n \"def plot_graph():\\n name = request.args.get('instance')\\n name = str(name)\\n distance = request.args.get('distance')\\n path = request.args.get('path')\\n if name == 'Custom':\\n coords = request.args.get('coords')\\n coords = str(coords)\\n nodes = custom_nodes(coords)\\n else:\\n nodes = create_nodes(name)\\n fig = Figure()\\n axis = fig.add_subplot(1, 1, 1)\\n\\n axis.set_title(name + \\\" - Distance: \\\"+ str(distance))\\n path = str(path).split(',')\\n path = [int(i) for i in path]\\n for i in range(len(path) - 1):\\n\\n start_node = nodes[path[i]]\\n x1, y1 = start_node.x, start_node.y\\n axis.scatter(x1, y1, c = 'b', label = str(path[i]))\\n axis.text(x1,y1, str(path[i]))\\n end_node = nodes[path[i+1]]\\n x2, y2 = end_node.x, end_node.y\\n axis.plot([x1,x2], [y1, y2])\\n\\n last_node = nodes[path[len(path)-1]]\\n x1, y1 = last_node.x, last_node.y\\n axis.text(x1,y1, str(path[len(path)-1]))\\n\\n begin_node = nodes[path[0]]\\n x2, y2 = begin_node.x, begin_node.y\\n axis.scatter(x1, y1, c = 'b', label = str(path[len(path)-1]))\\n axis.plot([x1,x2], [y1, y2])\\n\\n output = io.BytesIO()\\n FigureCanvas(fig).print_png(output)\\n return Response(output.getvalue(), mimetype=\\\"image/png\\\")\",\n \"def get_layout(self, songs: dict) -> html.Div:\\n # Prepare the data that is to be shown.\\n columns = [\\\"title\\\", \\\"artist\\\", \\\"album\\\", \\\"release_date\\\", \\\"genre\\\", \\\"publisher\\\", \\\"composer\\\", \\\"duration\\\", \\\"bit_rate\\\"]\\n complete = 0\\n years = []\\n genre = {}\\n for song in songs:\\n if all(i in songs[song].keys() for i in columns):\\n complete += 1\\n if songs[song].get(\\\"genre\\\") not in genre:\\n genre[songs[song].get(\\\"genre\\\")] = 1 \\n else:\\n genre[songs[song].get(\\\"genre\\\")] += 1\\n if \\\"release_date\\\" in songs[song]:\\n if songs[song].get(\\\"release_date\\\") not in years:\\n years.append(songs[song].get(\\\"release_date\\\"))\\n\\n if len(genre) >= 10:\\n for element in list(genre.keys()):\\n if genre[element] <= 10:\\n genre.pop(element)\\n if None in genre:\\n genre[\\\"Unknown\\\"] = genre.pop(None)\\n\\n # Create basic statistics.\\n quick_stat = html.Div(\\n children=[\\n dbc.Alert(\\\"Music number : \\\" + str(len(songs)) , color=\\\"primary\\\"),\\n dbc.Alert(\\\"Music number with complete data : \\\" + str(complete) , color=\\\"success\\\"),\\n dbc.Alert(\\\"Music number with incomplete data : \\\" + str(len(songs) - complete) , color=\\\"danger\\\"),\\n dbc.Alert(\\\"Music dates range from : \\\" + str(min(years)) + \\\" to \\\" + str(max(years)), color=\\\"dark\\\"),\\n dbc.Alert(\\\"Music is from \\\" + str(len(years)) + \\\" different years\\\", color=\\\"dark\\\"),\\n dbc.Alert(\\\"Music is from \\\" + str(len(genre)) + \\\" different genres\\\", color=\\\"dark\\\"),\\n ]\\n )\\n\\n # Create the \\\"Number of genres\\\" pie chart.\\n pie = dcc.Graph(\\n id=\\\"piechart\\\",\\n figure={\\n \\\"data\\\": [\\n {\\n \\\"labels\\\": list(genre.keys()),\\n \\\"values\\\": list(genre.values()),\\n \\\"type\\\": \\\"pie\\\",\\n \\\"marker\\\": {\\\"line\\\": {\\\"color\\\": \\\"white\\\", \\\"width\\\": 1}},\\n \\\"hoverinfo\\\": \\\"values\\\",\\n \\\"textinfo\\\": \\\"label\\\",\\n }\\n ],\\n \\\"layout\\\": {\\n \\\"title\\\": \\\"Number of genres\\\",\\n \\\"showlegend\\\": True,\\n \\\"autosize\\\": True,\\n },\\n },\\n )\\n\\n # Make the pie chart appear from a collapsable button.\\n collapse = html.Div(\\n [\\n dbc.Button(\\n \\\"Basic statistics\\\",\\n id=\\\"collapse-button\\\",\\n className=\\\"mb-3\\\",\\n color=\\\"primary\\\",\\n ),\\n dbc.Collapse(\\n quick_stat,\\n id=\\\"collapse\\\",\\n ),\\n ], style={'marginTop': 50, 'textAlign': 'center',}\\n )\\n\\n @app.callback(\\n Output(\\\"collapse\\\", \\\"is_open\\\"),\\n [Input(\\\"collapse-button\\\", \\\"n_clicks\\\")],\\n [State(\\\"collapse\\\", \\\"is_open\\\")],\\n )\\n def toggle_collapse(n, is_open):\\n if n:\\n return not is_open\\n return is_open\\n\\n # Group the whole layout in a single HTML division.\\n layout_home = html.Div(\\n children=[\\n nav,\\n collapse,\\n pie,\\n ]\\n )\\n\\n return layout_home\",\n \"def graph(graph_file):\\n return render_template(graph_file)\",\n \"def render(self, content=Render.NOTHING):\\r\\n self.__render = content\\r\\n\\r\\n if self.__render == Render.NOTHING:\\r\\n if self.__ax1:\\r\\n self.__ax1.get_figure().close()\\r\\n self.__ax1 = None\\r\\n if self.__ax2:\\r\\n self.__ax2.get_figure().close()\\r\\n self.__ax2 = None\\r\\n if self.__render == Render.TRAINING:\\r\\n if self.__ax2 is None:\\r\\n fig, self.__ax2 = plt.subplots(1, 1, tight_layout=True)\\r\\n fig.canvas.set_window_title(\\\"Best move\\\")\\r\\n self.__ax2.set_axis_off()\\r\\n self.render_q(None)\\r\\n if self.__render in (Render.MOVES, Render.TRAINING):\\r\\n if self.__ax1 is None:\\r\\n fig, self.__ax1 = plt.subplots(1, 1, tight_layout=True)\\r\\n fig.canvas.set_window_title(\\\"Maze\\\")\\r\\n\\r\\n plt.show(block=False)\",\n \"def displayGraph(self):\\n self.dto.displayVerticalGraph()\\n print(\\\"Vertical Bar Graph displayed.\\\")\",\n \"def get_ecg_graph():\\n titles = ['ecg1', 'ecg2', 'ecg3']\\n colors = ['rgb(240,0,0)', 'rgb(0,240,0)', 'rgb(0,0,240)']\\n update()\\n signames_ecg = queries['signames_ecg']\\n signals = queries['signals']\\n latesthr = queries['latesthr']\\n return html.Div(className='ecg', children=[\\n html.Div(style={'display': 'flex', 'height': '40vh'},\\n children=[dcc.Graph(\\n id=titles[i] + signame,\\n style={'width': '100%'},\\n figure={\\n 'data': [\\n {'x': signals[signame]['time'],\\n 'y': signals[signame][titles[i]],\\n 'mode': 'line', 'name': signame, 'line': {'color':colors[i]}}\\n ],\\n 'layout': {\\n 'font': {'color':'#fff'},\\n 'title': '{}-{}'.format(signame, titles[i]),\\n 'xaxis': {'title': 'time', 'color': '#fff', 'showgrid': 'False'},\\n 'yaxis': {'title': 'voltage (mv)', 'color': '#fff', 'showgrid': 'False', 'range': np.linspace(-2.5, 2.5, 10)},\\n 'paper_bgcolor':'#000', 'plot_bgcolor':'#000'\\n }\\n }\\n ) for i in range(len(titles))]\\n +\\n [html.Div(\\n style={'justify-content': 'center', 'display': 'flex',\\n 'align-items': 'center', 'width': '10vh', 'font-size': '30pt', 'color': 'white'},\\n children=['{}'.format(latesthr[signame][0])])\\n ]\\n ) for signame in signames_ecg])\",\n \"def home():\\n return render_template(\\\"d3_graph.html\\\")\",\n \"def makeGraph(self):\\n self.graphFrame = Frame(height=400, width=400, bd=10, bg='black')\\n self.graphFrame.grid(row=1, column=0)\",\n \"def render(self):\\r\\n super().render()\\r\\n layers, titles, latVect, lonVect = self.make_layers()\\r\\n LON, LAT = np.meshgrid(lonVect, latVect)\\r\\n lon = LON.flatten()\\r\\n lat = LAT.flatten()\\r\\n for i in range(len(layers)):\\r\\n vals = layers[i].flatten()\\r\\n hovertext = []\\r\\n for k in range(len(vals)):\\r\\n hovertext.append('lon: {:.2f}<br>lat: {:.2f}<br>{}: {:.1e}'.format(lon[k], lat[k], self.variable + self.unit,vals[k]))\\r\\n if self.levels == 0:\\r\\n data = [\\r\\n go.Heatmap(\\r\\n x=lon,\\r\\n y=lat,\\r\\n z=vals,\\r\\n colorscale=self.cmap,\\r\\n zmin=self.vmin,\\r\\n zmax=self.vmax,\\r\\n hoverinfo='text',\\r\\n text=hovertext \\r\\n )\\r\\n ]\\r\\n elif self.levels > 0:\\r\\n data = [\\r\\n go.Contour(\\r\\n x=lon,\\r\\n y=lat,\\r\\n z=vals,\\r\\n colorscale=self.cmap,\\r\\n hoverinfo='text',\\r\\n text=hovertext, \\r\\n connectgaps=False,\\r\\n contours=dict(\\r\\n coloring='heatmap',\\r\\n showlabels=True,\\r\\n start=self.vmin,\\r\\n end=self.vmax,\\r\\n size=(self.vmax-self.vmin) / float(self.levels)\\r\\n )\\r\\n # line=dict(smoothing=0.85) \\r\\n )\\r\\n ] \\r\\n\\r\\n\\r\\n layout = go.Layout(\\r\\n autosize=False,\\r\\n title=titles[i],\\r\\n width=self.width,\\r\\n height=self.height,\\r\\n xaxis={'title': self.xlabel},\\r\\n yaxis={'title': self.ylabel}\\r\\n ) \\r\\n\\r\\n\\r\\n\\r\\n if self.surface3D:\\r\\n data = [\\r\\n go.Surface(\\r\\n x=lonVect,\\r\\n y=latVect,\\r\\n z=layers[i],\\r\\n colorscale=self.cmap,\\r\\n # hoverinfo='text',\\r\\n # text=hovertext \\r\\n )\\r\\n ]\\r\\n\\r\\n layout = go.Layout(\\r\\n autosize=False,\\r\\n title=titles[i],\\r\\n width=self.width,\\r\\n height=self.height,\\r\\n scene = dict(\\r\\n xaxis={'title': self.xlabel},\\r\\n yaxis={'title': self.ylabel},\\r\\n zaxis={'title': self.variable + self.unit}\\r\\n )\\r\\n ) \\r\\n\\r\\n\\r\\n self._save_plotly_(go, data, layout)\",\n \"def graph():\\n port_to_csv()\\n\\n source = ''\\n if request.form.get('GraphType', '') == '':\\n source = url_for('static', filename='frog no graph.png')\\n else:\\n source = s_modular(request.form.get('GraphType', ''), '')\\n\\n return render_template(\\n 'tmpGraph.jade',\\n title=\\\"Graph\\\",\\n year=datetime.now().year,\\n src=source\\n )\",\n \"def renderNode(self, node):\\n self.html += '<div id=\\\\\\\"nodeDecoration\\\\\\\">'\\n self.html += '<p id=\\\\\\\"nodeTitle\\\\\\\">'\\n self.html += escape(node.titleLong)\\n self.html += '</p></div>\\\\n'\\n for idevice in node.idevices:\\n block = g_blockFactory.createBlock(None, idevice)\\n if not block:\\n log.critical(\\\"Unable to render iDevice.\\\")\\n raise Error(\\\"Unable to render iDevice.\\\")\\n if hasattr(idevice, \\\"isQuiz\\\"):\\n self.html += block.renderJavascriptForWeb()\\n self.html += block.renderView(self.style)\\n for child in node.children:\\n self.renderNode(child)\",\n \"def index():\\n return render_template(\\\"charts.html\\\")\",\n \"def render(self):\\n\\n self.desert_image.render()\\n self.cannon_image.render()\\n self.play_button.render()\\n self.escape_label.render()\",\n \"def render_tab_content(active_tab):\\n if active_tab is not None:\\n if active_tab == \\\"graph1\\\":\\n return dcc.Graph(figure=example_graph1, id='graph')\\n elif active_tab == \\\"graph2\\\":\\n return dcc.Graph(figure=example_graph2, id='graph')\\n elif active_tab == \\\"graph3\\\":\\n return dcc.Graph(figure=example_graph3, id='graph')\\n return \\\"No tab selected\\\"\",\n \"def get(self):\\n self.render_front()\",\n \"def buildPage(self):\\n args = {}\\n args['valueCol'] = 'value'\\n args['textCol'] = 'size'\\n args['y'] = 'index'\\n args['x'] = 'number'\\n args['orientation'] = 'h'\\n args['title'] = ''\\n args['x_title'] = ''\\n args['y_title'] = ''\\n args['height'] = 900\\n args['width'] = 900\\n\\n self.add_basic_layout()\\n layout = hpstats.quick_numbers_panel()\\n dfs = hpstats.get_db_stats_data()\\n plots = []\\n plots.append(hpstats.plot_store_size_components(dfs, title='DB Store Size', args=args))\\n plots.append(hpstats.plot_node_rel_per_label(dfs, focus='nodes', title='Nodes per Label', args=args))\\n plots.append(hpstats.plot_node_rel_per_label(dfs, focus='relationships', title='Relationships per Type', args=args))\\n self.extend_layout(layout)\\n self.extend_layout(plots)\",\n \"def render(self):\\n content = self._render_pre_content('div')\\n for widget in self._child_widgets:\\n content += widget.render()\\n content += self._render_post_content('div')\\n self._widget_content = content\\n return self._widget_content\",\n \"def draw(self, stats=[]):\\n clear_output(wait=True)\\n svg_html = self.to_html(stats)\\n display(svg_html)\",\n \"def render(self, **kwargs):\\n self.color_domain = [\\n self.vmin + (self.vmax - self.vmin) * k / 499.0 for k in range(500)\\n ]\\n self.color_range = [self.__call__(x) for x in self.color_domain]\\n if self.tick_labels is None:\\n self.tick_labels = legend_scaler(self.index, self.max_labels)\\n\\n super().render(**kwargs)\\n\\n figure = self.get_root()\\n assert isinstance(figure, Figure), (\\n \\\"You cannot render this Element \\\" \\\"if it is not in a Figure.\\\"\\n )\\n\\n figure.header.add_child(\\n JavascriptLink(\\\"https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.5/d3.min.js\\\"),\\n name=\\\"d3\\\",\\n ) # noqa\",\n \"def visualize_graph(self):\\n self._graph.GetVertexData().AddArray(self._labels)\\n self._graph.GetEdgeData().AddArray(self._weights)\\n colors = vtk.vtkUnsignedCharArray()\\n colors.SetNumberOfComponents(1)\\n colors.SetName('Colors')\\n types = int(245 / len(self._color_dict))\\n for c in self._colors:\\n colors.InsertNextValue(int(c * types))\\n self._graph.GetVertexData().AddArray(colors)\\n graphLayoutView = vtk.vtkGraphLayoutView()\\n graphLayoutView.AddRepresentationFromInput(self._graph)\\n graphLayoutView.SetLayoutStrategy(vtk.vtkSpanTreeLayoutStrategy())\\n graphLayoutView.GetLayoutStrategy().SetEdgeWeightField(\\\"Weights\\\")\\n graphLayoutView.GetLayoutStrategy().SetWeightEdges(1)\\n graphLayoutView.GetRenderer().GetActiveCamera().ParallelProjectionOff()\\n graphLayoutView.SetEdgeLabelArrayName(\\\"Weights\\\")\\n graphLayoutView.SetEdgeLabelVisibility(1)\\n graphLayoutView.SetVertexLabelArrayName('labels')\\n graphLayoutView.SetVertexLabelVisibility(1)\\n graphLayoutView.SetVertexColorArrayName('Colors')\\n graphLayoutView.SetColorVertices(1)\\n graphLayoutView.SetInteractorStyle(MouseAndKeysInteractor(graphLayoutView))\\n graphLayoutView.ResetCamera()\\n graphLayoutView.Render()\\n graphLayoutView.GetInteractor().Start()\",\n \"def render(self):\",\n \"def render(self):\\n raise NotImplementedError\",\n \"def render(self):\\n content = self._attach_css() + \\\"\\\\n\\\"\\n content += self._render_pre_content('div')\\n content += \\\"<div id='\\\" + self._name + \\\"_handle' class='ui-slider-handle'></div>\\\"\\n content += self._render_post_content('div')\\n self._widget_content = content + \\\"\\\\n\\\" + self._attach_script() + \\\"\\\\n\\\" + self._attach_polling()\\n return self._widget_content\",\n \"def show_graphs(self):\\n self.frequency_plot_graph.show()\\n self.resistance_graph.show()\\n self.temperature_plot_graph.show()\\n self.pressure_plot_graph.show()\\n self.humidity_plot_graph.show()\\n self.overview_graph.show()\\n self.overview_graph.setXRange(-1000, 5000)\",\n \"def plot(self):\\n attr = self.Graph[\\\"root\\\"]\\n if (self.type == 0 or self.type == 1):\\n self.subplot_1(attr, 0)\\n else:\\n self.subplot_2(attr, 0)\",\n \"def render(self):\\n canvas_id = 'zdog_{}'.format(self.CANVAS_INDEX)\\n illo_id = 'illo_{}'.format(self.CANVAS_INDEX)\\n Scene.CANVAS_INDEX += 1\\n\\n html_lines = []\\n\\n js_lines = []\\n\\n euler = -rowan.to_euler(\\n self.rotation, convention='xyz', axis_type='intrinsic')\\n translation = self.translation*(1, -1, 1)\\n\\n pan_cfg = self.get_feature_config('pan')\\n pan = pan_cfg.get('value', True) if pan_cfg is not None else False\\n\\n js_lines.append(\\\"\\\"\\\"\\n let {illo_id} = new Zdog.Illustration({{\\n element: '#{canvas_id}',\\n zoom: {zoom},\\n dragRotate: {rotation_enabled},\\n rotate: {{x: {angle[0]}, y: {angle[1]}, z: {angle[2]}}},\\n translate: {{x: {pos[0]}, y: {pos[1]}, z: {pos[2]}}},\\n }});\\n \\\"\\\"\\\".format(\\n illo_id=illo_id, canvas_id=canvas_id, zoom=self.zoom*self.pixel_scale,\\n angle=euler, pos=translation,\\n rotation_enabled=('false' if pan else 'true')))\\n\\n config = self.get_feature_config('ambient_light')\\n ambient_light = 0 if config is None else config.get('value', .4)\\n\\n config = self.get_feature_config('directional_light')\\n directional_light = ([(0, 0, 0)] if config is None else\\n config.get('value', [(0, 0, 0)]))\\n directional_light = np.atleast_2d(directional_light)\\n\\n shapeIndex = 0\\n for i, prim in enumerate(self._primitives):\\n js_lines.extend(prim.render(\\n rotation=self.rotation, illo_id=illo_id,\\n name_suffix=i, ambient_light=ambient_light,\\n directional_light=directional_light))\\n\\n (width, height) = map(int, self.size_pixels)\\n html_lines.append(\\\"\\\"\\\"\\n <canvas id=\\\"{canvas_id}\\\" width=\\\"{width}\\\" height=\\\"{height}\\\"></canvas>\\n \\\"\\\"\\\".format(canvas_id=canvas_id, width=width, height=height))\\n\\n html_lines.append(\\\"\\\"\\\"<script>\\n var fill_{canvas_id} = function() {{\\n \\\"\\\"\\\".format(canvas_id=canvas_id))\\n html_lines.append(LOCAL_HELPER_SCRIPT)\\n html_lines.extend(js_lines)\\n\\n pan_snippet = \\\"\\\"\\\"\\n new Zdog.Dragger({{\\n startElement: {illo_id}.element,\\n onDragStart: function( pointer, moveX, moveY) {{\\n this.lastX = 0;\\n this.lastY = 0;\\n }},\\n onDragMove: function( pointer, moveX, moveY ) {{\\n let deltax = moveX - this.lastX;\\n let deltay = moveY - this.lastY;\\n let scale = 1.0/{illo_id}.zoom;\\n {illo_id}.translate.x += deltax*scale;\\n {illo_id}.translate.y += deltay*scale;\\n this.lastX = moveX;\\n this.lastY = moveY;\\n }}\\n }});\\\"\\\"\\\".format(illo_id=illo_id)\\n if pan:\\n html_lines.append(pan_snippet)\\n\\n html_lines.append(\\\"\\\"\\\"\\n let this_canvas = document.querySelector(\\\"#{canvas_id}\\\");\\n \\\"\\\"\\\".format(canvas_id=canvas_id))\\n html_lines.append(\\\"\\\"\\\"\\n let animate_{canvas_id} = function() {{\\n if(is_in_view(this_canvas))\\n {{\\n {illo_id}.updateRenderGraph();\\n }}\\n if(document.contains(this_canvas))\\n {{\\n requestAnimationFrame(animate_{canvas_id});\\n }}\\n }};\\n animate_{canvas_id}();\\\"\\\"\\\".format(canvas_id=canvas_id, illo_id=illo_id))\\n # remove the global reference to this function after using it\\n html_lines.append('fill_{canvas_id} = null;'.format(canvas_id=canvas_id))\\n html_lines.append('};') # end of fill_{canvas_id}\\n # now call fill_{canvas_id}, possibly after loading zdog\\n html_lines.append(\\\"\\\"\\\"\\n if (typeof Zdog == 'undefined')\\n {{\\n var script = document.createElement('script');\\n script.addEventListener('load', fill_{canvas_id}, false);\\n script.src = 'https://unpkg.com/zdog@1/dist/zdog.dist.min.js';\\n document.getElementsByTagName('head')[0].appendChild(script);\\n }}\\n else\\n fill_{canvas_id}();\\n \\\"\\\"\\\".format(canvas_id=canvas_id))\\n html_lines.append('</script>')\\n\\n return '\\\\n'.join(html_lines)\",\n \"def draw_nodes(self):\\n pass\",\n \"def render(self):\\n self.axial.Render()\\n self.coronal.Render()\\n self.sagittal.Render()\\n #self.isosurface.Render()\\n #self.rwi_pcp.Render()\",\n \"def render(self):\\n pass\",\n \"def render(self):\\n pass\",\n \"def render(self):\\n pass\",\n \"def render(self):\\n pass\",\n \"def render(self):\\n pass\",\n \"def render(self):\\n pass\",\n \"def layout():\\n # Needs db connection! (Set up tunnel if testing app locally)\\n _ids = get_doc_ids_from_db() \\n dropdown_dates = {num2str_month(_id): _id for _id in _ids}\\n\\n children_list = [\\n html.Div([\\n html.H2('Top women and men quoted'),\\n html.P('''\\n In this section, we display the top women and men quoted as sources in a\\n given month. First, select a month from the dropdown menu below.\\n ''')],\\n ),\\n html.Br(),\\n dcc.Dropdown(\\n id='date-dropdown',\\n options=[\\n {'label': date_str, 'value': date_num}\\n for date_str, date_num in dropdown_dates.items()\\n ],\\n value=_ids[-1],\\n className='dropdown'\\n ),\\n html.Br(),\\n html.Div(\\n dcc.Loading(\\n id='topic-load-progress',\\n children=[\\n dcc.Store(id='top-sources-topic-data'),\\n dcc.Store(id='top-sources-stats'),\\n ])\\n ),\\n html.Br(),\\n html.H4('Topics and gender representation among sources'),\\n dcc.Markdown('''\\n First, we display the *gender prominence* for each topic discovered in the \\n selected month. Gender prominence is a measure we use to study whether a\\n given topic features quotes by men or women more prominently.\\n '''),\\n html.Div([\\n dcc.Graph(id='top-sources-outlet-gender-heatmap'),\\n ]),\\n html.Br(),\\n html.Div([\\n html.H4('Top quoted sources by gender'),\\n html.P(f'''\\n Next, we display the top {NUM_SOURCES_TO_SHOW} sources per gender for the given month.\\n Hover over the dots to display the total number of articles in which each source was \\n quoted.\\n '''),\\n html.Div([\\n dcc.Graph(id='top-sources-dotplot', className='chart'),\\n ]),\\n ]),\\n html.H4('Observations'),\\n dcc.Markdown(id='user-comment-display'),\\n ]\\n return children_list\",\n \"def render(self):\\n content = self._render_pre_content('div')\\n for widget in self._child_widgets:\\n content += \\\"\\\\n\\\" + widget.render()\\n content += self._render_post_content('div')\\n content += \\\"\\\"\\\"<script>\\n $(function(){\\n $(\\\"#%s\\\").accordion({\\n collapsible: %s,\\n icons: %s,\\n heightStyle: \\\"%s\\\"\\n });\\n });\\n </script>\\n \\\"\\\"\\\" % (self._name, \\\"true\\\" if self._collapsible else \\\"false\\\",\\n self._icons, \\\"fill\\\" if self._fill_space else \\\"\\\")\\n self._widget_content = content\\n return self._widget_content\",\n \"def graphs(self, title: str, graph_name: str) -> NoReturn:\\n self.add_page()\\n self.set_text_color(0, 250, 154)\\n self.cell(0, 0, title, align='C', ln=2)\\n self.ln(self.line_height)\\n img = Image.open(full_path(f'./output/{graph_name}'))\\n image_width = self.w - (self.l_margin + self.r_margin)\\n image_height = self.h - (self.t_margin + self.b_margin + self.get_y())\\n self.image(img, self.get_x(), self.get_y(), w=image_width,\\n h=image_height)\",\n \"def on_draw(self):\\n\\t\\tself.render()\",\n \"def on_draw(self):\\n\\t\\tself.render()\",\n \"def draw_graph(self):\\n\\t\\tif None in self.graph:\\n\\t\\t\\tdel self.graph[None]\\n\\n\\t\\tfor vs in self.graph.itervalues():\\n\\t\\t\\tto_delete = []\\n\\t\\t\\tfor i in xrange(len(vs)):\\n\\t\\t\\t\\tif vs[i] is None:\\n\\t\\t\\t\\t\\tto_delete.append(i)\\n\\n\\t\\t\\tfor i in reversed(to_delete):\\n\\t\\t\\t\\tdel vs[i]\\n\\n\\t\\tself.G=nx.Graph(self.graph)\\n\\n\\t\\tfor k,v in self.labels.iteritems():\\n\\t\\t\\tif v[:6] == 'Module':\\n\\t\\t\\t\\troot = k\\n\\t\\t\\t\\tbreak\\n\\n\\t\\treturn self.__dfs_plot(root)\",\n \"def render(self):\\n print(self._get_grid_representations())\",\n \"def render(self):\\n raise NotImplementedError()\",\n \"def dspyRender(self):\\n pass\",\n \"def gc_content_plot (self): \\n if 'gc_content' not in self.fastqc_data or len(self.fastqc_data['gc_content']) == 0:\\n log.debug('gc_content not found in FastQC reports')\\n return None\\n \\n pconfig = {\\n 'id': 'fastqc_gc_content_plot',\\n 'title': 'Per Sequence GC Content',\\n 'ylab': 'Count',\\n 'xlab': '%GC',\\n 'ymin': 0,\\n 'xmax': 100,\\n 'xmin': 0,\\n 'yDecimals': False,\\n 'tt_label': '<b>{point.x}% GC</b>: {point.y}',\\n 'colors': self.get_status_cols('gc_content'),\\n }\\n self.sections.append({\\n 'name': 'Per Sequence GC Content',\\n 'anchor': 'fastqc_gc_content',\\n 'content': '<p>The average GC content of reads. Normal random library typically have a roughly normal distribution of GC content. ' +\\n 'See the <a href=\\\"http://www.bioinformatics.babraham.ac.uk/projects/fastqc/Help/3%20Analysis%20Modules/5%20Per%20Sequence%20GC%20Content.html\\\" target=\\\"_bkank\\\">FastQC help</a>.</p>' +\\n self.plot_xy_data(self.fastqc_data['gc_content'], pconfig)\\n })\",\n \"def draw(self):\\n\\t\\tnx_graph = self.parse_graph()\\n\\t\\tpos = nx.spring_layout(nx_graph, k=0.15, iterations=20) # to spread out the nodes\\n\\n\\t\\tnx.draw(nx_graph, pos, edge_color=\\\"black\\\", width=1, linewidths=1, node_size=500, node_color=\\\"pink\\\", alpha=0.9, with_labels=True)\\n\\n\\t\\tedge_labels = {(edge[0], edge[1]):edge[2] for edge in self.edges}\\n\\t\\tnx.draw_networkx_edge_labels(nx_graph, pos, edge_labels=edge_labels, font_color='red')\\n\\n\\t\\tplt.show()\",\n \"def __render(self):\\r\\n scores = self.__score_repository.get_high_scores()\\r\\n self.__renderer.draw(\\\"high_scores\\\", scores=scores)\",\n \"def plot(self):\\n layout = self.graph.layout(\\\"kk\\\")\\n bbox = igraph.BoundingBox(600, 600)\\n figure = igraph.Plot(bbox=bbox, background=\\\"white\\\")\\n bbox = bbox.contract(100)\\n figure.add(self.graph, layout = layout, bbox=bbox)\\n figure.show()\",\n \"def visualize_dependency_graph(self):\\n if self.graph is None:\\n self.logger.error(\\\"Graph value none cannot be plotted\\\")\\n return\\n\\n nx.draw(self.graph, cmap=plt.get_cmap('jet'), with_labels=True)\\n plt.show()\",\n \"def paint(self):\\n x = []\\n y = []\\n plt.figure(figsize=(10, 5), facecolor=\\\"silver\\\")\\n ax = plt.axes()\\n for node in self.graph.nodes.values():\\n x.append(node.get_pos()[0])\\n y.append(node.get_pos()[1])\\n ax.scatter(x, y, color=\\\"black\\\", s=50)\\n xl = ax.get_xlim()[1] - ax.get_xlim()[0]\\n yl = ax.get_ylim()[1] - ax.get_ylim()[0]\\n for nd in self.graph.nodes.values():\\n for ed in self.graph.all_out_edges_of_node(Node.get_key(nd)).keys():\\n desti: Node = self.graph.get_node(ed)\\n destx = desti.get_pos()[0] - nd.get_pos()[0]\\n desty = desti.get_pos()[1] - nd.get_pos()[1]\\n ax.arrow(nd.get_pos()[0], nd.get_pos()[1], destx, desty, head_width=xl * 0.007,\\n length_includes_head=True,\\n head_length=yl * 0.02, width=xl * 0.0001 * yl, color='grey')\\n plt.title(\\\"Your graph!\\\")\\n plt.show()\",\n \"def _render(self) -> None:\\n pass\",\n \"def show_data(self):\\n\\n self.area_canvas.axes.cla()\\n self.draw_scatterplot(self.scatter_canvas, 'x [µm]', 'y [µm]', self.p_inputs['flip y-axis'].isChecked())\\n self.draw_hist(self.area_canvas, 'area', 'cluster area [µm²]', 'number of clusters')\\n self.draw_hist(self.number_canvas, 'nclusters', 'number of cluster', 'number of regions')\\n self.draw_hist(self.density_canvas, 'density', 'cluster density [µm⁻²]', 'number of clusters')\\n self.draw_hist(self.percentage_canvas, 'pclustered', 'percentage clustered',\\n 'number of regions')\\n self.draw_hist(self.ratio_canvas, 'reldensity', 'relative density clusters/background',\\n 'number of regions')\",\n \"def render_sample(cls,\\n nusc: 'NuScenes',\\n radar_data_gp: 'RadarDataGroup',\\n front_cam_data: 'CameraData',\\n host_data:'HostData',\\n fig_info:dict,\\n box_vis_level: BoxVisibility = BoxVisibility.ANY,\\n out_path: str = None) -> None:\\n cls.colors=radar_data_gp.colors\\n fig, axes = plt.subplots(1, 2, figsize=(16, 24))\\n #left diagram to show front view\\n ax1 = axes[0]\\n cls.render_front_view(cls, nusc=nusc, radar_data_gp=radar_data_gp, front_cam_data=front_cam_data,\\n ax =ax1, use_flat_vehicle_coordinates=False, with_anns=False, with_radar=True)\\n #right diagram to show bird view\\n ax2 = axes[1] \\n \\n cls.render_bird_view(cls, nusc=nusc, radar_data_gp=radar_data_gp, front_cam_data=front_cam_data, \\n host_data=host_data, ax =ax2, use_flat_vehicle_coordinates=True)\\n #figure information\\n fig.text(0.01, 0.97, 'Figure information: ', weight='bold', color='green',fontsize = 15) \\n fig.text(0.01, 0.93, 'package: '+nusc.version, fontsize = 12) \\n fig.text(0.01, 0.9, 'scene name: '+fig_info['scene_name'], fontsize = 12) \\n fig.text(0.01, 0.87, 'timestamp: '+str(front_cam_data.time_stamp*1e-6)+'(s)', fontsize = 12)\\n fig.text(0.01, 0.84, 'elapse time: : '+str((fig_info['elapse_time'])*1e-3)+'(ms)', fontsize = 12)\\n \\n plt.tight_layout()\\n fig.subplots_adjust(wspace=0, hspace=0)\\n if out_path is not None:\\n plt.savefig(out_path,dpi=200)\\n if fig_info['verbose']: \\n plt.show()\",\n \"def data_graph():\\n station_reference = request.args.get(\\\"stationReference\\\")\\n station_name = request.args.get(\\\"stationName\\\")\\n station_name = station_name.replace(\\\" \\\",\\\"+\\\")\\n\\n if station_name is not None:\\n # station_data = station_data.replace(\\\" \\\", \\\"+\\\")\\n station = station_data.loc[station_data.stationName == station_name]\\n else:\\n station = station_data.loc[station_data.stationReference == station_reference]\\n result_station = station.iloc[0]\\n\\n # Get optional parameters\\n time_from = request.args.get(\\\"from\\\")\\n time_to = request.args.get(\\\"to\\\")\\n if time_from:\\n pass\\n else:\\n time_from = None\\n if time_to:\\n pass\\n else:\\n time_to = None\\n # plot pic\\n magic_trick= data.station_graph(result_station.stationName, time_from, time_to)\\n # img_stream = io.BytesIO(img)\\n # img = Image.open(img_stream)\\n # imgByteArr = io.BytesIO()\\n # img.save(imgByteArr,format='PNG')\\n # imgByteArr = imgByteArr.getvalue()\\n # return send_file(io.BytesIO(imgByteArr),\\n # mimetype = 'image/png',\\n # as_attachment = True,\\n # attachment_filename = 'tmp.png')\\n image_data = open(\\\"tmp.png\\\", \\\"rb\\\").read()\\n response = make_response(image_data)\\n response.headers['Content-Type'] = 'image/png'\\n return response\",\n \"def show_visualizations(self, number = -1):\\n instance = self.instance\\n if number > instance.view_num:\\n print(\\\"In function show_visualizations: Error, input number greater than the view numbers.\\\")\\n return Page()\\n if self.rank_method == methods_of_ranking[3]: # diversified_ranking\\n G = myGraph(instance.view_num)\\n for i in range(instance.view_num):\\n view = instance.tables[instance.views[i].table_pos].views[instance.views[i].view_pos]\\n G.addNode(view)\\n G.getSim()\\n result = G.getTopK(instance.view_num)\\n if number != -1:\\n begin = number - 1\\n end = number\\n else:\\n begin = 0\\n end = instance.view_num\\n page = Page()\\n for order in range(begin, end):\\n if self.rank_method == methods_of_ranking[3]: # diversified_ranking\\n view = G.nodes[result[order]]\\n else:\\n view = instance.tables[instance.views[order].table_pos].views[instance.views[order].view_pos]\\n data = {}\\n data['order'] = order\\n data['chartname'] = instance.table_name\\n data['describe'] = view.table.describe\\n data['x_name'] = view.fx.name\\n data['y_name'] = view.fy.name\\n data['chart'] = Chart.chart[view.chart]\\n data['classify'] = [v[0] for v in view.table.classes]\\n data['x_data'] = view.X\\n data['y_data'] = view.Y\\n data['title_top'] = 5\\n \\n # 以下代码与html_handle相似\\n margin = str(data['title_top']) + '%'\\n \\n if data['chart'] == 'bar':\\n chart = (Bar().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\\n xaxis_opts=opts.AxisOpts(name=data['x_name']),\\n yaxis_opts=opts.AxisOpts(name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\\n elif data['chart'] == 'pie': \\n chart = (Pie().set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin)))\\n elif data['chart'] == 'line': \\n chart = (Line().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\\n xaxis_opts=opts.AxisOpts(name=data['x_name']),\\n yaxis_opts=opts.AxisOpts(name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\\n elif data['chart']== 'scatter': \\n chart = (Scatter().set_series_opts(label_opts=opts.LabelOpts(is_show=False))\\n .set_global_opts(title_opts=opts.TitleOpts(title=data['chartname'], subtitle=data['describe'], pos_left='center', pos_top=margin),\\n xaxis_opts=opts.AxisOpts(type_='value', name=data['x_name'], splitline_opts=opts.SplitLineOpts(is_show=True)),\\n yaxis_opts=opts.AxisOpts(type_='value', name=data['y_name'], splitline_opts=opts.SplitLineOpts(is_show=True))))\\n else :\\n print (\\\"not valid chart\\\")\\n \\n if not data[\\\"classify\\\"] :\\n attr = data[\\\"x_data\\\"][0]\\n val = data[\\\"y_data\\\"][0]\\n if data['chart'] == 'bar': \\n chart.add_xaxis(attr).add_yaxis(\\\"\\\", val, label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'line': \\n chart.add_xaxis(attr).add_yaxis(\\\"\\\", val, label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'pie': \\n chart.add(\\\"\\\", [list(z) for z in zip(attr, val)])\\n elif data['chart'] == 'scatter': \\n if isinstance(attr[0], str):\\n attr = [x for x in attr if x != '']\\n attr = list(map(float, attr))\\n if isinstance(val[0], str):\\n val = [x for x in val if x != '']\\n val = list(map(float, val))\\n chart.add_xaxis(attr).add_yaxis(\\\"\\\", val, label_opts=opts.LabelOpts(is_show=False))\\n page.add(chart)\\n else :\\n attr = data[\\\"x_data\\\"][0]\\n for i in range(len(data[\\\"classify\\\"])) :\\n val = data[\\\"y_data\\\"][i]\\n name = (data[\\\"classify\\\"][i][0] if type(data[\\\"classify\\\"][i]) == type(('a','b')) else data[\\\"classify\\\"][i])\\n if i == 0:\\n if data['chart'] != 'pie' and data['chart'] != 'scatter':\\n chart.add_xaxis(attr)\\n if data['chart'] == 'bar': \\n chart.add_yaxis(name, val, stack=\\\"stack1\\\", label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'line': \\n chart.add_yaxis(name, val, label_opts=opts.LabelOpts(is_show=False))\\n elif data['chart'] == 'pie': \\n chart.add(\\\"\\\", [list(z) for z in zip(attr, val)])\\n elif data['chart'] == 'scatter': \\n attr_scatter = data[\\\"x_data\\\"][i]\\n if isinstance(attr_scatter[0], str):\\n attr_scatter = [x for x in attr_scatter if x != '']\\n attr_scatter = list(map(float, attr_scatter))\\n if isinstance(val[0], str):\\n val = [x for x in val if x != '']\\n val = list(map(float, val))\\n chart.add_xaxis(attr_scatter).add_yaxis(name, val, label_opts=opts.LabelOpts(is_show=False))\\n page.add(chart)\\n return page\",\n \"def _render(self):\\n self._renderer.render_menu()\\n pg.display.update()\",\n \"def index():\\n # create table for original dataset\\n table_1 = data_table_low(filepath = \\\"sparkify_data.csv\\\", title='Raw Sparkify Data')\\n\\n table_2 = data_table_low(filepath = \\\"cleaned_data.csv\\\", title='Cleaned Sparkify Data')\\n\\n # create and append plotly visuals into an array to be passed later for graphJSON file\\n graphs = [table_1, table_2]\\n\\n # encode plotly graphs in JSON\\n ids = [\\\"graph-{}\\\".format(i) for i, _ in enumerate(graphs)]\\n graphJSON = json.dumps(graphs, cls=plotly.utils.PlotlyJSONEncoder)\\n\\n # render web page with plotly graphs\\n return render_template(\\\"master.html\\\", ids=ids, graphJSON=graphJSON)\",\n \"def render(results, out_file):\\n fig, (ax_backlog, ax_merges, ax_open, ax_health) = plt.subplots(\\n 4, sharex=True, figsize=(16, 10), dpi=100)\\n\\n fig.autofmt_xdate()\\n plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%m/%d/%Y'))\\n plt.gca().xaxis.set_major_locator(mdates.DayLocator())\\n if results.dts:\\n render_queue(results, ax_open)\\n render_merges(results, ax_merges)\\n render_backlog(results, ax_backlog)\\n render_health(results, ax_health)\\n fig.text(\\n 0.1, 0.00,\\n 'image: %s, sample: %s' % (\\n datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M'),\\n results.dts[-1].strftime('%Y-%m-%d %H:%M'),\\n ),\\n horizontalalignment='left',\\n fontsize='x-small',\\n color=fresh_color(results.dts[-1]),\\n )\\n\\n plt.savefig(out_file, bbox_inches='tight', format='svg')\\n plt.close()\",\n \"def visualize(request, slug, handle_id):\\n nh = get_object_or_404(NodeHandle, pk=handle_id)\\n node = nh.get_node()\\n return render(request, 'noclook/visualize/visualize.html', {'node_handle': nh, 'node': node, 'slug': slug})\",\n \"def draw_graph(self,path):\\n print(\\\"Drawing HashTag Graph!\\\")\\n\\n layout = self.graph.layout(\\\"kk\\\")\\n\\n self.graph.vs[\\\"label\\\"] = self.graph.vs[\\\"name\\\"]\\n\\n\\n visual_style = {}\\n visual_style[\\\"bbox\\\"] = (1600,1600)\\n visual_style[\\\"vertex_size\\\"] = 10\\n visual_style[\\\"edge_width\\\"] = 1\\n visual_style[\\\"edge_color\\\"] = 'blue'\\n visual_style[\\\"layout\\\"] = layout\\n visual_style[\\\"margin\\\"] = 100\\n\\n graph_plot = plot(self.graph, **visual_style)\\n graph_plot.save(fname=path)\\n\\n return 0\",\n \"def render(self):\\n content = self._render_pre_content('ul')\\n for widget in self._child_widgets:\\n content += widget.render()\\n content += self._render_post_content('ul')\\n self._widget_content = content + \\\"\\\\n\\\" + self._attach_script() + \\\"\\\\n\\\" + self._attach_css()\\n return self._widget_content\",\n \"def chart(request):\\n assert isinstance(request, HttpRequest)\\n filename = 'ppg_RawDataSheet13.mat'\\n subtitle = 'VerityDB/' + filename\\n return render(\\n request,\\n 'research/chart.html',\\n {\\n 'title':'Chart',\\n 'message':'Highcharts Based',\\n 'year':datetime.now().year,\\n #'data': content['val'][0:11]\\n 'temp': models.load_data(),\\n 'test': models.load_data_filename(filename),\\n 'subtitle_text': subtitle,\\n }\\n )\",\n \"def simple_map_graph(id_, title):\\n return html.Div(\\n className=\\\"main-card mb-4\\\",\\n children=[\\n html.Div(title, className=\\\"title-centered title-bold\\\"),\\n html.Hr(),\\n dcc.Graph(id=id_),\\n ],\\n )\",\n \"def jloggraph(self, codebase=\\\"\\\", width=400, height=300):\\n\\n # Wraps the show method\\n jloggraph = (\\n '<applet width=\\\"'\\n + str(width)\\n + '\\\" height=\\\"'\\n + str(height)\\n + '\\\" code=\\\"JLogGraph.class\\\"\\\\n'\\n + 'codebase=\\\"'\\n + str(codebase)\\n + '\\\"><param name=\\\"table\\\" value=\\\"\\\\n'\\n )\\n jloggraph = jloggraph + self.show(loggraph=True)\\n jloggraph = jloggraph + '\\\"><b>For inline graphs use a Java browser</b></applet>'\\n return jloggraph\",\n \"def render(self, filename):\\n lines = []\\n for name in self._name_to_graph:\\n text_graph = self._name_to_graph[name].render()\\n lines.append(text_graph)\\n if filename is None:\\n print(\\\"\\\\n\\\".join(lines))\\n else:\\n with open(filename, \\\"w\\\") as out_file:\\n out_file.write(\\\"\\\\n\\\".join(lines))\",\n \"def echarts_Timeline(graph,\\r\\n h,\\r\\n x='',\\r\\n y='',\\r\\n symbol_size=20,\\r\\n line_width=1,\\r\\n repulsion=500,\\r\\n is_draggable=True,\\r\\n width=\\\"800px\\\",\\r\\n height=\\\"500px\\\",\\r\\n path='timelineExample.html',\\r\\n title='Timeline_graph',\\r\\n subtitle='',\\r\\n pageLayout=Page.DraggablePageLayout,\\r\\n layout=\\\"circular\\\",\\r\\n show_node_value=True,\\r\\n render=True):\\r\\n\\r\\n # initialize nodes list\\r\\n nodes = []\\r\\n if layout == 'none':\\r\\n for i in range(len(graph.nodes.aslist())):\\r\\n # calculate reachability for each nodes\\r\\n reachability = ot.calculate_reachability(graph, graph.nodes.labels()[i])\\r\\n if reachability > h:\\r\\n # nodes with reachability more than h will be assigned category 0\\r\\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\\r\\n x=graph.nodes.aslist()[i].data[x],\\r\\n y=graph.nodes.aslist()[i].data[y],\\r\\n category=0,\\r\\n value=reachability))\\r\\n else:\\r\\n # nodes with reachability less than or equal to h will be assigned category 1\\r\\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\\r\\n x=graph.nodes.aslist()[i].data[x],\\r\\n y=graph.nodes.aslist()[i].data[y],\\r\\n category=1,\\r\\n value=reachability))\\r\\n else:\\r\\n for i in range(len(graph.nodes.aslist())):\\r\\n # calculate reachability for each nodes\\r\\n reachability = ot.calculate_reachability(graph, graph.nodes.labels()[i])\\r\\n if reachability > h:\\r\\n # nodes with reachability more than h will be assigned category 0\\r\\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\\r\\n category=0,\\r\\n value=reachability))\\r\\n else:\\r\\n # nodes with reachability less than or equal to h will be assigned category 1\\r\\n nodes.append(opts.GraphNode(name=graph.nodes.labels()[i],\\r\\n category=1,\\r\\n value=reachability))\\r\\n\\r\\n # initialize links list\\r\\n links = []\\r\\n for i in graph.edges.timespan():\\r\\n tmpLinks = []\\r\\n for j in range(len(graph.edges.labels())):\\r\\n\\r\\n if graph.edges.start_times()[j] == i:\\r\\n tmp = graph.edges.labels()[j].split('-')\\r\\n edgeval = '{start time: ' + str(graph.edges.start_times()[j]) + ', end time: ' + str(\\r\\n graph.edges.end_times()[j]) + '}'\\r\\n tmpLinks.append(opts.GraphLink(source=tmp[0], target=tmp[1], value=edgeval))\\r\\n links.append(tmpLinks)\\r\\n\\r\\n # initialize categories list\\r\\n categories = [\\r\\n opts.GraphCategory(name='nodes with reachability more than {}'.format(h)),\\r\\n opts.GraphCategory(name='nodes with reachability less than or equal to {}'.format(h))\\r\\n ]\\r\\n\\r\\n tl = Timeline()\\r\\n for i in graph.edges.timespan():\\r\\n c = (\\r\\n Graph(init_opts=opts.InitOpts(width=width, height=height))\\r\\n .add(\\r\\n \\\"\\\",\\r\\n nodes=nodes,\\r\\n links=links[i - graph.edges.start_times()[0]],\\r\\n categories=categories,\\r\\n layout=layout,\\r\\n is_draggable=is_draggable,\\r\\n is_rotate_label=True,\\r\\n symbol_size=symbol_size,\\r\\n linestyle_opts=opts.LineStyleOpts(is_show=True, curve=0.1, color=\\\"source\\\", width=line_width),\\r\\n label_opts=opts.LabelOpts(position=\\\"right\\\"),\\r\\n edge_symbol=['circle', 'arrow'],\\r\\n edge_symbol_size=10\\r\\n )\\r\\n .set_global_opts(\\r\\n title_opts=opts.TitleOpts(title=title, subtitle=subtitle,\\r\\n title_textstyle_opts=opts.TextStyleOpts(font_size=40),\\r\\n subtitle_textstyle_opts=opts.TextStyleOpts(font_size=20)),\\r\\n legend_opts=opts.LegendOpts(orient=\\\"vertical\\\", pos_left=\\\"2%\\\", pos_top=\\\"20%\\\",\\r\\n textstyle_opts=opts.TextStyleOpts(font_size=20)),\\r\\n )\\r\\n )\\r\\n tl.add(c, \\\"{}\\\".format(i))\\r\\n\\r\\n # if render is True, generate an html file\\r\\n if render:\\r\\n page = Page(layout=pageLayout)\\r\\n page.add(tl)\\r\\n page.render(path)\\r\\n\\r\\n return c\",\n \"def render(self):\\n mode = self.check_mode()\\n if mode == MODE_DISPLAY_ALL:\\n self.display_all()\\n elif mode == MODE_DISPLAY_STATUS:\\n self.display_status()\\n else:\\n self.display_active_sensor()\",\n \"def student_view(self, context=None): # pylint: disable=unused-argument\\n html = self.resource_string(\\\"static/html/chartsxblock.html\\\")\\n frag = Fragment(html.format(self=self))\\n frag.add_css(self.resource_string(\\\"static/css/chartsxblock.css\\\"))\\n frag.add_javascript(self.resource_string(\\\"static/vendor/GCloader.js\\\"))\\n frag.add_javascript(self.resource_string(\\\"static/js/src/chartsxblock.js\\\"))\\n frag.initialize_js('ChartsXBlock', {'chartData': self.chart_data,\\n 'chartType': self.chart_type,\\n 'chartName': self.chart_name,\\n 'chartTypes': self.chart_types})\\n return frag\",\n \"def plot(self):\\n pass\",\n \"def draw_edges(self):\\n pass\",\n \"def _PlotGraph(self, event):\\n self._rcvLock.acquire()\\n for j in event.data[0].keys():\\n data = event.data[0][j]\\n #print data\\n line = []\\n for k in data.keys():\\n if k in COLORS.keys():\\n c = COLORS[k]\\n else:\\n c = 'black'\\n line.append(plot.PolyLine(data[k], colour=c, width=1,\\n legend=\\\"Node %d\\\"%(k,)))\\n # To draw markers: default colour = black, size = 2\\n # shapes = 'circle', 'cross', 'square', 'dot', 'plus'\\n #marker = plot.PolyMarker(event.data[1], marker='triangle')\\n\\n # set up text, axis and draw\\n if j == ERRORPLOT:\\n t = \\\"Synchronization Error\\\"\\n xa = \\\"Time [s]\\\"\\n ya = \\\"Error [ms]\\\"\\n elif j == TEMPPLOT:\\n t = \\\"Temperature Index\\\"\\n xa = \\\"Time [s]\\\"\\n ya = \\\"Index\\\"\\n elif j == SKEWPLOT:\\n t = \\\"Frequency Error\\\"\\n xa = \\\"Time [s]\\\"\\n ya = \\\"Frequency Error [ppm]\\\"\\n gc = plot.PlotGraphics(line, t, xa, ya)\\n # Draw graphs for each plot\\n self.plotter[j].Draw(gc, xAxis=(self._x_lower,\\n self._x_upper), yAxis=(float(self._y_lower[j]),\\n float(self._y_upper[j])))\\n self._rcvLock.release()\",\n \"def graph():\\n # Try to get params request\\n params = extract_variables(['start_time', 'end_time', 'sensor_id'], request)\\n # Fetch data from database\\n results = query_climate_range(**params)\\n\\n # Turn it in to lists which can be graphed\\n dates = []\\n humids = []\\n temps = []\\n pressures = []\\n for result in results:\\n dates.append(datetime.datetime.fromtimestamp(result['time']))\\n humids.append(result['humid'])\\n temps.append(result['temp'])\\n pressures.append(result['pressure'])\\n\\n # Graph it\\n fig = Figure()\\n # First y axis (temp and humid)\\n axis = fig.add_subplot(1, 1, 1)\\n # Plot humidity and temp on the same scale\\n axis.plot_date(dates, humids, '-', color=COLORS['blue'])\\n axis.plot_date(dates, temps, '-', color=COLORS['red'])\\n axis.xaxis.set_major_formatter(DateFormatter('%d/%m/%y %H:%M'))\\n axis.set_ylabel('Humidity in % & Temps in C')\\n axis.set_xlabel('Time')\\n # Second y axis (pressure)\\n axis_pressure = axis.twinx()\\n # Plot pressure\\n axis_pressure.plot_date(dates, pressures, '-', color=COLORS['green'])\\n axis_pressure.xaxis.set_major_formatter(DateFormatter('%d/%m/%y %H:%M'))\\n axis_pressure.set_ylabel('Pressure in mbar')\\n # Configure the figure\\n fig.autofmt_xdate()\\n fig.legend(['Humidity', 'Temperature', 'Pressure'], loc='lower right')\\n fig.set_tight_layout(True)\\n canvas = FigureCanvas(fig)\\n # Save output\\n png_output = BytesIO()\\n canvas.print_png(png_output)\\n\\n # Create the response and send it\\n response = make_response(png_output.getvalue())\\n response.headers['Content-Type'] = 'image/png'\\n return response\",\n \"def plot_graph(self) -> None:\\n\\n nodes_on_graph = self.dw_graph.get_all_v()\\n for k, v in nodes_on_graph.items():\\n if v.position is None:\\n x_rand = random.uniform(0.5, self.dw_graph.v_size())\\n y_rand = random.uniform(0.5, self.dw_graph.v_size())\\n v.position = (x_rand, y_rand)\\n x_vals = []\\n y_vals = []\\n n = list(nodes_on_graph.keys())\\n for k, v in nodes_on_graph.items(): # draw nodes\\n x_vals.append(v.position[0])\\n y_vals.append(v.position[1])\\n\\n fig, ax = plt.subplots()\\n plt.plot(x_vals, y_vals, 'ro', markersize=5, data=\\\"d\\\")\\n\\n for p, txt in enumerate(n):\\n ax.annotate(n[p], (x_vals[p]+0.00003, y_vals[p]), color='g')\\n\\n for n in nodes_on_graph:\\n n1 = self.dw_graph.get_nodes(n)\\n x = n1.position[0]\\n y = n1.position[1]\\n for r in self.dw_graph.all_out_edges_of_node(n):\\n dx = self.dw_graph.get_nodes(r).position[0]\\n dy = self.dw_graph.get_nodes(r).position[1]\\n ax.quiver(x, y, dx-x, dy-y, angles='xy', scale_units='xy', scale=1)\\n #plt.arrow(x, y, dx - x, dy - y, head_width=0.0009, width=0.00005, length_includes_head=True)\\n\\n\\n plt.xlabel(\\\"x axis \\\")\\n plt.ylabel(\\\"y axis \\\")\\n plt.title(\\\"The title of the graph\\\")\\n plt.show()\",\n \"def showGraph(self, file_name = \\\"\\\"):\\n \\n # prepare edges and weights for visualization\\n edges = self.graph.edges()\\n weights = [self.graph_data[u]['pheromones'][v] for u,v in edges]\\n weights_sum = sum(weights)\\n weights = [ (w/weights_sum)*50 for w in weights]\\n \\n # prepare different shades of red to be used to optionally differentiate\\n # between edges with different costs\\n # to show more informatiion on the same graph\\n colors = []\\n max_cost = max([self.graph_data[u]['costs'][v] for u,v in edges])\\n for u,v in edges:\\n if self.graph_data[u]['costs'][v] <= max_cost/32:\\n colors.append('#ff7f7f')\\n continue\\n if self.graph_data[u]['costs'][v] <= max_cost/16:\\n colors.append('#ff6666')\\n continue\\n if self.graph_data[u]['costs'][v] <= max_cost/8:\\n colors.append('#ff4c4c')\\n continue\\n if self.graph_data[u]['costs'][v] <= max_cost/4:\\n colors.append('#ff3232')\\n continue\\n if self.graph_data[u]['costs'][v] <= max_cost/2:\\n colors.append('#ff1919')\\n continue\\n if self.graph_data[u]['costs'][v] <= max_cost:\\n colors.append('#ff0000')\\n continue\\n \\n # print the graph \\n pos=nx.circular_layout(self.graph)\\n nx.draw( self.graph,pos=pos,node_size=200,node_color='#A8A8A8', with_labels=True,edges=edges, edge_color=colors,edge_cmap=plt.cm.Blues, width=weights)\\n if file_name != \\\"\\\":\\n path = \\\"img/\\\"+file_name\\n plt.savefig(path, format=\\\"PNG\\\")\\n plt.show()\",\n \"def adapter_content_plot (self):\\n if 'adapter_content' not in self.fastqc_data or len(self.fastqc_data['adapter_content']) == 0:\\n log.debug('adapter_content not found in FastQC reports')\\n return None\\n \\n pconfig = {\\n 'id': 'fastqc_adapter_content_plot',\\n 'title': 'Adapter Content',\\n 'ylab': '% of Sequences',\\n 'xlab': 'Position',\\n 'yCeiling': 100,\\n 'yMinRange': 5,\\n 'ymin': 0,\\n 'xDecimals': False,\\n 'tt_label': '<b>Base {point.x}</b>: {point.y:.2f}%',\\n 'hide_empty': True,\\n 'yPlotBands': [\\n {'from': 20, 'to': 100, 'color': '#e6c3c3'},\\n {'from': 5, 'to': 20, 'color': '#e6dcc3'},\\n {'from': 0, 'to': 5, 'color': '#c3e6c3'},\\n ],\\n }\\n # Note - colours are messy as we've added adapter names here. Not\\n # possible to break down pass / warn / fail for each adapter, which\\n # could lead to misleading labelling (fails on adapter types with\\n # little or no contamination)\\n \\n self.sections.append({\\n 'name': 'Adapter Content',\\n 'anchor': 'fastqc_adapter_content',\\n 'content': '<p>The cumulative percentage count of the proportion of your library which has seen each of the adapter sequences at each position. ' +\\n 'See the <a href=\\\"http://www.bioinformatics.babraham.ac.uk/projects/fastqc/Help/3%20Analysis%20Modules/10%20Adapter%20Content.html\\\" target=\\\"_bkank\\\">FastQC help</a>.</p>' +\\n self.plot_xy_data(self.fastqc_data['adapter_content'], pconfig)\\n })\",\n \"def render(self):\\n content = self._render_pre_content('li')\\n if self._icon is None:\\n content += \\\"<div>\\\" + self._title + \\\"</div>\\\"\\n else:\\n content += \\\"<div><span id='\\\" + (self._name + \\\"_icon\\\")\\\\\\n + \\\"' class='ui-icon \\\" + self._icon + \\\"'></span>\\\"\\\\\\n + self._title + \\\"</div>\\\"\\n content += self._render_post_content('li')\\n self._widget_content = content + \\\"\\\\n\\\" + self._attach_polling()\\n return self._widget_content\",\n \"def render(self):\\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\\n print(''.join(map[i] for i in self.grid[0:3]))\\n print(''.join(map[i] for i in self.grid[3:6]))\\n print(''.join(map[i] for i in self.grid[6:9]))\\n print('====')\",\n \"def render(self):\\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\\n print(''.join(map[i] for i in self.grid[0:3]))\\n print(''.join(map[i] for i in self.grid[3:6]))\\n print(''.join(map[i] for i in self.grid[6:9]))\\n print('====')\",\n \"def draw(self):\\n g = self.to_networkx()\\n pos = nx.spring_layout(g)\\n nx.draw_networkx_edges(g, pos,\\n edge_color=EDGE_COLOR,\\n width=EDGE_WIDTH)\\n obj = nx.draw_networkx_nodes(g, pos, nodelist=self.vs.values(),\\n node_size=NODE_SIZE,\\n node_color=NODE_COLOR_NORMAL)\\n obj.set_linewidth(NODE_BORDER_WIDTH)\\n obj.set_edgecolor(NODE_BORDER_COLOR)\\n nx.draw_networkx_nodes(g, pos, nodelist=self.fs,\\n node_size=FACTOR_NODE_SIZE,\\n node_color=FACTOR_NODE_COLOR,\\n node_shape=FACTOR_NODE_SHAPE)\\n nx.draw_networkx_labels(g, pos, {v: v.name\\n for v in self.vs.values()},\\n font_color=LABEL_COLOR)\",\n \"def display(self):\\n options = {\\\"ent_only_plot\\\": True,\\n \\\"rel_only_plot\\\": not self.config.plot_entity_only,\\n \\\"ent_and_rel_plot\\\": not self.config.plot_entity_only}\\n\\n if self.config.plot_embedding:\\n viz = Visualization(model=self.model, vis_opts = options)\\n\\n viz.plot_embedding(resultpath=self.config.figures, algos=self.model.model_name, show_label=False)\\n\\n if self.config.plot_training_result:\\n viz = Visualization(model=self.model)\\n viz.plot_train_result()\\n\\n if self.config.plot_testing_result:\\n viz = Visualization(model=self.model)\\n viz.plot_test_result()\",\n \"def drawLayout(self):\\r\\n self.drawBorder()\\r\\n self.drawAxes()\\r\\n self.drawLabels()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7299308","0.71782285","0.68271524","0.6663665","0.664291","0.6620926","0.6457115","0.6414615","0.6356832","0.6356767","0.63431394","0.63144624","0.6310719","0.6260441","0.6242107","0.6227696","0.6209762","0.6199873","0.6185111","0.61758035","0.61743957","0.61538535","0.61371624","0.6129639","0.61221933","0.606532","0.6037196","0.6015912","0.60127","0.6012332","0.6002034","0.5979728","0.5967805","0.5964279","0.5963674","0.5962178","0.5953249","0.59367585","0.5924327","0.5911534","0.5907033","0.5889036","0.5854805","0.5842699","0.58234394","0.58220184","0.58154917","0.5815104","0.57994294","0.57994294","0.57994294","0.57994294","0.57994294","0.57994294","0.57832456","0.57829565","0.57804805","0.5777896","0.5777896","0.57758665","0.57712597","0.5764858","0.5761563","0.5761291","0.576064","0.57601774","0.5758383","0.57509995","0.5732888","0.5728674","0.5724715","0.57220054","0.57158697","0.5705458","0.57020605","0.56989026","0.5693534","0.56627357","0.5659952","0.5637641","0.5630891","0.5629763","0.5629284","0.5625406","0.56222916","0.5614237","0.561266","0.5612338","0.5610412","0.55971444","0.5582797","0.5578078","0.55752164","0.55709106","0.55705893","0.5569418","0.5569418","0.55686975","0.55684245","0.55677414"],"string":"[\n \"0.7299308\",\n \"0.71782285\",\n \"0.68271524\",\n \"0.6663665\",\n \"0.664291\",\n \"0.6620926\",\n \"0.6457115\",\n \"0.6414615\",\n \"0.6356832\",\n \"0.6356767\",\n \"0.63431394\",\n \"0.63144624\",\n \"0.6310719\",\n \"0.6260441\",\n \"0.6242107\",\n \"0.6227696\",\n \"0.6209762\",\n \"0.6199873\",\n \"0.6185111\",\n \"0.61758035\",\n \"0.61743957\",\n \"0.61538535\",\n \"0.61371624\",\n \"0.6129639\",\n \"0.61221933\",\n \"0.606532\",\n \"0.6037196\",\n \"0.6015912\",\n \"0.60127\",\n \"0.6012332\",\n \"0.6002034\",\n \"0.5979728\",\n \"0.5967805\",\n \"0.5964279\",\n \"0.5963674\",\n \"0.5962178\",\n \"0.5953249\",\n \"0.59367585\",\n \"0.5924327\",\n \"0.5911534\",\n \"0.5907033\",\n \"0.5889036\",\n \"0.5854805\",\n \"0.5842699\",\n \"0.58234394\",\n \"0.58220184\",\n \"0.58154917\",\n \"0.5815104\",\n \"0.57994294\",\n \"0.57994294\",\n \"0.57994294\",\n \"0.57994294\",\n \"0.57994294\",\n \"0.57994294\",\n \"0.57832456\",\n \"0.57829565\",\n \"0.57804805\",\n \"0.5777896\",\n \"0.5777896\",\n \"0.57758665\",\n \"0.57712597\",\n \"0.5764858\",\n \"0.5761563\",\n \"0.5761291\",\n \"0.576064\",\n \"0.57601774\",\n \"0.5758383\",\n \"0.57509995\",\n \"0.5732888\",\n \"0.5728674\",\n \"0.5724715\",\n \"0.57220054\",\n \"0.57158697\",\n \"0.5705458\",\n \"0.57020605\",\n \"0.56989026\",\n \"0.5693534\",\n \"0.56627357\",\n \"0.5659952\",\n \"0.5637641\",\n \"0.5630891\",\n \"0.5629763\",\n \"0.5629284\",\n \"0.5625406\",\n \"0.56222916\",\n \"0.5614237\",\n \"0.561266\",\n \"0.5612338\",\n \"0.5610412\",\n \"0.55971444\",\n \"0.5582797\",\n \"0.5578078\",\n \"0.55752164\",\n \"0.55709106\",\n \"0.55705893\",\n \"0.5569418\",\n \"0.5569418\",\n \"0.55686975\",\n \"0.55684245\",\n \"0.55677414\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6722177"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":74289,"cells":{"query":{"kind":"string","value":"something has gone wrong that causes the page not to render correctly return some xml to respond to this"},"document":{"kind":"string","value":"def get_bad_container(self):\n return XMLFile(\n FilePath(\"TrackerDash/snippets/no_dash_data_container.xml\"))"},"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 xml():\n try:\n return Response(render_template(\n 'lti.xml.j2'), mimetype='application/xml'\n )\n except:\n app.logger.error(\"Error with XML.\")\n return return_error('''Error with XML. Please refresh and try again. If this error persists,\n please contact support.''')","def xml(self, request):\n raise Exception(\"Not Implemented\")","def bad_request(e):\n return render_template(\"400.html\", page_title=400)","def renderHTTP_exception(request, failure):","def page_not_found(er): \n return render_template('errors.html'), 400","def _error_response(self):\r\n response_dict = {'success': False, 'version': 1}\r\n self.send_response(\r\n 400, content=json.dumps(response_dict),\r\n headers={'Content-type': 'application/json'}\r\n )","def page_not_found(e):\n return render_template(\"500.html\"), 500","def page_not_found(er):\n return render_template('errors.html'), 500","def xml():\n response = make_response(render_template(\"sample.xml\"))\n response.headers[\"Content-Type\"] = \"application/xml\"\n return response","def fourohfour(error):\n response = make_response('<?xml version=\"1.0\"?>\\n<updates>\\n</updates>')\n response.mimetype = 'text/xml'\n return response","def page_not_found(error):\n return '<h1> 404 - Not Found</h1>', 404","def send404(start_response):\n start_response('404 Not Found', [('Content-type',\n 'text/html; charset=utf-8')])\n return [RDFServer.render_html(YZ_NOT_FOUND_TITLE,\n YZ_NOT_FOUND_PAGE).encode('utf-8')]","def error(self, request):\n if self.debug:\n import cgitb\n request.stdout.write('Content-Type: text/html\\r\\n\\r\\n' +\n cgitb.html(sys.exc_info()))\n else:\n errorpage = \"\"\"<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n<title>Unhandled Exception</title>\n</head><body>\n<h1>Unhandled Exception</h1>\n<p>An unhandled exception was thrown by the application.</p>\n</body></html>\n\"\"\"\n request.stdout.write('Content-Type: text/html\\r\\n\\r\\n' +\n errorpage)","def handle_error(request, response, template):\n response.write(\n loader.render_to_string(\n template,\n None,\n RequestContext(\n request,\n dict = {\"blogs\": Blog.objects.select_related(),\n \"tags\": Tag.used_tags(),\n \"archive_qualifier\": \"\",\n \"recent_active_months\": Blog.recent_active_months()}\n )\n )\n )\n return response","def epg_xml() -> Response:\n xml = render_template('epg.xml',\n stations=locast_service.get_stations(),\n url_base=host_and_port)\n return Response(xml, mimetype='text/xml')","def page_error(e):\n\n return render_template('404.html')","def internal_error(e):\n return render_template(\"errors/500.html\"), 500","def test_incomplete_xml(self):\n self.__opener.contents = '<Report></Report>>'\n self.assertEqual(-1, self.__uft.failed_tests('url'))","def response(self):\r\n error = unicode(self)\r\n return HttpResponseBadRequest(json.dumps({'error': error}))","def renderHTTP(self, ctx):\n return 'Keep trying. You are almost there.'","def page_not_found(e):\n return render_template(\"404.html\"), 404","def render_GET(self, request):\n return etree.tostring(self.xml(request), pretty_print=True)","def respond(caller, value):\n\ttemplate_values = {'value': value,}\n\ttemplate_path = os.path.join(TEMPLATE_FOLDER, 'response.xml') #TODO: more details on what actually happened? error into own xml tag?\n\n\tcaller.response.out.write(template.render(template_path, template_values))","def page_not_found(er):\n return render_template('errors.html'), 404","def main_response(self, data):","def main_response(self, data):","def error404(e) -> tuple:\n return render_template('404.html'), 404","def page_not_found(e):\n return render_template('404.html'), 404","def page_not_found(e):\n return render_template('404.html'), 404","def replicate_no_data_error():\r\n for i in range(10):\r\n content = ust.get_web_xml(2002)\r\n print(content[:100])\r\n if not content.startswith(\"<?xml\"):\r\n ust.save_local_xml(\"error\", content)","def server_error(request):\n response = render(request, '500.html')\n response.status_code = 500\n\n return response","def error_page(e):\n \n return render_template('error-page.html'), 404","def page_not_found(e):\n\treturn 'Sorry, No Valid Game There.', 404","def Write404Error(self):\n self.error(404)\n self.response.out.write(\n ''.join(['<html><head><title>404: Not Found</title></head>',\n '<body><b><h2>Error 404</h2><br/>',\n 'File not found</b></body></html>']))","def Write404Error(self):\n self.error(404)\n self.response.out.write(\n ''.join(['<html><head><title>404: Not Found</title></head>',\n '<body><b><h2>Error 404</h2><br/>',\n 'File not found</b></body></html>']))","def output_xml(data,code,headers=None):\r\n resp = make_response(dumps({'response': data}), code)\r\n resp.headers.extend(headers or {})\r\n return resp","def page_not_found(e):\n\n return render_template('404.html'), 404","def _check_status(self, status, res):\n try:\n super()._check_status(status, res)\n except AppError as exc:\n escaped_page_name = res.request.path_qs[1:].replace('/', '')\n dump_file_path = \"/tmp/debug_%d_%s.html\" % (time.time() * 1000, escaped_page_name)\n if os.path.exists(\"/tmp\"):\n with open(dump_file_path, 'w') as dump_file:\n print(res.ubody, file=dump_file)\n # Update exception message with info about this dumped file\n exc.args = ('%s html error file dump in %s' % (exc.args[0], dump_file_path), ) + exc.args[1:]\n raise exc","def is_good_enough_xml(self, resp):\n content_type = resp.headers['Content-Type'].lower()\n \n return (resp.status_code == 200 \n and content_type is not None \n and content_type.find('xml') > -1)","def bad_request(error):\r\n\treturn render_template('error_template.html' , title = \"Aaaah ...\", \r\n\t\t\t\t\t\t\t\t\t\t\t\t\tmessage = \"나는 이해하지 못한다.\",\r\n \t\t\t\t\t\t\t\t\t\t\t\tsubline = \"Yeah, the server couldn't understand what you asked for, probably because you didn't give a choice of download.\", \r\n \t\t\t\t\t\t\t\t\t\t\t\timage_location = url_for('static', filename = 'images/simpson-gangam.jpg')), 400","def error():\n return render_template(\"404.html\")","def bad_request(request):\n return Response(render_template('core/bad_request.html'),\n status=400, mimetype='text/html')","def not_implemented(self):\n response.status = 501\n return {'message':'server was not able to complete this request'}","def send400(start_response, message=YZ_INVALID_QUERY):\n start_response('400 Bad Request', [('Content-type',\n 'text/html; charset=utf-8')])\n return [RDFServer.render_html(YZ_BAD_REQUEST, message).encode('utf-8')]","def handle_failure_request(self) -> HttpResponse:\n return HttpResponseNotFound()","def not_found(e):\n return render_template(\"errors/404.html\"), 404","def finish_failed_request(self):\n # build new response to be safe\n request = get_request()\n original_response = request.response\n request.response = HTTPResponse()\n #self.log(\"caught an error (%s), reporting it.\" %\n # sys.exc_info()[1])\n\n (exc_type, exc_value, tb) = sys.exc_info()\n error_summary = traceback.format_exception_only(exc_type, exc_value)\n error_summary = error_summary[0][0:-1] # de-listify and strip newline\n\n plain_error_msg = self._generate_plaintext_error(request,\n original_response,\n exc_type, exc_value,\n tb)\n\n if not self.config.display_exceptions:\n # DISPLAY_EXCEPTIONS is false, so return the most\n # secure (and cryptic) page.\n request.response.set_header(\"Content-Type\", \"text/html\")\n user_error_msg = self._generate_internal_error(request)\n elif self.config.display_exceptions == 'html':\n # Generate a spiffy HTML display using cgitb\n request.response.set_header(\"Content-Type\", \"text/html\")\n user_error_msg = self._generate_cgitb_error(request,\n original_response,\n exc_type, exc_value,\n tb)\n else:\n # Generate a plaintext page containing the traceback\n request.response.set_header(\"Content-Type\", \"text/plain\")\n user_error_msg = plain_error_msg\n\n self.logger.log_internal_error(error_summary, plain_error_msg)\n request.response.set_status(500)\n self.session_manager.finish_failed_request()\n return user_error_msg","def xml(self):\n strg = \"<Exception>\\n\"\n strg += \"<Object>\\n\"\n strg += \"%s\\n\" % self.name\n strg += \"</Object>\\n\"\n strg += \"<Message>\\n\"\n strg += self._message\n strg += \"</Message>\\n\"\n strg += \"<DataItems>\\n\"\n for key, value in viewitems(self.data):\n strg += \"<DataItem>\\n\"\n strg += \"<Key>\\n\"\n strg += str(key)\n strg += \"</Key>\\n\"\n strg += \"<Value>\\n\"\n strg += str(value)\n strg += \"</Value>\\n\"\n strg += \"</DataItem>\\n\"\n strg += \"</DataItems>\\n\"\n strg += \"</Exception>\\n\"\n logging.error(strg)\n return strg","def page_not_found(e):\n return 'Þessi vefslóð er ekki rétt', 404","def page_not_found(e):\n\n # Respons to api request\n if request.accept_mimetypes.accept_json and \\\n not request.accept_mimetypes.accept_html:\n resp = jsonify({'error': 'not found'})\n resp.status_code = 404\n return resp\n\n return render_template('errors/404.html'), 404","def gremlin(request):\n raise Exception(\"This endpoint is throwing a 500 error!\")","def wrapper(self, *args, **kwd):\n try:\n retval = function(self, *args, **kwd)\n except (ValueError, AttributeError), log:\n LOG('SlapTool', INFO, 'Converting ValueError to NotFound, real error:',\n error=True)\n raise NotFound(log)\n except SoftwareInstanceNotReady, log:\n self.REQUEST.response.setStatus(408)\n self.REQUEST.response.setHeader('Cache-Control', 'private')\n return self.REQUEST.response\n except ValidationFailed:\n LOG('SlapTool', INFO, 'Converting ValidationFailed to ValidationFailed,'\\\n ' real error:',\n error=True)\n raise ValidationFailed\n except Unauthorized:\n LOG('SlapTool', INFO, 'Converting Unauthorized to Unauthorized,'\\\n ' real error:',\n error=True)\n raise Unauthorized\n\n self.REQUEST.response.setHeader('Content-Type', 'text/xml; charset=utf-8')\n return '%s' % retval","def make_request_xml(self):\n #print (self.url)\n try:\n with closing(get(self.url, stream=True)) as resp: #returns b`xml`\n if self.is_good_enough_xml(resp):\n return resp.content\n else:\n return None\n except RequestException as e:\n print('Error during requests to {0} : {1}'.format(url, str(e)))\n return None","def default(self, *args, **kwargs):\n Page = startHTML + \"I don't know where you're trying to go, so have a 404 Error.\"\n cherrypy.response.status = 404\n return Page","def page_not_found(e):\n return \"Hey Bozo. You don't belong here -- scramo.\", 403","def server_error(e):\n return render_template('500.html'), 500","def getDefaultResponse():\n return \"\"\"<HTML>\n <BODY>\n Default updater response\n </BODY>\n</HTML>\"\"\"","def page_not_found(e):\n return render_template('404.html')","def page_not_found(e):\n return render_template(\"error/404.html\"), 404","def internal_server_error(e):\n return render_template(\"error/500.html\"), 500","def page_not_found(e):\n return jsonify({\"error\": \"page not found\"})","def _err_response(msg):\r\n return HttpResponse(json.dumps({'success': False, 'error': msg}),\r\n mimetype=\"application/json\")","def set_response(self):\r\n import cherrypy\r\n \r\n response = cherrypy.response\r\n \r\n clean_headers(self.status)\r\n \r\n # In all cases, finalize will be called after this method,\r\n # so don't bother cleaning up response values here.\r\n response.status = self.status\r\n tb = None\r\n if cherrypy.request.show_tracebacks:\r\n tb = format_exc()\r\n response.headers['Content-Type'] = \"text/html\"\r\n \r\n content = self.get_error_page(self.status, traceback=tb,\r\n message=self._message)\r\n response.body = content\r\n response.headers['Content-Length'] = len(content)\r\n \r\n _be_ie_unfriendly(self.status)","def test():\n r = Response(response=\"This worked!\", status=200,\n mimetype=\"application/xml\")\n r.headers[\"Content-Type\"] = \"text/xml; charset=utf-8\"\n return r","def check_response(self, xml_str, xml_name):\n\n if \"<ok/>\" not in xml_str:\n self.module.fail_json(msg='Error: %s failed.' % xml_name)","def error(request, text=_(u'Sorry, your request is mot available')):\n extra_context = {'message': text}\n template = 'dynamicLink/not_avallible.html'\n return render_to_response(template, extra_context, context_instance=RequestContext(request))","def create_500_response() -> bytes:\n content_data = HttpServer.get_content_data(\"/internal_server_error.html\")\n date = datetime.datetime.now(datetime.timezone.utc).strftime(\"%a, %d %b %Y %H:%M:%S GMT\")\n\n header = \"HTTP/1.1 500 Internal Server Error\" + \"\\r\\nDate: \" + date + \"\\r\\n\" + content_data + \"\\r\\n\\r\\n\"\n raw_header = header.encode(HttpServer.FORMAT)\n print(header)\n raw_body = HttpServer.create_body(\"/internal_server_error.html\")\n response = raw_header + raw_body\n\n return response","def post_traceback(self, req):\n debug_info = req.debug_info\n long_xml_er = formatter.format_xml(debug_info.exc_data, \n show_hidden_frames=True, show_extra_data=False, \n libraries=self.libraries)[0]\n host = req.GET['host']\n headers = req.headers\n conn = httplib.HTTPConnection(host)\n headers = {'Content-Length':len(long_xml_er), \n 'Content-Type':'application/xml'}\n conn.request(\"POST\", req.GET['path'], long_xml_er, headers=headers)\n resp = conn.getresponse()\n res = Response()\n for header, value in resp.getheaders():\n if header.lower() in ['server', 'date']: continue\n res.headers[header] = value\n res.body = resp.read()\n return res","def test_error_html_using_get(self):\n pass","def key_error_page(e):\n return render_template(\"index.html\", error=e), 500","def report_404(self):\n self.send_response(404)\n response = 'No such page'\n self.send_header(\"Content-type\", \"text/plain\")\n self.send_header(\"Content-length\", str(len(response)))\n self.end_headers()\n self.wfile.write(response)","def _err_response(self, msg):\r\n return {'success': False, 'error': msg}","def page_not_found():\n return render_template(\"errors/404.html\"), 404","def server_fault(e):\n return \"Something went wrong, and it is our fault. Try reloading the page.\"","def internal_server_error(e):\n return render_template('500.html', error=repr(e)), 500","def err500():\n return render_template('404.html', year=datetime.now().year)","def xml(self):\n raise NotImplementedError('This api does not return xml')","def _page_not_found():\n return render_template(\n \"error.html\",\n title=\"Page Not Found\"\n ), 404","def sww_view(request):\n from django.http import HttpResponse\n return HttpResponse(\"<h1>Something Went Wrong...</h1>\")","def error_404(self):\n response = self.render_template('404.html')\n response.status_code = 404\n return response","def internal_server_error(e):\n\n # Respons to api request\n if request.accept_mimetypes.accept_json and \\\n not request.accept_mimetypes.accept_html:\n resp = jsonify({'error': 'internal server error'})\n resp.status_code = 500\n return resp\n\n return render_template('errors/500.html'), 500","def err_xml(message, type='Sender', code='ValidationError'):\n return \"\"\"\\\n<ErrorResponse xmlns=\"http://elasticmapreduce.amazonaws.com/doc/2009-03-31\">\n <Error>\n <Type>%s</Type>\n <Code>%s</Code>\n <Message>%s</Message>\n </Error>\n <RequestId>eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee</RequestId>\n</ErrorResponse>\"\"\" % (type, code, message)","def err404():\n return render_template('404.html', year=datetime.now().year)","def default_response(self,response_msg='A pretty minimal response'):\n resp = []\n resp.append(\"Content-Type: text/plain\")\n resp.append(\"\")\n resp.append(response_msg)\n res_str = \"\\r\\n\".join(resp)\n return res_str","def get_error_response():\n response = HTTPResponse.HTTPResponse(version=1.0, status_code=500,\n phrase=\"Internal Error\")\n headers = HTTPHeaders.HTTPHeaders()\n add_default_headers(headers)\n headers[\"Content-Length\"] = str(0)\n headers[\"Connection\"] = \"close\"\n response.set_headers(headers)\n\n return response.build_response()","def device_xml() -> Response:\n xml = render_template('device.xml',\n device_model=config.device_model,\n device_version=config.device_version,\n friendly_name=locast_service.city,\n uid=uid,\n host_and_port=host_and_port)\n return Response(xml, mimetype='text/xml')","def render(self):\n _ = self.request.getText\n form = self.request.form\n \n if form.has_key('cancel'):\n # User canceled\n return self.page.send_page(self.request)\n\n try:\n if not self.allowed():\n raise ActionError(_('You are not allowed to edit this page.'))\n elif not self.page.exists():\n raise ActionError(_('This page is already deleted or was never created!'))\n \n self.package()\n except ActionError, e:\n return self.page.send_page(self.request, msg=e.args[0])","def application_error(e):\n return render_template('500.html', error=e), 500","def bad_request(start_response):\n\n output = []\n output_len = sum(len(line) for line in output)\n start_response('400 Bad Request',\n [('Content-type', 'text/html'),\n ('Content-Length', str(output_len))])\n \n return output","def _handle_error(cls, e, request):\r\n if e.check(InvalidRequest):\r\n msg = e.getErrorMessage()\r\n code = httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0]\r\n else:\r\n e.printTraceback()\r\n msg = 'Fatal Error'\r\n code = httpstatus.HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR[0]\r\n\r\n cls._render(request, code, 'text/plain; charset=utf-8', msg)","def render_mainpageerror(errormsg) -> 'html':\n return render_template('mainpage.html',\n title='Word association',\n analyse=errormsg)","def view_500(request, url = None):\n res = render_to_response(\"500.html\", context_instance=RequestContext(request))\n res.status_code = 500\n return res","def _process_not_ok_response(content, status):\n if status == codes.bad:\n length = len(content)\n err_msg = (content if length > 0 else str(status))\n raise NoSQLException('Error response: ' + err_msg)\n raise NoSQLException('Error response = ' + str(status))","def _build_response(cls, addr, version, request):\r\n msg = {'url' : 'ws://{0}/'.format(addr)}\r\n\r\n if version < CURRENT_VERSION:\r\n msg['current'] = CURRENT_VERSION\r\n elif version > CURRENT_VERSION:\r\n # Should never happen; is already handled in render_GET\r\n raise ValueError\r\n\r\n cls._render(request, httpstatus.HTTP_STATUS_CODE_OK[0],\r\n 'application/json; charset=utf-8', json.dumps(msg))","def error_invalid_response(self):\r\n return self.type() == 0x00","def jsonable_server_error(request, template_name='500.html'):\r\n if request.is_ajax():\r\n msg = {\"error\": \"The edX servers encountered an error\"}\r\n return HttpResponseServerError(json.dumps(msg))\r\n else:\r\n return server_error(request, template_name=template_name)","def xmlrpc_response(data):\n xml = xmlrpc_marshal(data)\n response = webob.Response(xml)\n response.content_type = 'text/xml'\n response.content_length = len(xml)\n return response","def _processGETErr(self, e, request):\r\n if e.check(InvalidRequest):\r\n msg = e.getErrorMessage()\r\n code = httplib.BAD_REQUEST\r\n elif e.check(UnauthorizedLogin):\r\n msg = e.getErrorMessage()\r\n code = httplib.UNAUTHORIZED\r\n elif e.check(InternalError):\r\n e.printTraceback()\r\n msg = 'Internal Error'\r\n code = httplib.INTERNAL_SERVER_ERROR\r\n else:\r\n e.printTraceback()\r\n msg = 'Fatal Error'\r\n code = httplib.INTERNAL_SERVER_ERROR\r\n\r\n self._render_GET(request, code, 'text/plain; charset=utf-8', msg)","def nondefault_500_error(request, template_name='500nondefault.html'):\n t = loader.get_template(template_name) # You need to create a 500.html template.\n ltype,lvalue,ltraceback = sys.exc_info()\n sys.exc_clear() #for fun, and to point out I only -think- this hasn't happened at \n #this point in the process already\n return http.HttpResponseServerError(t.render(Context({'type':ltype,'value':lvalue,'traceback':ltraceback})))","def page_not_found(e):\n return render_template(\"404.html\", page_title=404)","def HTMLResponse():\n\n\thtml = \t\"<html><head><title>MA MAURO ESISTE?</title><style type='text/css'>body{width:30%}</style></head><body><pre>\"\n\thtml += \" _ __<br>\"\n\thtml += \" (_) / /<br>\"\n\thtml += \" ______ __ ____ ____ / /____<br>\"\n\thtml += \" / ___/ / _ \\\\/ _ \\\\/ / _ \\\\<br>\"\n\thtml += \" / / / / /_) / /_) / / ____/<br>\"\n\thtml += \"/__/ /__/ .___/ .___/__/ \\\\_____/<br>\"\n\thtml += \" / / / /<br>\"\n\thtml += \" /__/ /__/<br>\"\n\thtml += \"<b>PYTHON > ALL VERSION</b><br><br>\"\n\thtml += \"<marquee style='white-space:pre;'><br>\"\n\thtml += \" .. o .<br>\"\n\thtml += \" o.o o . o<br>\"\n\thtml += \" oo...<br>\"\n\thtml += \" __[]__<br>\"\n\thtml += \" phwr--> _\\\\:D/_/o_o_o_|__ <span style=\\\"font-family: 'Comic Sans MS'; font-size: 8pt;\\\">u wot m8</span><br>\"\n\thtml += \" \\\\\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"/<br>\"\n\thtml += \" \\\\ . .. .. . /<br>\"\n\thtml += \"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^<br>\"\n\thtml += \"</marquee><br><strike>reverse engineering a protocol impossible to reverse engineer since always</strike><br>we are actually reverse engineering bancho successfully. for the third time.</pre></body></html>\"\n\treturn html"],"string":"[\n \"def xml():\\n try:\\n return Response(render_template(\\n 'lti.xml.j2'), mimetype='application/xml'\\n )\\n except:\\n app.logger.error(\\\"Error with XML.\\\")\\n return return_error('''Error with XML. Please refresh and try again. If this error persists,\\n please contact support.''')\",\n \"def xml(self, request):\\n raise Exception(\\\"Not Implemented\\\")\",\n \"def bad_request(e):\\n return render_template(\\\"400.html\\\", page_title=400)\",\n \"def renderHTTP_exception(request, failure):\",\n \"def page_not_found(er): \\n return render_template('errors.html'), 400\",\n \"def _error_response(self):\\r\\n response_dict = {'success': False, 'version': 1}\\r\\n self.send_response(\\r\\n 400, content=json.dumps(response_dict),\\r\\n headers={'Content-type': 'application/json'}\\r\\n )\",\n \"def page_not_found(e):\\n return render_template(\\\"500.html\\\"), 500\",\n \"def page_not_found(er):\\n return render_template('errors.html'), 500\",\n \"def xml():\\n response = make_response(render_template(\\\"sample.xml\\\"))\\n response.headers[\\\"Content-Type\\\"] = \\\"application/xml\\\"\\n return response\",\n \"def fourohfour(error):\\n response = make_response('<?xml version=\\\"1.0\\\"?>\\\\n<updates>\\\\n</updates>')\\n response.mimetype = 'text/xml'\\n return response\",\n \"def page_not_found(error):\\n return '<h1> 404 - Not Found</h1>', 404\",\n \"def send404(start_response):\\n start_response('404 Not Found', [('Content-type',\\n 'text/html; charset=utf-8')])\\n return [RDFServer.render_html(YZ_NOT_FOUND_TITLE,\\n YZ_NOT_FOUND_PAGE).encode('utf-8')]\",\n \"def error(self, request):\\n if self.debug:\\n import cgitb\\n request.stdout.write('Content-Type: text/html\\\\r\\\\n\\\\r\\\\n' +\\n cgitb.html(sys.exc_info()))\\n else:\\n errorpage = \\\"\\\"\\\"<!DOCTYPE HTML PUBLIC \\\"-//IETF//DTD HTML 2.0//EN\\\">\\n<html><head>\\n<title>Unhandled Exception</title>\\n</head><body>\\n<h1>Unhandled Exception</h1>\\n<p>An unhandled exception was thrown by the application.</p>\\n</body></html>\\n\\\"\\\"\\\"\\n request.stdout.write('Content-Type: text/html\\\\r\\\\n\\\\r\\\\n' +\\n errorpage)\",\n \"def handle_error(request, response, template):\\n response.write(\\n loader.render_to_string(\\n template,\\n None,\\n RequestContext(\\n request,\\n dict = {\\\"blogs\\\": Blog.objects.select_related(),\\n \\\"tags\\\": Tag.used_tags(),\\n \\\"archive_qualifier\\\": \\\"\\\",\\n \\\"recent_active_months\\\": Blog.recent_active_months()}\\n )\\n )\\n )\\n return response\",\n \"def epg_xml() -> Response:\\n xml = render_template('epg.xml',\\n stations=locast_service.get_stations(),\\n url_base=host_and_port)\\n return Response(xml, mimetype='text/xml')\",\n \"def page_error(e):\\n\\n return render_template('404.html')\",\n \"def internal_error(e):\\n return render_template(\\\"errors/500.html\\\"), 500\",\n \"def test_incomplete_xml(self):\\n self.__opener.contents = '<Report></Report>>'\\n self.assertEqual(-1, self.__uft.failed_tests('url'))\",\n \"def response(self):\\r\\n error = unicode(self)\\r\\n return HttpResponseBadRequest(json.dumps({'error': error}))\",\n \"def renderHTTP(self, ctx):\\n return 'Keep trying. You are almost there.'\",\n \"def page_not_found(e):\\n return render_template(\\\"404.html\\\"), 404\",\n \"def render_GET(self, request):\\n return etree.tostring(self.xml(request), pretty_print=True)\",\n \"def respond(caller, value):\\n\\ttemplate_values = {'value': value,}\\n\\ttemplate_path = os.path.join(TEMPLATE_FOLDER, 'response.xml') #TODO: more details on what actually happened? error into own xml tag?\\n\\n\\tcaller.response.out.write(template.render(template_path, template_values))\",\n \"def page_not_found(er):\\n return render_template('errors.html'), 404\",\n \"def main_response(self, data):\",\n \"def main_response(self, data):\",\n \"def error404(e) -> tuple:\\n return render_template('404.html'), 404\",\n \"def page_not_found(e):\\n return render_template('404.html'), 404\",\n \"def page_not_found(e):\\n return render_template('404.html'), 404\",\n \"def replicate_no_data_error():\\r\\n for i in range(10):\\r\\n content = ust.get_web_xml(2002)\\r\\n print(content[:100])\\r\\n if not content.startswith(\\\"<?xml\\\"):\\r\\n ust.save_local_xml(\\\"error\\\", content)\",\n \"def server_error(request):\\n response = render(request, '500.html')\\n response.status_code = 500\\n\\n return response\",\n \"def error_page(e):\\n \\n return render_template('error-page.html'), 404\",\n \"def page_not_found(e):\\n\\treturn 'Sorry, No Valid Game There.', 404\",\n \"def Write404Error(self):\\n self.error(404)\\n self.response.out.write(\\n ''.join(['<html><head><title>404: Not Found</title></head>',\\n '<body><b><h2>Error 404</h2><br/>',\\n 'File not found</b></body></html>']))\",\n \"def Write404Error(self):\\n self.error(404)\\n self.response.out.write(\\n ''.join(['<html><head><title>404: Not Found</title></head>',\\n '<body><b><h2>Error 404</h2><br/>',\\n 'File not found</b></body></html>']))\",\n \"def output_xml(data,code,headers=None):\\r\\n resp = make_response(dumps({'response': data}), code)\\r\\n resp.headers.extend(headers or {})\\r\\n return resp\",\n \"def page_not_found(e):\\n\\n return render_template('404.html'), 404\",\n \"def _check_status(self, status, res):\\n try:\\n super()._check_status(status, res)\\n except AppError as exc:\\n escaped_page_name = res.request.path_qs[1:].replace('/', '')\\n dump_file_path = \\\"/tmp/debug_%d_%s.html\\\" % (time.time() * 1000, escaped_page_name)\\n if os.path.exists(\\\"/tmp\\\"):\\n with open(dump_file_path, 'w') as dump_file:\\n print(res.ubody, file=dump_file)\\n # Update exception message with info about this dumped file\\n exc.args = ('%s html error file dump in %s' % (exc.args[0], dump_file_path), ) + exc.args[1:]\\n raise exc\",\n \"def is_good_enough_xml(self, resp):\\n content_type = resp.headers['Content-Type'].lower()\\n \\n return (resp.status_code == 200 \\n and content_type is not None \\n and content_type.find('xml') > -1)\",\n \"def bad_request(error):\\r\\n\\treturn render_template('error_template.html' , title = \\\"Aaaah ...\\\", \\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tmessage = \\\"나는 이해하지 못한다.\\\",\\r\\n \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tsubline = \\\"Yeah, the server couldn't understand what you asked for, probably because you didn't give a choice of download.\\\", \\r\\n \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\timage_location = url_for('static', filename = 'images/simpson-gangam.jpg')), 400\",\n \"def error():\\n return render_template(\\\"404.html\\\")\",\n \"def bad_request(request):\\n return Response(render_template('core/bad_request.html'),\\n status=400, mimetype='text/html')\",\n \"def not_implemented(self):\\n response.status = 501\\n return {'message':'server was not able to complete this request'}\",\n \"def send400(start_response, message=YZ_INVALID_QUERY):\\n start_response('400 Bad Request', [('Content-type',\\n 'text/html; charset=utf-8')])\\n return [RDFServer.render_html(YZ_BAD_REQUEST, message).encode('utf-8')]\",\n \"def handle_failure_request(self) -> HttpResponse:\\n return HttpResponseNotFound()\",\n \"def not_found(e):\\n return render_template(\\\"errors/404.html\\\"), 404\",\n \"def finish_failed_request(self):\\n # build new response to be safe\\n request = get_request()\\n original_response = request.response\\n request.response = HTTPResponse()\\n #self.log(\\\"caught an error (%s), reporting it.\\\" %\\n # sys.exc_info()[1])\\n\\n (exc_type, exc_value, tb) = sys.exc_info()\\n error_summary = traceback.format_exception_only(exc_type, exc_value)\\n error_summary = error_summary[0][0:-1] # de-listify and strip newline\\n\\n plain_error_msg = self._generate_plaintext_error(request,\\n original_response,\\n exc_type, exc_value,\\n tb)\\n\\n if not self.config.display_exceptions:\\n # DISPLAY_EXCEPTIONS is false, so return the most\\n # secure (and cryptic) page.\\n request.response.set_header(\\\"Content-Type\\\", \\\"text/html\\\")\\n user_error_msg = self._generate_internal_error(request)\\n elif self.config.display_exceptions == 'html':\\n # Generate a spiffy HTML display using cgitb\\n request.response.set_header(\\\"Content-Type\\\", \\\"text/html\\\")\\n user_error_msg = self._generate_cgitb_error(request,\\n original_response,\\n exc_type, exc_value,\\n tb)\\n else:\\n # Generate a plaintext page containing the traceback\\n request.response.set_header(\\\"Content-Type\\\", \\\"text/plain\\\")\\n user_error_msg = plain_error_msg\\n\\n self.logger.log_internal_error(error_summary, plain_error_msg)\\n request.response.set_status(500)\\n self.session_manager.finish_failed_request()\\n return user_error_msg\",\n \"def xml(self):\\n strg = \\\"<Exception>\\\\n\\\"\\n strg += \\\"<Object>\\\\n\\\"\\n strg += \\\"%s\\\\n\\\" % self.name\\n strg += \\\"</Object>\\\\n\\\"\\n strg += \\\"<Message>\\\\n\\\"\\n strg += self._message\\n strg += \\\"</Message>\\\\n\\\"\\n strg += \\\"<DataItems>\\\\n\\\"\\n for key, value in viewitems(self.data):\\n strg += \\\"<DataItem>\\\\n\\\"\\n strg += \\\"<Key>\\\\n\\\"\\n strg += str(key)\\n strg += \\\"</Key>\\\\n\\\"\\n strg += \\\"<Value>\\\\n\\\"\\n strg += str(value)\\n strg += \\\"</Value>\\\\n\\\"\\n strg += \\\"</DataItem>\\\\n\\\"\\n strg += \\\"</DataItems>\\\\n\\\"\\n strg += \\\"</Exception>\\\\n\\\"\\n logging.error(strg)\\n return strg\",\n \"def page_not_found(e):\\n return 'Þessi vefslóð er ekki rétt', 404\",\n \"def page_not_found(e):\\n\\n # Respons to api request\\n if request.accept_mimetypes.accept_json and \\\\\\n not request.accept_mimetypes.accept_html:\\n resp = jsonify({'error': 'not found'})\\n resp.status_code = 404\\n return resp\\n\\n return render_template('errors/404.html'), 404\",\n \"def gremlin(request):\\n raise Exception(\\\"This endpoint is throwing a 500 error!\\\")\",\n \"def wrapper(self, *args, **kwd):\\n try:\\n retval = function(self, *args, **kwd)\\n except (ValueError, AttributeError), log:\\n LOG('SlapTool', INFO, 'Converting ValueError to NotFound, real error:',\\n error=True)\\n raise NotFound(log)\\n except SoftwareInstanceNotReady, log:\\n self.REQUEST.response.setStatus(408)\\n self.REQUEST.response.setHeader('Cache-Control', 'private')\\n return self.REQUEST.response\\n except ValidationFailed:\\n LOG('SlapTool', INFO, 'Converting ValidationFailed to ValidationFailed,'\\\\\\n ' real error:',\\n error=True)\\n raise ValidationFailed\\n except Unauthorized:\\n LOG('SlapTool', INFO, 'Converting Unauthorized to Unauthorized,'\\\\\\n ' real error:',\\n error=True)\\n raise Unauthorized\\n\\n self.REQUEST.response.setHeader('Content-Type', 'text/xml; charset=utf-8')\\n return '%s' % retval\",\n \"def make_request_xml(self):\\n #print (self.url)\\n try:\\n with closing(get(self.url, stream=True)) as resp: #returns b`xml`\\n if self.is_good_enough_xml(resp):\\n return resp.content\\n else:\\n return None\\n except RequestException as e:\\n print('Error during requests to {0} : {1}'.format(url, str(e)))\\n return None\",\n \"def default(self, *args, **kwargs):\\n Page = startHTML + \\\"I don't know where you're trying to go, so have a 404 Error.\\\"\\n cherrypy.response.status = 404\\n return Page\",\n \"def page_not_found(e):\\n return \\\"Hey Bozo. You don't belong here -- scramo.\\\", 403\",\n \"def server_error(e):\\n return render_template('500.html'), 500\",\n \"def getDefaultResponse():\\n return \\\"\\\"\\\"<HTML>\\n <BODY>\\n Default updater response\\n </BODY>\\n</HTML>\\\"\\\"\\\"\",\n \"def page_not_found(e):\\n return render_template('404.html')\",\n \"def page_not_found(e):\\n return render_template(\\\"error/404.html\\\"), 404\",\n \"def internal_server_error(e):\\n return render_template(\\\"error/500.html\\\"), 500\",\n \"def page_not_found(e):\\n return jsonify({\\\"error\\\": \\\"page not found\\\"})\",\n \"def _err_response(msg):\\r\\n return HttpResponse(json.dumps({'success': False, 'error': msg}),\\r\\n mimetype=\\\"application/json\\\")\",\n \"def set_response(self):\\r\\n import cherrypy\\r\\n \\r\\n response = cherrypy.response\\r\\n \\r\\n clean_headers(self.status)\\r\\n \\r\\n # In all cases, finalize will be called after this method,\\r\\n # so don't bother cleaning up response values here.\\r\\n response.status = self.status\\r\\n tb = None\\r\\n if cherrypy.request.show_tracebacks:\\r\\n tb = format_exc()\\r\\n response.headers['Content-Type'] = \\\"text/html\\\"\\r\\n \\r\\n content = self.get_error_page(self.status, traceback=tb,\\r\\n message=self._message)\\r\\n response.body = content\\r\\n response.headers['Content-Length'] = len(content)\\r\\n \\r\\n _be_ie_unfriendly(self.status)\",\n \"def test():\\n r = Response(response=\\\"This worked!\\\", status=200,\\n mimetype=\\\"application/xml\\\")\\n r.headers[\\\"Content-Type\\\"] = \\\"text/xml; charset=utf-8\\\"\\n return r\",\n \"def check_response(self, xml_str, xml_name):\\n\\n if \\\"<ok/>\\\" not in xml_str:\\n self.module.fail_json(msg='Error: %s failed.' % xml_name)\",\n \"def error(request, text=_(u'Sorry, your request is mot available')):\\n extra_context = {'message': text}\\n template = 'dynamicLink/not_avallible.html'\\n return render_to_response(template, extra_context, context_instance=RequestContext(request))\",\n \"def create_500_response() -> bytes:\\n content_data = HttpServer.get_content_data(\\\"/internal_server_error.html\\\")\\n date = datetime.datetime.now(datetime.timezone.utc).strftime(\\\"%a, %d %b %Y %H:%M:%S GMT\\\")\\n\\n header = \\\"HTTP/1.1 500 Internal Server Error\\\" + \\\"\\\\r\\\\nDate: \\\" + date + \\\"\\\\r\\\\n\\\" + content_data + \\\"\\\\r\\\\n\\\\r\\\\n\\\"\\n raw_header = header.encode(HttpServer.FORMAT)\\n print(header)\\n raw_body = HttpServer.create_body(\\\"/internal_server_error.html\\\")\\n response = raw_header + raw_body\\n\\n return response\",\n \"def post_traceback(self, req):\\n debug_info = req.debug_info\\n long_xml_er = formatter.format_xml(debug_info.exc_data, \\n show_hidden_frames=True, show_extra_data=False, \\n libraries=self.libraries)[0]\\n host = req.GET['host']\\n headers = req.headers\\n conn = httplib.HTTPConnection(host)\\n headers = {'Content-Length':len(long_xml_er), \\n 'Content-Type':'application/xml'}\\n conn.request(\\\"POST\\\", req.GET['path'], long_xml_er, headers=headers)\\n resp = conn.getresponse()\\n res = Response()\\n for header, value in resp.getheaders():\\n if header.lower() in ['server', 'date']: continue\\n res.headers[header] = value\\n res.body = resp.read()\\n return res\",\n \"def test_error_html_using_get(self):\\n pass\",\n \"def key_error_page(e):\\n return render_template(\\\"index.html\\\", error=e), 500\",\n \"def report_404(self):\\n self.send_response(404)\\n response = 'No such page'\\n self.send_header(\\\"Content-type\\\", \\\"text/plain\\\")\\n self.send_header(\\\"Content-length\\\", str(len(response)))\\n self.end_headers()\\n self.wfile.write(response)\",\n \"def _err_response(self, msg):\\r\\n return {'success': False, 'error': msg}\",\n \"def page_not_found():\\n return render_template(\\\"errors/404.html\\\"), 404\",\n \"def server_fault(e):\\n return \\\"Something went wrong, and it is our fault. Try reloading the page.\\\"\",\n \"def internal_server_error(e):\\n return render_template('500.html', error=repr(e)), 500\",\n \"def err500():\\n return render_template('404.html', year=datetime.now().year)\",\n \"def xml(self):\\n raise NotImplementedError('This api does not return xml')\",\n \"def _page_not_found():\\n return render_template(\\n \\\"error.html\\\",\\n title=\\\"Page Not Found\\\"\\n ), 404\",\n \"def sww_view(request):\\n from django.http import HttpResponse\\n return HttpResponse(\\\"<h1>Something Went Wrong...</h1>\\\")\",\n \"def error_404(self):\\n response = self.render_template('404.html')\\n response.status_code = 404\\n return response\",\n \"def internal_server_error(e):\\n\\n # Respons to api request\\n if request.accept_mimetypes.accept_json and \\\\\\n not request.accept_mimetypes.accept_html:\\n resp = jsonify({'error': 'internal server error'})\\n resp.status_code = 500\\n return resp\\n\\n return render_template('errors/500.html'), 500\",\n \"def err_xml(message, type='Sender', code='ValidationError'):\\n return \\\"\\\"\\\"\\\\\\n<ErrorResponse xmlns=\\\"http://elasticmapreduce.amazonaws.com/doc/2009-03-31\\\">\\n <Error>\\n <Type>%s</Type>\\n <Code>%s</Code>\\n <Message>%s</Message>\\n </Error>\\n <RequestId>eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee</RequestId>\\n</ErrorResponse>\\\"\\\"\\\" % (type, code, message)\",\n \"def err404():\\n return render_template('404.html', year=datetime.now().year)\",\n \"def default_response(self,response_msg='A pretty minimal response'):\\n resp = []\\n resp.append(\\\"Content-Type: text/plain\\\")\\n resp.append(\\\"\\\")\\n resp.append(response_msg)\\n res_str = \\\"\\\\r\\\\n\\\".join(resp)\\n return res_str\",\n \"def get_error_response():\\n response = HTTPResponse.HTTPResponse(version=1.0, status_code=500,\\n phrase=\\\"Internal Error\\\")\\n headers = HTTPHeaders.HTTPHeaders()\\n add_default_headers(headers)\\n headers[\\\"Content-Length\\\"] = str(0)\\n headers[\\\"Connection\\\"] = \\\"close\\\"\\n response.set_headers(headers)\\n\\n return response.build_response()\",\n \"def device_xml() -> Response:\\n xml = render_template('device.xml',\\n device_model=config.device_model,\\n device_version=config.device_version,\\n friendly_name=locast_service.city,\\n uid=uid,\\n host_and_port=host_and_port)\\n return Response(xml, mimetype='text/xml')\",\n \"def render(self):\\n _ = self.request.getText\\n form = self.request.form\\n \\n if form.has_key('cancel'):\\n # User canceled\\n return self.page.send_page(self.request)\\n\\n try:\\n if not self.allowed():\\n raise ActionError(_('You are not allowed to edit this page.'))\\n elif not self.page.exists():\\n raise ActionError(_('This page is already deleted or was never created!'))\\n \\n self.package()\\n except ActionError, e:\\n return self.page.send_page(self.request, msg=e.args[0])\",\n \"def application_error(e):\\n return render_template('500.html', error=e), 500\",\n \"def bad_request(start_response):\\n\\n output = []\\n output_len = sum(len(line) for line in output)\\n start_response('400 Bad Request',\\n [('Content-type', 'text/html'),\\n ('Content-Length', str(output_len))])\\n \\n return output\",\n \"def _handle_error(cls, e, request):\\r\\n if e.check(InvalidRequest):\\r\\n msg = e.getErrorMessage()\\r\\n code = httpstatus.HTTP_STATUS_CODE_BAD_REQUEST[0]\\r\\n else:\\r\\n e.printTraceback()\\r\\n msg = 'Fatal Error'\\r\\n code = httpstatus.HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR[0]\\r\\n\\r\\n cls._render(request, code, 'text/plain; charset=utf-8', msg)\",\n \"def render_mainpageerror(errormsg) -> 'html':\\n return render_template('mainpage.html',\\n title='Word association',\\n analyse=errormsg)\",\n \"def view_500(request, url = None):\\n res = render_to_response(\\\"500.html\\\", context_instance=RequestContext(request))\\n res.status_code = 500\\n return res\",\n \"def _process_not_ok_response(content, status):\\n if status == codes.bad:\\n length = len(content)\\n err_msg = (content if length > 0 else str(status))\\n raise NoSQLException('Error response: ' + err_msg)\\n raise NoSQLException('Error response = ' + str(status))\",\n \"def _build_response(cls, addr, version, request):\\r\\n msg = {'url' : 'ws://{0}/'.format(addr)}\\r\\n\\r\\n if version < CURRENT_VERSION:\\r\\n msg['current'] = CURRENT_VERSION\\r\\n elif version > CURRENT_VERSION:\\r\\n # Should never happen; is already handled in render_GET\\r\\n raise ValueError\\r\\n\\r\\n cls._render(request, httpstatus.HTTP_STATUS_CODE_OK[0],\\r\\n 'application/json; charset=utf-8', json.dumps(msg))\",\n \"def error_invalid_response(self):\\r\\n return self.type() == 0x00\",\n \"def jsonable_server_error(request, template_name='500.html'):\\r\\n if request.is_ajax():\\r\\n msg = {\\\"error\\\": \\\"The edX servers encountered an error\\\"}\\r\\n return HttpResponseServerError(json.dumps(msg))\\r\\n else:\\r\\n return server_error(request, template_name=template_name)\",\n \"def xmlrpc_response(data):\\n xml = xmlrpc_marshal(data)\\n response = webob.Response(xml)\\n response.content_type = 'text/xml'\\n response.content_length = len(xml)\\n return response\",\n \"def _processGETErr(self, e, request):\\r\\n if e.check(InvalidRequest):\\r\\n msg = e.getErrorMessage()\\r\\n code = httplib.BAD_REQUEST\\r\\n elif e.check(UnauthorizedLogin):\\r\\n msg = e.getErrorMessage()\\r\\n code = httplib.UNAUTHORIZED\\r\\n elif e.check(InternalError):\\r\\n e.printTraceback()\\r\\n msg = 'Internal Error'\\r\\n code = httplib.INTERNAL_SERVER_ERROR\\r\\n else:\\r\\n e.printTraceback()\\r\\n msg = 'Fatal Error'\\r\\n code = httplib.INTERNAL_SERVER_ERROR\\r\\n\\r\\n self._render_GET(request, code, 'text/plain; charset=utf-8', msg)\",\n \"def nondefault_500_error(request, template_name='500nondefault.html'):\\n t = loader.get_template(template_name) # You need to create a 500.html template.\\n ltype,lvalue,ltraceback = sys.exc_info()\\n sys.exc_clear() #for fun, and to point out I only -think- this hasn't happened at \\n #this point in the process already\\n return http.HttpResponseServerError(t.render(Context({'type':ltype,'value':lvalue,'traceback':ltraceback})))\",\n \"def page_not_found(e):\\n return render_template(\\\"404.html\\\", page_title=404)\",\n \"def HTMLResponse():\\n\\n\\thtml = \\t\\\"<html><head><title>MA MAURO ESISTE?</title><style type='text/css'>body{width:30%}</style></head><body><pre>\\\"\\n\\thtml += \\\" _ __<br>\\\"\\n\\thtml += \\\" (_) / /<br>\\\"\\n\\thtml += \\\" ______ __ ____ ____ / /____<br>\\\"\\n\\thtml += \\\" / ___/ / _ \\\\\\\\/ _ \\\\\\\\/ / _ \\\\\\\\<br>\\\"\\n\\thtml += \\\" / / / / /_) / /_) / / ____/<br>\\\"\\n\\thtml += \\\"/__/ /__/ .___/ .___/__/ \\\\\\\\_____/<br>\\\"\\n\\thtml += \\\" / / / /<br>\\\"\\n\\thtml += \\\" /__/ /__/<br>\\\"\\n\\thtml += \\\"<b>PYTHON > ALL VERSION</b><br><br>\\\"\\n\\thtml += \\\"<marquee style='white-space:pre;'><br>\\\"\\n\\thtml += \\\" .. o .<br>\\\"\\n\\thtml += \\\" o.o o . o<br>\\\"\\n\\thtml += \\\" oo...<br>\\\"\\n\\thtml += \\\" __[]__<br>\\\"\\n\\thtml += \\\" phwr--> _\\\\\\\\:D/_/o_o_o_|__ <span style=\\\\\\\"font-family: 'Comic Sans MS'; font-size: 8pt;\\\\\\\">u wot m8</span><br>\\\"\\n\\thtml += \\\" \\\\\\\\\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"/<br>\\\"\\n\\thtml += \\\" \\\\\\\\ . .. .. . /<br>\\\"\\n\\thtml += \\\"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^<br>\\\"\\n\\thtml += \\\"</marquee><br><strike>reverse engineering a protocol impossible to reverse engineer since always</strike><br>we are actually reverse engineering bancho successfully. for the third time.</pre></body></html>\\\"\\n\\treturn html\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6696877","0.6493592","0.6273593","0.6260683","0.6117754","0.60652006","0.60274285","0.60092545","0.5996741","0.59941775","0.58831203","0.5871651","0.58566284","0.58541214","0.57838386","0.5783325","0.576661","0.57623935","0.5737121","0.5731637","0.57185394","0.5698145","0.56930643","0.5674114","0.5670812","0.5670812","0.5664557","0.56596106","0.56596106","0.5656139","0.5652059","0.5647842","0.56444967","0.56422687","0.56422687","0.56397974","0.5630728","0.5630219","0.56264895","0.561989","0.56187","0.56152475","0.5613077","0.56113625","0.5605056","0.56047076","0.56010824","0.5600979","0.55975795","0.5591107","0.55868435","0.5576873","0.55759037","0.5574738","0.55736816","0.5568028","0.5566559","0.5560268","0.555878","0.5557516","0.55446625","0.55443674","0.5543697","0.55416816","0.5540562","0.5534693","0.5531993","0.55288196","0.55168337","0.5512572","0.55068696","0.5505542","0.5504867","0.54933465","0.5469067","0.5460091","0.54558605","0.5452642","0.54523873","0.5438725","0.54378283","0.5434198","0.5432371","0.5421626","0.5419412","0.54180485","0.54112583","0.5410597","0.541007","0.54093957","0.54043293","0.53977364","0.5391879","0.5387681","0.53766847","0.5365503","0.5364727","0.5363997","0.5362531","0.53612614","0.53548115"],"string":"[\n \"0.6696877\",\n \"0.6493592\",\n \"0.6273593\",\n \"0.6260683\",\n \"0.6117754\",\n \"0.60652006\",\n \"0.60274285\",\n \"0.60092545\",\n \"0.5996741\",\n \"0.59941775\",\n \"0.58831203\",\n \"0.5871651\",\n \"0.58566284\",\n \"0.58541214\",\n \"0.57838386\",\n \"0.5783325\",\n \"0.576661\",\n \"0.57623935\",\n \"0.5737121\",\n \"0.5731637\",\n \"0.57185394\",\n \"0.5698145\",\n \"0.56930643\",\n \"0.5674114\",\n \"0.5670812\",\n \"0.5670812\",\n \"0.5664557\",\n \"0.56596106\",\n \"0.56596106\",\n \"0.5656139\",\n \"0.5652059\",\n \"0.5647842\",\n \"0.56444967\",\n \"0.56422687\",\n \"0.56422687\",\n \"0.56397974\",\n \"0.5630728\",\n \"0.5630219\",\n \"0.56264895\",\n \"0.561989\",\n \"0.56187\",\n \"0.56152475\",\n \"0.5613077\",\n \"0.56113625\",\n \"0.5605056\",\n \"0.56047076\",\n \"0.56010824\",\n \"0.5600979\",\n \"0.55975795\",\n \"0.5591107\",\n \"0.55868435\",\n \"0.5576873\",\n \"0.55759037\",\n \"0.5574738\",\n \"0.55736816\",\n \"0.5568028\",\n \"0.5566559\",\n \"0.5560268\",\n \"0.555878\",\n \"0.5557516\",\n \"0.55446625\",\n \"0.55443674\",\n \"0.5543697\",\n \"0.55416816\",\n \"0.5540562\",\n \"0.5534693\",\n \"0.5531993\",\n \"0.55288196\",\n \"0.55168337\",\n \"0.5512572\",\n \"0.55068696\",\n \"0.5505542\",\n \"0.5504867\",\n \"0.54933465\",\n \"0.5469067\",\n \"0.5460091\",\n \"0.54558605\",\n \"0.5452642\",\n \"0.54523873\",\n \"0.5438725\",\n \"0.54378283\",\n \"0.5434198\",\n \"0.5432371\",\n \"0.5421626\",\n \"0.5419412\",\n \"0.54180485\",\n \"0.54112583\",\n \"0.5410597\",\n \"0.541007\",\n \"0.54093957\",\n \"0.54043293\",\n \"0.53977364\",\n \"0.5391879\",\n \"0.5387681\",\n \"0.53766847\",\n \"0.5365503\",\n \"0.5364727\",\n \"0.5363997\",\n \"0.5362531\",\n \"0.53612614\",\n \"0.53548115\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":74290,"cells":{"query":{"kind":"string","value":"get the showreel item url array"},"document":{"kind":"string","value":"def get_showreel_item_urls(self):\n\n links = []\n rel_path = \"../\"\n if self.display:\n rel_path = rel_path * 2\n for item in self.showreel_document[\"reels\"]:\n if item[\"item_type\"] == 'dashboard':\n link = \"../%sdisplay/dashboard/%s\" % (rel_path, item[\"title\"])\n links.append(json.dumps(link))\n elif item[\"item_type\"] == 'graph':\n link = \"../%sdisplay/graph/%s\" % (rel_path, item[\"title\"])\n links.append(json.dumps(link))\n\n return links"},"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 getURLs():","def url(self):\n return url_for_item(self.key)","def url(self):\n return url_for_item(self.key)","def url(self, index):\r\n return self.arraydata[index.row()][3]","def get_item_url(self, item):\n return self.get_absolute_url(item, 'detail')","def get_url(self, item):\n config = {}\n uuid = self.data.get('uuid', None)\n obj = uuidToObject(uuid)\n if uuid and obj:\n config = copy.copy(self.get_config(obj))\n\n url = u'{0}{1}'.format(self.view_url(obj), item.id.value)\n if config.get('modify_url', True):\n url = u'{0}___{1}-{2}'.format(\n url,\n item.title.value,\n item.location.value,\n )\n return url","def get_urls():\r\n return []","def url(result):\n return result.entities.get(u'urls')","def get_item_url(self):\n try:\n return self.content_object.get_absolute_url()\n except AttributeError:\n return self.external_url","def getLink(self):","def urls(self) -> list[str]:\r\n ...","def urls(self) -> str:\n return self._data['urls']","def get_urls(self, data):\n data = json.loads(data)\n urls = []\n for article in data['articles']:\n urls.append(article['url'])\n return urls","def url(self):\n return self.data[\"attributes\"][\"URL\"]","def get_phones_url(self) -> list:\n urls = []\n\n for page_number in range(self.number_of_pages):\n url = f\"https://www.ebay.com/b/{self.__brand}-Cell-Phones-Smartphones/9355/bn_{self.brand_id}?LH_ItemCondition={self.condition_code}&LH_PrefLoc=5&LH_Sold=1&rt=nc&_pgn={page_number}\"\n page = requests.get(url, headers={\"User-Agent\": self.user_agent.google})\n soup = BeautifulSoup(page.content, \"html.parser\")\n\n urls.extend([links.get('href', np.nan) for links in soup.find_all('a', class_=\"s-item__link\")])\n \n return urls","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 getNewsIconURL(newsBrain):","def show_orion_url(self, obj):\n return obj.orion_url","def Url(self) -> str:","def get_absolute_url(self):\n return ('listar_parroquia', [self.id, ])","def get_urls(self, **kwargs):\n pass # pragma: no cover","def _parse_sources(self, item):\n return [{'url': item['url']}]","def url(self):\n return self.full()","def getExpandedLinks():","def getUrl(self): #$NON-NLS-1$\r","def getUrl(self): #$NON-NLS-1$\r","def get_links(self):\r\n return self.links","def uri(self) -> list:\n raise NotImplementedError(\"ErddapArgoDataFetcher.uri not implemented\")","def url(self):\r\n return self.urlparts.geturl()","def url(self):\n return url_search_posts(self.parameters, url_domain=self.url_domain)","def url(self):\n ...","def get_urls(db):\n return db.meta.find_one({'name':\"urls\"})['urls']","def get_shelflist_urls():\n def _get_shelflist_urls(records):\n locations = set([r['location_code'] for r in records])\n return { loc: ('{}locations/{}/shelflistitems/'.format(API_ROOT, loc)) \n for loc in locations }\n return _get_shelflist_urls","def get_product_urls(self, page):\n return self.__url_list(page)","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 get_urls(self):\n urls = []\n params = ['<{}>'.format(x) for x in self.args]\n args_length = len(self.args) - len(self.defaults)\n for i in range(len(self.defaults) + 1):\n index = -i if i > args_length else None\n urls.append(self.get_url(params[:index]))\n return urls","def get_urls(self):\n urls = super(EasyPublisher, self).get_urls()\n admin_site = self.admin_site\n opts = self.model._meta\n info = opts.app_label, opts.module_name,\n \n easy_publisher_urls = patterns(\"\",\n url(r\"^([^/]+)/drafts/$\", admin_site.admin_view(self.drafts_view), name='%s_%s_draftlist' % info),\n url(r\"^([^/]+)/drafts/([^/]+)/\", admin_site.admin_view(self.publish_view), name='%s_%s_draft' % info),\n url(r\"^(.+)/current/$\", admin_site.admin_view(self.change_view), {'extra_context':{'current':True}}, name='%s_%s_current' % info)\n )\n\n return easy_publisher_urls + urls","def barbican_url(self):","def links(self):\n\t\treturn self.list_of_links","def URLs(self, default=[{}]):\n tmp = self.data.get('urls', default)\n return [HEP.URLObject(i) for i in tmp]","def url(self):\n return reverse('snippet-list')","def get_item_url(self, soup: BeautifulSoup) -> Optional[str]:\n try:\n url = f\"https://www.airbnb.com{soup.find('a').get('href')}\"\n except AttributeError:\n url = None\n self.__collected_dic[\"url\"].append(url)\n return url","def getUrl(self):\n\n return self.toUrlForm()","def uri(self):\n if not self.parallel:\n return [self.get_url()]\n else:\n self.Chunker = Chunker(\n {\"box\": self.BOX}, chunks=self.chunks, chunksize=self.chunks_maxsize\n )\n boxes = self.Chunker.fit_transform()\n urls = []\n for box in boxes:\n urls.append(Fetch_box(box=box, ds=self.dataset_id).get_url())\n return urls","def get_urls():\n return (constants.UNREVIEWED.col_values(3) +\n constants.REVIEWED.col_values(3) +\n constants.LAST.col_values(3))","def thumbnails_urls(request):\n return {'thumbnails_urls': ThumbnailsUrls()}","def getVotacion(self, url):","def _get_url(self, absolute):","def get_absolute_url(self):\n return reverse('brand-detail', args=[str(self.id)]) #View on Site (front-end)","def get_thumbnail_url():","def _parse_links(self, item) -> list:\n # TODO This would be a \"nice to have\" but is not necessary right now.\n return [{\"href\": \"\", \"title\": \"\"}]","def url(self):\n return self.__values['url']","def get_url(url_index: str) -> list:\n url = get_url_category(url_index)\n return url","def url(self):\n _, body = self.request('/v1.1/url', 'GET')\n return body.get('url', None)","def getUrl(self):\n return self.__get('url')","def URLs(self, default=[{}]):\n tmp = self.data.get('metadata', {}).get('urls', default)\n return [HEP.URLObject(i) for i in tmp]","def __get_url(self, conf):\n url_file = conf[self.conf_item.get_url_list_file()]\n url_list = list()\n map((lambda url: url_list.append(url.strip())), open(url_file))\n return url_list","def links(self) -> str:\n return pulumi.get(self, \"links\")","def result_urls(self, job_id: str, show_progress: bool = False) -> List:\n data = self.result_json(job_id, show_progress)\n urls = [x['href'] for x in data.get('links', []) if x['rel'] == 'data']\n return urls","def get_links(self):\n return self.__data['links']","def url(self):\n\n if not hasattr(self, \"_url\"):\n query = db.Query(\"query_term u\", \"u.value\")\n query.join(\"query_term t\", \"t.doc_id = u.doc_id\")\n query.where(f\"u.path = '{self.URL_PATH}'\")\n query.where(f\"t.path = '{self.TERM_PATH}'\")\n query.where(query.Condition(\"t.int_val\", self.id))\n rows = query.execute(self.loader.cdr_cursor).fetchall()\n self._url = rows[0].value if rows else \"\"\n return self._url","def get_url(self):\n return self.url","def get_url(self):\n return self.url","def get_url(self):\n return self.resource.url","def get_links(self):\n msg = self.get_message()\n return msg.split()","def get_info_url(self):\n return self.get_info(\"URL\")","def getLinks(tvshow, season, episode):\n numPage = 1\n possible_links = []\n doNext = True\n while(doNext):\n urltv = getTvShowUrl(tvshow, season, episode, numPage)\n src_urltv = getPage(urltv)\n if (src_urltv == -1):\n return possible_links\n npage = False\n for line in src_urltv:\n if (\"next_page\" in line):\n npage = True\n if (\"disabled next_page\" in line):\n doNext = False\n for nameModule in sidereel_mod.__all__:\n realName = sidereel_mod.__all2__[nameModule]\n if ((realName in line) and ('data-viewable-url') in line):\n possible_links.append([line.split('\"')[5], \\\n \"sidereel_mod.\" + nameModule])\n numPage += 1\n if (npage == False):\n doNext = False\n return possible_links\n \n \n \n\n ## liste=[]\n ## for i in sidereel_mod.__all__:\n ## __import__(\"aggregators.sidereel_mod.\" + i)\n ## liste += sys.modules[\"aggregators.sidereel_mod.\"+i].getFlv(a)\n ## return liste","def links(self):\n links = {}\n data = self.data['links']\n for key in data:\n links[key] = data[key]['url']\n return links","def get_image_url():","def get_links(self) -> List[str]:\n return self.__links","def get_top_grossing_movie_links(url):\n pass","def inshorts_urls():\n\n url1 = 'https://inshorts.com/en/read/business'\n url2 = 'https://inshorts.com/en/read/sports'\n url3 = 'https://inshorts.com/en/read/technology'\n url4 = 'https://inshorts.com/en/read/entertainment'\n return [url1, url2, url3, url4]","def get_absolute_url(self):\n return reverse('product-detail', args=[str(self.id_produto)])","def make_node_urls(self, node_data):\n node_display = node_data['display_url']\n if node_data['__typename'] == 'GraphVideo':\n return ['video', node_display, node_data['video_url']]\n\n return ['image', node_display, node_display]","def getURLForThing(thing):","def get_absolute_url(self):\n return reverse(\"cars:rental_list\")","def geturl(self):\n return self.__url","def urls(self):\n return lambda : self.config.urls(active_only=True)","def url(self):\n url = self.url\n return url","def _links_get(self, cr, uid, context=None):\n obj = self.pool.get('res.request.link')\n ids = obj.search(cr, uid, [])\n res = obj.read(cr, uid, ids, ['object', 'name'], context)\n return [(r['object'], r['name']) for r in res]","def puxa_link(soup):\n link = []\n for item in soup.select('.listing-item__title'):\n link.append(item.a.get('href'))\n return link","def get_image_links(data):\n painting_links = []\n\n print(data)\n\n for painting in data:\n painting_links.append(painting['image'])\n\n return painting_links","def get_link(self, list_item):\n link = list_item.find('a', {'class': 'biz-name'})\n return self.base_url + link.get('href')","def listingURLs(soup):\n\n #Get URLs\n itemListing = soup.find_all(class_=\"user-ad-row link link--base-color-inherit link--hover-color-none link--no-underline\")\n itemListing += soup.find_all(class_=\"user-ad-row user-ad-row--featured-or-premium link link--base-color-inherit link--hover-color-none link--no-underline\")\n itemListing += soup.find_all(class_=\"user-ad-row user-ad-row--premium user-ad-row--featured-or-premium link link--base-color-inherit link--hover-color-none link--no-underline\")\n #Create list\n urlList = [i['href'] for i in itemListing]\n return urlList","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 getUrl(self):\n return self.url","def get_links(self):\n soup = BeautifulSoup(requests.get(self.locations_url).text.strip(), features=\"lxml\")\n for region in soup.select('td[class=\"navbox-list navbox-odd\"]'):\n self.links.extend(region.div.find_all('a'))\n\n soup_prague = BeautifulSoup(requests.get(self.url_prague).text.strip(), features=\"lxml\")\n table_prague = soup_prague.findAll('table', {\"class\": \"wikitable\"})[3]\n for prague_parts in table_prague.select(\"tr > td:nth-child(3)\"):\n self.links.extend(prague_parts.find_all('a'))\n\n self.links = [self.url + i['href'] for i in self.links]\n self.links.append(self.url_prague)\n return None","def get_links(self):\r\n return self.__links","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 tab_url(self) -> str:","def get_item_url(pk):\n return reverse('staff:procedure-detail', args=[pk])","def get_absolute_url(self):\n return reverse('product-detail', args=[str(self.id)])","def url(self):\n # type: () -> string_types\n return self._url","def url_assets(self):\n return self.assets(asset_type='URL')","def show(self):\n return self.items","def _link_items(self):\n pass","def get_item_links_in_page(self):\n css_selector = \"td.id > a\"\n id_links = self.driver.find_elements_by_css_selector(css_selector)\n return id_links","def get_links(proj,exp):\n response = do_method(\"experiment.info\",\n {\"proj\":proj,\"exp\":exp,\"aspect\":\"links\"})\n check_response(response)\n return response['value']","def get_absolute_url(self):\n return reverse('market:product-detail', args=[str(self.id)])","def get_urls(self) -> Dict[str, str]:\n return {}"],"string":"[\n \"def getURLs():\",\n \"def url(self):\\n return url_for_item(self.key)\",\n \"def url(self):\\n return url_for_item(self.key)\",\n \"def url(self, index):\\r\\n return self.arraydata[index.row()][3]\",\n \"def get_item_url(self, item):\\n return self.get_absolute_url(item, 'detail')\",\n \"def get_url(self, item):\\n config = {}\\n uuid = self.data.get('uuid', None)\\n obj = uuidToObject(uuid)\\n if uuid and obj:\\n config = copy.copy(self.get_config(obj))\\n\\n url = u'{0}{1}'.format(self.view_url(obj), item.id.value)\\n if config.get('modify_url', True):\\n url = u'{0}___{1}-{2}'.format(\\n url,\\n item.title.value,\\n item.location.value,\\n )\\n return url\",\n \"def get_urls():\\r\\n return []\",\n \"def url(result):\\n return result.entities.get(u'urls')\",\n \"def get_item_url(self):\\n try:\\n return self.content_object.get_absolute_url()\\n except AttributeError:\\n return self.external_url\",\n \"def getLink(self):\",\n \"def urls(self) -> list[str]:\\r\\n ...\",\n \"def urls(self) -> str:\\n return self._data['urls']\",\n \"def get_urls(self, data):\\n data = json.loads(data)\\n urls = []\\n for article in data['articles']:\\n urls.append(article['url'])\\n return urls\",\n \"def url(self):\\n return self.data[\\\"attributes\\\"][\\\"URL\\\"]\",\n \"def get_phones_url(self) -> list:\\n urls = []\\n\\n for page_number in range(self.number_of_pages):\\n url = f\\\"https://www.ebay.com/b/{self.__brand}-Cell-Phones-Smartphones/9355/bn_{self.brand_id}?LH_ItemCondition={self.condition_code}&LH_PrefLoc=5&LH_Sold=1&rt=nc&_pgn={page_number}\\\"\\n page = requests.get(url, headers={\\\"User-Agent\\\": self.user_agent.google})\\n soup = BeautifulSoup(page.content, \\\"html.parser\\\")\\n\\n urls.extend([links.get('href', np.nan) for links in soup.find_all('a', class_=\\\"s-item__link\\\")])\\n \\n return urls\",\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 getNewsIconURL(newsBrain):\",\n \"def show_orion_url(self, obj):\\n return obj.orion_url\",\n \"def Url(self) -> str:\",\n \"def get_absolute_url(self):\\n return ('listar_parroquia', [self.id, ])\",\n \"def get_urls(self, **kwargs):\\n pass # pragma: no cover\",\n \"def _parse_sources(self, item):\\n return [{'url': item['url']}]\",\n \"def url(self):\\n return self.full()\",\n \"def getExpandedLinks():\",\n \"def getUrl(self): #$NON-NLS-1$\\r\",\n \"def getUrl(self): #$NON-NLS-1$\\r\",\n \"def get_links(self):\\r\\n return self.links\",\n \"def uri(self) -> list:\\n raise NotImplementedError(\\\"ErddapArgoDataFetcher.uri not implemented\\\")\",\n \"def url(self):\\r\\n return self.urlparts.geturl()\",\n \"def url(self):\\n return url_search_posts(self.parameters, url_domain=self.url_domain)\",\n \"def url(self):\\n ...\",\n \"def get_urls(db):\\n return db.meta.find_one({'name':\\\"urls\\\"})['urls']\",\n \"def get_shelflist_urls():\\n def _get_shelflist_urls(records):\\n locations = set([r['location_code'] for r in records])\\n return { loc: ('{}locations/{}/shelflistitems/'.format(API_ROOT, loc)) \\n for loc in locations }\\n return _get_shelflist_urls\",\n \"def get_product_urls(self, page):\\n return self.__url_list(page)\",\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 get_urls(self):\\n urls = []\\n params = ['<{}>'.format(x) for x in self.args]\\n args_length = len(self.args) - len(self.defaults)\\n for i in range(len(self.defaults) + 1):\\n index = -i if i > args_length else None\\n urls.append(self.get_url(params[:index]))\\n return urls\",\n \"def get_urls(self):\\n urls = super(EasyPublisher, self).get_urls()\\n admin_site = self.admin_site\\n opts = self.model._meta\\n info = opts.app_label, opts.module_name,\\n \\n easy_publisher_urls = patterns(\\\"\\\",\\n url(r\\\"^([^/]+)/drafts/$\\\", admin_site.admin_view(self.drafts_view), name='%s_%s_draftlist' % info),\\n url(r\\\"^([^/]+)/drafts/([^/]+)/\\\", admin_site.admin_view(self.publish_view), name='%s_%s_draft' % info),\\n url(r\\\"^(.+)/current/$\\\", admin_site.admin_view(self.change_view), {'extra_context':{'current':True}}, name='%s_%s_current' % info)\\n )\\n\\n return easy_publisher_urls + urls\",\n \"def barbican_url(self):\",\n \"def links(self):\\n\\t\\treturn self.list_of_links\",\n \"def URLs(self, default=[{}]):\\n tmp = self.data.get('urls', default)\\n return [HEP.URLObject(i) for i in tmp]\",\n \"def url(self):\\n return reverse('snippet-list')\",\n \"def get_item_url(self, soup: BeautifulSoup) -> Optional[str]:\\n try:\\n url = f\\\"https://www.airbnb.com{soup.find('a').get('href')}\\\"\\n except AttributeError:\\n url = None\\n self.__collected_dic[\\\"url\\\"].append(url)\\n return url\",\n \"def getUrl(self):\\n\\n return self.toUrlForm()\",\n \"def uri(self):\\n if not self.parallel:\\n return [self.get_url()]\\n else:\\n self.Chunker = Chunker(\\n {\\\"box\\\": self.BOX}, chunks=self.chunks, chunksize=self.chunks_maxsize\\n )\\n boxes = self.Chunker.fit_transform()\\n urls = []\\n for box in boxes:\\n urls.append(Fetch_box(box=box, ds=self.dataset_id).get_url())\\n return urls\",\n \"def get_urls():\\n return (constants.UNREVIEWED.col_values(3) +\\n constants.REVIEWED.col_values(3) +\\n constants.LAST.col_values(3))\",\n \"def thumbnails_urls(request):\\n return {'thumbnails_urls': ThumbnailsUrls()}\",\n \"def getVotacion(self, url):\",\n \"def _get_url(self, absolute):\",\n \"def get_absolute_url(self):\\n return reverse('brand-detail', args=[str(self.id)]) #View on Site (front-end)\",\n \"def get_thumbnail_url():\",\n \"def _parse_links(self, item) -> list:\\n # TODO This would be a \\\"nice to have\\\" but is not necessary right now.\\n return [{\\\"href\\\": \\\"\\\", \\\"title\\\": \\\"\\\"}]\",\n \"def url(self):\\n return self.__values['url']\",\n \"def get_url(url_index: str) -> list:\\n url = get_url_category(url_index)\\n return url\",\n \"def url(self):\\n _, body = self.request('/v1.1/url', 'GET')\\n return body.get('url', None)\",\n \"def getUrl(self):\\n return self.__get('url')\",\n \"def URLs(self, default=[{}]):\\n tmp = self.data.get('metadata', {}).get('urls', default)\\n return [HEP.URLObject(i) for i in tmp]\",\n \"def __get_url(self, conf):\\n url_file = conf[self.conf_item.get_url_list_file()]\\n url_list = list()\\n map((lambda url: url_list.append(url.strip())), open(url_file))\\n return url_list\",\n \"def links(self) -> str:\\n return pulumi.get(self, \\\"links\\\")\",\n \"def result_urls(self, job_id: str, show_progress: bool = False) -> List:\\n data = self.result_json(job_id, show_progress)\\n urls = [x['href'] for x in data.get('links', []) if x['rel'] == 'data']\\n return urls\",\n \"def get_links(self):\\n return self.__data['links']\",\n \"def url(self):\\n\\n if not hasattr(self, \\\"_url\\\"):\\n query = db.Query(\\\"query_term u\\\", \\\"u.value\\\")\\n query.join(\\\"query_term t\\\", \\\"t.doc_id = u.doc_id\\\")\\n query.where(f\\\"u.path = '{self.URL_PATH}'\\\")\\n query.where(f\\\"t.path = '{self.TERM_PATH}'\\\")\\n query.where(query.Condition(\\\"t.int_val\\\", self.id))\\n rows = query.execute(self.loader.cdr_cursor).fetchall()\\n self._url = rows[0].value if rows else \\\"\\\"\\n return self._url\",\n \"def get_url(self):\\n return self.url\",\n \"def get_url(self):\\n return self.url\",\n \"def get_url(self):\\n return self.resource.url\",\n \"def get_links(self):\\n msg = self.get_message()\\n return msg.split()\",\n \"def get_info_url(self):\\n return self.get_info(\\\"URL\\\")\",\n \"def getLinks(tvshow, season, episode):\\n numPage = 1\\n possible_links = []\\n doNext = True\\n while(doNext):\\n urltv = getTvShowUrl(tvshow, season, episode, numPage)\\n src_urltv = getPage(urltv)\\n if (src_urltv == -1):\\n return possible_links\\n npage = False\\n for line in src_urltv:\\n if (\\\"next_page\\\" in line):\\n npage = True\\n if (\\\"disabled next_page\\\" in line):\\n doNext = False\\n for nameModule in sidereel_mod.__all__:\\n realName = sidereel_mod.__all2__[nameModule]\\n if ((realName in line) and ('data-viewable-url') in line):\\n possible_links.append([line.split('\\\"')[5], \\\\\\n \\\"sidereel_mod.\\\" + nameModule])\\n numPage += 1\\n if (npage == False):\\n doNext = False\\n return possible_links\\n \\n \\n \\n\\n ## liste=[]\\n ## for i in sidereel_mod.__all__:\\n ## __import__(\\\"aggregators.sidereel_mod.\\\" + i)\\n ## liste += sys.modules[\\\"aggregators.sidereel_mod.\\\"+i].getFlv(a)\\n ## return liste\",\n \"def links(self):\\n links = {}\\n data = self.data['links']\\n for key in data:\\n links[key] = data[key]['url']\\n return links\",\n \"def get_image_url():\",\n \"def get_links(self) -> List[str]:\\n return self.__links\",\n \"def get_top_grossing_movie_links(url):\\n pass\",\n \"def inshorts_urls():\\n\\n url1 = 'https://inshorts.com/en/read/business'\\n url2 = 'https://inshorts.com/en/read/sports'\\n url3 = 'https://inshorts.com/en/read/technology'\\n url4 = 'https://inshorts.com/en/read/entertainment'\\n return [url1, url2, url3, url4]\",\n \"def get_absolute_url(self):\\n return reverse('product-detail', args=[str(self.id_produto)])\",\n \"def make_node_urls(self, node_data):\\n node_display = node_data['display_url']\\n if node_data['__typename'] == 'GraphVideo':\\n return ['video', node_display, node_data['video_url']]\\n\\n return ['image', node_display, node_display]\",\n \"def getURLForThing(thing):\",\n \"def get_absolute_url(self):\\n return reverse(\\\"cars:rental_list\\\")\",\n \"def geturl(self):\\n return self.__url\",\n \"def urls(self):\\n return lambda : self.config.urls(active_only=True)\",\n \"def url(self):\\n url = self.url\\n return url\",\n \"def _links_get(self, cr, uid, context=None):\\n obj = self.pool.get('res.request.link')\\n ids = obj.search(cr, uid, [])\\n res = obj.read(cr, uid, ids, ['object', 'name'], context)\\n return [(r['object'], r['name']) for r in res]\",\n \"def puxa_link(soup):\\n link = []\\n for item in soup.select('.listing-item__title'):\\n link.append(item.a.get('href'))\\n return link\",\n \"def get_image_links(data):\\n painting_links = []\\n\\n print(data)\\n\\n for painting in data:\\n painting_links.append(painting['image'])\\n\\n return painting_links\",\n \"def get_link(self, list_item):\\n link = list_item.find('a', {'class': 'biz-name'})\\n return self.base_url + link.get('href')\",\n \"def listingURLs(soup):\\n\\n #Get URLs\\n itemListing = soup.find_all(class_=\\\"user-ad-row link link--base-color-inherit link--hover-color-none link--no-underline\\\")\\n itemListing += soup.find_all(class_=\\\"user-ad-row user-ad-row--featured-or-premium link link--base-color-inherit link--hover-color-none link--no-underline\\\")\\n itemListing += soup.find_all(class_=\\\"user-ad-row user-ad-row--premium user-ad-row--featured-or-premium link link--base-color-inherit link--hover-color-none link--no-underline\\\")\\n #Create list\\n urlList = [i['href'] for i in itemListing]\\n return urlList\",\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 getUrl(self):\\n return self.url\",\n \"def get_links(self):\\n soup = BeautifulSoup(requests.get(self.locations_url).text.strip(), features=\\\"lxml\\\")\\n for region in soup.select('td[class=\\\"navbox-list navbox-odd\\\"]'):\\n self.links.extend(region.div.find_all('a'))\\n\\n soup_prague = BeautifulSoup(requests.get(self.url_prague).text.strip(), features=\\\"lxml\\\")\\n table_prague = soup_prague.findAll('table', {\\\"class\\\": \\\"wikitable\\\"})[3]\\n for prague_parts in table_prague.select(\\\"tr > td:nth-child(3)\\\"):\\n self.links.extend(prague_parts.find_all('a'))\\n\\n self.links = [self.url + i['href'] for i in self.links]\\n self.links.append(self.url_prague)\\n return None\",\n \"def get_links(self):\\r\\n return self.__links\",\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 tab_url(self) -> str:\",\n \"def get_item_url(pk):\\n return reverse('staff:procedure-detail', args=[pk])\",\n \"def get_absolute_url(self):\\n return reverse('product-detail', args=[str(self.id)])\",\n \"def url(self):\\n # type: () -> string_types\\n return self._url\",\n \"def url_assets(self):\\n return self.assets(asset_type='URL')\",\n \"def show(self):\\n return self.items\",\n \"def _link_items(self):\\n pass\",\n \"def get_item_links_in_page(self):\\n css_selector = \\\"td.id > a\\\"\\n id_links = self.driver.find_elements_by_css_selector(css_selector)\\n return id_links\",\n \"def get_links(proj,exp):\\n response = do_method(\\\"experiment.info\\\",\\n {\\\"proj\\\":proj,\\\"exp\\\":exp,\\\"aspect\\\":\\\"links\\\"})\\n check_response(response)\\n return response['value']\",\n \"def get_absolute_url(self):\\n return reverse('market:product-detail', args=[str(self.id)])\",\n \"def get_urls(self) -> Dict[str, str]:\\n return {}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6485568","0.645834","0.645834","0.6320854","0.6319648","0.63013756","0.6289393","0.6228144","0.6174826","0.6151455","0.60874134","0.5989771","0.59726894","0.59524935","0.5925669","0.59131056","0.5910598","0.58754987","0.58629525","0.5838614","0.58370227","0.58306247","0.58112675","0.5801311","0.5797863","0.5797863","0.5762998","0.57628155","0.5759781","0.57566226","0.57498187","0.5743359","0.5735177","0.56887436","0.56859994","0.5685819","0.5684721","0.56601095","0.56512064","0.56376195","0.56219745","0.5615694","0.56152064","0.56070787","0.56037897","0.5583465","0.5581732","0.55750674","0.55635417","0.55608773","0.5551019","0.5544563","0.55423534","0.55395365","0.5532773","0.55239326","0.55154485","0.5502067","0.54901","0.54870003","0.54858255","0.5484275","0.5484275","0.5467131","0.54577637","0.5456349","0.5453051","0.54482764","0.5437596","0.5430119","0.5428552","0.54257506","0.54211265","0.5419215","0.5413219","0.5403879","0.5398478","0.53916156","0.53902876","0.53896445","0.53894955","0.53894395","0.53762686","0.5375018","0.536971","0.5366228","0.5364825","0.53574055","0.5356027","0.5355206","0.5352692","0.53501964","0.5344011","0.5342567","0.5340866","0.5335799","0.5335027","0.5329742","0.5328024","0.53277093"],"string":"[\n \"0.6485568\",\n \"0.645834\",\n \"0.645834\",\n \"0.6320854\",\n \"0.6319648\",\n \"0.63013756\",\n \"0.6289393\",\n \"0.6228144\",\n \"0.6174826\",\n \"0.6151455\",\n \"0.60874134\",\n \"0.5989771\",\n \"0.59726894\",\n \"0.59524935\",\n \"0.5925669\",\n \"0.59131056\",\n \"0.5910598\",\n \"0.58754987\",\n \"0.58629525\",\n \"0.5838614\",\n \"0.58370227\",\n \"0.58306247\",\n \"0.58112675\",\n \"0.5801311\",\n \"0.5797863\",\n \"0.5797863\",\n \"0.5762998\",\n \"0.57628155\",\n \"0.5759781\",\n \"0.57566226\",\n \"0.57498187\",\n \"0.5743359\",\n \"0.5735177\",\n \"0.56887436\",\n \"0.56859994\",\n \"0.5685819\",\n \"0.5684721\",\n \"0.56601095\",\n \"0.56512064\",\n \"0.56376195\",\n \"0.56219745\",\n \"0.5615694\",\n \"0.56152064\",\n \"0.56070787\",\n \"0.56037897\",\n \"0.5583465\",\n \"0.5581732\",\n \"0.55750674\",\n \"0.55635417\",\n \"0.55608773\",\n \"0.5551019\",\n \"0.5544563\",\n \"0.55423534\",\n \"0.55395365\",\n \"0.5532773\",\n \"0.55239326\",\n \"0.55154485\",\n \"0.5502067\",\n \"0.54901\",\n \"0.54870003\",\n \"0.54858255\",\n \"0.5484275\",\n \"0.5484275\",\n \"0.5467131\",\n \"0.54577637\",\n \"0.5456349\",\n \"0.5453051\",\n \"0.54482764\",\n \"0.5437596\",\n \"0.5430119\",\n \"0.5428552\",\n \"0.54257506\",\n \"0.54211265\",\n \"0.5419215\",\n \"0.5413219\",\n \"0.5403879\",\n \"0.5398478\",\n \"0.53916156\",\n \"0.53902876\",\n \"0.53896445\",\n \"0.53894955\",\n \"0.53894395\",\n \"0.53762686\",\n \"0.5375018\",\n \"0.536971\",\n \"0.5366228\",\n \"0.5364825\",\n \"0.53574055\",\n \"0.5356027\",\n \"0.5355206\",\n \"0.5352692\",\n \"0.53501964\",\n \"0.5344011\",\n \"0.5342567\",\n \"0.5340866\",\n \"0.5335799\",\n \"0.5335027\",\n \"0.5329742\",\n \"0.5328024\",\n \"0.53277093\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8105406"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74291,"cells":{"query":{"kind":"string","value":"We ask for owners as email addresses but LDAP needs the DN for the appropriate object"},"document":{"kind":"string","value":"def process_group_owners(data):\n owner_list = []\n owners = data.split(\"\\r\\n\")\n for owner in owners:\n if owner != \"\":\n result = shared_ldap.find_from_email(owner)\n if result is None:\n shared_sd.post_comment(\n \"Unable to add %s as an owner as the email address \"\n \"cannot be found in Linaro Login.\" % owner, True)\n else:\n # Need to make sure we append the mailing group if it\n # is a group!\n if \",ou=security,\" not in result:\n owner_list.append(result)\n shared_sd.post_comment(\n \"Adding %s as an owner.\" % owner, True)\n return owner_list"},"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 handle_empty_owners():\n result = shared_ldap.find_from_email(shared.globals.REPORTER)\n if result is not None:\n shared_sd.post_comment(\n \"Adding %s as the owner of the group.\" % shared.globals.REPORTER, True)\n return [result]\n\n # OK - something stupid is happening but let's give ourselves\n # a safety net.\n shared_sd.post_comment(\n \"Unable to add %s as an owner as the email address cannot be \"\n \"found in Linaro Login. This means the automation has not \"\n \"been able to find any of the specified email addresses in \"\n \"Linaro Login. Consequently, IT Services will need to manage \"\n \"it in the interim.\" % shared.globals.REPORTER, True)\n return [\"cn=its,ou=mailing,ou=groups,dc=linaro,dc=org\"]","def ldap_get_email(self, user):\n result = super(Auth42, self)._search_not_empty(user)\n if result is not None:\n alias = result.get(\"alias\")[1]\n return alias\n\n return None","def get_dn(conn, object_class, property_value, property_name='sAMAccountName'):\n\n ldap_filter = f'(&(objectClass={object_class})({property_name}={property_value}))'\n conn.search(conn.server.info.other['DefaultNamingContext'], ldap_filter)\n dn_list = [entry.entry_dn for entry in conn.entries]\n return dn_list","def owners(self):\n return self.properties.get('owners',\n DirectoryObjectCollection(self.context, ResourcePath(\"owners\", self.resource_path)))","def get_ldap_users(conn, searchfilter, attrs):\n\n base_dn = conn.server.info.other['DefaultNamingContext'][0]\n conn.search(search_base=base_dn, search_filter=searchfilter, attributes=attrs)\n return conn.entries","def email_lookup(self):\n if not hasattr(self, \"_email_lookup\"):\n self._email_lookup = {}\n self.load_data()\n for entry in self.data.get(\"contributor\", []):\n if \"email\" in entry:\n self._email_lookup[entry[\"email\"]] = entry\n return self._email_lookup","def getPropertyOwners(self) -> List[unicode]:\n ...","def referring_ad_rep_email(obj):\n if obj.ad_rep is None:\n email = ''\n else:\n email = obj.ad_rep.email\n return \"%s\" % email","def list_ou(self, _):\n cn_re = re_compile(\"{[^}]+}\")\n results = self.engine.query(self.engine.GPO_INFO_FILTER(), [\"cn\", \"displayName\"])\n gpos = {}\n for gpo in results:\n gpos[gpo[\"cn\"]] = gpo[\"displayName\"]\n\n results = self.engine.query(self.engine.OU_FILTER())\n for result in results:\n print(result[\"distinguishedName\"])\n if \"gPLink\" in result:\n guids = cn_re.findall(result[\"gPLink\"])\n if len(guids) > 0:\n print(\"[gPLink]\")\n print(\"* {}\".format(\"\\n* \".join([gpos[g] if g in gpos else g for g in guids])))","def _MakeOwners(document, path, emails_with_dom_elements):\n owner_elements = []\n # TODO(crbug.com/987709): An OWNERS file API would be ideal.\n emails_from_owners_file = _ExtractEmailAddressesFromOWNERS(path)\n if not emails_from_owners_file:\n raise Error('No emails could be derived from {}.'.format(path))\n\n # A list is used to respect the order of email addresses in the OWNERS file.\n deduped_emails_from_owners_file = []\n for email in emails_from_owners_file:\n if email not in emails_with_dom_elements:\n deduped_emails_from_owners_file.append(email)\n emails_with_dom_elements.add(email)\n\n for email in deduped_emails_from_owners_file:\n owner_element = document.createElement('owner')\n owner_element.appendChild(document.createTextNode(email))\n owner_elements.append(owner_element)\n return owner_elements","def owners(self):\n return self.find_users_by_rel('owner')","def ad_rep_email(obj):\n return '%s' % obj.ad_rep.email","def prov_account(ldp_cnf, ldap_query, attrs):\n for dn, entry in ldapQuery(ldp_cnf, ldap_query, attrs):\n mail_account = entry['zimbraMailDeliveryAddress'][0]\n print 'ca %s 12qwasZX.,1\\n' % mail_account,\n print 'ma %s ' % mail_account,\n for zimbra_attr in zimbra_attributes():\n try:\n attr_data = entry[zimbra_attr]\n print zimbra_attr,\n for value in attr_data:\n # We need to print \\n instead of breaking line.\n value = value.replace('\\n', '\\\\n')\n # We need to escape single quotes.\n value = value.replace(\"'\", \"\\\\'\")\n if zimbra_attr == 'zimbraPrefMailForwardingAddress':\n # zimbraPrefMailForwardingAddress must always have accounts separated by comma\n value = value.replace(';', ',')\n\n print \"'%s'\" % value,\n except KeyError:\n continue\n \n # Attributes finished for the given account, we need to break line to move to next account\n print\n\n if entry.get('zimbraMailAlias'):\n for alias in entry['zimbraMailAlias']:\n print 'aal', mail_account, alias\n###Forward oculto +zimbraMailForwardingAddress\n if entry.get('zimbraMailForwardingAddress'):\n for forward in entry['zimbraMailForwardingAddress']:\n print 'ma', mail_account, '+zimbraMailForwardingAddress', forward","def getResponsibleUsers():","def locate_users_with_gapps(self):\n return self.ldap_connection.search_s(\"ou=mx,dc=redhat,dc=com\",\n ldap.SCOPE_SUBTREE, \"(|(sendmailMTAAliasValue=*@gapps.redhat.com)(sendmailMTAKey=*@gapps.redhat.com))\",\n [\"sendmailMTAKey\", \"sendmailMTAAliasValue\", \"rhatMTAAllowExternal\"])","def get_owners_list(self):\n final_list = []\n for entry in self.bot_data_file[\"owners_data\"][\"owners_list\"]:\n final_list.append(str(entry[\"name\"]))\n if len(final_list) == 0:\n print(\"ERROR GETTING THE OWNERS LIST (i need at least 1 owner) - BOT ABORTING\")\n quit(1)\n else:\n return final_list","def get_account_info(accountType,baseDN,user,password):\n accounts = []\n searchScope = ldap.SCOPE_SUBTREE\n try:\n l = ldap.initialize('ldap://ldap1.kps')\n l.protocol_version = ldap.VERSION3\n l.simple_bind_s(user, password)\n r = l.search_s(baseDN, searchScope, searchFilter, retrieveAttributes)\n res = ldaphelper.get_search_results(r)\n for record in res:\n cn = record.get_attr_values('cn')[0]\n cn = cn.lower()\n mail = record.get_attr_values('mail')[0]\n mail = mail.lower()\n id = record.get_attr_values('studentID')[0]\n accounts.append(id,cn,email)\n except ldap.LDAPError, e:\n print e\n return accounts","def test_search_attrsonly(self):\n obj = self.conn.search(self.basedn, 2, \"(objectclass=person)\",\n ['cn'], attrsonly=True)[0]\n self.assertIsNotNone(obj)\n self.assertListEqual(obj['cn'], [])","def direct():\n\n unsafe_dc = request.args['dc']\n unsafe_filter = request.args['username']\n\n dn = \"dc={}\".format(unsafe_dc)\n search_filter = \"(user={})\".format(unsafe_filter)\n\n srv = ldap3.Server('ldap://127.0.0.1')\n conn = ldap3.Connection(srv, user=dn, auto_bind=True).search(\n dn, search_filter)","def business_owner_email(self):\n return self._business_owner_email","def technical_owner_email(self):\n return self._technical_owner_email","def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"owners\")","def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"owners\")","def search( self, base=False, trim=False, **kwargs ): \n scope = pyldap.SCOPE_SUBTREE\n if not base:\n base = self.users\n \n filterstr =''\n for key, value in kwargs.iteritems():\n filterstr += '({0}={1})'.format(key,value)\n if key == 'dn': \n filterstr = '(objectClass=*)'\n base = value\n scope = pyldap.SCOPE_BASE\n break\n \n if len(kwargs) > 1:\n filterstr = '(&'+filterstr+')'\n \n result = self.ldap.search_s(base, pyldap.SCOPE_SUBTREE, filterstr, ['*','+'])\n if base == self.users:\n for member in result:\n groups = self.getGroups(member[0])\n member[1]['groups'] = groups\n if 'eboard' in member[1]['groups']:\n member[1]['committee'] = self.search(base=self.committees, \\\n head=member[0])[0][1]['cn'][0]\n\n if trim: return self.trimResult(result)\n else: return result","def owners(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"owners\")","def owner(self):\n return Organization.objects.get(id=self.owner_id)","def manager_info(self, manager_cn):\n manager_login = manager_cn[4:manager_cn.find(\",\")]\n manager_info = self.locate_user(manager_login)\n try:\n return manager_info[0][1]['cn'][0] + \\\n \" (\" + manager_info[0][1]['uid'][0] + \")\"\n except IndexError:\n return \"(LDAP record removed) %s\" % manager_cn","def _get_dn(self, environ, identity):\n\n if self.bind_dn:\n try:\n self.ldap_connection.bind_s(self.bind_dn, self.bind_password)\n except ldap.LDAPError:\n raise ValueError(\"Couldn't bind with supplied credentials\")\n try:\n login_name = identity['login'].replace('*',r'\\*')\n srch = self.search_pattern % login_name\n dn_list = self.ldap_connection.search_s(\n self.base_dn,\n self.search_scope,\n srch,\n )\n\n # here is the change; return the CN of the first.\n if len(dn_list) >= 1:\n return dn_list[0][0]\n else:\n raise ValueError('No entry found for %s' %srch)\n except (KeyError, TypeError, ldap.LDAPError):\n raise # ValueError","def normal():\n\n unsafe_dc = request.args['dc']\n unsafe_filter = request.args['username']\n\n dn = \"dc={}\".format(unsafe_dc)\n search_filter = \"(user={})\".format(unsafe_filter)\n\n srv = ldap3.Server('ldap://127.0.0.1')\n conn = ldap3.Connection(srv, user=dn, auto_bind=True)\n conn.search(dn, search_filter)","def get_emails(parsed_data):\n result = []\n known_values = []\n contacts = {'registrant_contact': [], 'administrative_contact': [], 'technical_contact': [],\n 'domain_registrar': []}\n if 'registrant_contact' in parsed_data:\n contacts['registrant_contact'].append(parsed_data['registrant_contact'])\n if 'administrative_contact' in parsed_data:\n contacts['administrative_contact'].append(parsed_data['administrative_contact'])\n if 'technical_contact' in parsed_data:\n contacts['technical_contact'].append(parsed_data['technical_contact'])\n if 'domain_registrar' in parsed_data:\n contacts['domain_registrar'].append(parsed_data['domain_registrar'])\n # parsing email address from contact block\n\n for contact, info in contacts.items():\n if info is not None:\n d = {'type': 2, 'data': '', 'properties': {}, 'special_properties': {}, 'is_valid': False, 'ref': {}}\n # properties dictionary\n is_valid = {}\n owner = {'owner': '', 'type': 11}\n organization = {'organization': '', 'type': 11}\n local_address = {'local_address': '', 'type': 5}\n domain_name = {'domain_name': '', 'type': 12}\n properties_list = []\n special_properties_list = []\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': ''}})\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\n d['ref']['whois_for'] = parsed_data['domain_name']\n if 'whois_server' in parsed_data:\n d['ref']['whois_from'] = parsed_data['whois_server']\n\n for name in info:\n if \"email_address\" in name:\n if name['email_address'] in known_values:\n break\n for feature in name.keys():\n if feature == \"email_address\":\n d['data'] = name['email_address']\n known_values.append(name['email_address'])\n\n if feature == \"full_name\":\n owner['owner'] = name['full_name']\n properties_list.append(owner)\n\n if feature == \"city_name\":\n organization['organization'] = name['city_name']\n properties_list.append(organization)\n\n d['is_valid'] = ''\n is_valid = {'isvalid': '', 'type': 0}\n\n # prevent from create result if phone number of contact is not available\n if d['data'] == '':\n continue\n try:\n domain_name['domain_name'] = d['data'].split('@')[1]\n local_address['local_address'] = d['data'].split('@')[0]\n properties_list.append(domain_name)\n properties_list.append(local_address)\n except:\n\n domain_name['domain_name'] = ''\n local_address['local_address'] = d['data']\n properties_list.append(domain_name)\n properties_list.append(local_address)\n\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': '', 'label': ''}})\n d['ref']['label'] = \"%s_name\" % contact\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\n d['ref']['whois_for'] = parsed_data['domain_name']\n if 'whois_server' in parsed_data:\n d['ref']['whois_from'] = parsed_data['whois_server']\n d['properties'] = properties_list\n special_properties_list.append(is_valid)\n d['special_properties'] = special_properties_list\n result.append(d)\n\n return result","def get_owner(self, obj):\n return obj.user.username","def search_ldap(l, filter, base, scope=ldap.SCOPE_SUBTREE, attributes=None, accountname=None, DEBUG=False):\r\n if '%s' in filter:\r\n query = filter % accountname\r\n else:\r\n query = filter\r\n if DEBUG:\r\n warning(\"searching for user '%s' in base: %s. retrieve attributes: %s, scope: %s\"%(accountname, base, attributes, scope))\r\n warning('Filter string: %s'%(query,))\r\n try:\r\n ldap_result_id = l.search(base, scope, query, attributes)\r\n if DEBUG:\r\n warning('ldap_result_id: %s'%ldap_result_id)\r\n result_set = llist()\r\n result_type, result_data = l.result(ldap_result_id, 0)\r\n if DEBUG:\r\n warning('len of result_data: %d'%len(result_data))\r\n while result_type == ldap.RES_SEARCH_ENTRY:\r\n result_data = result_data[0]\r\n #data = ( result_data[0] , { i:result_data[1][i] for i in result_data[1] } )\r\n user_data = ldict({i: result_data[1][i][0] if len(result_data[1][i])==1 else result_data[1][i] for i in result_data[1]})\r\n user_data['dn'] = result_data[0]\r\n if isinstance(user_data['dn'], list):\r\n user_data['dn'] = user_data['dn'][0]\r\n\r\n result_set.append(user_data)\r\n result_type, result_data = l.result(ldap_result_id, 0)\r\n if DEBUG:\r\n warning('len of result_data: %d'%len(result_data))\r\n\r\n return result_set\r\n\r\n except ldap.LDAPError, e:\r\n print e\r\n return None","def test_search_attr(self):\n obj = self.conn.search(self.basedn, 2, \"(objectclass=person)\",\n ['cn'])[0]\n self.assertIsNotNone(obj)\n if 'cn' not in obj.keys():\n self.fail()","def fetch_owner_accounts():\n resp = oauth.tapkey.get('Owners')\n owner_accounts = resp.json()\n return owner_accounts","def search_user_information(conn, ldap_domain, ldap_domain_ext, user_login):\n try:\n search_base = \"dc={}, dc={}\".format(ldap_domain, ldap_domain_ext)\n query = \"(&(objectclass=user)(objectCategory=person)\" \\\n \"(sAMAccountName={})(userAccountControl=512))\".format(user_login)\n attributes = ['distinguishedName', 'displayname']\n\n conn.search(search_base, query, attributes=attributes)\n user = conn.entries\n\n if not user:\n raise Exception(\"users not found\")\n except Exception as e:\n raise Exception(\"unable to search user information :: {}\".format(e))\n return user","def get_email(obj):\r\n return obj.user.email","def get_ldap_contact(ldap_conn, base_dn, employee_number, unique_id, attrs, cache):\r\n search_filter = '{0}={1}'.format(unique_id, employee_number)\r\n results = ldap_conn.search_s(base_dn, ldap.SCOPE_SUBTREE, search_filter, attrs)\r\n contact_found = {}\r\n if results:\r\n attrs_found = results[0][1]\r\n # cache the dn for the employee_number\r\n cache[employee_number] = results[0][0]\r\n for key in attrs:\r\n if key in attrs_found:\r\n contact_found[key] = attrs_found[key][0]\r\n else:\r\n contact_found[key] = False\r\n else:\r\n logging.warning('Cannot found employee in ldap ' + employee_number)\r\n return contact_found","def provDistributionList(ldp_conf, ldap_query, attrs):\n for dn, entry in ldapQuery(ldp_conf, ldap_query, attrs):\n distribution_list_name = entry['mail'][0]\n print 'cdl', distribution_list_name\n print 'adlm', distribution_list_name, \n if not 'zimbraMailForwardingAddress' in entry:\n continue\n for member in entry['zimbraMailForwardingAddress']:\n print member,\n # Break line, distribution list member finished\n print\n # Finish\n print","def search(self, base=USERS, trim=False, **kwargs):\n search_filter = ''\n for key, value in kwargs.items():\n if isinstance(value, list):\n search_filter += '(|'\n for term in value:\n term = term.replace('(', '\\\\(')\n term = term.replace(')', '\\\\)')\n search_filter += '({0}={1})'.format(key, term)\n search_filter += ')'\n else:\n value = value.replace('(', '\\\\(')\n value = value.replace(')', '\\\\)')\n search_filter += '({0}={1})'.format(key, value)\n\n if key == 'dn':\n search_filter = '(objectClass=*)'\n base = value\n break\n\n if len(kwargs) > 1:\n search_filter = '(&' + search_filter + ')'\n\n result = self.ldap_conn.search(search_base=base, search_filter=search_filter, attributes=['*', '+'])\n if result:\n if base == USERS:\n for member in self.ldap_conn.response:\n if self.debug:\n print(\"[DEBUG] Entry: \" + str(member))\n\n groups = self.get_groups(member['dn'])\n member['attributes']['groups'] = groups\n\n if 'eboard' in member['attributes']['groups']:\n eboard_search = self.search(base=COMMITTEES, head=member['dn'])\n\n if eboard_search:\n member.committee = self.ldap_conn.reponse[0]['attributes']['cn']\n\n if self.objects:\n return self.member_objects(self.ldap_conn.response)\n\n final_result = self._trim_result(self.ldap_conn.response) if trim else self.ldap_conn.response\n else:\n final_result = []\n\n return final_result","def _process_ldap_info_for_one_user(self, record, result_data):\n #One entry only in the ldap data because we used a filter\n #to find one user only\n ldapentry = result_data[0][1]\n logger.debug(\"LDAP.PY \\t LdapFindUser ldapentry %s\" % (ldapentry))\n tmpname = ldapentry['uid'][0]\n\n tmpemail = ldapentry['mail'][0]\n if ldapentry['mail'][0] == \"unknown\":\n tmpemail = None\n\n parent_hrn = None\n peer_authority = None\n if 'hrn' in record:\n hrn = record['hrn']\n parent_hrn = get_authority(hrn)\n if parent_hrn != self.authname:\n peer_authority = parent_hrn\n #In case the user was not imported from Iotlab LDAP\n #but from another federated site, has an account in\n #iotlab but currently using his hrn from federated site\n #then the login is different from the one found in its hrn\n if tmpname != hrn.split('.')[1]:\n hrn = None\n else:\n hrn = None\n\n results = {\n 'type': 'user',\n 'pkey': ldapentry['sshPublicKey'],\n #'uid': ldapentry[1]['uid'][0],\n 'uid': tmpname,\n 'email': tmpemail,\n #'email': ldapentry[1]['mail'][0],\n 'first_name': ldapentry['givenName'][0],\n 'last_name': ldapentry['sn'][0],\n #'phone': 'none',\n 'serial': 'none',\n 'authority': parent_hrn,\n 'peer_authority': peer_authority,\n 'pointer': -1,\n 'hrn': hrn,\n }\n return results","def _ExtractEmailAddressesFromOWNERS(path, depth=0):\n # It is unlikely that any chain of OWNERS files will exceed 10 redirections\n # via file:// directives.\n limit = 10\n if (depth > limit):\n raise Error('_ExtractEmailAddressesFromOWNERS has been called {} times. The'\n ' path {} may be part of an OWNERS loop.'.format(limit, path))\n\n directive = 'file://'\n email_pattern = re.compile(_EMAIL_PATTERN)\n extracted_emails = []\n\n with open(path, 'r') as owners_file:\n for line in [line.lstrip()\n for line in owners_file.read().splitlines() if line]:\n index = line.find(' ')\n first_word = line[:index] if index != -1 else line\n\n if email_pattern.match(first_word):\n extracted_emails.append(first_word)\n\n elif first_word.startswith(directive):\n next_path = _GetOwnersFilePath(\n os.path.join(SRC, first_word[len(directive):]))\n\n if os.path.exists(next_path) and os.path.isfile(next_path):\n extracted_emails.extend(\n _ExtractEmailAddressesFromOWNERS(next_path, depth + 1))\n else:\n raise Error('The path derived from {} does not exist. '\n 'Derived path: {}'.format(first_word, next_path))\n\n return extracted_emails","def _return_specific_owner_prs(all_prs, filters):\n if _validate_list_of_dict(all_prs):\n owner_prs = [pr for pr in all_prs if filters['owner'] == pr['pr'].user.login]\n logger.debug(\"OWNER PRS: %s\", [pr['pr'].number for pr in owner_prs])\n return owner_prs\n else:\n return []","def _ssl_dn_extract_info(dn_string):\r\n ss = re.search('/emailAddress=(.*)@([^/]+)', dn_string)\r\n if ss:\r\n user = ss.group(1)\r\n email = \"%s@%s\" % (user, ss.group(2))\r\n else:\r\n return None\r\n ss = re.search('/CN=([^/]+)/', dn_string)\r\n if ss:\r\n fullname = ss.group(1)\r\n else:\r\n return None\r\n return (user, email, fullname)","def copyToLdap(user_email):\n user = User.objects.get(email=user_email)\n social = user.social_auth.get(provider='google-oauth2')\n print (\"Get social\")\n print (social)\n domain = user_email.split('@')[1]\n print(domain)\n response = requests.get(\n 'https://www.googleapis.com/admin/directory/v1/users?domain={}'.format(domain),\n params={'access_token': social.extra_data['access_token']}\n )\n print (response.json())\n gappsUsers = response.json().get('users')\n # update records\n confirmedLdapUsers = []\n for gUser in gappsUsers:\n print (gUser.get('primaryEmail'))\n try:\n usr = LdapUser.objects.get(email=gUser.get('primaryEmail'))\n #check if user needs to be deleted\n if gUser['suspended']:\n usr.delete()\n continue\n except LdapUser.DoesNotExist:\n if gUser['suspended']:\n continue\n usr = LdapUser(email=gUser.get('primaryEmail'), password = ''.join(secrets.choice(ALPHABET) for i in range(10)))\n \n usr.group = 1\n usr.uid = gUser['id'] \n usr.first_name = gUser['name']['givenName']\n usr.last_name = gUser['name']['familyName']\n usr.full_name = gUser['name']['fullName']\n usr.username = gUser.get('primaryEmail')\n usr.home_directory = \"/\"\n usr.save()\n\n confirmedLdapUsers.append(usr.email)\n\n #delete users from ldap that are not gApps users\n LdapUser.objects.all().exclude(email__in=confirmedLdapUsers).delete()\n\n return domain","def search_from_ldap(conn, base, scope=ldap.SCOPE_BASE,\n filterstr=\"(objectClass=*)\",\n attrlist=None, attrsonly=0):\n try:\n result = conn.search_s(base, scope)\n ret = result[0]\n except ldap.NO_SUCH_OBJECT:\n ret = (\"\", {},)\n return ret","def get_accounts_for_emails(cls, emails):\n return cls.get_by_key_name(['<%s>' % email for email in emails])","def update_from_emails(self, emails):\n # Now add contributors using cache (new GitHub contributors) with known email or orcid that isn't present\n for email in emails:\n if email not in self.email_lookup:\n bot.info(f\" Updating with new added email: {email}\")\n entry = {\"@type\": \"Person\", \"email\": email}\n self.lookup.append(entry)","def get_author_emails(self, author_node):\n emails = author_node.xpath('string(./e-address[@type=\"email\"][1])').getall()\n\n return emails","def owner_name(self, operator: Enum, owner_name: list | str):\n if isinstance(owner_name, list) and operator not in self.list_types:\n raise RuntimeError(\n 'Operator must be CONTAINS, NOT_CONTAINS, IN'\n 'or NOT_IN when filtering on a list of values.'\n )\n\n self._tql.add_filter('ownerName', operator, owner_name, TqlType.STRING)","def get_recipients(item_container):\n if item_container.item.string_1 != '':\n user_folder = get_item_container_by_path(item_container.item.string_1)\n return get_all_users_with_email(user_folder)\n else:\n while not check_userfolder(item_container):\n item_container = item_container.get_parent()\n return get_all_users_with_email(item_container)","def get_users_for(self, email):\r\n # this is a list rather than a generator because we probably want to do a len() on it right away\r\n return [address.user for address in EmailAddress.objects.filter(verified=True, email=email)]","def emails() -> st.SearchStrategy[str]:\n return (\n st.emails()\n .map(lambda s: s.lower())\n .map(_validate_email)\n .filter(_is_valid_email)\n .map(lambda m: m.normalized) # type: ignore[union-attr]\n )","def get_from_ldap(val):\n def process_stuff(ask):\n result = []\n r = json.loads(ask.text)\n for e in r:\n if e['is_active']:\n if e['primary_affiliation'] == 'student':\n affiliation = _('Étudiant')\n cmp = e['main_registration_code'] if e[\n 'main_registration_code'] is not None else _(\n 'Non renseigné')\n else:\n cmp = e['main_affectation_code'] if e[\n 'main_affectation_code'] is not None else _(\n 'Non renseigné')\n if e['primary_affiliation'] == 'employee':\n affiliation = _('Administratif')\n else:\n affiliation = _('Enseignant')\n person = {\n \"last_name\": \"%s (%s)\" % (e['last_name'], val.capitalize(\n )) if val.capitalize() != e['last_name'].capitalize(\n ) and '*' not in val else e['last_name'],\n \"first_name\": e.get('first_name').title(),\n \"status\": affiliation,\n \"institute\": cmp,\n \"birth_date\": e.get('birth_date'),\n \"username\": e.get('username'),\n \"mail\": e.get('mail'),\n \"birth_name\": e.get('birth_name').title()\n }\n result.append(person)\n return result\n client = create_client('ldap_client', settings.LDAP_TOKEN,\n settings.LDAP_SPORE, settings.LDAP_BASE_URL)\n ask = client.list_accounts(\n format='json', establishment='UDS', last_or_birth_name=val)\n\n return process_stuff(ask)","def get_owners(self, property_class_name):\n res = []\n for x in self.owner_properties:\n if str(x.__class__.__name__) == str(property_class_name):\n res.append(x.owner)\n return res","def orcid_lookup(self):\n if not hasattr(self, \"_orcid_lookup\"):\n self._orcid_lookup = {}\n self.load_data()\n for entry in self.data.get(\"contributor\", []):\n if \"@id\" in entry:\n # Orcid represented as full URL but we just want id\n orcid = entry[\"@id\"].split(\"/\")[-1]\n self._orcid_lookup[orcid] = entry\n return self._orcid_lookup","def audit_emails_in_metadata(self):\n\n # Iterate over commits....\n disallowed_domains = [\"localhost\", \"localhost.localdomain\", \"(none)\", \"bombardier.com\", \"rail.bombardier.com\"]\n for commit in self.repository.commits.values():\n for email_address in [ commit.committer_email, commit.author_email ]:\n # Extract the email address, and reject them if extraction fails....\n extraction = re.match(\"^(\\S+)@(\\S+)$\", email_address)\n if not extraction:\n self.__log_failure(commit.sha1, \"Seemingly invalid email address: \" + email_address)\n continue\n\n # Don't allow domains which are disallowed...\n domain = extraction.group(2)\n if domain in disallowed_domains:\n self.__log_failure(commit.sha1, \"Email address using a blocked domain: \" + email_address)\n continue\n\n # Ensure they have a valid MX/A entry in DNS....\n try:\n dns.resolver.query(domain, \"MX\")\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel):\n try:\n dns.resolver.query(domain, \"A\")\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel, dns.resolver.NXDOMAIN):\n self.__log_failure(commit.sha1, \"Email address has an invalid domain : \" + email_address)\n except (dns.resolver.NXDOMAIN, dns.resolver.NoNameservers):\n self.__log_failure(commit.sha1, \"Email address has an invalid domain : \" + email_address)","def _process_ldap_info_for_all_users(self, result_data):\n results = []\n logger.debug(\" LDAP.py _process_ldap_info_for_all_users result_data %s \"\n % (result_data))\n for ldapentry in result_data:\n logger.debug(\" LDAP.py _process_ldap_info_for_all_users \\\n ldapentry name : %s \" % (ldapentry[1]['uid'][0]))\n tmpname = ldapentry[1]['uid'][0]\n hrn = self.authname + \".\" + tmpname\n\n tmpemail = ldapentry[1]['mail'][0]\n if ldapentry[1]['mail'][0] == \"unknown\":\n tmpemail = None\n\n try:\n results.append({\n 'type': 'user',\n 'pkey': ldapentry[1]['sshPublicKey'][0],\n #'uid': ldapentry[1]['uid'][0],\n 'uid': tmpname ,\n 'email':tmpemail,\n #'email': ldapentry[1]['mail'][0],\n 'first_name': ldapentry[1]['givenName'][0],\n 'last_name': ldapentry[1]['sn'][0],\n #'phone': 'none',\n 'serial': 'none',\n 'authority': self.authname,\n 'peer_authority': '',\n 'pointer': -1,\n 'hrn': hrn,\n })\n except KeyError, error:\n logger.log_exc(\"LDAPapi.PY \\t LdapFindUser EXCEPTION %s\"\n % (error))\n return\n\n return results","def sambaaccountsindomainroot(domainroot, l):\n dns = {}\n r = l.search_s(domainroot, ldap.SCOPE_SUBTREE, '(objectClass=sambaSamAccount)', ['uidNumber'])\n for dn, entry in r:\n try:\n dns[dn] = entry['uidNumber'][0]\n except KeyError:\n sys.stderr.write(\"dn %s has no uidNumber!\\n\" % dn)\n return dns","def list_delegations(self, kwargs):\n verbose = kwargs.get(\"verbose\", False)\n filter_ = kwargs.get(\"filter\", \"all\")\n\n attributes = ALL if verbose else [\"sAMAccountName\", \"userAccountControl\"]\n\n if filter_ == \"all\":\n if not verbose:\n attributes.extend([\n \"msDS-AllowedToDelegateTo\",\n \"msDS-AllowedToActOnBehalfOfOtherIdentity\"\n ])\n entries = self.engine.query(self.engine.ALL_DELEGATIONS_FILTER(), attributes)\n elif filter_ == \"unconstrained\":\n entries = self.engine.query(self.engine.UNCONSTRAINED_DELEGATION_FILTER(), attributes)\n elif filter_ == \"constrained\":\n if not verbose:\n attributes.append(\"msDS-AllowedToDelegateTo\")\n entries = self.engine.query(self.engine.CONSTRAINED_DELEGATION_FILTER(), attributes)\n elif filter_ == \"rbcd\":\n if not verbose:\n attributes.append(\"msDS-AllowedToActOnBehalfOfOtherIdentity\")\n entries = self.engine.query(self.engine.RESOURCE_BASED_CONSTRAINED_DELEGATION_FILTER(), attributes)\n else:\n return None\n\n if verbose:\n self.display(entries, verbose)\n else:\n for entry in entries:\n try:\n uac = entry[\"userAccountControl\"]\n sam = entry[\"sAMAccountName\"]\n delegate = entry.get(\"msDS-AllowedToDelegateTo\")\n allowed_to_act = entry.get(\"msDS-AllowedToActOnBehalfOfOtherIdentity\")\n if (filter_ == \"unconstrained\" or filter_ == \"all\") and \"TRUSTED_FOR_DELEGATION\" in uac:\n print(f\"{sam}:unconstrained:\")\n if (filter_ == \"constrained\" or filter_ == \"all\") and delegate:\n transition = \"with\" if \"TRUSTED_TO_AUTH_FOR_DELEGATION\" in uac else \"without\"\n for a in delegate:\n print(f\"{sam}:constrained {transition} protocol transition:{a}\")\n if (filter_ == \"rbcd\" or filter_ == \"all\") and allowed_to_act:\n sd = parse_ntSecurityDescriptor(allowed_to_act)\n for ace in sd['DACL']['ACEs']:\n try:\n sid = ace.get('SID')\n if not sid:\n continue\n res = self.engine.resolve_sid(sid)\n name = res[0]['sAMAccountName']\n print(f\"{name}:rbcd:{sam}\")\n except Exception:\n print(f\"{sid}:rbcd:{sam}\")\n except Exception:\n continue","def get_owner_entities(self, username):\n\t\t#print('Quasar Utility Server getting owner entities for username{' + username + '}')\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_GET_OWNER_ENTITIES, username)","def clean_owner(self):\n username = self.cleaned_data['owner']\n owner = User.objects.filter(username=username).first()\n if owner is None:\n raise forms.ValidationError(\n _('User %(username)s does not exist'),\n params={'username': username},\n )\n if self.organization.owners.filter(username=username).exists():\n raise forms.ValidationError(\n _('User %(username)s is already an owner'),\n params={'username': username},\n )\n return owner","def test_search_ldapdn(self):\n ldap_dn = LDAPDN(self.basedn)\n obj = self.conn.search(ldap_dn, 1)\n self.assertIsNotNone(obj)","def test_resource_user_resource_get_user_by_email_address_get(self):\n pass","def get_email(nt_id):\n\n secret = json.loads(get_secret())\n username = secret['account_name']\n pw = secret['password']\n data = {\n \"domain\": \"corporate.t-mobile.com\",\n \"base_dname\": \"OU=Production,OU=Users,OU=Accounts,DC=Corporate,DC=T-Mobile,DC=com\",\n \"bind_dname\": \"CN=%s,OU=LDAPS,OU=Non-production,OU=Services,OU=Accounts,DC=corporate,DC=t-mobile,DC=com\" % username,\n \"password\": pw,\n \"obj_name\": nt_id,\n \"obj_class\": \"user\",\n \"attributes\": [\"mail\"],\n }\n lambda_client = boto3.client('lambda')\n invoke_response = lambda_client.invoke(\n FunctionName= os.environ.get(\"query_ldap\"),\n InvocationType= \"RequestResponse\",\n Payload= json.dumps(data)\n )\n if (\"FunctionError\" not in invoke_response):\n data = ast.literal_eval(json.load(invoke_response['Payload'])['body'])\n print(data)\n return data[0][0][1]['mail'][0]\n\n return None","def __getRecord(self, username):\n #ldap.set_option(ldap.OPT_DEBUG_LEVEL,4095)\n ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)\n ldap.set_option(ldap.OPT_X_TLS_CACERTFILE, self.certfile)\n self.ldo = ldap.initialize(self.host)\n self.ldo.set_option(ldap.OPT_PROTOCOL_VERSION, 3)\n self.ldo.simple_bind_s(self.dn, self.password)\n result = self.ldo.search_s(\"dc=mozilla\", ldap.SCOPE_SUBTREE, \"mail=\"+username)\n self.ldo.unbind_s()\n return result","def owners(self):\n return self._owners","def owners(self):\n return self._owners","def getInterestedUsers():","def authors(self):\n return self.properties.get('Authors', ClientValueCollection(SharedWithMeDocumentUser))","def ldap_search(self, ldapfilter):\n # Determine the scope value\n if self.args.recursive:\n scope = ldap.SCOPE_SUBTREE\n else:\n scope = ldap.SCOPE_ONELEVEL\n \n # Search ldap for results\n try:\n self.searchresult = self.ldapobj.search_s(self.args.basedn, scope, ldapfilter)\n except ldap.REFERRAL as ex:\n print >> sys.stderr, \"Error: LDAP referral received. Is the basedn correct?\"\n sys.exit(1)\n except ldap.INVALID_CREDENTIALS:\n print >> sys.stderr, \"Error: Invalid credentials\"\n sys.exit(1)\n except Exception as ex:\n print ex.__class__.__name__\n finally:\n self.ldapobj.unbind_s()","def test_owner(self):\n self.business_item_class.businesses_list = [{\"owner\": \"chairman\", \"business_name\":\"Maendeleo\", \"category\":\"Backaend\", \"location\":\"myhomecity\"},\n {\"owner\": \"chairmanwe\", \"business_name\":\"NshMaendeleo\", \"category\":\"Backaend\", \"location\":\"myhomecity\"}]\n user = \"chairman\"\n msg = self.business_item_class.getOwner(user)\n self.assertEqual(msg, [{\"owner\": \"chairman\", \"business_name\":\"Maendeleo\", \"category\":\"Backaend\", \"location\":\"myhomecity\"}])","def repo(owner: str, repo: str, uname: Optional[str] = typer.Argument(None)):\n typer.echo(github.find_emails_from_repo(username=owner, repo=repo, uname=uname))","def get_objects_owners(obj):\n type = obj.get_type()\n owners = []\n for user in obj.user_set.all():\n if type == Entities.TASK:\n relation = UserTasks.objects.get(user=user, task=obj)\n elif type == Entities.EVENT:\n relation = UserEvents.objects.get(user=user, event=obj)\n elif type == Entities.PLAN:\n relation = UserPlans.objects.get(user=user, plan=obj)\n else:\n raise TypeError\n owners.append(Owner(user.name, relation.access_level))\n\n return owners","def owners_only(command):\n @wraps(command)\n def wrapped_up(bot):\n if bot.message.nick not in conf.get('owners', []):\n return irc.Response('Sorry, you are not an owner thus not authorised to use this command', pm_user=True)\n return command(bot)\n wrapped_up.owner_only = True\n return wrapped_up","def test_get_user_by_emailuser_email_get(self):\n pass","def _IsValidPrimaryOwnerEmail(owner_tag_text):\n if '-' in owner_tag_text: # Check whether it's a team email address.\n return False\n\n return (owner_tag_text.endswith('@chromium.org')\n or owner_tag_text.endswith('@google.com'))","def owner(self):\n answer = self._call('owner')\n return answer.owner","def email(self):\n return \"{}.{}@company.com\".format(self.first, self.last)","def _init_owners(self, identity, record, **kwargs):\n # if the given identity is that of a user, we add the\n # corresponding user to the owners (record.access.owned_by)\n is_sys_id = system_process in identity.provides\n if not record.access.owned_by and not is_sys_id:\n record.access.owned_by.add({\"user\": identity.id})","def dn(self):\n return self._dn","def deep_clean_one2(self, email, dealno=0):\r\n resp = self.check_db(email, clean_type=1)\r\n try:\r\n return resp[EMAIL]\r\n except:\r\n return self.deep_clean_one(email, dealno=dealno)","def get_donor_email(self):\n input_name = self.get_donor()\n if input_name in self.all_donors:\n print(self.r.hget(input_name, 'email'))","def get_owner_info(\n self, auth_client: globus_sdk.AuthClient | None = None\n ) -> None | globus_sdk.GlobusConnectPersonalOwnerInfo | dict[str, t.Any]:\n fname = os.path.join(self._local_data_dir, \"gridmap\")\n try:\n # read file data into an owner info object\n try:\n owner_info = GlobusConnectPersonalOwnerInfo._from_file(fname)\n except ValueError: # may ValueError on invalid DN data\n return None\n except OSError as e:\n # no such file or directory\n if e.errno == 2:\n return None\n raise\n\n if auth_client is None:\n return owner_info\n\n if owner_info.id is not None:\n res = auth_client.get_identities(ids=owner_info.id)\n elif owner_info.username is not None:\n res = auth_client.get_identities(usernames=owner_info.username)\n else: # pragma: no cover\n raise ValueError(\"Something went wrong. Could not parse owner info.\")\n\n try: # could get no data back in theory, if the identity isn't visible\n return t.cast(t.Dict[str, t.Any], res[\"identities\"][0])\n except (KeyError, IndexError):\n return None","def owner(self) -> discord.User:\n if self.config.owner_id:\n return self.get_user(self.config.owner_id)\n if self.owner_ids:\n return self.get_user(self.config.owner_ids[0])\n return None","def get_subscription_owner(request, list_entry):\n return list_entry.profile_item.topic.profile.km_user.user","def get_users_for(self, email):\n # this is a list rather than a generator because we probably want to\n # do a len() on it right away\n return [address.user for address in \\\n self.filter(verified=True, email=email)]","def get_followings_of_a_user(tx: Transaction, email: str) -> BoltStatementResult:\n query = f\"\"\"\n MATCH (:Person {{email: '{email}'}})-[:FOLLOWS]->(follower) RETURN follower.full_name AS full_name, follower.email AS email, follower.profile_image AS profile_image\n \"\"\"\n return tx.run(query)","def displayname(self):\n return self.email","def adjust_entry_ldap(entry, base_path):\n if 'mail' not in entry:\n return\n mail = entry['mail'][0]\n\n # remove attribute if exist\n rm_keys = ['modifytimestamp', 'birthyear', 'birthday']\n for rm_key in rm_keys:\n if rm_key in entry:\n del entry[rm_key]\n\n # append attribute\n if 'cn' not in entry:\n entry['cn'] = [mail]\n\n if 'sn' not in entry:\n entry['sn'] = [mail]\n\n # replace attribute\n if 'dn' in entry:\n entry['dn'] = [f'mail={mail},{base_path}']","def email(self, instance):\r\n return instance.user.email","def computeMailboxOu(portal, title):\n\n catalog = portal.portal_catalog\n\n current = cleaned = toAscii(title).lower()\n i = 1\n existing = True\n while existing:\n existing = catalog(ou=current)\n if not existing:\n break\n current = '%s_%d' % (cleaned, i)\n i += 1\n dtool = getToolByName(portal, 'portal_directories', None)\n if dtool is not None: # not in unit tests\n ldir = getattr(dtool, 'local_addressbook_ldap', None)\n if ldir is not None:\n createOuInLDAP(ldir, current)\n return current","def __filter_by_domain_and_username(self, cursor):\n result = []\n for _ in range(cursor.count()):\n record = cursor.next()\n domain = record[PASSWORD_MANAGER_COLLECTION_DOMAIN_FIELD]\n username = record[PASSWORD_MANAGER_COLLECTION_USERNAME_FIELD]\n if self.domain.lower() in domain.lower():\n if self.username != None:\n if self.username.lower() in username.lower():\n result.append({\n PASSWORD_MANAGER_COLLECTION_DOMAIN_FIELD: domain,\n PASSWORD_MANAGER_COLLECTION_USERNAME_FIELD: username\n })\n else:\n result.append({\n PASSWORD_MANAGER_COLLECTION_DOMAIN_FIELD: domain,\n PASSWORD_MANAGER_COLLECTION_USERNAME_FIELD: username\n })\n return result","def getObjectSearchItem(self, user, dn):\n # Start the query and bring the result in a usable form\n index = PluginRegistry.getInstance(\"ObjectIndex\")\n\n item = index.find(user, {'dn': dn})\n if len(item) == 1:\n item = item[0]\n else:\n return None\n\n if item['_type'] not in self.__search_aid['mapping']:\n return None\n\n entry = {'tag': item['_type']}\n for k, v in self.__search_aid['mapping'][item['_type']].items():\n if k:\n if v in item and item[v]:\n if v == \"dn\":\n entry[k] = item[v]\n else:\n entry[k] = item[v][0]\n else:\n entry[k] = self.__build_value(v, item)\n\n return entry","def userdn(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"userdn\")","def userdn(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"userdn\")","def test_get_email_address(self):\n email_addr = 'test_get_email_addr' + '@' + self.email_dom\n org = 'o=%s' % (self.org_name)\n people = '%s=%s' % (self.container_attr, self.user_container)\n uid = '%s=%s' % (self.user_key, self.user_id)\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\n dn_info = {self.smtp_address: [email_addr]}\n expected_result = [(dn, dn_info)] \n addr = SpokeEmailAddress(self.org_name, self.user_id)\n addr.create(email_addr)\n result = addr.get(email_addr)['data']\n self.assertEqual(result, expected_result)","def __get_addr_grp(self, objtype, address=None):\n if address is not None:\n return self.get(\"/%s/entry[@name='%s']\"%(objtype, address))\n else:\n return self.get(\"/%s/entry\"%objtype)","def manage_owners():\n\n owner_data = request.get_json(force=True)\n return _get_owner_service().create_owner(owner_data)","def _find_groups_for_user(email):\n return [g['name'] for g in groups.find({\"users\":email})]","def email(self):\n return '{}.{}@email.com'.format(self.fname,self.lname)"],"string":"[\n \"def handle_empty_owners():\\n result = shared_ldap.find_from_email(shared.globals.REPORTER)\\n if result is not None:\\n shared_sd.post_comment(\\n \\\"Adding %s as the owner of the group.\\\" % shared.globals.REPORTER, True)\\n return [result]\\n\\n # OK - something stupid is happening but let's give ourselves\\n # a safety net.\\n shared_sd.post_comment(\\n \\\"Unable to add %s as an owner as the email address cannot be \\\"\\n \\\"found in Linaro Login. This means the automation has not \\\"\\n \\\"been able to find any of the specified email addresses in \\\"\\n \\\"Linaro Login. Consequently, IT Services will need to manage \\\"\\n \\\"it in the interim.\\\" % shared.globals.REPORTER, True)\\n return [\\\"cn=its,ou=mailing,ou=groups,dc=linaro,dc=org\\\"]\",\n \"def ldap_get_email(self, user):\\n result = super(Auth42, self)._search_not_empty(user)\\n if result is not None:\\n alias = result.get(\\\"alias\\\")[1]\\n return alias\\n\\n return None\",\n \"def get_dn(conn, object_class, property_value, property_name='sAMAccountName'):\\n\\n ldap_filter = f'(&(objectClass={object_class})({property_name}={property_value}))'\\n conn.search(conn.server.info.other['DefaultNamingContext'], ldap_filter)\\n dn_list = [entry.entry_dn for entry in conn.entries]\\n return dn_list\",\n \"def owners(self):\\n return self.properties.get('owners',\\n DirectoryObjectCollection(self.context, ResourcePath(\\\"owners\\\", self.resource_path)))\",\n \"def get_ldap_users(conn, searchfilter, attrs):\\n\\n base_dn = conn.server.info.other['DefaultNamingContext'][0]\\n conn.search(search_base=base_dn, search_filter=searchfilter, attributes=attrs)\\n return conn.entries\",\n \"def email_lookup(self):\\n if not hasattr(self, \\\"_email_lookup\\\"):\\n self._email_lookup = {}\\n self.load_data()\\n for entry in self.data.get(\\\"contributor\\\", []):\\n if \\\"email\\\" in entry:\\n self._email_lookup[entry[\\\"email\\\"]] = entry\\n return self._email_lookup\",\n \"def getPropertyOwners(self) -> List[unicode]:\\n ...\",\n \"def referring_ad_rep_email(obj):\\n if obj.ad_rep is None:\\n email = ''\\n else:\\n email = obj.ad_rep.email\\n return \\\"%s\\\" % email\",\n \"def list_ou(self, _):\\n cn_re = re_compile(\\\"{[^}]+}\\\")\\n results = self.engine.query(self.engine.GPO_INFO_FILTER(), [\\\"cn\\\", \\\"displayName\\\"])\\n gpos = {}\\n for gpo in results:\\n gpos[gpo[\\\"cn\\\"]] = gpo[\\\"displayName\\\"]\\n\\n results = self.engine.query(self.engine.OU_FILTER())\\n for result in results:\\n print(result[\\\"distinguishedName\\\"])\\n if \\\"gPLink\\\" in result:\\n guids = cn_re.findall(result[\\\"gPLink\\\"])\\n if len(guids) > 0:\\n print(\\\"[gPLink]\\\")\\n print(\\\"* {}\\\".format(\\\"\\\\n* \\\".join([gpos[g] if g in gpos else g for g in guids])))\",\n \"def _MakeOwners(document, path, emails_with_dom_elements):\\n owner_elements = []\\n # TODO(crbug.com/987709): An OWNERS file API would be ideal.\\n emails_from_owners_file = _ExtractEmailAddressesFromOWNERS(path)\\n if not emails_from_owners_file:\\n raise Error('No emails could be derived from {}.'.format(path))\\n\\n # A list is used to respect the order of email addresses in the OWNERS file.\\n deduped_emails_from_owners_file = []\\n for email in emails_from_owners_file:\\n if email not in emails_with_dom_elements:\\n deduped_emails_from_owners_file.append(email)\\n emails_with_dom_elements.add(email)\\n\\n for email in deduped_emails_from_owners_file:\\n owner_element = document.createElement('owner')\\n owner_element.appendChild(document.createTextNode(email))\\n owner_elements.append(owner_element)\\n return owner_elements\",\n \"def owners(self):\\n return self.find_users_by_rel('owner')\",\n \"def ad_rep_email(obj):\\n return '%s' % obj.ad_rep.email\",\n \"def prov_account(ldp_cnf, ldap_query, attrs):\\n for dn, entry in ldapQuery(ldp_cnf, ldap_query, attrs):\\n mail_account = entry['zimbraMailDeliveryAddress'][0]\\n print 'ca %s 12qwasZX.,1\\\\n' % mail_account,\\n print 'ma %s ' % mail_account,\\n for zimbra_attr in zimbra_attributes():\\n try:\\n attr_data = entry[zimbra_attr]\\n print zimbra_attr,\\n for value in attr_data:\\n # We need to print \\\\n instead of breaking line.\\n value = value.replace('\\\\n', '\\\\\\\\n')\\n # We need to escape single quotes.\\n value = value.replace(\\\"'\\\", \\\"\\\\\\\\'\\\")\\n if zimbra_attr == 'zimbraPrefMailForwardingAddress':\\n # zimbraPrefMailForwardingAddress must always have accounts separated by comma\\n value = value.replace(';', ',')\\n\\n print \\\"'%s'\\\" % value,\\n except KeyError:\\n continue\\n \\n # Attributes finished for the given account, we need to break line to move to next account\\n print\\n\\n if entry.get('zimbraMailAlias'):\\n for alias in entry['zimbraMailAlias']:\\n print 'aal', mail_account, alias\\n###Forward oculto +zimbraMailForwardingAddress\\n if entry.get('zimbraMailForwardingAddress'):\\n for forward in entry['zimbraMailForwardingAddress']:\\n print 'ma', mail_account, '+zimbraMailForwardingAddress', forward\",\n \"def getResponsibleUsers():\",\n \"def locate_users_with_gapps(self):\\n return self.ldap_connection.search_s(\\\"ou=mx,dc=redhat,dc=com\\\",\\n ldap.SCOPE_SUBTREE, \\\"(|(sendmailMTAAliasValue=*@gapps.redhat.com)(sendmailMTAKey=*@gapps.redhat.com))\\\",\\n [\\\"sendmailMTAKey\\\", \\\"sendmailMTAAliasValue\\\", \\\"rhatMTAAllowExternal\\\"])\",\n \"def get_owners_list(self):\\n final_list = []\\n for entry in self.bot_data_file[\\\"owners_data\\\"][\\\"owners_list\\\"]:\\n final_list.append(str(entry[\\\"name\\\"]))\\n if len(final_list) == 0:\\n print(\\\"ERROR GETTING THE OWNERS LIST (i need at least 1 owner) - BOT ABORTING\\\")\\n quit(1)\\n else:\\n return final_list\",\n \"def get_account_info(accountType,baseDN,user,password):\\n accounts = []\\n searchScope = ldap.SCOPE_SUBTREE\\n try:\\n l = ldap.initialize('ldap://ldap1.kps')\\n l.protocol_version = ldap.VERSION3\\n l.simple_bind_s(user, password)\\n r = l.search_s(baseDN, searchScope, searchFilter, retrieveAttributes)\\n res = ldaphelper.get_search_results(r)\\n for record in res:\\n cn = record.get_attr_values('cn')[0]\\n cn = cn.lower()\\n mail = record.get_attr_values('mail')[0]\\n mail = mail.lower()\\n id = record.get_attr_values('studentID')[0]\\n accounts.append(id,cn,email)\\n except ldap.LDAPError, e:\\n print e\\n return accounts\",\n \"def test_search_attrsonly(self):\\n obj = self.conn.search(self.basedn, 2, \\\"(objectclass=person)\\\",\\n ['cn'], attrsonly=True)[0]\\n self.assertIsNotNone(obj)\\n self.assertListEqual(obj['cn'], [])\",\n \"def direct():\\n\\n unsafe_dc = request.args['dc']\\n unsafe_filter = request.args['username']\\n\\n dn = \\\"dc={}\\\".format(unsafe_dc)\\n search_filter = \\\"(user={})\\\".format(unsafe_filter)\\n\\n srv = ldap3.Server('ldap://127.0.0.1')\\n conn = ldap3.Connection(srv, user=dn, auto_bind=True).search(\\n dn, search_filter)\",\n \"def business_owner_email(self):\\n return self._business_owner_email\",\n \"def technical_owner_email(self):\\n return self._technical_owner_email\",\n \"def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"owners\\\")\",\n \"def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"owners\\\")\",\n \"def search( self, base=False, trim=False, **kwargs ): \\n scope = pyldap.SCOPE_SUBTREE\\n if not base:\\n base = self.users\\n \\n filterstr =''\\n for key, value in kwargs.iteritems():\\n filterstr += '({0}={1})'.format(key,value)\\n if key == 'dn': \\n filterstr = '(objectClass=*)'\\n base = value\\n scope = pyldap.SCOPE_BASE\\n break\\n \\n if len(kwargs) > 1:\\n filterstr = '(&'+filterstr+')'\\n \\n result = self.ldap.search_s(base, pyldap.SCOPE_SUBTREE, filterstr, ['*','+'])\\n if base == self.users:\\n for member in result:\\n groups = self.getGroups(member[0])\\n member[1]['groups'] = groups\\n if 'eboard' in member[1]['groups']:\\n member[1]['committee'] = self.search(base=self.committees, \\\\\\n head=member[0])[0][1]['cn'][0]\\n\\n if trim: return self.trimResult(result)\\n else: return result\",\n \"def owners(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"owners\\\")\",\n \"def owner(self):\\n return Organization.objects.get(id=self.owner_id)\",\n \"def manager_info(self, manager_cn):\\n manager_login = manager_cn[4:manager_cn.find(\\\",\\\")]\\n manager_info = self.locate_user(manager_login)\\n try:\\n return manager_info[0][1]['cn'][0] + \\\\\\n \\\" (\\\" + manager_info[0][1]['uid'][0] + \\\")\\\"\\n except IndexError:\\n return \\\"(LDAP record removed) %s\\\" % manager_cn\",\n \"def _get_dn(self, environ, identity):\\n\\n if self.bind_dn:\\n try:\\n self.ldap_connection.bind_s(self.bind_dn, self.bind_password)\\n except ldap.LDAPError:\\n raise ValueError(\\\"Couldn't bind with supplied credentials\\\")\\n try:\\n login_name = identity['login'].replace('*',r'\\\\*')\\n srch = self.search_pattern % login_name\\n dn_list = self.ldap_connection.search_s(\\n self.base_dn,\\n self.search_scope,\\n srch,\\n )\\n\\n # here is the change; return the CN of the first.\\n if len(dn_list) >= 1:\\n return dn_list[0][0]\\n else:\\n raise ValueError('No entry found for %s' %srch)\\n except (KeyError, TypeError, ldap.LDAPError):\\n raise # ValueError\",\n \"def normal():\\n\\n unsafe_dc = request.args['dc']\\n unsafe_filter = request.args['username']\\n\\n dn = \\\"dc={}\\\".format(unsafe_dc)\\n search_filter = \\\"(user={})\\\".format(unsafe_filter)\\n\\n srv = ldap3.Server('ldap://127.0.0.1')\\n conn = ldap3.Connection(srv, user=dn, auto_bind=True)\\n conn.search(dn, search_filter)\",\n \"def get_emails(parsed_data):\\n result = []\\n known_values = []\\n contacts = {'registrant_contact': [], 'administrative_contact': [], 'technical_contact': [],\\n 'domain_registrar': []}\\n if 'registrant_contact' in parsed_data:\\n contacts['registrant_contact'].append(parsed_data['registrant_contact'])\\n if 'administrative_contact' in parsed_data:\\n contacts['administrative_contact'].append(parsed_data['administrative_contact'])\\n if 'technical_contact' in parsed_data:\\n contacts['technical_contact'].append(parsed_data['technical_contact'])\\n if 'domain_registrar' in parsed_data:\\n contacts['domain_registrar'].append(parsed_data['domain_registrar'])\\n # parsing email address from contact block\\n\\n for contact, info in contacts.items():\\n if info is not None:\\n d = {'type': 2, 'data': '', 'properties': {}, 'special_properties': {}, 'is_valid': False, 'ref': {}}\\n # properties dictionary\\n is_valid = {}\\n owner = {'owner': '', 'type': 11}\\n organization = {'organization': '', 'type': 11}\\n local_address = {'local_address': '', 'type': 5}\\n domain_name = {'domain_name': '', 'type': 12}\\n properties_list = []\\n special_properties_list = []\\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': ''}})\\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\\n d['ref']['whois_for'] = parsed_data['domain_name']\\n if 'whois_server' in parsed_data:\\n d['ref']['whois_from'] = parsed_data['whois_server']\\n\\n for name in info:\\n if \\\"email_address\\\" in name:\\n if name['email_address'] in known_values:\\n break\\n for feature in name.keys():\\n if feature == \\\"email_address\\\":\\n d['data'] = name['email_address']\\n known_values.append(name['email_address'])\\n\\n if feature == \\\"full_name\\\":\\n owner['owner'] = name['full_name']\\n properties_list.append(owner)\\n\\n if feature == \\\"city_name\\\":\\n organization['organization'] = name['city_name']\\n properties_list.append(organization)\\n\\n d['is_valid'] = ''\\n is_valid = {'isvalid': '', 'type': 0}\\n\\n # prevent from create result if phone number of contact is not available\\n if d['data'] == '':\\n continue\\n try:\\n domain_name['domain_name'] = d['data'].split('@')[1]\\n local_address['local_address'] = d['data'].split('@')[0]\\n properties_list.append(domain_name)\\n properties_list.append(local_address)\\n except:\\n\\n domain_name['domain_name'] = ''\\n local_address['local_address'] = d['data']\\n properties_list.append(domain_name)\\n properties_list.append(local_address)\\n\\n d.update({'ref': {'task': 'whois', 'whois_for': '', 'whois_from': '', 'label': ''}})\\n d['ref']['label'] = \\\"%s_name\\\" % contact\\n if 'domain_name' in parsed_data and len(parsed_data['domain_name']) > 0:\\n d['ref']['whois_for'] = parsed_data['domain_name']\\n if 'whois_server' in parsed_data:\\n d['ref']['whois_from'] = parsed_data['whois_server']\\n d['properties'] = properties_list\\n special_properties_list.append(is_valid)\\n d['special_properties'] = special_properties_list\\n result.append(d)\\n\\n return result\",\n \"def get_owner(self, obj):\\n return obj.user.username\",\n \"def search_ldap(l, filter, base, scope=ldap.SCOPE_SUBTREE, attributes=None, accountname=None, DEBUG=False):\\r\\n if '%s' in filter:\\r\\n query = filter % accountname\\r\\n else:\\r\\n query = filter\\r\\n if DEBUG:\\r\\n warning(\\\"searching for user '%s' in base: %s. retrieve attributes: %s, scope: %s\\\"%(accountname, base, attributes, scope))\\r\\n warning('Filter string: %s'%(query,))\\r\\n try:\\r\\n ldap_result_id = l.search(base, scope, query, attributes)\\r\\n if DEBUG:\\r\\n warning('ldap_result_id: %s'%ldap_result_id)\\r\\n result_set = llist()\\r\\n result_type, result_data = l.result(ldap_result_id, 0)\\r\\n if DEBUG:\\r\\n warning('len of result_data: %d'%len(result_data))\\r\\n while result_type == ldap.RES_SEARCH_ENTRY:\\r\\n result_data = result_data[0]\\r\\n #data = ( result_data[0] , { i:result_data[1][i] for i in result_data[1] } )\\r\\n user_data = ldict({i: result_data[1][i][0] if len(result_data[1][i])==1 else result_data[1][i] for i in result_data[1]})\\r\\n user_data['dn'] = result_data[0]\\r\\n if isinstance(user_data['dn'], list):\\r\\n user_data['dn'] = user_data['dn'][0]\\r\\n\\r\\n result_set.append(user_data)\\r\\n result_type, result_data = l.result(ldap_result_id, 0)\\r\\n if DEBUG:\\r\\n warning('len of result_data: %d'%len(result_data))\\r\\n\\r\\n return result_set\\r\\n\\r\\n except ldap.LDAPError, e:\\r\\n print e\\r\\n return None\",\n \"def test_search_attr(self):\\n obj = self.conn.search(self.basedn, 2, \\\"(objectclass=person)\\\",\\n ['cn'])[0]\\n self.assertIsNotNone(obj)\\n if 'cn' not in obj.keys():\\n self.fail()\",\n \"def fetch_owner_accounts():\\n resp = oauth.tapkey.get('Owners')\\n owner_accounts = resp.json()\\n return owner_accounts\",\n \"def search_user_information(conn, ldap_domain, ldap_domain_ext, user_login):\\n try:\\n search_base = \\\"dc={}, dc={}\\\".format(ldap_domain, ldap_domain_ext)\\n query = \\\"(&(objectclass=user)(objectCategory=person)\\\" \\\\\\n \\\"(sAMAccountName={})(userAccountControl=512))\\\".format(user_login)\\n attributes = ['distinguishedName', 'displayname']\\n\\n conn.search(search_base, query, attributes=attributes)\\n user = conn.entries\\n\\n if not user:\\n raise Exception(\\\"users not found\\\")\\n except Exception as e:\\n raise Exception(\\\"unable to search user information :: {}\\\".format(e))\\n return user\",\n \"def get_email(obj):\\r\\n return obj.user.email\",\n \"def get_ldap_contact(ldap_conn, base_dn, employee_number, unique_id, attrs, cache):\\r\\n search_filter = '{0}={1}'.format(unique_id, employee_number)\\r\\n results = ldap_conn.search_s(base_dn, ldap.SCOPE_SUBTREE, search_filter, attrs)\\r\\n contact_found = {}\\r\\n if results:\\r\\n attrs_found = results[0][1]\\r\\n # cache the dn for the employee_number\\r\\n cache[employee_number] = results[0][0]\\r\\n for key in attrs:\\r\\n if key in attrs_found:\\r\\n contact_found[key] = attrs_found[key][0]\\r\\n else:\\r\\n contact_found[key] = False\\r\\n else:\\r\\n logging.warning('Cannot found employee in ldap ' + employee_number)\\r\\n return contact_found\",\n \"def provDistributionList(ldp_conf, ldap_query, attrs):\\n for dn, entry in ldapQuery(ldp_conf, ldap_query, attrs):\\n distribution_list_name = entry['mail'][0]\\n print 'cdl', distribution_list_name\\n print 'adlm', distribution_list_name, \\n if not 'zimbraMailForwardingAddress' in entry:\\n continue\\n for member in entry['zimbraMailForwardingAddress']:\\n print member,\\n # Break line, distribution list member finished\\n print\\n # Finish\\n print\",\n \"def search(self, base=USERS, trim=False, **kwargs):\\n search_filter = ''\\n for key, value in kwargs.items():\\n if isinstance(value, list):\\n search_filter += '(|'\\n for term in value:\\n term = term.replace('(', '\\\\\\\\(')\\n term = term.replace(')', '\\\\\\\\)')\\n search_filter += '({0}={1})'.format(key, term)\\n search_filter += ')'\\n else:\\n value = value.replace('(', '\\\\\\\\(')\\n value = value.replace(')', '\\\\\\\\)')\\n search_filter += '({0}={1})'.format(key, value)\\n\\n if key == 'dn':\\n search_filter = '(objectClass=*)'\\n base = value\\n break\\n\\n if len(kwargs) > 1:\\n search_filter = '(&' + search_filter + ')'\\n\\n result = self.ldap_conn.search(search_base=base, search_filter=search_filter, attributes=['*', '+'])\\n if result:\\n if base == USERS:\\n for member in self.ldap_conn.response:\\n if self.debug:\\n print(\\\"[DEBUG] Entry: \\\" + str(member))\\n\\n groups = self.get_groups(member['dn'])\\n member['attributes']['groups'] = groups\\n\\n if 'eboard' in member['attributes']['groups']:\\n eboard_search = self.search(base=COMMITTEES, head=member['dn'])\\n\\n if eboard_search:\\n member.committee = self.ldap_conn.reponse[0]['attributes']['cn']\\n\\n if self.objects:\\n return self.member_objects(self.ldap_conn.response)\\n\\n final_result = self._trim_result(self.ldap_conn.response) if trim else self.ldap_conn.response\\n else:\\n final_result = []\\n\\n return final_result\",\n \"def _process_ldap_info_for_one_user(self, record, result_data):\\n #One entry only in the ldap data because we used a filter\\n #to find one user only\\n ldapentry = result_data[0][1]\\n logger.debug(\\\"LDAP.PY \\\\t LdapFindUser ldapentry %s\\\" % (ldapentry))\\n tmpname = ldapentry['uid'][0]\\n\\n tmpemail = ldapentry['mail'][0]\\n if ldapentry['mail'][0] == \\\"unknown\\\":\\n tmpemail = None\\n\\n parent_hrn = None\\n peer_authority = None\\n if 'hrn' in record:\\n hrn = record['hrn']\\n parent_hrn = get_authority(hrn)\\n if parent_hrn != self.authname:\\n peer_authority = parent_hrn\\n #In case the user was not imported from Iotlab LDAP\\n #but from another federated site, has an account in\\n #iotlab but currently using his hrn from federated site\\n #then the login is different from the one found in its hrn\\n if tmpname != hrn.split('.')[1]:\\n hrn = None\\n else:\\n hrn = None\\n\\n results = {\\n 'type': 'user',\\n 'pkey': ldapentry['sshPublicKey'],\\n #'uid': ldapentry[1]['uid'][0],\\n 'uid': tmpname,\\n 'email': tmpemail,\\n #'email': ldapentry[1]['mail'][0],\\n 'first_name': ldapentry['givenName'][0],\\n 'last_name': ldapentry['sn'][0],\\n #'phone': 'none',\\n 'serial': 'none',\\n 'authority': parent_hrn,\\n 'peer_authority': peer_authority,\\n 'pointer': -1,\\n 'hrn': hrn,\\n }\\n return results\",\n \"def _ExtractEmailAddressesFromOWNERS(path, depth=0):\\n # It is unlikely that any chain of OWNERS files will exceed 10 redirections\\n # via file:// directives.\\n limit = 10\\n if (depth > limit):\\n raise Error('_ExtractEmailAddressesFromOWNERS has been called {} times. The'\\n ' path {} may be part of an OWNERS loop.'.format(limit, path))\\n\\n directive = 'file://'\\n email_pattern = re.compile(_EMAIL_PATTERN)\\n extracted_emails = []\\n\\n with open(path, 'r') as owners_file:\\n for line in [line.lstrip()\\n for line in owners_file.read().splitlines() if line]:\\n index = line.find(' ')\\n first_word = line[:index] if index != -1 else line\\n\\n if email_pattern.match(first_word):\\n extracted_emails.append(first_word)\\n\\n elif first_word.startswith(directive):\\n next_path = _GetOwnersFilePath(\\n os.path.join(SRC, first_word[len(directive):]))\\n\\n if os.path.exists(next_path) and os.path.isfile(next_path):\\n extracted_emails.extend(\\n _ExtractEmailAddressesFromOWNERS(next_path, depth + 1))\\n else:\\n raise Error('The path derived from {} does not exist. '\\n 'Derived path: {}'.format(first_word, next_path))\\n\\n return extracted_emails\",\n \"def _return_specific_owner_prs(all_prs, filters):\\n if _validate_list_of_dict(all_prs):\\n owner_prs = [pr for pr in all_prs if filters['owner'] == pr['pr'].user.login]\\n logger.debug(\\\"OWNER PRS: %s\\\", [pr['pr'].number for pr in owner_prs])\\n return owner_prs\\n else:\\n return []\",\n \"def _ssl_dn_extract_info(dn_string):\\r\\n ss = re.search('/emailAddress=(.*)@([^/]+)', dn_string)\\r\\n if ss:\\r\\n user = ss.group(1)\\r\\n email = \\\"%s@%s\\\" % (user, ss.group(2))\\r\\n else:\\r\\n return None\\r\\n ss = re.search('/CN=([^/]+)/', dn_string)\\r\\n if ss:\\r\\n fullname = ss.group(1)\\r\\n else:\\r\\n return None\\r\\n return (user, email, fullname)\",\n \"def copyToLdap(user_email):\\n user = User.objects.get(email=user_email)\\n social = user.social_auth.get(provider='google-oauth2')\\n print (\\\"Get social\\\")\\n print (social)\\n domain = user_email.split('@')[1]\\n print(domain)\\n response = requests.get(\\n 'https://www.googleapis.com/admin/directory/v1/users?domain={}'.format(domain),\\n params={'access_token': social.extra_data['access_token']}\\n )\\n print (response.json())\\n gappsUsers = response.json().get('users')\\n # update records\\n confirmedLdapUsers = []\\n for gUser in gappsUsers:\\n print (gUser.get('primaryEmail'))\\n try:\\n usr = LdapUser.objects.get(email=gUser.get('primaryEmail'))\\n #check if user needs to be deleted\\n if gUser['suspended']:\\n usr.delete()\\n continue\\n except LdapUser.DoesNotExist:\\n if gUser['suspended']:\\n continue\\n usr = LdapUser(email=gUser.get('primaryEmail'), password = ''.join(secrets.choice(ALPHABET) for i in range(10)))\\n \\n usr.group = 1\\n usr.uid = gUser['id'] \\n usr.first_name = gUser['name']['givenName']\\n usr.last_name = gUser['name']['familyName']\\n usr.full_name = gUser['name']['fullName']\\n usr.username = gUser.get('primaryEmail')\\n usr.home_directory = \\\"/\\\"\\n usr.save()\\n\\n confirmedLdapUsers.append(usr.email)\\n\\n #delete users from ldap that are not gApps users\\n LdapUser.objects.all().exclude(email__in=confirmedLdapUsers).delete()\\n\\n return domain\",\n \"def search_from_ldap(conn, base, scope=ldap.SCOPE_BASE,\\n filterstr=\\\"(objectClass=*)\\\",\\n attrlist=None, attrsonly=0):\\n try:\\n result = conn.search_s(base, scope)\\n ret = result[0]\\n except ldap.NO_SUCH_OBJECT:\\n ret = (\\\"\\\", {},)\\n return ret\",\n \"def get_accounts_for_emails(cls, emails):\\n return cls.get_by_key_name(['<%s>' % email for email in emails])\",\n \"def update_from_emails(self, emails):\\n # Now add contributors using cache (new GitHub contributors) with known email or orcid that isn't present\\n for email in emails:\\n if email not in self.email_lookup:\\n bot.info(f\\\" Updating with new added email: {email}\\\")\\n entry = {\\\"@type\\\": \\\"Person\\\", \\\"email\\\": email}\\n self.lookup.append(entry)\",\n \"def get_author_emails(self, author_node):\\n emails = author_node.xpath('string(./e-address[@type=\\\"email\\\"][1])').getall()\\n\\n return emails\",\n \"def owner_name(self, operator: Enum, owner_name: list | str):\\n if isinstance(owner_name, list) and operator not in self.list_types:\\n raise RuntimeError(\\n 'Operator must be CONTAINS, NOT_CONTAINS, IN'\\n 'or NOT_IN when filtering on a list of values.'\\n )\\n\\n self._tql.add_filter('ownerName', operator, owner_name, TqlType.STRING)\",\n \"def get_recipients(item_container):\\n if item_container.item.string_1 != '':\\n user_folder = get_item_container_by_path(item_container.item.string_1)\\n return get_all_users_with_email(user_folder)\\n else:\\n while not check_userfolder(item_container):\\n item_container = item_container.get_parent()\\n return get_all_users_with_email(item_container)\",\n \"def get_users_for(self, email):\\r\\n # this is a list rather than a generator because we probably want to do a len() on it right away\\r\\n return [address.user for address in EmailAddress.objects.filter(verified=True, email=email)]\",\n \"def emails() -> st.SearchStrategy[str]:\\n return (\\n st.emails()\\n .map(lambda s: s.lower())\\n .map(_validate_email)\\n .filter(_is_valid_email)\\n .map(lambda m: m.normalized) # type: ignore[union-attr]\\n )\",\n \"def get_from_ldap(val):\\n def process_stuff(ask):\\n result = []\\n r = json.loads(ask.text)\\n for e in r:\\n if e['is_active']:\\n if e['primary_affiliation'] == 'student':\\n affiliation = _('Étudiant')\\n cmp = e['main_registration_code'] if e[\\n 'main_registration_code'] is not None else _(\\n 'Non renseigné')\\n else:\\n cmp = e['main_affectation_code'] if e[\\n 'main_affectation_code'] is not None else _(\\n 'Non renseigné')\\n if e['primary_affiliation'] == 'employee':\\n affiliation = _('Administratif')\\n else:\\n affiliation = _('Enseignant')\\n person = {\\n \\\"last_name\\\": \\\"%s (%s)\\\" % (e['last_name'], val.capitalize(\\n )) if val.capitalize() != e['last_name'].capitalize(\\n ) and '*' not in val else e['last_name'],\\n \\\"first_name\\\": e.get('first_name').title(),\\n \\\"status\\\": affiliation,\\n \\\"institute\\\": cmp,\\n \\\"birth_date\\\": e.get('birth_date'),\\n \\\"username\\\": e.get('username'),\\n \\\"mail\\\": e.get('mail'),\\n \\\"birth_name\\\": e.get('birth_name').title()\\n }\\n result.append(person)\\n return result\\n client = create_client('ldap_client', settings.LDAP_TOKEN,\\n settings.LDAP_SPORE, settings.LDAP_BASE_URL)\\n ask = client.list_accounts(\\n format='json', establishment='UDS', last_or_birth_name=val)\\n\\n return process_stuff(ask)\",\n \"def get_owners(self, property_class_name):\\n res = []\\n for x in self.owner_properties:\\n if str(x.__class__.__name__) == str(property_class_name):\\n res.append(x.owner)\\n return res\",\n \"def orcid_lookup(self):\\n if not hasattr(self, \\\"_orcid_lookup\\\"):\\n self._orcid_lookup = {}\\n self.load_data()\\n for entry in self.data.get(\\\"contributor\\\", []):\\n if \\\"@id\\\" in entry:\\n # Orcid represented as full URL but we just want id\\n orcid = entry[\\\"@id\\\"].split(\\\"/\\\")[-1]\\n self._orcid_lookup[orcid] = entry\\n return self._orcid_lookup\",\n \"def audit_emails_in_metadata(self):\\n\\n # Iterate over commits....\\n disallowed_domains = [\\\"localhost\\\", \\\"localhost.localdomain\\\", \\\"(none)\\\", \\\"bombardier.com\\\", \\\"rail.bombardier.com\\\"]\\n for commit in self.repository.commits.values():\\n for email_address in [ commit.committer_email, commit.author_email ]:\\n # Extract the email address, and reject them if extraction fails....\\n extraction = re.match(\\\"^(\\\\S+)@(\\\\S+)$\\\", email_address)\\n if not extraction:\\n self.__log_failure(commit.sha1, \\\"Seemingly invalid email address: \\\" + email_address)\\n continue\\n\\n # Don't allow domains which are disallowed...\\n domain = extraction.group(2)\\n if domain in disallowed_domains:\\n self.__log_failure(commit.sha1, \\\"Email address using a blocked domain: \\\" + email_address)\\n continue\\n\\n # Ensure they have a valid MX/A entry in DNS....\\n try:\\n dns.resolver.query(domain, \\\"MX\\\")\\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel):\\n try:\\n dns.resolver.query(domain, \\\"A\\\")\\n except (dns.resolver.NoAnswer, dns.exception.Timeout, dns.name.EmptyLabel, dns.resolver.NXDOMAIN):\\n self.__log_failure(commit.sha1, \\\"Email address has an invalid domain : \\\" + email_address)\\n except (dns.resolver.NXDOMAIN, dns.resolver.NoNameservers):\\n self.__log_failure(commit.sha1, \\\"Email address has an invalid domain : \\\" + email_address)\",\n \"def _process_ldap_info_for_all_users(self, result_data):\\n results = []\\n logger.debug(\\\" LDAP.py _process_ldap_info_for_all_users result_data %s \\\"\\n % (result_data))\\n for ldapentry in result_data:\\n logger.debug(\\\" LDAP.py _process_ldap_info_for_all_users \\\\\\n ldapentry name : %s \\\" % (ldapentry[1]['uid'][0]))\\n tmpname = ldapentry[1]['uid'][0]\\n hrn = self.authname + \\\".\\\" + tmpname\\n\\n tmpemail = ldapentry[1]['mail'][0]\\n if ldapentry[1]['mail'][0] == \\\"unknown\\\":\\n tmpemail = None\\n\\n try:\\n results.append({\\n 'type': 'user',\\n 'pkey': ldapentry[1]['sshPublicKey'][0],\\n #'uid': ldapentry[1]['uid'][0],\\n 'uid': tmpname ,\\n 'email':tmpemail,\\n #'email': ldapentry[1]['mail'][0],\\n 'first_name': ldapentry[1]['givenName'][0],\\n 'last_name': ldapentry[1]['sn'][0],\\n #'phone': 'none',\\n 'serial': 'none',\\n 'authority': self.authname,\\n 'peer_authority': '',\\n 'pointer': -1,\\n 'hrn': hrn,\\n })\\n except KeyError, error:\\n logger.log_exc(\\\"LDAPapi.PY \\\\t LdapFindUser EXCEPTION %s\\\"\\n % (error))\\n return\\n\\n return results\",\n \"def sambaaccountsindomainroot(domainroot, l):\\n dns = {}\\n r = l.search_s(domainroot, ldap.SCOPE_SUBTREE, '(objectClass=sambaSamAccount)', ['uidNumber'])\\n for dn, entry in r:\\n try:\\n dns[dn] = entry['uidNumber'][0]\\n except KeyError:\\n sys.stderr.write(\\\"dn %s has no uidNumber!\\\\n\\\" % dn)\\n return dns\",\n \"def list_delegations(self, kwargs):\\n verbose = kwargs.get(\\\"verbose\\\", False)\\n filter_ = kwargs.get(\\\"filter\\\", \\\"all\\\")\\n\\n attributes = ALL if verbose else [\\\"sAMAccountName\\\", \\\"userAccountControl\\\"]\\n\\n if filter_ == \\\"all\\\":\\n if not verbose:\\n attributes.extend([\\n \\\"msDS-AllowedToDelegateTo\\\",\\n \\\"msDS-AllowedToActOnBehalfOfOtherIdentity\\\"\\n ])\\n entries = self.engine.query(self.engine.ALL_DELEGATIONS_FILTER(), attributes)\\n elif filter_ == \\\"unconstrained\\\":\\n entries = self.engine.query(self.engine.UNCONSTRAINED_DELEGATION_FILTER(), attributes)\\n elif filter_ == \\\"constrained\\\":\\n if not verbose:\\n attributes.append(\\\"msDS-AllowedToDelegateTo\\\")\\n entries = self.engine.query(self.engine.CONSTRAINED_DELEGATION_FILTER(), attributes)\\n elif filter_ == \\\"rbcd\\\":\\n if not verbose:\\n attributes.append(\\\"msDS-AllowedToActOnBehalfOfOtherIdentity\\\")\\n entries = self.engine.query(self.engine.RESOURCE_BASED_CONSTRAINED_DELEGATION_FILTER(), attributes)\\n else:\\n return None\\n\\n if verbose:\\n self.display(entries, verbose)\\n else:\\n for entry in entries:\\n try:\\n uac = entry[\\\"userAccountControl\\\"]\\n sam = entry[\\\"sAMAccountName\\\"]\\n delegate = entry.get(\\\"msDS-AllowedToDelegateTo\\\")\\n allowed_to_act = entry.get(\\\"msDS-AllowedToActOnBehalfOfOtherIdentity\\\")\\n if (filter_ == \\\"unconstrained\\\" or filter_ == \\\"all\\\") and \\\"TRUSTED_FOR_DELEGATION\\\" in uac:\\n print(f\\\"{sam}:unconstrained:\\\")\\n if (filter_ == \\\"constrained\\\" or filter_ == \\\"all\\\") and delegate:\\n transition = \\\"with\\\" if \\\"TRUSTED_TO_AUTH_FOR_DELEGATION\\\" in uac else \\\"without\\\"\\n for a in delegate:\\n print(f\\\"{sam}:constrained {transition} protocol transition:{a}\\\")\\n if (filter_ == \\\"rbcd\\\" or filter_ == \\\"all\\\") and allowed_to_act:\\n sd = parse_ntSecurityDescriptor(allowed_to_act)\\n for ace in sd['DACL']['ACEs']:\\n try:\\n sid = ace.get('SID')\\n if not sid:\\n continue\\n res = self.engine.resolve_sid(sid)\\n name = res[0]['sAMAccountName']\\n print(f\\\"{name}:rbcd:{sam}\\\")\\n except Exception:\\n print(f\\\"{sid}:rbcd:{sam}\\\")\\n except Exception:\\n continue\",\n \"def get_owner_entities(self, username):\\n\\t\\t#print('Quasar Utility Server getting owner entities for username{' + username + '}')\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_GET_OWNER_ENTITIES, username)\",\n \"def clean_owner(self):\\n username = self.cleaned_data['owner']\\n owner = User.objects.filter(username=username).first()\\n if owner is None:\\n raise forms.ValidationError(\\n _('User %(username)s does not exist'),\\n params={'username': username},\\n )\\n if self.organization.owners.filter(username=username).exists():\\n raise forms.ValidationError(\\n _('User %(username)s is already an owner'),\\n params={'username': username},\\n )\\n return owner\",\n \"def test_search_ldapdn(self):\\n ldap_dn = LDAPDN(self.basedn)\\n obj = self.conn.search(ldap_dn, 1)\\n self.assertIsNotNone(obj)\",\n \"def test_resource_user_resource_get_user_by_email_address_get(self):\\n pass\",\n \"def get_email(nt_id):\\n\\n secret = json.loads(get_secret())\\n username = secret['account_name']\\n pw = secret['password']\\n data = {\\n \\\"domain\\\": \\\"corporate.t-mobile.com\\\",\\n \\\"base_dname\\\": \\\"OU=Production,OU=Users,OU=Accounts,DC=Corporate,DC=T-Mobile,DC=com\\\",\\n \\\"bind_dname\\\": \\\"CN=%s,OU=LDAPS,OU=Non-production,OU=Services,OU=Accounts,DC=corporate,DC=t-mobile,DC=com\\\" % username,\\n \\\"password\\\": pw,\\n \\\"obj_name\\\": nt_id,\\n \\\"obj_class\\\": \\\"user\\\",\\n \\\"attributes\\\": [\\\"mail\\\"],\\n }\\n lambda_client = boto3.client('lambda')\\n invoke_response = lambda_client.invoke(\\n FunctionName= os.environ.get(\\\"query_ldap\\\"),\\n InvocationType= \\\"RequestResponse\\\",\\n Payload= json.dumps(data)\\n )\\n if (\\\"FunctionError\\\" not in invoke_response):\\n data = ast.literal_eval(json.load(invoke_response['Payload'])['body'])\\n print(data)\\n return data[0][0][1]['mail'][0]\\n\\n return None\",\n \"def __getRecord(self, username):\\n #ldap.set_option(ldap.OPT_DEBUG_LEVEL,4095)\\n ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)\\n ldap.set_option(ldap.OPT_X_TLS_CACERTFILE, self.certfile)\\n self.ldo = ldap.initialize(self.host)\\n self.ldo.set_option(ldap.OPT_PROTOCOL_VERSION, 3)\\n self.ldo.simple_bind_s(self.dn, self.password)\\n result = self.ldo.search_s(\\\"dc=mozilla\\\", ldap.SCOPE_SUBTREE, \\\"mail=\\\"+username)\\n self.ldo.unbind_s()\\n return result\",\n \"def owners(self):\\n return self._owners\",\n \"def owners(self):\\n return self._owners\",\n \"def getInterestedUsers():\",\n \"def authors(self):\\n return self.properties.get('Authors', ClientValueCollection(SharedWithMeDocumentUser))\",\n \"def ldap_search(self, ldapfilter):\\n # Determine the scope value\\n if self.args.recursive:\\n scope = ldap.SCOPE_SUBTREE\\n else:\\n scope = ldap.SCOPE_ONELEVEL\\n \\n # Search ldap for results\\n try:\\n self.searchresult = self.ldapobj.search_s(self.args.basedn, scope, ldapfilter)\\n except ldap.REFERRAL as ex:\\n print >> sys.stderr, \\\"Error: LDAP referral received. Is the basedn correct?\\\"\\n sys.exit(1)\\n except ldap.INVALID_CREDENTIALS:\\n print >> sys.stderr, \\\"Error: Invalid credentials\\\"\\n sys.exit(1)\\n except Exception as ex:\\n print ex.__class__.__name__\\n finally:\\n self.ldapobj.unbind_s()\",\n \"def test_owner(self):\\n self.business_item_class.businesses_list = [{\\\"owner\\\": \\\"chairman\\\", \\\"business_name\\\":\\\"Maendeleo\\\", \\\"category\\\":\\\"Backaend\\\", \\\"location\\\":\\\"myhomecity\\\"},\\n {\\\"owner\\\": \\\"chairmanwe\\\", \\\"business_name\\\":\\\"NshMaendeleo\\\", \\\"category\\\":\\\"Backaend\\\", \\\"location\\\":\\\"myhomecity\\\"}]\\n user = \\\"chairman\\\"\\n msg = self.business_item_class.getOwner(user)\\n self.assertEqual(msg, [{\\\"owner\\\": \\\"chairman\\\", \\\"business_name\\\":\\\"Maendeleo\\\", \\\"category\\\":\\\"Backaend\\\", \\\"location\\\":\\\"myhomecity\\\"}])\",\n \"def repo(owner: str, repo: str, uname: Optional[str] = typer.Argument(None)):\\n typer.echo(github.find_emails_from_repo(username=owner, repo=repo, uname=uname))\",\n \"def get_objects_owners(obj):\\n type = obj.get_type()\\n owners = []\\n for user in obj.user_set.all():\\n if type == Entities.TASK:\\n relation = UserTasks.objects.get(user=user, task=obj)\\n elif type == Entities.EVENT:\\n relation = UserEvents.objects.get(user=user, event=obj)\\n elif type == Entities.PLAN:\\n relation = UserPlans.objects.get(user=user, plan=obj)\\n else:\\n raise TypeError\\n owners.append(Owner(user.name, relation.access_level))\\n\\n return owners\",\n \"def owners_only(command):\\n @wraps(command)\\n def wrapped_up(bot):\\n if bot.message.nick not in conf.get('owners', []):\\n return irc.Response('Sorry, you are not an owner thus not authorised to use this command', pm_user=True)\\n return command(bot)\\n wrapped_up.owner_only = True\\n return wrapped_up\",\n \"def test_get_user_by_emailuser_email_get(self):\\n pass\",\n \"def _IsValidPrimaryOwnerEmail(owner_tag_text):\\n if '-' in owner_tag_text: # Check whether it's a team email address.\\n return False\\n\\n return (owner_tag_text.endswith('@chromium.org')\\n or owner_tag_text.endswith('@google.com'))\",\n \"def owner(self):\\n answer = self._call('owner')\\n return answer.owner\",\n \"def email(self):\\n return \\\"{}.{}@company.com\\\".format(self.first, self.last)\",\n \"def _init_owners(self, identity, record, **kwargs):\\n # if the given identity is that of a user, we add the\\n # corresponding user to the owners (record.access.owned_by)\\n is_sys_id = system_process in identity.provides\\n if not record.access.owned_by and not is_sys_id:\\n record.access.owned_by.add({\\\"user\\\": identity.id})\",\n \"def dn(self):\\n return self._dn\",\n \"def deep_clean_one2(self, email, dealno=0):\\r\\n resp = self.check_db(email, clean_type=1)\\r\\n try:\\r\\n return resp[EMAIL]\\r\\n except:\\r\\n return self.deep_clean_one(email, dealno=dealno)\",\n \"def get_donor_email(self):\\n input_name = self.get_donor()\\n if input_name in self.all_donors:\\n print(self.r.hget(input_name, 'email'))\",\n \"def get_owner_info(\\n self, auth_client: globus_sdk.AuthClient | None = None\\n ) -> None | globus_sdk.GlobusConnectPersonalOwnerInfo | dict[str, t.Any]:\\n fname = os.path.join(self._local_data_dir, \\\"gridmap\\\")\\n try:\\n # read file data into an owner info object\\n try:\\n owner_info = GlobusConnectPersonalOwnerInfo._from_file(fname)\\n except ValueError: # may ValueError on invalid DN data\\n return None\\n except OSError as e:\\n # no such file or directory\\n if e.errno == 2:\\n return None\\n raise\\n\\n if auth_client is None:\\n return owner_info\\n\\n if owner_info.id is not None:\\n res = auth_client.get_identities(ids=owner_info.id)\\n elif owner_info.username is not None:\\n res = auth_client.get_identities(usernames=owner_info.username)\\n else: # pragma: no cover\\n raise ValueError(\\\"Something went wrong. Could not parse owner info.\\\")\\n\\n try: # could get no data back in theory, if the identity isn't visible\\n return t.cast(t.Dict[str, t.Any], res[\\\"identities\\\"][0])\\n except (KeyError, IndexError):\\n return None\",\n \"def owner(self) -> discord.User:\\n if self.config.owner_id:\\n return self.get_user(self.config.owner_id)\\n if self.owner_ids:\\n return self.get_user(self.config.owner_ids[0])\\n return None\",\n \"def get_subscription_owner(request, list_entry):\\n return list_entry.profile_item.topic.profile.km_user.user\",\n \"def get_users_for(self, email):\\n # this is a list rather than a generator because we probably want to\\n # do a len() on it right away\\n return [address.user for address in \\\\\\n self.filter(verified=True, email=email)]\",\n \"def get_followings_of_a_user(tx: Transaction, email: str) -> BoltStatementResult:\\n query = f\\\"\\\"\\\"\\n MATCH (:Person {{email: '{email}'}})-[:FOLLOWS]->(follower) RETURN follower.full_name AS full_name, follower.email AS email, follower.profile_image AS profile_image\\n \\\"\\\"\\\"\\n return tx.run(query)\",\n \"def displayname(self):\\n return self.email\",\n \"def adjust_entry_ldap(entry, base_path):\\n if 'mail' not in entry:\\n return\\n mail = entry['mail'][0]\\n\\n # remove attribute if exist\\n rm_keys = ['modifytimestamp', 'birthyear', 'birthday']\\n for rm_key in rm_keys:\\n if rm_key in entry:\\n del entry[rm_key]\\n\\n # append attribute\\n if 'cn' not in entry:\\n entry['cn'] = [mail]\\n\\n if 'sn' not in entry:\\n entry['sn'] = [mail]\\n\\n # replace attribute\\n if 'dn' in entry:\\n entry['dn'] = [f'mail={mail},{base_path}']\",\n \"def email(self, instance):\\r\\n return instance.user.email\",\n \"def computeMailboxOu(portal, title):\\n\\n catalog = portal.portal_catalog\\n\\n current = cleaned = toAscii(title).lower()\\n i = 1\\n existing = True\\n while existing:\\n existing = catalog(ou=current)\\n if not existing:\\n break\\n current = '%s_%d' % (cleaned, i)\\n i += 1\\n dtool = getToolByName(portal, 'portal_directories', None)\\n if dtool is not None: # not in unit tests\\n ldir = getattr(dtool, 'local_addressbook_ldap', None)\\n if ldir is not None:\\n createOuInLDAP(ldir, current)\\n return current\",\n \"def __filter_by_domain_and_username(self, cursor):\\n result = []\\n for _ in range(cursor.count()):\\n record = cursor.next()\\n domain = record[PASSWORD_MANAGER_COLLECTION_DOMAIN_FIELD]\\n username = record[PASSWORD_MANAGER_COLLECTION_USERNAME_FIELD]\\n if self.domain.lower() in domain.lower():\\n if self.username != None:\\n if self.username.lower() in username.lower():\\n result.append({\\n PASSWORD_MANAGER_COLLECTION_DOMAIN_FIELD: domain,\\n PASSWORD_MANAGER_COLLECTION_USERNAME_FIELD: username\\n })\\n else:\\n result.append({\\n PASSWORD_MANAGER_COLLECTION_DOMAIN_FIELD: domain,\\n PASSWORD_MANAGER_COLLECTION_USERNAME_FIELD: username\\n })\\n return result\",\n \"def getObjectSearchItem(self, user, dn):\\n # Start the query and bring the result in a usable form\\n index = PluginRegistry.getInstance(\\\"ObjectIndex\\\")\\n\\n item = index.find(user, {'dn': dn})\\n if len(item) == 1:\\n item = item[0]\\n else:\\n return None\\n\\n if item['_type'] not in self.__search_aid['mapping']:\\n return None\\n\\n entry = {'tag': item['_type']}\\n for k, v in self.__search_aid['mapping'][item['_type']].items():\\n if k:\\n if v in item and item[v]:\\n if v == \\\"dn\\\":\\n entry[k] = item[v]\\n else:\\n entry[k] = item[v][0]\\n else:\\n entry[k] = self.__build_value(v, item)\\n\\n return entry\",\n \"def userdn(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"userdn\\\")\",\n \"def userdn(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"userdn\\\")\",\n \"def test_get_email_address(self):\\n email_addr = 'test_get_email_addr' + '@' + self.email_dom\\n org = 'o=%s' % (self.org_name)\\n people = '%s=%s' % (self.container_attr, self.user_container)\\n uid = '%s=%s' % (self.user_key, self.user_id)\\n dn = '%s,%s,%s,%s' % (uid, people, org, self.base_dn)\\n dn_info = {self.smtp_address: [email_addr]}\\n expected_result = [(dn, dn_info)] \\n addr = SpokeEmailAddress(self.org_name, self.user_id)\\n addr.create(email_addr)\\n result = addr.get(email_addr)['data']\\n self.assertEqual(result, expected_result)\",\n \"def __get_addr_grp(self, objtype, address=None):\\n if address is not None:\\n return self.get(\\\"/%s/entry[@name='%s']\\\"%(objtype, address))\\n else:\\n return self.get(\\\"/%s/entry\\\"%objtype)\",\n \"def manage_owners():\\n\\n owner_data = request.get_json(force=True)\\n return _get_owner_service().create_owner(owner_data)\",\n \"def _find_groups_for_user(email):\\n return [g['name'] for g in groups.find({\\\"users\\\":email})]\",\n \"def email(self):\\n return '{}.{}@email.com'.format(self.fname,self.lname)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6519693","0.6108533","0.601819","0.5960598","0.59551305","0.5824557","0.5728829","0.5621332","0.55355567","0.5514881","0.5485151","0.5441718","0.54410255","0.5418896","0.54182565","0.54131806","0.53478324","0.5340073","0.5334549","0.5328107","0.53239036","0.5311947","0.5311947","0.5301679","0.53011936","0.5299812","0.5296129","0.5294063","0.52506477","0.52198046","0.5217254","0.52158284","0.519962","0.519921","0.5189494","0.5182026","0.5156723","0.51567125","0.515249","0.513466","0.51212007","0.5103582","0.51025444","0.5096983","0.5091862","0.50831586","0.50806516","0.5073994","0.5052781","0.50517744","0.50280815","0.50208694","0.50167483","0.5005956","0.4990116","0.49853575","0.49832097","0.4978642","0.49710524","0.4956458","0.49497387","0.49471647","0.49469644","0.49412534","0.4931906","0.49282822","0.49282822","0.4917869","0.49174204","0.49114025","0.49071977","0.49033618","0.48912454","0.4883692","0.48798588","0.48777136","0.48669875","0.48645747","0.48637292","0.48616657","0.48604953","0.4849343","0.4847908","0.48468354","0.48420423","0.48262334","0.48239812","0.48239344","0.48176986","0.48115382","0.48106927","0.4798821","0.47965577","0.47855574","0.47855574","0.47842327","0.47778285","0.4767104","0.47497344","0.47479624"],"string":"[\n \"0.6519693\",\n \"0.6108533\",\n \"0.601819\",\n \"0.5960598\",\n \"0.59551305\",\n \"0.5824557\",\n \"0.5728829\",\n \"0.5621332\",\n \"0.55355567\",\n \"0.5514881\",\n \"0.5485151\",\n \"0.5441718\",\n \"0.54410255\",\n \"0.5418896\",\n \"0.54182565\",\n \"0.54131806\",\n \"0.53478324\",\n \"0.5340073\",\n \"0.5334549\",\n \"0.5328107\",\n \"0.53239036\",\n \"0.5311947\",\n \"0.5311947\",\n \"0.5301679\",\n \"0.53011936\",\n \"0.5299812\",\n \"0.5296129\",\n \"0.5294063\",\n \"0.52506477\",\n \"0.52198046\",\n \"0.5217254\",\n \"0.52158284\",\n \"0.519962\",\n \"0.519921\",\n \"0.5189494\",\n \"0.5182026\",\n \"0.5156723\",\n \"0.51567125\",\n \"0.515249\",\n \"0.513466\",\n \"0.51212007\",\n \"0.5103582\",\n \"0.51025444\",\n \"0.5096983\",\n \"0.5091862\",\n \"0.50831586\",\n \"0.50806516\",\n \"0.5073994\",\n \"0.5052781\",\n \"0.50517744\",\n \"0.50280815\",\n \"0.50208694\",\n \"0.50167483\",\n \"0.5005956\",\n \"0.4990116\",\n \"0.49853575\",\n \"0.49832097\",\n \"0.4978642\",\n \"0.49710524\",\n \"0.4956458\",\n \"0.49497387\",\n \"0.49471647\",\n \"0.49469644\",\n \"0.49412534\",\n \"0.4931906\",\n \"0.49282822\",\n \"0.49282822\",\n \"0.4917869\",\n \"0.49174204\",\n \"0.49114025\",\n \"0.49071977\",\n \"0.49033618\",\n \"0.48912454\",\n \"0.4883692\",\n \"0.48798588\",\n \"0.48777136\",\n \"0.48669875\",\n \"0.48645747\",\n \"0.48637292\",\n \"0.48616657\",\n \"0.48604953\",\n \"0.4849343\",\n \"0.4847908\",\n \"0.48468354\",\n \"0.48420423\",\n \"0.48262334\",\n \"0.48239812\",\n \"0.48239344\",\n \"0.48176986\",\n \"0.48115382\",\n \"0.48106927\",\n \"0.4798821\",\n \"0.47965577\",\n \"0.47855574\",\n \"0.47855574\",\n \"0.47842327\",\n \"0.47778285\",\n \"0.4767104\",\n \"0.47497344\",\n \"0.47479624\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60889524"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":74292,"cells":{"query":{"kind":"string","value":"Try to add the reporter as a fallback owner or if no alternative owners have been specified. This should work since only employees are allowed to use this request type and all employees are in LDAP."},"document":{"kind":"string","value":"def handle_empty_owners():\n result = shared_ldap.find_from_email(shared.globals.REPORTER)\n if result is not None:\n shared_sd.post_comment(\n \"Adding %s as the owner of the group.\" % shared.globals.REPORTER, True)\n return [result]\n\n # OK - something stupid is happening but let's give ourselves\n # a safety net.\n shared_sd.post_comment(\n \"Unable to add %s as an owner as the email address cannot be \"\n \"found in Linaro Login. This means the automation has not \"\n \"been able to find any of the specified email addresses in \"\n \"Linaro Login. Consequently, IT Services will need to manage \"\n \"it in the interim.\" % shared.globals.REPORTER, True)\n return [\"cn=its,ou=mailing,ou=groups,dc=linaro,dc=org\"]"},"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_user(self, requestor, requestee, default=None):\n self.lock.acquire()\n self.users.add(requestor)\n ok = requestee in self.users\n self.lock.release()\n\n # if this isn't the default app, also add the user to the default app\n if default != self and default != None:\n default.check_user(requestor, requestee)\n\n return ok","def _init_owners(self, identity, record, **kwargs):\n # if the given identity is that of a user, we add the\n # corresponding user to the owners (record.access.owned_by)\n is_sys_id = system_process in identity.provides\n if not record.access.owned_by and not is_sys_id:\n record.access.owned_by.add({\"user\": identity.id})","def fix_discovery(self):\r\n for item in self.collections['response']['collections']:\r\n if item['id'] == 'LDSO':\r\n try:\r\n self.collections['LDSO'] = self.get(['links']['self']['href'])\r\n except:\r\n self.lds_user = False\r\n else:\r\n self.lds_user = True\r\n else:\r\n self.collections[item['id']] = item['links']['self']['href']\r\n try:\r\n self.user = self.get_current_user()['response']['users'][0]\r\n except:\r\n self.user = \"\"","def add_owner(urn: str, owner: str, owner_type: str) -> None:\n\n if not urn.startswith(\"urn:li:dataProduct:\"):\n urn = f\"urn:li:dataProduct:{urn}\"\n dataproduct_patcher: DataProductPatchBuilder = DataProduct.get_patch_builder(urn)\n dataproduct_patcher.add_owner(\n owner=OwnerClass(owner=_get_owner_urn(owner), type=owner_type)\n )\n with get_default_graph() as graph:\n _abort_if_non_existent_urn(graph, urn, \"add owners\")\n for mcp in dataproduct_patcher.build():\n graph.emit(mcp)","def add(self, user_or_username, set_as_default=False, **kwargs):\n user = super().add(user_or_username, set_as_default=set_as_default, **kwargs)\n\n if user.expected_prompt == -1 and self.default and self.default.expected_prompt != -1:\n user.expected_prompt = self.default.expected_prompt\n\n return user","def which_owner(self):\n LOGGER.debug(self.details)\n for override_function, override_map in self.team_owner_overrides.items():\n for override_key, override_team in override_map.items():\n if override_key in self.details[override_function]: # pylint: disable=unsupported-membership-test\n self.details[\"owner\"] = override_team\n break\n\n # for chassis and blades in d42, use their role to determine ownership\n if re.match('^c[0-9]*b[0-9]*', self.details['function']) is not None:\n self.load_from_device42()\n\n if self.details[\"owner\"] == \"team-unclassified\":\n for owner, teamregex in self.team_ownership_regexes.items():\n if re.search(teamregex, self.details[\"function\"]):\n self.details[\"owner\"] = owner\n break","def owner(self) -> discord.User:\n if self.config.owner_id:\n return self.get_user(self.config.owner_id)\n if self.owner_ids:\n return self.get_user(self.config.owner_ids[0])\n return None","def test_owner_has_no_locations(self):\n self.owner = CommCareUser.create(self.domain, 'no_location', '***', None, None)\n form, (case, ) = _create_case(domain=self.domain, case_id=uuid.uuid4().hex, owner_id=self.owner.get_id)\n location = get_case_location(case)\n self.assertIsNone(location)","def _set_owner_groups(self):\n group_id: int = 1\n if self._report_key == ReportTypes.MHR_TRANSFER:\n if self._report_data.get('addOwnerGroups'):\n has_na: bool = False\n for group in self._report_data.get('addOwnerGroups'):\n if group.get('type', '') == MhrTenancyTypes.NA and not group.get('interestNumerator') and \\\n not group.get('interestDenominator'):\n has_na = True\n group['groupId'] = group_id\n group_id += 1\n self._report_data['hasNA'] = has_na\n elif self._report_key == ReportTypes.MHR_REGISTRATION:\n has_na: bool = False\n for group in self._report_data.get('ownerGroups'):\n group['groupId'] = group_id\n group_id += 1\n if group.get('type', '') == MhrTenancyTypes.NA and not group.get('interestNumerator') and \\\n not group.get('interestDenominator'):\n has_na = True\n self._report_data['hasNA'] = has_na\n elif self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_BODY_REPORT):\n for detail in self._report_data['details']:\n group_id = 1\n has_na: bool = False\n for group in detail.get('ownerGroups'):\n group['groupId'] = group_id\n group_id += 1\n if group.get('type', '') == MhrTenancyTypes.NA and not group.get('interestNumerator') and \\\n not group.get('interestDenominator'):\n has_na = True\n self._report_data['hasNA'] = has_na","def every_non_existing_owner_should_not_have_profile_link(context):\n items = context.response.json()['items']\n for item in items:\n owner = item['owner']\n if not owner['user_type'] == 'does_not_exist':\n continue\n assert 'link' not in owner\n logging.debug(\n 'Not existing Owner %s does not have a valid profile link',\n owner['display_name'])","def update_owner(current_owner_email: str, new_owner_email: str):\n current_owner_id = find_user_id(current_owner_email)\n new_owner_id = find_user_id(new_owner_email) \n \n \"\"\" This block is executed to check if email addresses provided are associated with two Looker users \"\"\"\n \n if type(new_owner_id) != int and type(new_owner_id) != int:\n print(\"The email addresses for both the current owner and the new owner are not associated with any Looker user id\")\n\n elif type(current_owner_id) != int: \n print(\"The email address for the current owner is not associated with any Looker user id\")\n\n elif type(new_owner_id) != int:\n print(\"The email address for the new owner is not associated with any Looker user id\")\n\n else: \n body = {}\n body['user_id'] = new_owner_id\n find = find_schedules(current_owner_id) \n for i in find.values(): \n sdk.update_scheduled_plan(i,body)\n print(\"Successfully transfer all schedules of \" + current_owner_email + \" to \" + new_owner_email)","def every_non_existing_owner_should_not_have_profile_image_link(context):\n items = context.response.json()['items']\n for item in items:\n owner = item['owner']\n if not owner['user_type'] == 'does_not_exist':\n continue\n assert 'profile_image' not in owner\n logging.debug(\n 'Not existing Owner %s does not have a valid profile image link',\n owner['display_name'])","def test_no_owner(self):\n form, (case, ) = _create_case(domain=self.domain, case_id=uuid.uuid4().hex, owner_id=None)\n location = get_case_location(case)\n self.assertIsNone(location)","def _check_owner(user, study):\n if not user.id == study.owner:\n raise HTTPError(403, \"User %s does not own study %d\" %\n (user.id, study.id))","def clean_owner(self):\n username = self.cleaned_data['owner']\n owner = User.objects.filter(username=username).first()\n if owner is None:\n raise forms.ValidationError(\n _('User %(username)s does not exist'),\n params={'username': username},\n )\n if self.organization.owners.filter(username=username).exists():\n raise forms.ValidationError(\n _('User %(username)s is already an owner'),\n params={'username': username},\n )\n return owner","def generate_report(self, owners_users_data):\n domain_types = ['addon_domains', 'parked_domains', 'sub_domains']\n\n report = ''\n\n for owner in owners_users_data.keys():\n report += '\\n{0} | {1:>8} | {2:>21} | {3:>28}\\n'.format('OWNER', 'USER/DOMAIN', 'IP/MX/NS', 'DOCUMENT ROOT')\n report += owner\n users = owners_users_data[owner].keys()\n users.sort()\n for user in users:\n user_domains = server.get_account_domains(user)\n domain = user_domains['main_domain']\n\n self.populate_domain_data(domain)\n domain_resolving = self.domain_data[domain]['resolving']\n document_root = self.domain_data[domain]['documentroot']\n report += '{0:>17}: LOCAL IP: {1:34}\\n'.format(user, owners_users_data[owner][user]['ip'])\n report += '{0:>13}{1:34} {2:54}\\n'.format(' ', domain, document_root)\n report += '{0:>13}IP: {1}\\n'.format(' ', domain_resolving['A'])\n report += '{0:>13}MX: {1}\\n'.format(' ', domain_resolving['MX'])\n report += '{0:>13}NS: {1}\\n\\n'.format(' ', domain_resolving['NS'])\n\n for domain_type in domain_types:\n for domain in user_domains[domain_type]:\n self.populate_domain_data(domain)\n document_root = self.domain_data[domain]['documentroot']\n report += '{0:>13}{1:34} {2:54}\\n'.format(' ', domain, document_root)\n report += '{0:>13}{1}\\n'.format(' ', domain_resolving['A'] )\n report += '{0:>13}MX: {1}\\n'.format(' ', domain_resolving['MX'])\n report += '{0:>13}NS: {1}\\n\\n'.format(' ', domain_resolving['NS'])\n\n server.mail_report(self.__class__.__name__, content=report)","def test_make_default_ach_user(self):\n\n user = self.client.users.create({})\n\n FundingSources.get_user_ach_funding_source(user)\n source = FundingSources.get_user_ach_funding_source(user)\n\n default = self.client.funding_sources(source.token).make_default()\n\n verify_payment_card_response_model(\n self, default, {'is_default_account': True})","def generate_report_p24(self, owners_users_data):\n domain_types = ['addon_domains', 'parked_domains', 'sub_domains']\n\n report = ''\n\n for owner in owners_users_data.keys():\n report += '\\nOWNER, USER/DOMAIN, IP/MX/NS, DOCUMENT ROOT\\n'\n report += owner\n users = owners_users_data[owner].keys()\n users.sort()\n for user in users:\n user_domains = server.get_account_domains(user)\n domain = user_domains['main_domain']\n\n self.populate_domain_data(domain)\n domain_resolving = self.domain_data[domain]['resolving']\n document_root = self.domain_data[domain]['documentroot']\n report += '%17s: LOCAL IP: %34s\\n' % (user, owners_users_data[owner][user]['ip'])\n report += '%13s, %34s %54s\\n' % (' ', domain, document_root)\n report += '%13s IP: %s\\n' % (' ', domain_resolving['A'])\n report += '%13s MX: %s\\n' % (' ', domain_resolving['MX'])\n report += '%13s NS: %s\\n\\n' % (' ', domain_resolving['NS'])\n\n for domain_type in domain_types:\n for domain in user_domains[domain_type]:\n self.populate_domain_data(domain)\n document_root = self.domain_data[domain]['documentroot']\n report += '%13s, %34s %54s\\n' % (' ', domain, document_root)\n report += '%13s IP: %s\\n' % (' ', domain_resolving['A'])\n report += '%13s MX: %s\\n' % (' ', domain_resolving['MX'])\n report += '%13s NS: %s\\n\\n' % (' ', domain_resolving['NS'])\n\n server.mail_report(self.__class__.__name__, content=report)","def __init__(__self__, *,\n owner_type: str,\n assigned_to: Optional[str] = None,\n email: Optional[str] = None,\n object_id: Optional[str] = None,\n user_principal_name: Optional[str] = None):\n pulumi.set(__self__, \"owner_type\", owner_type)\n if assigned_to is not None:\n pulumi.set(__self__, \"assigned_to\", assigned_to)\n if email is not None:\n pulumi.set(__self__, \"email\", email)\n if object_id is not None:\n pulumi.set(__self__, \"object_id\", object_id)\n if user_principal_name is not None:\n pulumi.set(__self__, \"user_principal_name\", user_principal_name)","def hook_assign_assistance(self, data):\n request_id = data[\"request_id\"]\n assignee_chat_id = data[\"volunteer\"]\n log.info(\"ASSIGN req:%s to vol:%s\", request_id, assignee_chat_id)\n\n try:\n request_details = self.updater.persistence.bot_data[request_id]\n except KeyError:\n log.debug(\"No such request %s, ignoring\", request_id)\n return\n else:\n self.updater.dispatcher.bot_data[request_id].update(\n {\"time\": utc_short_to_user_short(data[\"time\"])}\n )\n\n # first of all, notify the others that they are off the hook and update their state accordingly\n for chat_id in request_details[\"volunteers\"]:\n if chat_id != assignee_chat_id:\n self.send_message(chat_id, c.MSG_ANOTHER_ASSIGNEE)\n updated_state = {\"state\": c.State.AVAILABLE, \"reviewed_request\": None}\n self.updater.dispatcher.user_data[chat_id].update(updated_state)\n\n self.updater.dispatcher.user_data[assignee_chat_id].update({\"current_request\": request_id})\n self.updater.dispatcher.update_persistence()\n\n # notify the assigned volunteer, so they know they're responsible; at this point they still have to confirm\n # that they're in good health and they still have an option to cancel\n self.updater.bot.send_message(\n chat_id=assignee_chat_id,\n text=c.MSG_CAUTION,\n reply_markup=InlineKeyboardMarkup(k.caution_choices),\n )","def match_Owner(self, object, options) :\n\t\tif options.has_key(\"owner\") :\n\t\t\townerinfo = object.owner_info()\n\t\t\tif ownerinfo is not None :\n\t\t\t\t# at least /Control_Panel/Products[/*] doesn't satisfy the following test\n\t\t\t\tif hasattr(ownerinfo, \"has_key\") and ownerinfo.has_key('id') :\n\t\t\t\t\treturn self.match_anystring(\"owner\", ownerinfo['id'], options)\n\t\t\treturn 0 # Not owned or no owner: never match\n\t\treturn 1\t # No owner option: always match","def test_non_matching_type(self):\n user1 = get_user_model().objects.get(username='test1@example.com')\n self.client.login(username='test1@example.com', password='1')\n\n office = OfficeLocation.objects.all()[0]\n org = OrgGroup.objects.filter(parent__isnull=True)[0]\n\n submission1 = Interest()\n submission1.owner = user1\n submission1.for_coffee = True\n submission1.save()\n submission1.locations.add(office)\n submission1.departments.add(org)\n\n resp = self.client.get(reverse('mystery:mystery'))\n self.assertContains(resp, \"Cancel this\", status_code=200)\n\n user2 = random_user()\n submission2 = Interest()\n submission2.owner = user2\n submission2.is_active = False\n submission2.save()\n submission2.for_lunch = True\n submission2.locations.add(office)\n submission2.departments.add(org)\n submission2.is_active = True\n submission2.save()\n\n resp = self.client.get(reverse('mystery:mystery'))\n self.assertContains(resp, \"Cancel this\", status_code=200)","def _get_owner(self):\n if self.resource.owner is not None:\n try:\n return pwd.getpwnam(self.resource.owner).pw_uid\n except KeyError:\n raise error.InvalidUser()","def set_owner(self, owner):\n self.settings[\"owner\"] = owner","def owner(self, owner):\n if self.local_vars_configuration.client_side_validation and owner is None: # noqa: E501\n raise ValueError(\"Invalid value for `owner`, must not be `None`\") # noqa: E501\n\n self._owner = owner","def resolved_by(self):\n return User(None, self.get_data(\"resolved_by\"), **self._new_session_args)","def _determine_uploader_by_changedby_field(self):\n maintainer_string = self.changes.get('Changed-By')\n log.debug(\"Determining user from 'Changed-By:' field: %s\" % maintainer_string)\n maintainer_realname, maintainer_email_address = email.utils.parseaddr(maintainer_string)\n log.debug(\"Changed-By's email address is: %s\", maintainer_email_address)\n self._find_user_by_email_address(maintainer_email_address)","def test_channel_addowner_not_owner():\n clear()\n auth_register('randemail@gmail.com', 'password1234', 'Jane', 'Citizen')\n register_second_result = auth_register('randemail2@gmail.com', 'password1234', 'Jane', 'Citizen')\n register_third_result = auth_register('randemail3@gmail.com', 'password1234', 'Jane', 'Citizen')\n register_forth_result = auth_register('randemail4@gmail.com', 'password1234', 'Jane', 'Citizen')\n randChannel_id = channels_create(register_second_result['token'], 'Random Channel', True)\n with pytest.raises(AccessError):\n assert channel_addowner(register_third_result['token'], randChannel_id['channel_id'], register_forth_result['u_id'])","def set_owner_allowed(self, data):\n self._owner_allowed = self._uni(data)","def test_channel_addowner_already_an_owner():\n clear()\n auth_register('randemail@gmail.com', 'password1234', 'Jane', 'Citizen')\n register_second_result = auth_register('randemail2@gmail.com', 'password1234', 'Jane', 'Citizen')\n randChannel_id = channels_create(register_second_result['token'], 'Random Channel', True)\n register_third_result = auth_register('randemail3@gmail.com', 'password1234', 'Jane', 'Citizen')\n channel_addowner(register_second_result['token'], randChannel_id['channel_id'], register_third_result['u_id'])\n with pytest.raises(InputError):\n assert channel_addowner(register_second_result['token'], randChannel_id['channel_id'], register_third_result['u_id'])","def test_is_owner_inherited_and_local(self):\n self.make_assignment(self.project, self.user_alice, self.role_owner)\n self.assertTrue(self.project.is_owner(self.user_alice))","def owner(self, owner: str):\n\n self._owner = owner","def __init__(self, owner=None, *args, **kwargs):\n super(CalendarForm, self).__init__(*args, **kwargs)\n if owner is not None:\n self.owner = owner\n without_owner = UserProfile.objects.all().exclude(pk=owner.pk)\n self.fields['readers'].queryset = without_owner\n self.fields['modifiers'].queryset = without_owner","def test_get_one_for_other_organization_forbidden(self):\n org = Organization.create(name='foo', program_id=self.program.uid)\n org.put()\n coAdmin = User.create(name='coAdmin', email='teammate@bar.com',\n owned_organizations=[org.uid])\n coAdmin.put()\n user = User.create(name='foo', email='foo@bar.com')\n user.put()\n response = self.testapp.get(\n '/api/organizations/{}/users/{}'.format(org.uid, coAdmin.uid),\n headers=self.login_headers(user),\n status=403,\n )","def is_owner(self, author):\n return not self.server or author == self.server.owner","def ldap_get_email(self, user):\n result = super(Auth42, self)._search_not_empty(user)\n if result is not None:\n alias = result.get(\"alias\")[1]\n return alias\n\n return None","def items_should_contain_owner_object(context):\n items = context.response.json()['items']\n existing_owner_fields = [\n 'accept_rate', 'display_name', 'link', 'profile_image', 'reputation',\n 'user_id', 'user_type'\n ]\n non_existing_owner_fields = ['display_name', 'user_type']\n\n for item in items:\n assert 'owner' in item\n assert isinstance(item['owner'], dict)\n owner = item['owner']\n if owner['user_type'] == 'does_not_exist':\n all(field in owner for field in non_existing_owner_fields)\n logging.debug(\n ('Item %d contains an non-existing Owner object for user \"%s\" '\n 'with all required fields: %s'), item['question_id'], \n owner['display_name'], ', '.join(non_existing_owner_fields))\n else:\n all(field in owner for field in existing_owner_fields)\n logging.debug(\n ('Item %d contains an existing Owner object for user ID \"%d\" '\n 'with all required fields: %s'), item['question_id'], \n owner['user_id'], ', '.join(existing_owner_fields))","def owner(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"owner\")","def ownercheck(self, userhost):\n if self.cfg and self.cfg.owner:\n if userhost in self.cfg.owner: return True\n return False","def OnFindManager(self, event):\r\n \r\n event.SetManager(self._owner_mgr)","def _return_specific_owner_prs(all_prs, filters):\n if _validate_list_of_dict(all_prs):\n owner_prs = [pr for pr in all_prs if filters['owner'] == pr['pr'].user.login]\n logger.debug(\"OWNER PRS: %s\", [pr['pr'].number for pr in owner_prs])\n return owner_prs\n else:\n return []","def get_reporter(reporter):\n if six.PY2:\n file_types = file, io.IOBase\n else:\n file_types = (io.IOBase, )\n\n if isinstance(reporter, str):\n if reporter.lower() == 'default':\n reporter = BasicReporter()\n elif reporter.lower() == 'silent':\n reporter = SilentReporter()\n else:\n raise ValueError('If reporter is string, it should be \"default\" or \"silent\".')\n elif isinstance(reporter, file_types):\n return BasicReporter(reporter)\n elif reporter is None:\n reporter = SilentReporter()\n elif not isinstance(reporter, BasicReporter):\n raise ValueError('Pass either a string, BasicReporter or None for reporter. ')\n return reporter","def _process_ldap_info_for_one_user(self, record, result_data):\n #One entry only in the ldap data because we used a filter\n #to find one user only\n ldapentry = result_data[0][1]\n logger.debug(\"LDAP.PY \\t LdapFindUser ldapentry %s\" % (ldapentry))\n tmpname = ldapentry['uid'][0]\n\n tmpemail = ldapentry['mail'][0]\n if ldapentry['mail'][0] == \"unknown\":\n tmpemail = None\n\n parent_hrn = None\n peer_authority = None\n if 'hrn' in record:\n hrn = record['hrn']\n parent_hrn = get_authority(hrn)\n if parent_hrn != self.authname:\n peer_authority = parent_hrn\n #In case the user was not imported from Iotlab LDAP\n #but from another federated site, has an account in\n #iotlab but currently using his hrn from federated site\n #then the login is different from the one found in its hrn\n if tmpname != hrn.split('.')[1]:\n hrn = None\n else:\n hrn = None\n\n results = {\n 'type': 'user',\n 'pkey': ldapentry['sshPublicKey'],\n #'uid': ldapentry[1]['uid'][0],\n 'uid': tmpname,\n 'email': tmpemail,\n #'email': ldapentry[1]['mail'][0],\n 'first_name': ldapentry['givenName'][0],\n 'last_name': ldapentry['sn'][0],\n #'phone': 'none',\n 'serial': 'none',\n 'authority': parent_hrn,\n 'peer_authority': peer_authority,\n 'pointer': -1,\n 'hrn': hrn,\n }\n return results","def process_group_owners(data):\n owner_list = []\n owners = data.split(\"\\r\\n\")\n for owner in owners:\n if owner != \"\":\n result = shared_ldap.find_from_email(owner)\n if result is None:\n shared_sd.post_comment(\n \"Unable to add %s as an owner as the email address \"\n \"cannot be found in Linaro Login.\" % owner, True)\n else:\n # Need to make sure we append the mailing group if it\n # is a group!\n if \",ou=security,\" not in result:\n owner_list.append(result)\n shared_sd.post_comment(\n \"Adding %s as an owner.\" % owner, True)\n return owner_list","def default_get(self, cr, uid, fields, context=None): \n \n \n res = super(granted_rights_order, self).default_get(cr, uid, fields, context=context)\n \n employee_obj = self.pool.get('hr.employee')\n department_obj = self.pool.get('hr.department')\n manager = False\n donor_emp_id = []\n \n if uid != 1 :\n\n donor_emp_id = employee_obj.search(cr ,uid, [('user_id' , '=' , uid )])\n deparment_id = employee_obj.browse(cr,uid,donor_emp_id[0]).department_id.id\n \n if donor_emp_id[0] == department_obj.browse(cr,uid,deparment_id).manager_id.id :\n manager = True\n \n \n \n \n \n \n \n \n \n if donor_emp_id :\n res.update({ 'employee_donor': donor_emp_id[0], \n 'department_id' : deparment_id,\n 'is_a_amanger' : manager,\n })\n return res","def assure_tender_assigned_to_user(self, tender_new_id, assigned_user):\n tenders_from_admin = ToDoTenders(division_admin_login, universal_password) # only admin see all chains\n\n all_tender_id_responsibles_chains = tenders_from_admin.get_all_assigned_users_for_tenders(\n tenders_from_admin.get_tenders_with_responsibles('in_work'))\n\n for chain in all_tender_id_responsibles_chains:\n if chain['tender_new_id'] == tender_new_id:\n for res in chain['responsibles']:\n if res['emailAddress'] == assigned_user:\n return True\n else:\n pass","def test_no_owner_exception(api: API, owners: list):\n api.candlepin.get_owners.return_value = owners\n account = Account(api, \"USERNAME\", \"PASSWORD\")\n with pytest.raises(IndexError):\n account.owner_id","def set_owner(self, data):\n self._owner = self._uni(data)\n self.add_payload('owner', data)","def get_owner_object(self):\n return None","def get_owner_object(self):\n return None","def get_owner_object(self):\n return None","def check_owner(data=None, **kw):\n if data and 'owner_id' in data and not data['owner_id'] == current_user.id:\n raise ProcessingException(description=\"No write privileges\",\n code=401)","def test_optional_email(self):\n\n consumer = LTIConsumerFactory(slug=\"consumer\")\n passport = LTIPassportFactory(title=\"consumer1_passport1\", consumer=consumer)\n\n user_count = get_user_model().objects.count()\n\n new_user = self._authenticate(\n {\n \"user_id\": \"7275a984-1e77-4084-9fe6-e54d0deba0e7\",\n \"lti_message_type\": \"basic-lti-launch-request\",\n \"lti_version\": \"LTI-1p0\",\n \"resource_link_id\": \"aaa\",\n \"context_id\": \"course-v1:fooschool+authbackend+0001\",\n \"lis_person_sourcedid\": \"user_without_email\",\n },\n passport,\n )\n\n self.assertEqual(\"user_without_email\", new_user.public_username)\n self.assertEqual(\"\", new_user.email)\n self.assertEqual(consumer, new_user.lti_consumer)\n self.assertEqual(\"user_without_email@consumer\", new_user.username)\n self.assertEqual(user_count + 1, get_user_model().objects.count())","def __init__(self, business_owner=None, business_owner_email=None, technical_owner=None, technical_owner_email=None):\n\n self._business_owner = None\n self._business_owner_email = None\n self._technical_owner = None\n self._technical_owner_email = None\n\n if business_owner is not None:\n self.business_owner = business_owner\n if business_owner_email is not None:\n self.business_owner_email = business_owner_email\n if technical_owner is not None:\n self.technical_owner = technical_owner\n if technical_owner_email is not None:\n self.technical_owner_email = technical_owner_email","def add_person(self, name, email, typ, wants_accomodation='N'):\n if typ == \"FELLOW\":\n if not email in self.all_persons.keys():\n new_fellow = Fellow(name, email, wants_accomodation)\n self.fellows[email] = new_fellow\n self.allocate_room(new_fellow)\n return new_fellow\n else:\n return \"Email already used!\"\n elif typ == \"STAFF\":\n if not email in self.all_persons.keys():\n new_staff = Staff(name, email)\n self.staff[email] = new_staff\n self.allocate_room(new_staff)\n return new_staff\n else:\n return \"Email already used!\"\n else:\n return -1","def must_be_owner(func):\n @functools.wraps(func)\n @login_required()\n def wrapped(request, poll_name, *args, **kwargs):\n try:\n cur_poll = Poll.objects.get(url=poll_name)\n except Poll.DoesNotExist:\n return db_error(_('This poll does not seem to exist, sorry.'))\n if cur_poll.is_owner(request.user.userinformation):\n return func(request, poll_name, *args, **kwargs)\n else:\n return redirect(reverse('login')+'?next='+request.path)\n return wrapped","def test_non_matching_org(self):\n user1 = get_user_model().objects.get(username='test1@example.com')\n self.client.login(username='test1@example.com', password='1')\n\n office = OfficeLocation.objects.all()[0]\n org = OrgGroup.objects.filter(parent__isnull=True)[0]\n\n submission1 = Interest()\n submission1.owner = user1\n submission1.for_coffee = True\n submission1.save()\n submission1.locations.add(office)\n submission1.departments.add(org)\n\n resp = self.client.get(reverse('mystery:mystery'))\n self.assertContains(resp, \"Cancel this\", status_code=200)\n\n user2 = random_user()\n org2 = OrgGroup()\n org2.parent = org\n org2.title = \"test org\"\n org2.save()\n submission2 = Interest()\n submission2.owner = user2\n submission2.is_active = False\n submission2.save()\n submission2.for_coffee = True\n submission2.locations.add(office)\n submission2.departments.add(org2)\n submission2.is_active = True\n submission2.save()\n\n resp = self.client.get(reverse('mystery:mystery'))\n self.assertContains(resp, \"Cancel this\", status_code=200)","def get_object(self, *args, **kwargs):\n lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field\n lookup = self.kwargs.get(lookup_url_kwarg, None)\n\n # for now, you can only access to the user/me/ object, for security\n # reasons. We'll probably change this in the future to allow service\n # managers to add/update/delete users from their area.\n # logged_in_user_model = self.get_logged_in_user_model()\n\n if lookup == self.me_lookup_url_kwargs:\n self.kwargs[lookup_url_kwarg] = self.request.user.username\n\n obj = super(BaseUserViewSet, self).get_object(*args, **kwargs)\n self.check_object_permissions(self.request, obj)\n return obj","def ensure_requester_exists(self, requester_id: str) -> None:\n with self.table_access_condition:\n conn = self._get_connection()\n c = conn.cursor()\n c.execute(\n \"\"\"\n INSERT OR IGNORE INTO requesters(\n requester_id,\n is_registered\n ) VALUES (?, ?);\n \"\"\",\n (requester_id, False),\n )\n conn.commit()\n return None","def organizer(self):\n if \"organizer\" in self._prop_dict:\n if isinstance(self._prop_dict[\"organizer\"], OneDriveObjectBase):\n return self._prop_dict[\"organizer\"]\n else :\n self._prop_dict[\"organizer\"] = Recipient(self._prop_dict[\"organizer\"])\n return self._prop_dict[\"organizer\"]\n\n return None","def get_owner_object(self):\n return False","def save_model(self, request, obj, form, change):\n try:\n owner = form.instance.owner\n except models.Application.owner.RelatedObjectDoesNotExist:\n form.instance.owner = request.user\n\n super().save_model(request, obj, form, change)","def raise_for_ownership(self, resource: Model) -> None:\n\n # pylint: disable=import-outside-toplevel\n from superset import db\n\n if self.is_admin():\n return\n\n # Set of wners that works across ORM models.\n owners: List[User] = []\n\n orig_resource = db.session.query(resource.__class__).get(resource.id)\n\n if orig_resource:\n if hasattr(resource, \"owners\"):\n owners += orig_resource.owners\n\n if hasattr(resource, \"owner\"):\n owners.append(orig_resource.owner)\n\n if hasattr(resource, \"created_by\"):\n owners.append(orig_resource.created_by)\n\n if g.user.is_anonymous or g.user not in owners:\n raise SupersetSecurityException(\n SupersetError(\n error_type=SupersetErrorType.MISSING_OWNERSHIP_ERROR,\n message=f\"You don't have the rights to alter [{resource}]\",\n level=ErrorLevel.ERROR,\n )\n )","def pre_save(self, obj):\n obj.owner = self.request.user","def owner_type(self, owner_type):\n\n self._owner_type = owner_type","def owners_only(command):\n @wraps(command)\n def wrapped_up(bot):\n if bot.message.nick not in conf.get('owners', []):\n return irc.Response('Sorry, you are not an owner thus not authorised to use this command', pm_user=True)\n return command(bot)\n wrapped_up.owner_only = True\n return wrapped_up","def owner(self):\n if self.get_team():\n return self.get_team()\n return None","def every_existing_owner_should_have_valid_profile_link(context):\n items = context.response.json()['items']\n for item in items:\n owner = item['owner']\n if owner['user_type'] == 'does_not_exist':\n continue\n link = owner['link']\n assert validators.url(link), (\n 'Owner %s (%d) in item %d has an invalid profile link: %s'.format(\n owner['display_name'], owner['user_id'], link))\n logging.debug(\n 'Owner %s (%d) has a valid profile link: %s',\n owner['display_name'], owner['user_id'], link)","def originalownerpe(self) :\n\t\ttry :\n\t\t\treturn self._originalownerpe\n\t\texcept Exception as e:\n\t\t\traise e","def owner(self) -> None:\n return self.bot.get_user(self.bot.config.owner_ids[0])","def _insert_default_fallback(self):\n db.add_destination_with_aliases(self.dbm,\n \"https://duckduckgo.com?q={}\",\n \"DuckDuckGo\",\n [\"ddg\"],\n True,\n True)","def create_entity_owner(self, owner_data):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_CREATE_ENTITY_OWNER, owner_data)","def technical_owner(self, technical_owner):\n\n self._technical_owner = technical_owner","def add_attendee(self, attendee, no_default_parameters=False, **parameters):\n from icalendar import vCalAddress, vText\n\n if isinstance(attendee, Principal):\n attendee_obj = attendee.get_vcal_address()\n elif isinstance(attendee, vCalAddress):\n attendee_obj = attendee\n elif isinstance(attendee, tuple):\n if attendee[1].startswith(\"mailto:\"):\n attendee_obj = vCalAddress(attendee[1])\n else:\n attendee_obj = vCalAddress(\"mailto:\" + attendee[1])\n attendee_obj.params[\"cn\"] = vText(attendee[0])\n elif isinstance(attendee, str):\n if attendee.startswith(\"ATTENDEE\"):\n raise NotImplementedError(\n \"do we need to support this anyway? Should be trivial, but can't figure out how to do it with the icalendar.Event/vCalAddress objects right now\"\n )\n elif attendee.startswith(\"mailto:\"):\n attendee_obj = vCalAddress(attendee)\n elif \"@\" in attendee and not \":\" in attendee and not \";\" in attendee:\n attendee_obj = vCalAddress(\"mailto:\" + attendee)\n else:\n error.assert_(False)\n attendee_obj = vCalAddress()\n\n ## TODO: if possible, check that the attendee exists\n ## TODO: check that the attendee will not be duplicated in the event.\n if not no_default_parameters:\n ## Sensible defaults:\n attendee_obj.params[\"partstat\"] = \"NEEDS-ACTION\"\n if not \"cutype\" in attendee_obj.params:\n attendee_obj.params[\"cutype\"] = \"UNKNOWN\"\n attendee_obj.params[\"rsvp\"] = \"TRUE\"\n attendee_obj.params[\"role\"] = \"REQ-PARTICIPANT\"\n params = {}\n for key in parameters:\n new_key = key.replace(\"_\", \"-\")\n if parameters[key] == True:\n params[new_key] = \"TRUE\"\n else:\n params[new_key] = parameters[key]\n attendee_obj.params.update(params)\n ievent = self.icalendar_component\n ievent.add(\"attendee\", attendee_obj)","def extranet_reporters(self, REQUEST):\n\n if not _is_authenticated(REQUEST):\n raise Unauthorized\n\n country_code = REQUEST.form.get(\"nfp\", 'eea')\n country_name = code_to_name(country_code)\n agent = self._get_ldap_agent()\n\n if not self._allowed(agent, REQUEST, country_code):\n raise Unauthorized\n\n try:\n extranet_reporter_roles = self.get_extranet_reporter_roles()\n except AttributeError:\n extranet_reporter_roles = EXTRANET_REPORTER_ROLES\n top_role_dns = [agent._role_dn(role)\n for role in extranet_reporter_roles]\n\n options = {'top_role_dns': top_role_dns,\n 'country': country_code,\n 'country_name': country_name or country_code,\n }\n self._set_breadcrumbs([(\"Browsing extranet reporter roles in %s\" %\n country_name, '#')])\n return self._render_template('zpt/nfp_nrc/extranet_reporters.zpt',\n **options)","def determine_preferred_contact(user_data):\n try:\n user_data['personal']['email']\n except KeyError:\n preferred_contact = 'mail'\n else:\n preferred_contact = 'email'\n return preferred_contact","def calc_owner(self, activation):\n from django.contrib.auth import get_user_model\n\n owner = self._owner\n if callable(owner):\n owner = owner(activation)\n elif isinstance(owner, dict):\n owner = get_user_model()._default_manager.get(**owner)\n return owner","def addProspect(self, user):\n if self.is_active and (user != self.owner) and not self.prospects.filter(pk=user.id).exists() \\\n and not self.workers.filter(pk=user.id) and not self.blacklist.filter(pk=user.id).exists():\n self.prospects.add(user)\n return self\n return None","def test_get_user_id_unknown_user(self):\n print('(' + self.test_get_user_id.__name__+')',\n self.test_get_user_id.__doc__)\n self.assertIsNone(self.connection.get_user_id(\n NON_EXIST_PATIENT_USERNAME))","def _IsValidPrimaryOwnerEmail(owner_tag_text):\n if '-' in owner_tag_text: # Check whether it's a team email address.\n return False\n\n return (owner_tag_text.endswith('@chromium.org')\n or owner_tag_text.endswith('@google.com'))","def search_relevant_first_email_for_user(\n issue_owner, messages, user, people_caches):\n # Shortcut. No need to calculate the value.\n if issue_owner == user:\n return None, False\n\n # Search for the first of:\n # - message by the issue owner sent to the user or to mailing lists.\n # - message by the user, for DRIVE_BY and NOT_REQUESTED.\n # Otherwise, return None.\n last_owner_message_index = None\n for i, m in enumerate(messages):\n if m.sender == issue_owner:\n last_owner_message_index = i\n if user in m.recipients:\n return i, False\n # Detect the use case where a request for review is sent to a mailing list\n # and a random reviewer picks it up. We don't want to downgrade the\n # reviewer from a proper review down to DRIVE_BY, so mark it as the\n # important message for everyone. A common usecase is code reviews on\n # golang-dev@googlegroups.com.\n recipients = set(m.recipients) - set([m.sender, issue_owner])\n if not figure_out_real_accounts(recipients, people_caches):\n return i, False\n elif m.sender == user:\n # The issue owner didn't send a request specifically to this user but the\n # dude replied anyway. It can happen if the user was on the cc list with\n # user+cc@example.com. In that case, use the last issue owner email.\n # We want to use this message for latency calculation DRIVE_BY and\n # NOT_REQUESTED.\n if last_owner_message_index is not None:\n return last_owner_message_index, True\n # issue_owner is MIA.\n return i, True\n else:\n # Maybe a reviewer added 'user' on the review on its behalf. Likely\n # m.sender wants to defer the review to someone else.\n if user in m.recipients:\n return i, False\n # Sends the last Message index if there is any.\n return last_owner_message_index, False","def get_default_department_id(self, cr, uid, context=None):\n user_obj = self.pool.get('res.users').browse(cr,uid,uid).employee_ids \n if user_obj: \n dept_id = self.pool.get('res.users').browse(cr,uid,uid).employee_ids[0].department_id and self.pool.get('res.users').browse(cr,uid,uid).employee_ids[0].department_id.id or False\n \n return dept_id","def technical_owner_email(self, technical_owner_email):\n\n self._technical_owner_email = technical_owner_email","def _test_pre_fill_and_assign_humor(self):\n for i in range(1, 50):\n User.objects.create_user(username=\"u{0}\".format(i))\n pre_fill.main([\"--managers\", \"--workshift\"])\n utils.make_workshift_pool_hours(semester=self.semester)\n # Assign manager shifts beforehand\n manager_shifts = RegularWorkshift.objects.filter(\n pool=self.p1, workshift_type__auto_assign=False,\n )\n profiles = WorkshiftProfile.objects.all()\n for profile, shift in zip(profiles, manager_shifts):\n shift.current_assignees.add(profile)\n shift.save()\n unfinished = utils.auto_assign_shifts(\n self.semester, pool=WorkshiftPool.objects.get(title=\"Humor Shift\")\n )\n self.assertEqual([], unfinished)","def owner_id(self) -> Optional[str]:\n return pulumi.get(self, \"owner_id\")","def manage_owners():\n\n owner_data = request.get_json(force=True)\n return _get_owner_service().create_owner(owner_data)","def owner(self, owner):\n self._owner = owner","def owner(self, owner):\n self._owner = owner","def owner(self, owner):\n self._owner = owner","def owner(self, owner):\n self._owner = owner","def test_bad_request_anon_user_no_name(self, zendesk_mock_class, datadog_mock):\r\n self._test_bad_request_omit_field(self._anon_user, self._anon_fields, \"name\", zendesk_mock_class, datadog_mock)\r\n self._test_bad_request_empty_field(self._anon_user, self._anon_fields, \"name\", zendesk_mock_class, datadog_mock)","def set_staff_request_reviewer(review_obj: models.Model):\n if review_obj.user:\n staff_member = review_obj.user.staffprofile\n manager = staff_member.supervisor\n if (\n manager\n and not Reviewer.objects.filter(\n review=review_obj, user=manager.user\n ).exists()\n ):\n reviewer = Reviewer(review=review_obj, user=manager.user)\n reviewer.save() # ensure save method is called\n\n hr_group_name = settings.SSHR_ADMIN_USER_GROUP_NAME\n for user in User.objects.filter(groups__name=hr_group_name):\n if not Reviewer.objects.filter(review=review_obj, user=user).exists():\n reviewer = Reviewer(review=review_obj, user=user)\n reviewer.save() # ensure save method is called","def run(self):\n # Determine if this filter doesn't apply.\n if (self.owner == None \\\n or (self.sense and self.user != self.owner) \\\n or ((not self.sense) and self.user == self.owner)):\n return 0\n\n # Perform the child actions.\n self.context.tokens['Owner'] = self.owner\n return super(FilterLockOwner, self).run()","def technical_owner(self):\n return self._technical_owner","def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"owners\")","def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"owners\")","def is_owner(self, is_owner):\n\n self._is_owner = is_owner","def every_existing_owner_should_have_valid_profile_image_link(context):\n items = context.response.json()['items']\n for item in items:\n owner = item['owner']\n if owner['user_type'] == 'does_not_exist':\n continue\n link = owner['profile_image']\n assert validators.url(link), (\n 'Owner %s (%d) in item %d has an invalid profile image link: %s'\n .format(owner['display_name'], owner['user_id'], link))\n logging.debug(\n 'Owner %s (%d) has a valid profile image link: %s',\n owner['display_name'], owner['user_id'], link)","def _get_default_org(user):\n org = user.default_organization\n # check if user is still in the org, i.e. s/he wasn't removed from his/her\n # default org or didn't have a set org and try to set the first one\n if (\n not org\n or not OrganizationUser.objects.filter(\n organization=org, user=user\n ).exists()\n ):\n org = user.orgs.first()\n user.default_organization = org\n user.save()\n if org:\n org_id = org.pk\n org_name = org.name\n ou = user.organizationuser_set.filter(organization=org).first()\n # parent org owner has no role (None) yet has access to the sub-org\n org_user_role = _get_js_role(ou.role_level) if ou else \"\"\n return org_id, org_name, org_user_role\n else:\n return \"\", \"\", \"\"","def check_NonExistingTestUser(test_case, override_user_name=null, override_headers=null, override_cookies=null):\n # type: (AnyMagpieTestCaseType, Optional[Str], Optional[HeadersType], Optional[CookiesType]) -> None\n users = TestSetup.get_RegisteredUsersList(test_case,\n override_headers=override_headers, override_cookies=override_cookies)\n user_name = override_user_name if override_user_name is not null else test_case.test_user_name\n check_val_not_in(user_name, users)"],"string":"[\n \"def check_user(self, requestor, requestee, default=None):\\n self.lock.acquire()\\n self.users.add(requestor)\\n ok = requestee in self.users\\n self.lock.release()\\n\\n # if this isn't the default app, also add the user to the default app\\n if default != self and default != None:\\n default.check_user(requestor, requestee)\\n\\n return ok\",\n \"def _init_owners(self, identity, record, **kwargs):\\n # if the given identity is that of a user, we add the\\n # corresponding user to the owners (record.access.owned_by)\\n is_sys_id = system_process in identity.provides\\n if not record.access.owned_by and not is_sys_id:\\n record.access.owned_by.add({\\\"user\\\": identity.id})\",\n \"def fix_discovery(self):\\r\\n for item in self.collections['response']['collections']:\\r\\n if item['id'] == 'LDSO':\\r\\n try:\\r\\n self.collections['LDSO'] = self.get(['links']['self']['href'])\\r\\n except:\\r\\n self.lds_user = False\\r\\n else:\\r\\n self.lds_user = True\\r\\n else:\\r\\n self.collections[item['id']] = item['links']['self']['href']\\r\\n try:\\r\\n self.user = self.get_current_user()['response']['users'][0]\\r\\n except:\\r\\n self.user = \\\"\\\"\",\n \"def add_owner(urn: str, owner: str, owner_type: str) -> None:\\n\\n if not urn.startswith(\\\"urn:li:dataProduct:\\\"):\\n urn = f\\\"urn:li:dataProduct:{urn}\\\"\\n dataproduct_patcher: DataProductPatchBuilder = DataProduct.get_patch_builder(urn)\\n dataproduct_patcher.add_owner(\\n owner=OwnerClass(owner=_get_owner_urn(owner), type=owner_type)\\n )\\n with get_default_graph() as graph:\\n _abort_if_non_existent_urn(graph, urn, \\\"add owners\\\")\\n for mcp in dataproduct_patcher.build():\\n graph.emit(mcp)\",\n \"def add(self, user_or_username, set_as_default=False, **kwargs):\\n user = super().add(user_or_username, set_as_default=set_as_default, **kwargs)\\n\\n if user.expected_prompt == -1 and self.default and self.default.expected_prompt != -1:\\n user.expected_prompt = self.default.expected_prompt\\n\\n return user\",\n \"def which_owner(self):\\n LOGGER.debug(self.details)\\n for override_function, override_map in self.team_owner_overrides.items():\\n for override_key, override_team in override_map.items():\\n if override_key in self.details[override_function]: # pylint: disable=unsupported-membership-test\\n self.details[\\\"owner\\\"] = override_team\\n break\\n\\n # for chassis and blades in d42, use their role to determine ownership\\n if re.match('^c[0-9]*b[0-9]*', self.details['function']) is not None:\\n self.load_from_device42()\\n\\n if self.details[\\\"owner\\\"] == \\\"team-unclassified\\\":\\n for owner, teamregex in self.team_ownership_regexes.items():\\n if re.search(teamregex, self.details[\\\"function\\\"]):\\n self.details[\\\"owner\\\"] = owner\\n break\",\n \"def owner(self) -> discord.User:\\n if self.config.owner_id:\\n return self.get_user(self.config.owner_id)\\n if self.owner_ids:\\n return self.get_user(self.config.owner_ids[0])\\n return None\",\n \"def test_owner_has_no_locations(self):\\n self.owner = CommCareUser.create(self.domain, 'no_location', '***', None, None)\\n form, (case, ) = _create_case(domain=self.domain, case_id=uuid.uuid4().hex, owner_id=self.owner.get_id)\\n location = get_case_location(case)\\n self.assertIsNone(location)\",\n \"def _set_owner_groups(self):\\n group_id: int = 1\\n if self._report_key == ReportTypes.MHR_TRANSFER:\\n if self._report_data.get('addOwnerGroups'):\\n has_na: bool = False\\n for group in self._report_data.get('addOwnerGroups'):\\n if group.get('type', '') == MhrTenancyTypes.NA and not group.get('interestNumerator') and \\\\\\n not group.get('interestDenominator'):\\n has_na = True\\n group['groupId'] = group_id\\n group_id += 1\\n self._report_data['hasNA'] = has_na\\n elif self._report_key == ReportTypes.MHR_REGISTRATION:\\n has_na: bool = False\\n for group in self._report_data.get('ownerGroups'):\\n group['groupId'] = group_id\\n group_id += 1\\n if group.get('type', '') == MhrTenancyTypes.NA and not group.get('interestNumerator') and \\\\\\n not group.get('interestDenominator'):\\n has_na = True\\n self._report_data['hasNA'] = has_na\\n elif self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_BODY_REPORT):\\n for detail in self._report_data['details']:\\n group_id = 1\\n has_na: bool = False\\n for group in detail.get('ownerGroups'):\\n group['groupId'] = group_id\\n group_id += 1\\n if group.get('type', '') == MhrTenancyTypes.NA and not group.get('interestNumerator') and \\\\\\n not group.get('interestDenominator'):\\n has_na = True\\n self._report_data['hasNA'] = has_na\",\n \"def every_non_existing_owner_should_not_have_profile_link(context):\\n items = context.response.json()['items']\\n for item in items:\\n owner = item['owner']\\n if not owner['user_type'] == 'does_not_exist':\\n continue\\n assert 'link' not in owner\\n logging.debug(\\n 'Not existing Owner %s does not have a valid profile link',\\n owner['display_name'])\",\n \"def update_owner(current_owner_email: str, new_owner_email: str):\\n current_owner_id = find_user_id(current_owner_email)\\n new_owner_id = find_user_id(new_owner_email) \\n \\n \\\"\\\"\\\" This block is executed to check if email addresses provided are associated with two Looker users \\\"\\\"\\\"\\n \\n if type(new_owner_id) != int and type(new_owner_id) != int:\\n print(\\\"The email addresses for both the current owner and the new owner are not associated with any Looker user id\\\")\\n\\n elif type(current_owner_id) != int: \\n print(\\\"The email address for the current owner is not associated with any Looker user id\\\")\\n\\n elif type(new_owner_id) != int:\\n print(\\\"The email address for the new owner is not associated with any Looker user id\\\")\\n\\n else: \\n body = {}\\n body['user_id'] = new_owner_id\\n find = find_schedules(current_owner_id) \\n for i in find.values(): \\n sdk.update_scheduled_plan(i,body)\\n print(\\\"Successfully transfer all schedules of \\\" + current_owner_email + \\\" to \\\" + new_owner_email)\",\n \"def every_non_existing_owner_should_not_have_profile_image_link(context):\\n items = context.response.json()['items']\\n for item in items:\\n owner = item['owner']\\n if not owner['user_type'] == 'does_not_exist':\\n continue\\n assert 'profile_image' not in owner\\n logging.debug(\\n 'Not existing Owner %s does not have a valid profile image link',\\n owner['display_name'])\",\n \"def test_no_owner(self):\\n form, (case, ) = _create_case(domain=self.domain, case_id=uuid.uuid4().hex, owner_id=None)\\n location = get_case_location(case)\\n self.assertIsNone(location)\",\n \"def _check_owner(user, study):\\n if not user.id == study.owner:\\n raise HTTPError(403, \\\"User %s does not own study %d\\\" %\\n (user.id, study.id))\",\n \"def clean_owner(self):\\n username = self.cleaned_data['owner']\\n owner = User.objects.filter(username=username).first()\\n if owner is None:\\n raise forms.ValidationError(\\n _('User %(username)s does not exist'),\\n params={'username': username},\\n )\\n if self.organization.owners.filter(username=username).exists():\\n raise forms.ValidationError(\\n _('User %(username)s is already an owner'),\\n params={'username': username},\\n )\\n return owner\",\n \"def generate_report(self, owners_users_data):\\n domain_types = ['addon_domains', 'parked_domains', 'sub_domains']\\n\\n report = ''\\n\\n for owner in owners_users_data.keys():\\n report += '\\\\n{0} | {1:>8} | {2:>21} | {3:>28}\\\\n'.format('OWNER', 'USER/DOMAIN', 'IP/MX/NS', 'DOCUMENT ROOT')\\n report += owner\\n users = owners_users_data[owner].keys()\\n users.sort()\\n for user in users:\\n user_domains = server.get_account_domains(user)\\n domain = user_domains['main_domain']\\n\\n self.populate_domain_data(domain)\\n domain_resolving = self.domain_data[domain]['resolving']\\n document_root = self.domain_data[domain]['documentroot']\\n report += '{0:>17}: LOCAL IP: {1:34}\\\\n'.format(user, owners_users_data[owner][user]['ip'])\\n report += '{0:>13}{1:34} {2:54}\\\\n'.format(' ', domain, document_root)\\n report += '{0:>13}IP: {1}\\\\n'.format(' ', domain_resolving['A'])\\n report += '{0:>13}MX: {1}\\\\n'.format(' ', domain_resolving['MX'])\\n report += '{0:>13}NS: {1}\\\\n\\\\n'.format(' ', domain_resolving['NS'])\\n\\n for domain_type in domain_types:\\n for domain in user_domains[domain_type]:\\n self.populate_domain_data(domain)\\n document_root = self.domain_data[domain]['documentroot']\\n report += '{0:>13}{1:34} {2:54}\\\\n'.format(' ', domain, document_root)\\n report += '{0:>13}{1}\\\\n'.format(' ', domain_resolving['A'] )\\n report += '{0:>13}MX: {1}\\\\n'.format(' ', domain_resolving['MX'])\\n report += '{0:>13}NS: {1}\\\\n\\\\n'.format(' ', domain_resolving['NS'])\\n\\n server.mail_report(self.__class__.__name__, content=report)\",\n \"def test_make_default_ach_user(self):\\n\\n user = self.client.users.create({})\\n\\n FundingSources.get_user_ach_funding_source(user)\\n source = FundingSources.get_user_ach_funding_source(user)\\n\\n default = self.client.funding_sources(source.token).make_default()\\n\\n verify_payment_card_response_model(\\n self, default, {'is_default_account': True})\",\n \"def generate_report_p24(self, owners_users_data):\\n domain_types = ['addon_domains', 'parked_domains', 'sub_domains']\\n\\n report = ''\\n\\n for owner in owners_users_data.keys():\\n report += '\\\\nOWNER, USER/DOMAIN, IP/MX/NS, DOCUMENT ROOT\\\\n'\\n report += owner\\n users = owners_users_data[owner].keys()\\n users.sort()\\n for user in users:\\n user_domains = server.get_account_domains(user)\\n domain = user_domains['main_domain']\\n\\n self.populate_domain_data(domain)\\n domain_resolving = self.domain_data[domain]['resolving']\\n document_root = self.domain_data[domain]['documentroot']\\n report += '%17s: LOCAL IP: %34s\\\\n' % (user, owners_users_data[owner][user]['ip'])\\n report += '%13s, %34s %54s\\\\n' % (' ', domain, document_root)\\n report += '%13s IP: %s\\\\n' % (' ', domain_resolving['A'])\\n report += '%13s MX: %s\\\\n' % (' ', domain_resolving['MX'])\\n report += '%13s NS: %s\\\\n\\\\n' % (' ', domain_resolving['NS'])\\n\\n for domain_type in domain_types:\\n for domain in user_domains[domain_type]:\\n self.populate_domain_data(domain)\\n document_root = self.domain_data[domain]['documentroot']\\n report += '%13s, %34s %54s\\\\n' % (' ', domain, document_root)\\n report += '%13s IP: %s\\\\n' % (' ', domain_resolving['A'])\\n report += '%13s MX: %s\\\\n' % (' ', domain_resolving['MX'])\\n report += '%13s NS: %s\\\\n\\\\n' % (' ', domain_resolving['NS'])\\n\\n server.mail_report(self.__class__.__name__, content=report)\",\n \"def __init__(__self__, *,\\n owner_type: str,\\n assigned_to: Optional[str] = None,\\n email: Optional[str] = None,\\n object_id: Optional[str] = None,\\n user_principal_name: Optional[str] = None):\\n pulumi.set(__self__, \\\"owner_type\\\", owner_type)\\n if assigned_to is not None:\\n pulumi.set(__self__, \\\"assigned_to\\\", assigned_to)\\n if email is not None:\\n pulumi.set(__self__, \\\"email\\\", email)\\n if object_id is not None:\\n pulumi.set(__self__, \\\"object_id\\\", object_id)\\n if user_principal_name is not None:\\n pulumi.set(__self__, \\\"user_principal_name\\\", user_principal_name)\",\n \"def hook_assign_assistance(self, data):\\n request_id = data[\\\"request_id\\\"]\\n assignee_chat_id = data[\\\"volunteer\\\"]\\n log.info(\\\"ASSIGN req:%s to vol:%s\\\", request_id, assignee_chat_id)\\n\\n try:\\n request_details = self.updater.persistence.bot_data[request_id]\\n except KeyError:\\n log.debug(\\\"No such request %s, ignoring\\\", request_id)\\n return\\n else:\\n self.updater.dispatcher.bot_data[request_id].update(\\n {\\\"time\\\": utc_short_to_user_short(data[\\\"time\\\"])}\\n )\\n\\n # first of all, notify the others that they are off the hook and update their state accordingly\\n for chat_id in request_details[\\\"volunteers\\\"]:\\n if chat_id != assignee_chat_id:\\n self.send_message(chat_id, c.MSG_ANOTHER_ASSIGNEE)\\n updated_state = {\\\"state\\\": c.State.AVAILABLE, \\\"reviewed_request\\\": None}\\n self.updater.dispatcher.user_data[chat_id].update(updated_state)\\n\\n self.updater.dispatcher.user_data[assignee_chat_id].update({\\\"current_request\\\": request_id})\\n self.updater.dispatcher.update_persistence()\\n\\n # notify the assigned volunteer, so they know they're responsible; at this point they still have to confirm\\n # that they're in good health and they still have an option to cancel\\n self.updater.bot.send_message(\\n chat_id=assignee_chat_id,\\n text=c.MSG_CAUTION,\\n reply_markup=InlineKeyboardMarkup(k.caution_choices),\\n )\",\n \"def match_Owner(self, object, options) :\\n\\t\\tif options.has_key(\\\"owner\\\") :\\n\\t\\t\\townerinfo = object.owner_info()\\n\\t\\t\\tif ownerinfo is not None :\\n\\t\\t\\t\\t# at least /Control_Panel/Products[/*] doesn't satisfy the following test\\n\\t\\t\\t\\tif hasattr(ownerinfo, \\\"has_key\\\") and ownerinfo.has_key('id') :\\n\\t\\t\\t\\t\\treturn self.match_anystring(\\\"owner\\\", ownerinfo['id'], options)\\n\\t\\t\\treturn 0 # Not owned or no owner: never match\\n\\t\\treturn 1\\t # No owner option: always match\",\n \"def test_non_matching_type(self):\\n user1 = get_user_model().objects.get(username='test1@example.com')\\n self.client.login(username='test1@example.com', password='1')\\n\\n office = OfficeLocation.objects.all()[0]\\n org = OrgGroup.objects.filter(parent__isnull=True)[0]\\n\\n submission1 = Interest()\\n submission1.owner = user1\\n submission1.for_coffee = True\\n submission1.save()\\n submission1.locations.add(office)\\n submission1.departments.add(org)\\n\\n resp = self.client.get(reverse('mystery:mystery'))\\n self.assertContains(resp, \\\"Cancel this\\\", status_code=200)\\n\\n user2 = random_user()\\n submission2 = Interest()\\n submission2.owner = user2\\n submission2.is_active = False\\n submission2.save()\\n submission2.for_lunch = True\\n submission2.locations.add(office)\\n submission2.departments.add(org)\\n submission2.is_active = True\\n submission2.save()\\n\\n resp = self.client.get(reverse('mystery:mystery'))\\n self.assertContains(resp, \\\"Cancel this\\\", status_code=200)\",\n \"def _get_owner(self):\\n if self.resource.owner is not None:\\n try:\\n return pwd.getpwnam(self.resource.owner).pw_uid\\n except KeyError:\\n raise error.InvalidUser()\",\n \"def set_owner(self, owner):\\n self.settings[\\\"owner\\\"] = owner\",\n \"def owner(self, owner):\\n if self.local_vars_configuration.client_side_validation and owner is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `owner`, must not be `None`\\\") # noqa: E501\\n\\n self._owner = owner\",\n \"def resolved_by(self):\\n return User(None, self.get_data(\\\"resolved_by\\\"), **self._new_session_args)\",\n \"def _determine_uploader_by_changedby_field(self):\\n maintainer_string = self.changes.get('Changed-By')\\n log.debug(\\\"Determining user from 'Changed-By:' field: %s\\\" % maintainer_string)\\n maintainer_realname, maintainer_email_address = email.utils.parseaddr(maintainer_string)\\n log.debug(\\\"Changed-By's email address is: %s\\\", maintainer_email_address)\\n self._find_user_by_email_address(maintainer_email_address)\",\n \"def test_channel_addowner_not_owner():\\n clear()\\n auth_register('randemail@gmail.com', 'password1234', 'Jane', 'Citizen')\\n register_second_result = auth_register('randemail2@gmail.com', 'password1234', 'Jane', 'Citizen')\\n register_third_result = auth_register('randemail3@gmail.com', 'password1234', 'Jane', 'Citizen')\\n register_forth_result = auth_register('randemail4@gmail.com', 'password1234', 'Jane', 'Citizen')\\n randChannel_id = channels_create(register_second_result['token'], 'Random Channel', True)\\n with pytest.raises(AccessError):\\n assert channel_addowner(register_third_result['token'], randChannel_id['channel_id'], register_forth_result['u_id'])\",\n \"def set_owner_allowed(self, data):\\n self._owner_allowed = self._uni(data)\",\n \"def test_channel_addowner_already_an_owner():\\n clear()\\n auth_register('randemail@gmail.com', 'password1234', 'Jane', 'Citizen')\\n register_second_result = auth_register('randemail2@gmail.com', 'password1234', 'Jane', 'Citizen')\\n randChannel_id = channels_create(register_second_result['token'], 'Random Channel', True)\\n register_third_result = auth_register('randemail3@gmail.com', 'password1234', 'Jane', 'Citizen')\\n channel_addowner(register_second_result['token'], randChannel_id['channel_id'], register_third_result['u_id'])\\n with pytest.raises(InputError):\\n assert channel_addowner(register_second_result['token'], randChannel_id['channel_id'], register_third_result['u_id'])\",\n \"def test_is_owner_inherited_and_local(self):\\n self.make_assignment(self.project, self.user_alice, self.role_owner)\\n self.assertTrue(self.project.is_owner(self.user_alice))\",\n \"def owner(self, owner: str):\\n\\n self._owner = owner\",\n \"def __init__(self, owner=None, *args, **kwargs):\\n super(CalendarForm, self).__init__(*args, **kwargs)\\n if owner is not None:\\n self.owner = owner\\n without_owner = UserProfile.objects.all().exclude(pk=owner.pk)\\n self.fields['readers'].queryset = without_owner\\n self.fields['modifiers'].queryset = without_owner\",\n \"def test_get_one_for_other_organization_forbidden(self):\\n org = Organization.create(name='foo', program_id=self.program.uid)\\n org.put()\\n coAdmin = User.create(name='coAdmin', email='teammate@bar.com',\\n owned_organizations=[org.uid])\\n coAdmin.put()\\n user = User.create(name='foo', email='foo@bar.com')\\n user.put()\\n response = self.testapp.get(\\n '/api/organizations/{}/users/{}'.format(org.uid, coAdmin.uid),\\n headers=self.login_headers(user),\\n status=403,\\n )\",\n \"def is_owner(self, author):\\n return not self.server or author == self.server.owner\",\n \"def ldap_get_email(self, user):\\n result = super(Auth42, self)._search_not_empty(user)\\n if result is not None:\\n alias = result.get(\\\"alias\\\")[1]\\n return alias\\n\\n return None\",\n \"def items_should_contain_owner_object(context):\\n items = context.response.json()['items']\\n existing_owner_fields = [\\n 'accept_rate', 'display_name', 'link', 'profile_image', 'reputation',\\n 'user_id', 'user_type'\\n ]\\n non_existing_owner_fields = ['display_name', 'user_type']\\n\\n for item in items:\\n assert 'owner' in item\\n assert isinstance(item['owner'], dict)\\n owner = item['owner']\\n if owner['user_type'] == 'does_not_exist':\\n all(field in owner for field in non_existing_owner_fields)\\n logging.debug(\\n ('Item %d contains an non-existing Owner object for user \\\"%s\\\" '\\n 'with all required fields: %s'), item['question_id'], \\n owner['display_name'], ', '.join(non_existing_owner_fields))\\n else:\\n all(field in owner for field in existing_owner_fields)\\n logging.debug(\\n ('Item %d contains an existing Owner object for user ID \\\"%d\\\" '\\n 'with all required fields: %s'), item['question_id'], \\n owner['user_id'], ', '.join(existing_owner_fields))\",\n \"def owner(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"owner\\\")\",\n \"def ownercheck(self, userhost):\\n if self.cfg and self.cfg.owner:\\n if userhost in self.cfg.owner: return True\\n return False\",\n \"def OnFindManager(self, event):\\r\\n \\r\\n event.SetManager(self._owner_mgr)\",\n \"def _return_specific_owner_prs(all_prs, filters):\\n if _validate_list_of_dict(all_prs):\\n owner_prs = [pr for pr in all_prs if filters['owner'] == pr['pr'].user.login]\\n logger.debug(\\\"OWNER PRS: %s\\\", [pr['pr'].number for pr in owner_prs])\\n return owner_prs\\n else:\\n return []\",\n \"def get_reporter(reporter):\\n if six.PY2:\\n file_types = file, io.IOBase\\n else:\\n file_types = (io.IOBase, )\\n\\n if isinstance(reporter, str):\\n if reporter.lower() == 'default':\\n reporter = BasicReporter()\\n elif reporter.lower() == 'silent':\\n reporter = SilentReporter()\\n else:\\n raise ValueError('If reporter is string, it should be \\\"default\\\" or \\\"silent\\\".')\\n elif isinstance(reporter, file_types):\\n return BasicReporter(reporter)\\n elif reporter is None:\\n reporter = SilentReporter()\\n elif not isinstance(reporter, BasicReporter):\\n raise ValueError('Pass either a string, BasicReporter or None for reporter. ')\\n return reporter\",\n \"def _process_ldap_info_for_one_user(self, record, result_data):\\n #One entry only in the ldap data because we used a filter\\n #to find one user only\\n ldapentry = result_data[0][1]\\n logger.debug(\\\"LDAP.PY \\\\t LdapFindUser ldapentry %s\\\" % (ldapentry))\\n tmpname = ldapentry['uid'][0]\\n\\n tmpemail = ldapentry['mail'][0]\\n if ldapentry['mail'][0] == \\\"unknown\\\":\\n tmpemail = None\\n\\n parent_hrn = None\\n peer_authority = None\\n if 'hrn' in record:\\n hrn = record['hrn']\\n parent_hrn = get_authority(hrn)\\n if parent_hrn != self.authname:\\n peer_authority = parent_hrn\\n #In case the user was not imported from Iotlab LDAP\\n #but from another federated site, has an account in\\n #iotlab but currently using his hrn from federated site\\n #then the login is different from the one found in its hrn\\n if tmpname != hrn.split('.')[1]:\\n hrn = None\\n else:\\n hrn = None\\n\\n results = {\\n 'type': 'user',\\n 'pkey': ldapentry['sshPublicKey'],\\n #'uid': ldapentry[1]['uid'][0],\\n 'uid': tmpname,\\n 'email': tmpemail,\\n #'email': ldapentry[1]['mail'][0],\\n 'first_name': ldapentry['givenName'][0],\\n 'last_name': ldapentry['sn'][0],\\n #'phone': 'none',\\n 'serial': 'none',\\n 'authority': parent_hrn,\\n 'peer_authority': peer_authority,\\n 'pointer': -1,\\n 'hrn': hrn,\\n }\\n return results\",\n \"def process_group_owners(data):\\n owner_list = []\\n owners = data.split(\\\"\\\\r\\\\n\\\")\\n for owner in owners:\\n if owner != \\\"\\\":\\n result = shared_ldap.find_from_email(owner)\\n if result is None:\\n shared_sd.post_comment(\\n \\\"Unable to add %s as an owner as the email address \\\"\\n \\\"cannot be found in Linaro Login.\\\" % owner, True)\\n else:\\n # Need to make sure we append the mailing group if it\\n # is a group!\\n if \\\",ou=security,\\\" not in result:\\n owner_list.append(result)\\n shared_sd.post_comment(\\n \\\"Adding %s as an owner.\\\" % owner, True)\\n return owner_list\",\n \"def default_get(self, cr, uid, fields, context=None): \\n \\n \\n res = super(granted_rights_order, self).default_get(cr, uid, fields, context=context)\\n \\n employee_obj = self.pool.get('hr.employee')\\n department_obj = self.pool.get('hr.department')\\n manager = False\\n donor_emp_id = []\\n \\n if uid != 1 :\\n\\n donor_emp_id = employee_obj.search(cr ,uid, [('user_id' , '=' , uid )])\\n deparment_id = employee_obj.browse(cr,uid,donor_emp_id[0]).department_id.id\\n \\n if donor_emp_id[0] == department_obj.browse(cr,uid,deparment_id).manager_id.id :\\n manager = True\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n if donor_emp_id :\\n res.update({ 'employee_donor': donor_emp_id[0], \\n 'department_id' : deparment_id,\\n 'is_a_amanger' : manager,\\n })\\n return res\",\n \"def assure_tender_assigned_to_user(self, tender_new_id, assigned_user):\\n tenders_from_admin = ToDoTenders(division_admin_login, universal_password) # only admin see all chains\\n\\n all_tender_id_responsibles_chains = tenders_from_admin.get_all_assigned_users_for_tenders(\\n tenders_from_admin.get_tenders_with_responsibles('in_work'))\\n\\n for chain in all_tender_id_responsibles_chains:\\n if chain['tender_new_id'] == tender_new_id:\\n for res in chain['responsibles']:\\n if res['emailAddress'] == assigned_user:\\n return True\\n else:\\n pass\",\n \"def test_no_owner_exception(api: API, owners: list):\\n api.candlepin.get_owners.return_value = owners\\n account = Account(api, \\\"USERNAME\\\", \\\"PASSWORD\\\")\\n with pytest.raises(IndexError):\\n account.owner_id\",\n \"def set_owner(self, data):\\n self._owner = self._uni(data)\\n self.add_payload('owner', data)\",\n \"def get_owner_object(self):\\n return None\",\n \"def get_owner_object(self):\\n return None\",\n \"def get_owner_object(self):\\n return None\",\n \"def check_owner(data=None, **kw):\\n if data and 'owner_id' in data and not data['owner_id'] == current_user.id:\\n raise ProcessingException(description=\\\"No write privileges\\\",\\n code=401)\",\n \"def test_optional_email(self):\\n\\n consumer = LTIConsumerFactory(slug=\\\"consumer\\\")\\n passport = LTIPassportFactory(title=\\\"consumer1_passport1\\\", consumer=consumer)\\n\\n user_count = get_user_model().objects.count()\\n\\n new_user = self._authenticate(\\n {\\n \\\"user_id\\\": \\\"7275a984-1e77-4084-9fe6-e54d0deba0e7\\\",\\n \\\"lti_message_type\\\": \\\"basic-lti-launch-request\\\",\\n \\\"lti_version\\\": \\\"LTI-1p0\\\",\\n \\\"resource_link_id\\\": \\\"aaa\\\",\\n \\\"context_id\\\": \\\"course-v1:fooschool+authbackend+0001\\\",\\n \\\"lis_person_sourcedid\\\": \\\"user_without_email\\\",\\n },\\n passport,\\n )\\n\\n self.assertEqual(\\\"user_without_email\\\", new_user.public_username)\\n self.assertEqual(\\\"\\\", new_user.email)\\n self.assertEqual(consumer, new_user.lti_consumer)\\n self.assertEqual(\\\"user_without_email@consumer\\\", new_user.username)\\n self.assertEqual(user_count + 1, get_user_model().objects.count())\",\n \"def __init__(self, business_owner=None, business_owner_email=None, technical_owner=None, technical_owner_email=None):\\n\\n self._business_owner = None\\n self._business_owner_email = None\\n self._technical_owner = None\\n self._technical_owner_email = None\\n\\n if business_owner is not None:\\n self.business_owner = business_owner\\n if business_owner_email is not None:\\n self.business_owner_email = business_owner_email\\n if technical_owner is not None:\\n self.technical_owner = technical_owner\\n if technical_owner_email is not None:\\n self.technical_owner_email = technical_owner_email\",\n \"def add_person(self, name, email, typ, wants_accomodation='N'):\\n if typ == \\\"FELLOW\\\":\\n if not email in self.all_persons.keys():\\n new_fellow = Fellow(name, email, wants_accomodation)\\n self.fellows[email] = new_fellow\\n self.allocate_room(new_fellow)\\n return new_fellow\\n else:\\n return \\\"Email already used!\\\"\\n elif typ == \\\"STAFF\\\":\\n if not email in self.all_persons.keys():\\n new_staff = Staff(name, email)\\n self.staff[email] = new_staff\\n self.allocate_room(new_staff)\\n return new_staff\\n else:\\n return \\\"Email already used!\\\"\\n else:\\n return -1\",\n \"def must_be_owner(func):\\n @functools.wraps(func)\\n @login_required()\\n def wrapped(request, poll_name, *args, **kwargs):\\n try:\\n cur_poll = Poll.objects.get(url=poll_name)\\n except Poll.DoesNotExist:\\n return db_error(_('This poll does not seem to exist, sorry.'))\\n if cur_poll.is_owner(request.user.userinformation):\\n return func(request, poll_name, *args, **kwargs)\\n else:\\n return redirect(reverse('login')+'?next='+request.path)\\n return wrapped\",\n \"def test_non_matching_org(self):\\n user1 = get_user_model().objects.get(username='test1@example.com')\\n self.client.login(username='test1@example.com', password='1')\\n\\n office = OfficeLocation.objects.all()[0]\\n org = OrgGroup.objects.filter(parent__isnull=True)[0]\\n\\n submission1 = Interest()\\n submission1.owner = user1\\n submission1.for_coffee = True\\n submission1.save()\\n submission1.locations.add(office)\\n submission1.departments.add(org)\\n\\n resp = self.client.get(reverse('mystery:mystery'))\\n self.assertContains(resp, \\\"Cancel this\\\", status_code=200)\\n\\n user2 = random_user()\\n org2 = OrgGroup()\\n org2.parent = org\\n org2.title = \\\"test org\\\"\\n org2.save()\\n submission2 = Interest()\\n submission2.owner = user2\\n submission2.is_active = False\\n submission2.save()\\n submission2.for_coffee = True\\n submission2.locations.add(office)\\n submission2.departments.add(org2)\\n submission2.is_active = True\\n submission2.save()\\n\\n resp = self.client.get(reverse('mystery:mystery'))\\n self.assertContains(resp, \\\"Cancel this\\\", status_code=200)\",\n \"def get_object(self, *args, **kwargs):\\n lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field\\n lookup = self.kwargs.get(lookup_url_kwarg, None)\\n\\n # for now, you can only access to the user/me/ object, for security\\n # reasons. We'll probably change this in the future to allow service\\n # managers to add/update/delete users from their area.\\n # logged_in_user_model = self.get_logged_in_user_model()\\n\\n if lookup == self.me_lookup_url_kwargs:\\n self.kwargs[lookup_url_kwarg] = self.request.user.username\\n\\n obj = super(BaseUserViewSet, self).get_object(*args, **kwargs)\\n self.check_object_permissions(self.request, obj)\\n return obj\",\n \"def ensure_requester_exists(self, requester_id: str) -> None:\\n with self.table_access_condition:\\n conn = self._get_connection()\\n c = conn.cursor()\\n c.execute(\\n \\\"\\\"\\\"\\n INSERT OR IGNORE INTO requesters(\\n requester_id,\\n is_registered\\n ) VALUES (?, ?);\\n \\\"\\\"\\\",\\n (requester_id, False),\\n )\\n conn.commit()\\n return None\",\n \"def organizer(self):\\n if \\\"organizer\\\" in self._prop_dict:\\n if isinstance(self._prop_dict[\\\"organizer\\\"], OneDriveObjectBase):\\n return self._prop_dict[\\\"organizer\\\"]\\n else :\\n self._prop_dict[\\\"organizer\\\"] = Recipient(self._prop_dict[\\\"organizer\\\"])\\n return self._prop_dict[\\\"organizer\\\"]\\n\\n return None\",\n \"def get_owner_object(self):\\n return False\",\n \"def save_model(self, request, obj, form, change):\\n try:\\n owner = form.instance.owner\\n except models.Application.owner.RelatedObjectDoesNotExist:\\n form.instance.owner = request.user\\n\\n super().save_model(request, obj, form, change)\",\n \"def raise_for_ownership(self, resource: Model) -> None:\\n\\n # pylint: disable=import-outside-toplevel\\n from superset import db\\n\\n if self.is_admin():\\n return\\n\\n # Set of wners that works across ORM models.\\n owners: List[User] = []\\n\\n orig_resource = db.session.query(resource.__class__).get(resource.id)\\n\\n if orig_resource:\\n if hasattr(resource, \\\"owners\\\"):\\n owners += orig_resource.owners\\n\\n if hasattr(resource, \\\"owner\\\"):\\n owners.append(orig_resource.owner)\\n\\n if hasattr(resource, \\\"created_by\\\"):\\n owners.append(orig_resource.created_by)\\n\\n if g.user.is_anonymous or g.user not in owners:\\n raise SupersetSecurityException(\\n SupersetError(\\n error_type=SupersetErrorType.MISSING_OWNERSHIP_ERROR,\\n message=f\\\"You don't have the rights to alter [{resource}]\\\",\\n level=ErrorLevel.ERROR,\\n )\\n )\",\n \"def pre_save(self, obj):\\n obj.owner = self.request.user\",\n \"def owner_type(self, owner_type):\\n\\n self._owner_type = owner_type\",\n \"def owners_only(command):\\n @wraps(command)\\n def wrapped_up(bot):\\n if bot.message.nick not in conf.get('owners', []):\\n return irc.Response('Sorry, you are not an owner thus not authorised to use this command', pm_user=True)\\n return command(bot)\\n wrapped_up.owner_only = True\\n return wrapped_up\",\n \"def owner(self):\\n if self.get_team():\\n return self.get_team()\\n return None\",\n \"def every_existing_owner_should_have_valid_profile_link(context):\\n items = context.response.json()['items']\\n for item in items:\\n owner = item['owner']\\n if owner['user_type'] == 'does_not_exist':\\n continue\\n link = owner['link']\\n assert validators.url(link), (\\n 'Owner %s (%d) in item %d has an invalid profile link: %s'.format(\\n owner['display_name'], owner['user_id'], link))\\n logging.debug(\\n 'Owner %s (%d) has a valid profile link: %s',\\n owner['display_name'], owner['user_id'], link)\",\n \"def originalownerpe(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._originalownerpe\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def owner(self) -> None:\\n return self.bot.get_user(self.bot.config.owner_ids[0])\",\n \"def _insert_default_fallback(self):\\n db.add_destination_with_aliases(self.dbm,\\n \\\"https://duckduckgo.com?q={}\\\",\\n \\\"DuckDuckGo\\\",\\n [\\\"ddg\\\"],\\n True,\\n True)\",\n \"def create_entity_owner(self, owner_data):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_CREATE_ENTITY_OWNER, owner_data)\",\n \"def technical_owner(self, technical_owner):\\n\\n self._technical_owner = technical_owner\",\n \"def add_attendee(self, attendee, no_default_parameters=False, **parameters):\\n from icalendar import vCalAddress, vText\\n\\n if isinstance(attendee, Principal):\\n attendee_obj = attendee.get_vcal_address()\\n elif isinstance(attendee, vCalAddress):\\n attendee_obj = attendee\\n elif isinstance(attendee, tuple):\\n if attendee[1].startswith(\\\"mailto:\\\"):\\n attendee_obj = vCalAddress(attendee[1])\\n else:\\n attendee_obj = vCalAddress(\\\"mailto:\\\" + attendee[1])\\n attendee_obj.params[\\\"cn\\\"] = vText(attendee[0])\\n elif isinstance(attendee, str):\\n if attendee.startswith(\\\"ATTENDEE\\\"):\\n raise NotImplementedError(\\n \\\"do we need to support this anyway? Should be trivial, but can't figure out how to do it with the icalendar.Event/vCalAddress objects right now\\\"\\n )\\n elif attendee.startswith(\\\"mailto:\\\"):\\n attendee_obj = vCalAddress(attendee)\\n elif \\\"@\\\" in attendee and not \\\":\\\" in attendee and not \\\";\\\" in attendee:\\n attendee_obj = vCalAddress(\\\"mailto:\\\" + attendee)\\n else:\\n error.assert_(False)\\n attendee_obj = vCalAddress()\\n\\n ## TODO: if possible, check that the attendee exists\\n ## TODO: check that the attendee will not be duplicated in the event.\\n if not no_default_parameters:\\n ## Sensible defaults:\\n attendee_obj.params[\\\"partstat\\\"] = \\\"NEEDS-ACTION\\\"\\n if not \\\"cutype\\\" in attendee_obj.params:\\n attendee_obj.params[\\\"cutype\\\"] = \\\"UNKNOWN\\\"\\n attendee_obj.params[\\\"rsvp\\\"] = \\\"TRUE\\\"\\n attendee_obj.params[\\\"role\\\"] = \\\"REQ-PARTICIPANT\\\"\\n params = {}\\n for key in parameters:\\n new_key = key.replace(\\\"_\\\", \\\"-\\\")\\n if parameters[key] == True:\\n params[new_key] = \\\"TRUE\\\"\\n else:\\n params[new_key] = parameters[key]\\n attendee_obj.params.update(params)\\n ievent = self.icalendar_component\\n ievent.add(\\\"attendee\\\", attendee_obj)\",\n \"def extranet_reporters(self, REQUEST):\\n\\n if not _is_authenticated(REQUEST):\\n raise Unauthorized\\n\\n country_code = REQUEST.form.get(\\\"nfp\\\", 'eea')\\n country_name = code_to_name(country_code)\\n agent = self._get_ldap_agent()\\n\\n if not self._allowed(agent, REQUEST, country_code):\\n raise Unauthorized\\n\\n try:\\n extranet_reporter_roles = self.get_extranet_reporter_roles()\\n except AttributeError:\\n extranet_reporter_roles = EXTRANET_REPORTER_ROLES\\n top_role_dns = [agent._role_dn(role)\\n for role in extranet_reporter_roles]\\n\\n options = {'top_role_dns': top_role_dns,\\n 'country': country_code,\\n 'country_name': country_name or country_code,\\n }\\n self._set_breadcrumbs([(\\\"Browsing extranet reporter roles in %s\\\" %\\n country_name, '#')])\\n return self._render_template('zpt/nfp_nrc/extranet_reporters.zpt',\\n **options)\",\n \"def determine_preferred_contact(user_data):\\n try:\\n user_data['personal']['email']\\n except KeyError:\\n preferred_contact = 'mail'\\n else:\\n preferred_contact = 'email'\\n return preferred_contact\",\n \"def calc_owner(self, activation):\\n from django.contrib.auth import get_user_model\\n\\n owner = self._owner\\n if callable(owner):\\n owner = owner(activation)\\n elif isinstance(owner, dict):\\n owner = get_user_model()._default_manager.get(**owner)\\n return owner\",\n \"def addProspect(self, user):\\n if self.is_active and (user != self.owner) and not self.prospects.filter(pk=user.id).exists() \\\\\\n and not self.workers.filter(pk=user.id) and not self.blacklist.filter(pk=user.id).exists():\\n self.prospects.add(user)\\n return self\\n return None\",\n \"def test_get_user_id_unknown_user(self):\\n print('(' + self.test_get_user_id.__name__+')',\\n self.test_get_user_id.__doc__)\\n self.assertIsNone(self.connection.get_user_id(\\n NON_EXIST_PATIENT_USERNAME))\",\n \"def _IsValidPrimaryOwnerEmail(owner_tag_text):\\n if '-' in owner_tag_text: # Check whether it's a team email address.\\n return False\\n\\n return (owner_tag_text.endswith('@chromium.org')\\n or owner_tag_text.endswith('@google.com'))\",\n \"def search_relevant_first_email_for_user(\\n issue_owner, messages, user, people_caches):\\n # Shortcut. No need to calculate the value.\\n if issue_owner == user:\\n return None, False\\n\\n # Search for the first of:\\n # - message by the issue owner sent to the user or to mailing lists.\\n # - message by the user, for DRIVE_BY and NOT_REQUESTED.\\n # Otherwise, return None.\\n last_owner_message_index = None\\n for i, m in enumerate(messages):\\n if m.sender == issue_owner:\\n last_owner_message_index = i\\n if user in m.recipients:\\n return i, False\\n # Detect the use case where a request for review is sent to a mailing list\\n # and a random reviewer picks it up. We don't want to downgrade the\\n # reviewer from a proper review down to DRIVE_BY, so mark it as the\\n # important message for everyone. A common usecase is code reviews on\\n # golang-dev@googlegroups.com.\\n recipients = set(m.recipients) - set([m.sender, issue_owner])\\n if not figure_out_real_accounts(recipients, people_caches):\\n return i, False\\n elif m.sender == user:\\n # The issue owner didn't send a request specifically to this user but the\\n # dude replied anyway. It can happen if the user was on the cc list with\\n # user+cc@example.com. In that case, use the last issue owner email.\\n # We want to use this message for latency calculation DRIVE_BY and\\n # NOT_REQUESTED.\\n if last_owner_message_index is not None:\\n return last_owner_message_index, True\\n # issue_owner is MIA.\\n return i, True\\n else:\\n # Maybe a reviewer added 'user' on the review on its behalf. Likely\\n # m.sender wants to defer the review to someone else.\\n if user in m.recipients:\\n return i, False\\n # Sends the last Message index if there is any.\\n return last_owner_message_index, False\",\n \"def get_default_department_id(self, cr, uid, context=None):\\n user_obj = self.pool.get('res.users').browse(cr,uid,uid).employee_ids \\n if user_obj: \\n dept_id = self.pool.get('res.users').browse(cr,uid,uid).employee_ids[0].department_id and self.pool.get('res.users').browse(cr,uid,uid).employee_ids[0].department_id.id or False\\n \\n return dept_id\",\n \"def technical_owner_email(self, technical_owner_email):\\n\\n self._technical_owner_email = technical_owner_email\",\n \"def _test_pre_fill_and_assign_humor(self):\\n for i in range(1, 50):\\n User.objects.create_user(username=\\\"u{0}\\\".format(i))\\n pre_fill.main([\\\"--managers\\\", \\\"--workshift\\\"])\\n utils.make_workshift_pool_hours(semester=self.semester)\\n # Assign manager shifts beforehand\\n manager_shifts = RegularWorkshift.objects.filter(\\n pool=self.p1, workshift_type__auto_assign=False,\\n )\\n profiles = WorkshiftProfile.objects.all()\\n for profile, shift in zip(profiles, manager_shifts):\\n shift.current_assignees.add(profile)\\n shift.save()\\n unfinished = utils.auto_assign_shifts(\\n self.semester, pool=WorkshiftPool.objects.get(title=\\\"Humor Shift\\\")\\n )\\n self.assertEqual([], unfinished)\",\n \"def owner_id(self) -> Optional[str]:\\n return pulumi.get(self, \\\"owner_id\\\")\",\n \"def manage_owners():\\n\\n owner_data = request.get_json(force=True)\\n return _get_owner_service().create_owner(owner_data)\",\n \"def owner(self, owner):\\n self._owner = owner\",\n \"def owner(self, owner):\\n self._owner = owner\",\n \"def owner(self, owner):\\n self._owner = owner\",\n \"def owner(self, owner):\\n self._owner = owner\",\n \"def test_bad_request_anon_user_no_name(self, zendesk_mock_class, datadog_mock):\\r\\n self._test_bad_request_omit_field(self._anon_user, self._anon_fields, \\\"name\\\", zendesk_mock_class, datadog_mock)\\r\\n self._test_bad_request_empty_field(self._anon_user, self._anon_fields, \\\"name\\\", zendesk_mock_class, datadog_mock)\",\n \"def set_staff_request_reviewer(review_obj: models.Model):\\n if review_obj.user:\\n staff_member = review_obj.user.staffprofile\\n manager = staff_member.supervisor\\n if (\\n manager\\n and not Reviewer.objects.filter(\\n review=review_obj, user=manager.user\\n ).exists()\\n ):\\n reviewer = Reviewer(review=review_obj, user=manager.user)\\n reviewer.save() # ensure save method is called\\n\\n hr_group_name = settings.SSHR_ADMIN_USER_GROUP_NAME\\n for user in User.objects.filter(groups__name=hr_group_name):\\n if not Reviewer.objects.filter(review=review_obj, user=user).exists():\\n reviewer = Reviewer(review=review_obj, user=user)\\n reviewer.save() # ensure save method is called\",\n \"def run(self):\\n # Determine if this filter doesn't apply.\\n if (self.owner == None \\\\\\n or (self.sense and self.user != self.owner) \\\\\\n or ((not self.sense) and self.user == self.owner)):\\n return 0\\n\\n # Perform the child actions.\\n self.context.tokens['Owner'] = self.owner\\n return super(FilterLockOwner, self).run()\",\n \"def technical_owner(self):\\n return self._technical_owner\",\n \"def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"owners\\\")\",\n \"def owners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"owners\\\")\",\n \"def is_owner(self, is_owner):\\n\\n self._is_owner = is_owner\",\n \"def every_existing_owner_should_have_valid_profile_image_link(context):\\n items = context.response.json()['items']\\n for item in items:\\n owner = item['owner']\\n if owner['user_type'] == 'does_not_exist':\\n continue\\n link = owner['profile_image']\\n assert validators.url(link), (\\n 'Owner %s (%d) in item %d has an invalid profile image link: %s'\\n .format(owner['display_name'], owner['user_id'], link))\\n logging.debug(\\n 'Owner %s (%d) has a valid profile image link: %s',\\n owner['display_name'], owner['user_id'], link)\",\n \"def _get_default_org(user):\\n org = user.default_organization\\n # check if user is still in the org, i.e. s/he wasn't removed from his/her\\n # default org or didn't have a set org and try to set the first one\\n if (\\n not org\\n or not OrganizationUser.objects.filter(\\n organization=org, user=user\\n ).exists()\\n ):\\n org = user.orgs.first()\\n user.default_organization = org\\n user.save()\\n if org:\\n org_id = org.pk\\n org_name = org.name\\n ou = user.organizationuser_set.filter(organization=org).first()\\n # parent org owner has no role (None) yet has access to the sub-org\\n org_user_role = _get_js_role(ou.role_level) if ou else \\\"\\\"\\n return org_id, org_name, org_user_role\\n else:\\n return \\\"\\\", \\\"\\\", \\\"\\\"\",\n \"def check_NonExistingTestUser(test_case, override_user_name=null, override_headers=null, override_cookies=null):\\n # type: (AnyMagpieTestCaseType, Optional[Str], Optional[HeadersType], Optional[CookiesType]) -> None\\n users = TestSetup.get_RegisteredUsersList(test_case,\\n override_headers=override_headers, override_cookies=override_cookies)\\n user_name = override_user_name if override_user_name is not null else test_case.test_user_name\\n check_val_not_in(user_name, users)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5346557","0.5095638","0.50383765","0.5028467","0.48953253","0.48707283","0.4851011","0.48406032","0.48377118","0.48243517","0.48027915","0.4784198","0.47707832","0.47077477","0.46895742","0.46746963","0.46505794","0.46497324","0.4624019","0.46179965","0.46117923","0.45987284","0.45917413","0.45887628","0.4536587","0.45016655","0.44982865","0.44971693","0.44922668","0.44723746","0.447048","0.44696572","0.44648546","0.4462166","0.44518492","0.44480377","0.44428626","0.44399038","0.4433801","0.4425852","0.44257808","0.44225997","0.44212076","0.4412081","0.44101474","0.44099668","0.43977347","0.438225","0.43810138","0.43810138","0.43810138","0.43802923","0.4337574","0.4328473","0.43249965","0.43226507","0.43134847","0.4305302","0.43011785","0.42987832","0.42888814","0.42799985","0.42764908","0.4276436","0.42722085","0.42716074","0.42667982","0.42645493","0.4262521","0.426193","0.4260587","0.42576063","0.4256292","0.4254652","0.4251817","0.42486617","0.42452738","0.42417777","0.42410102","0.42403382","0.4233526","0.42297968","0.42290372","0.4227221","0.42241523","0.42226058","0.42206657","0.42206657","0.42206657","0.42206657","0.42191276","0.4218988","0.42132983","0.42121676","0.4209886","0.4209886","0.4207021","0.42037535","0.4194415","0.41914353"],"string":"[\n \"0.5346557\",\n \"0.5095638\",\n \"0.50383765\",\n \"0.5028467\",\n \"0.48953253\",\n \"0.48707283\",\n \"0.4851011\",\n \"0.48406032\",\n \"0.48377118\",\n \"0.48243517\",\n \"0.48027915\",\n \"0.4784198\",\n \"0.47707832\",\n \"0.47077477\",\n \"0.46895742\",\n \"0.46746963\",\n \"0.46505794\",\n \"0.46497324\",\n \"0.4624019\",\n \"0.46179965\",\n \"0.46117923\",\n \"0.45987284\",\n \"0.45917413\",\n \"0.45887628\",\n \"0.4536587\",\n \"0.45016655\",\n \"0.44982865\",\n \"0.44971693\",\n \"0.44922668\",\n \"0.44723746\",\n \"0.447048\",\n \"0.44696572\",\n \"0.44648546\",\n \"0.4462166\",\n \"0.44518492\",\n \"0.44480377\",\n \"0.44428626\",\n \"0.44399038\",\n \"0.4433801\",\n \"0.4425852\",\n \"0.44257808\",\n \"0.44225997\",\n \"0.44212076\",\n \"0.4412081\",\n \"0.44101474\",\n \"0.44099668\",\n \"0.43977347\",\n \"0.438225\",\n \"0.43810138\",\n \"0.43810138\",\n \"0.43810138\",\n \"0.43802923\",\n \"0.4337574\",\n \"0.4328473\",\n \"0.43249965\",\n \"0.43226507\",\n \"0.43134847\",\n \"0.4305302\",\n \"0.43011785\",\n \"0.42987832\",\n \"0.42888814\",\n \"0.42799985\",\n \"0.42764908\",\n \"0.4276436\",\n \"0.42722085\",\n \"0.42716074\",\n \"0.42667982\",\n \"0.42645493\",\n \"0.4262521\",\n \"0.426193\",\n \"0.4260587\",\n \"0.42576063\",\n \"0.4256292\",\n \"0.4254652\",\n \"0.4251817\",\n \"0.42486617\",\n \"0.42452738\",\n \"0.42417777\",\n \"0.42410102\",\n \"0.42403382\",\n \"0.4233526\",\n \"0.42297968\",\n \"0.42290372\",\n \"0.4227221\",\n \"0.42241523\",\n \"0.42226058\",\n \"0.42206657\",\n \"0.42206657\",\n \"0.42206657\",\n \"0.42206657\",\n \"0.42191276\",\n \"0.4218988\",\n \"0.42132983\",\n \"0.42121676\",\n \"0.4209886\",\n \"0.4209886\",\n \"0.4207021\",\n \"0.42037535\",\n \"0.4194415\",\n \"0.41914353\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63934386"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74293,"cells":{"query":{"kind":"string","value":"Performs the designed action, based on the logic implemented for this method by all the classes that subclass this one, and overrides this method"},"document":{"kind":"string","value":"def play(self, rumble, **kwargs) -> Any:\n pass # abstract methods does not provides an implementation in Python"},"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 _do_action(self):\n pass","def _do_action(self):\n pass","def act(self):\n raise NotImplementedError","def _action(self):\n pass","def action(self):\n pass","def action(self):\n pass","def act(self):\n pass","def perform(self):\n pass","def act(self) -> None:\n pass","def perform(self):\n raise NotImplementedError","def take_action(self, *args, **kwargs):\r\n pass","def perform(self):\n return","def perform(self):\n return","def action_run(self):\n pass","def dispatch(self, *args, **kwargs):\n return super().dispatch(*args, **kwargs)","def perform_action(self, action_data):\n pass","def process(self):\n raise NotImplementedError('Method must be implemented by subclass.')","def perform(self) -> None:\n raise NotImplementedError()","def run(self):\n raise Exception('derived class should redefine this function')","def _proceed(self):\n raise NotImplementedError","def perform(self):\n raise TypeError(\"Derived class must implement\")","def proceed(self):\n pass","def processing(self):\n pass","def actions(self):\n raise NotImplementedError","def take_action(self, action):\n\t\traise NotImplementedError","def run(self):\n raise NotImplementedError # implement in subclass","def __call__(self,action=None):\n raise NYI","def actions(self, state):\n raise NotImplementedError # Override this!","def execute(self):\n raise NotImplementedError(\"Subclasses should override this method.\")","def act_on(self, X):\n raise NotImplementedError(\"base class called\")","def choose_action(self):\r\n pass","def __call__(self):\r\n raise NotImplementedError('override me')","def process_action(*args, **kwargs):\n raise NotImplementedError()","def process(self):\n pass","def __call__( self ):\n pass","def action_done(self):","def do_manipulations(self, *args, **kwargs):\n pass","def run(self):\n raise NotImplementedError(\"Subclass must implement abstract method\")","def post_execute(self):","def actions(self, state):\n\t\traise NotImplementedError","def _run_actions(self):\n\n if \"install-bento\" in self.actions:\n self._do_action_bento_setup()\n\n if \"create-tables\" in self.actions:\n self._do_action_tables_create()\n\n if \"import-ratings\" in self.actions:\n self._do_action_import_ratings()\n\n if \"import-user-info\" in self.actions:\n self._do_action_import_user_info()\n\n if \"import-movie-info\" in self.actions:\n self._do_action_import_movie_info()\n\n if \"train-item-item-cf\" in self.actions:\n self._do_action_train()\n\n if \"register-freshener\" in self.actions:\n self._do_action_register_freshener()","def runThis(self):\n print(\"Override method..\")","def do_action(self):\n func = self._get_action_func()\n func(self)","def choose_action(self, *args, **kwargs):\n return NotImplementedError","def action(self,item):\r\n pass","def dispatch(self, request, *args, **kwargs):\n return super().dispatch(request, *args, **kwargs)","def run(self):\n raise NotImplementedError(\"Subclasses mut override run()\")","def _post_dispatch(self, request, *args, **kwargs):\n pass","def _run(self):\n raise NotImplemented(\"Abstract method '_run' need to be defined\")","def process(self):","def process(self):","def process(self):","def _run(self):\n raise NotImplementedError","def _run(self):\n raise NotImplementedError","def call_action(self, action):\n pass","def perform_step(self, action):\n pass","def process(self):\n raise NotImplementedError","def dispatch(self, request, *args, **kwargs):\n return super(self.__class__, self).dispatch(request, *args, **kwargs)","def dispatch(self, request, *args, **kwargs):\n return super(self.__class__, self).dispatch(request, *args, **kwargs)","def dispatch(self, request, *args, **kwargs):\n return super(self.__class__, self).dispatch(request, *args, **kwargs)","def dispatch(self, request, *args, **kwargs):\n return super(self.__class__, self).dispatch(request, *args, **kwargs)","def dispatch(self, request, *args, **kwargs):\n return super(self.__class__, self).dispatch(request, *args, **kwargs)","def dispatch(self, request, *args, **kwargs):\n return super(self.__class__, self).dispatch(request, *args, **kwargs)","def dispatch(self, sender, event, *args, **kwargs):\n pass # pragma: no cover","def post(self):\n raise NotImplementedError()","def run(self):\n raise NotImplemented(\"Inheriting classes should implement this\")","def __call__(self):\n\t\treturn","def __call__(self, state, action):\n pass","def run(self): \r\n return","def dispatch(self, request, *args, **kwargs):\n return super(ShibView, self).dispatch(request, *args, **kwargs)","def __call__(self):\n raise NotImplementedError","def _activate(self):\n raise NotImplementedError('Subclasses must implement _activate()')","def _postprocess(self):","def action(self, state):\n return NotImplementedError()","def post_exec(self):\n raise NotImplementedError(\"Must implement in frontend subclass.\")","def act(self, ob_no):\n raise NotImplementedError","def _run ( self ) :\n raise NotImplementedError ( \"AppBase: method _run() should be implemented in a subclass\" )","def action_done(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def do_post_action_processing(self, i_state, low_level_actions):\n pass","def actions():\n pass","def run(self):\n\n self._action.execute()","def dispatch(self):\n\n if self.choice == 1:\n SelectCategory()","def _run(self, *args, **kwargs):\n raise NotImplementedError","def act(self, state):\n return","def _hook(self):","def dispatch(self):\n if self.index:\n if self.rebuild:\n answer = input(\"You sure you want to rebuild? [yes/No]? \")\n if answer.lower() == 'yes':\n # Drop and recreate tables\n db = IndexDb()\n db.clear()\n db.setup()\n print(f\"{ats()} Index cleared...\")\n else:\n print(f\"{ats()} Aborting...\")\n sys.exit(1)\n self.build_index()\n\n if self.download:\n self.download_filings()\n\n print(f\"{ats()} Finished. Good job!\")\n ok()","def run(self):\r\n pass","def act(self) -> int:\n raise NotImplementedError(\"Calling method act() in Abstract class Bandit_Agent\")","def apply(self):\n prequire(False, \"Called abstract version of apply\")","def __call__(self, **kwargs):\n raise NotImplementedError","def actions() -> None:\n pass","def execute(self):\r\n pass","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return","def apply(self):\r\n return"],"string":"[\n \"def _do_action(self):\\n pass\",\n \"def _do_action(self):\\n pass\",\n \"def act(self):\\n raise NotImplementedError\",\n \"def _action(self):\\n pass\",\n \"def action(self):\\n pass\",\n \"def action(self):\\n pass\",\n \"def act(self):\\n pass\",\n \"def perform(self):\\n pass\",\n \"def act(self) -> None:\\n pass\",\n \"def perform(self):\\n raise NotImplementedError\",\n \"def take_action(self, *args, **kwargs):\\r\\n pass\",\n \"def perform(self):\\n return\",\n \"def perform(self):\\n return\",\n \"def action_run(self):\\n pass\",\n \"def dispatch(self, *args, **kwargs):\\n return super().dispatch(*args, **kwargs)\",\n \"def perform_action(self, action_data):\\n pass\",\n \"def process(self):\\n raise NotImplementedError('Method must be implemented by subclass.')\",\n \"def perform(self) -> None:\\n raise NotImplementedError()\",\n \"def run(self):\\n raise Exception('derived class should redefine this function')\",\n \"def _proceed(self):\\n raise NotImplementedError\",\n \"def perform(self):\\n raise TypeError(\\\"Derived class must implement\\\")\",\n \"def proceed(self):\\n pass\",\n \"def processing(self):\\n pass\",\n \"def actions(self):\\n raise NotImplementedError\",\n \"def take_action(self, action):\\n\\t\\traise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError # implement in subclass\",\n \"def __call__(self,action=None):\\n raise NYI\",\n \"def actions(self, state):\\n raise NotImplementedError # Override this!\",\n \"def execute(self):\\n raise NotImplementedError(\\\"Subclasses should override this method.\\\")\",\n \"def act_on(self, X):\\n raise NotImplementedError(\\\"base class called\\\")\",\n \"def choose_action(self):\\r\\n pass\",\n \"def __call__(self):\\r\\n raise NotImplementedError('override me')\",\n \"def process_action(*args, **kwargs):\\n raise NotImplementedError()\",\n \"def process(self):\\n pass\",\n \"def __call__( self ):\\n pass\",\n \"def action_done(self):\",\n \"def do_manipulations(self, *args, **kwargs):\\n pass\",\n \"def run(self):\\n raise NotImplementedError(\\\"Subclass must implement abstract method\\\")\",\n \"def post_execute(self):\",\n \"def actions(self, state):\\n\\t\\traise NotImplementedError\",\n \"def _run_actions(self):\\n\\n if \\\"install-bento\\\" in self.actions:\\n self._do_action_bento_setup()\\n\\n if \\\"create-tables\\\" in self.actions:\\n self._do_action_tables_create()\\n\\n if \\\"import-ratings\\\" in self.actions:\\n self._do_action_import_ratings()\\n\\n if \\\"import-user-info\\\" in self.actions:\\n self._do_action_import_user_info()\\n\\n if \\\"import-movie-info\\\" in self.actions:\\n self._do_action_import_movie_info()\\n\\n if \\\"train-item-item-cf\\\" in self.actions:\\n self._do_action_train()\\n\\n if \\\"register-freshener\\\" in self.actions:\\n self._do_action_register_freshener()\",\n \"def runThis(self):\\n print(\\\"Override method..\\\")\",\n \"def do_action(self):\\n func = self._get_action_func()\\n func(self)\",\n \"def choose_action(self, *args, **kwargs):\\n return NotImplementedError\",\n \"def action(self,item):\\r\\n pass\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super().dispatch(request, *args, **kwargs)\",\n \"def run(self):\\n raise NotImplementedError(\\\"Subclasses mut override run()\\\")\",\n \"def _post_dispatch(self, request, *args, **kwargs):\\n pass\",\n \"def _run(self):\\n raise NotImplemented(\\\"Abstract method '_run' need to be defined\\\")\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def call_action(self, action):\\n pass\",\n \"def perform_step(self, action):\\n pass\",\n \"def process(self):\\n raise NotImplementedError\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super(self.__class__, self).dispatch(request, *args, **kwargs)\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super(self.__class__, self).dispatch(request, *args, **kwargs)\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super(self.__class__, self).dispatch(request, *args, **kwargs)\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super(self.__class__, self).dispatch(request, *args, **kwargs)\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super(self.__class__, self).dispatch(request, *args, **kwargs)\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super(self.__class__, self).dispatch(request, *args, **kwargs)\",\n \"def dispatch(self, sender, event, *args, **kwargs):\\n pass # pragma: no cover\",\n \"def post(self):\\n raise NotImplementedError()\",\n \"def run(self):\\n raise NotImplemented(\\\"Inheriting classes should implement this\\\")\",\n \"def __call__(self):\\n\\t\\treturn\",\n \"def __call__(self, state, action):\\n pass\",\n \"def run(self): \\r\\n return\",\n \"def dispatch(self, request, *args, **kwargs):\\n return super(ShibView, self).dispatch(request, *args, **kwargs)\",\n \"def __call__(self):\\n raise NotImplementedError\",\n \"def _activate(self):\\n raise NotImplementedError('Subclasses must implement _activate()')\",\n \"def _postprocess(self):\",\n \"def action(self, state):\\n return NotImplementedError()\",\n \"def post_exec(self):\\n raise NotImplementedError(\\\"Must implement in frontend subclass.\\\")\",\n \"def act(self, ob_no):\\n raise NotImplementedError\",\n \"def _run ( self ) :\\n raise NotImplementedError ( \\\"AppBase: method _run() should be implemented in a subclass\\\" )\",\n \"def action_done(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def do_post_action_processing(self, i_state, low_level_actions):\\n pass\",\n \"def actions():\\n pass\",\n \"def run(self):\\n\\n self._action.execute()\",\n \"def dispatch(self):\\n\\n if self.choice == 1:\\n SelectCategory()\",\n \"def _run(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def act(self, state):\\n return\",\n \"def _hook(self):\",\n \"def dispatch(self):\\n if self.index:\\n if self.rebuild:\\n answer = input(\\\"You sure you want to rebuild? [yes/No]? \\\")\\n if answer.lower() == 'yes':\\n # Drop and recreate tables\\n db = IndexDb()\\n db.clear()\\n db.setup()\\n print(f\\\"{ats()} Index cleared...\\\")\\n else:\\n print(f\\\"{ats()} Aborting...\\\")\\n sys.exit(1)\\n self.build_index()\\n\\n if self.download:\\n self.download_filings()\\n\\n print(f\\\"{ats()} Finished. Good job!\\\")\\n ok()\",\n \"def run(self):\\r\\n pass\",\n \"def act(self) -> int:\\n raise NotImplementedError(\\\"Calling method act() in Abstract class Bandit_Agent\\\")\",\n \"def apply(self):\\n prequire(False, \\\"Called abstract version of apply\\\")\",\n \"def __call__(self, **kwargs):\\n raise NotImplementedError\",\n \"def actions() -> None:\\n pass\",\n \"def execute(self):\\r\\n pass\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\",\n \"def apply(self):\\r\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76621544","0.76621544","0.7254013","0.71458393","0.7133721","0.7133721","0.7113193","0.70026004","0.69369143","0.6874843","0.6846552","0.673988","0.673988","0.6686165","0.6655994","0.6655625","0.660916","0.65968966","0.65783566","0.65521324","0.65328544","0.650625","0.6498291","0.6487187","0.64482963","0.63992107","0.63825303","0.6374713","0.62958896","0.6295041","0.62770194","0.6262908","0.6258261","0.6253792","0.6241057","0.623052","0.6209567","0.61921567","0.61867744","0.61296725","0.61281985","0.61236995","0.6103471","0.6084414","0.6081897","0.60675216","0.6056665","0.6044723","0.6027359","0.6024391","0.6024391","0.6024391","0.60127276","0.60127276","0.60118216","0.6001224","0.59984475","0.5983941","0.5983941","0.5983941","0.5983941","0.5983941","0.5983941","0.5968599","0.59678173","0.59567225","0.5946725","0.59112746","0.5897729","0.58960986","0.58771616","0.58690995","0.5866296","0.58655506","0.58641887","0.586008","0.58536094","0.585333","0.5850047","0.5850047","0.5850047","0.5850047","0.5850047","0.58335763","0.58314186","0.5809541","0.5805185","0.5804925","0.5797101","0.5786132","0.57843494","0.5778094","0.5777551","0.5773624","0.57685924","0.5767159","0.5760714","0.5758858","0.5758858","0.5758858","0.5758858"],"string":"[\n \"0.76621544\",\n \"0.76621544\",\n \"0.7254013\",\n \"0.71458393\",\n \"0.7133721\",\n \"0.7133721\",\n \"0.7113193\",\n \"0.70026004\",\n \"0.69369143\",\n \"0.6874843\",\n \"0.6846552\",\n \"0.673988\",\n \"0.673988\",\n \"0.6686165\",\n \"0.6655994\",\n \"0.6655625\",\n \"0.660916\",\n \"0.65968966\",\n \"0.65783566\",\n \"0.65521324\",\n \"0.65328544\",\n \"0.650625\",\n \"0.6498291\",\n \"0.6487187\",\n \"0.64482963\",\n \"0.63992107\",\n \"0.63825303\",\n \"0.6374713\",\n \"0.62958896\",\n \"0.6295041\",\n \"0.62770194\",\n \"0.6262908\",\n \"0.6258261\",\n \"0.6253792\",\n \"0.6241057\",\n \"0.623052\",\n \"0.6209567\",\n \"0.61921567\",\n \"0.61867744\",\n \"0.61296725\",\n \"0.61281985\",\n \"0.61236995\",\n \"0.6103471\",\n \"0.6084414\",\n \"0.6081897\",\n \"0.60675216\",\n \"0.6056665\",\n \"0.6044723\",\n \"0.6027359\",\n \"0.6024391\",\n \"0.6024391\",\n \"0.6024391\",\n \"0.60127276\",\n \"0.60127276\",\n \"0.60118216\",\n \"0.6001224\",\n \"0.59984475\",\n \"0.5983941\",\n \"0.5983941\",\n \"0.5983941\",\n \"0.5983941\",\n \"0.5983941\",\n \"0.5983941\",\n \"0.5968599\",\n \"0.59678173\",\n \"0.59567225\",\n \"0.5946725\",\n \"0.59112746\",\n \"0.5897729\",\n \"0.58960986\",\n \"0.58771616\",\n \"0.58690995\",\n \"0.5866296\",\n \"0.58655506\",\n \"0.58641887\",\n \"0.586008\",\n \"0.58536094\",\n \"0.585333\",\n \"0.5850047\",\n \"0.5850047\",\n \"0.5850047\",\n \"0.5850047\",\n \"0.5850047\",\n \"0.58335763\",\n \"0.58314186\",\n \"0.5809541\",\n \"0.5805185\",\n \"0.5804925\",\n \"0.5797101\",\n \"0.5786132\",\n \"0.57843494\",\n \"0.5778094\",\n \"0.5777551\",\n \"0.5773624\",\n \"0.57685924\",\n \"0.5767159\",\n \"0.5760714\",\n \"0.5758858\",\n \"0.5758858\",\n \"0.5758858\",\n \"0.5758858\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":74294,"cells":{"query":{"kind":"string","value":"From the start node assign registers as they are laid out in the ideal circuit diagram in [CDKM96]_. Assumes that the there are no dead ends in the graph, and any available neighbor can be selected from the start without any further checks."},"document":{"kind":"string","value":"def assign_registers_to_line_or_cycle(start: int, graph: nx.Graph, num_length: int) \\\n -> Tuple[Sequence[int], Sequence[int], int, int]:\n if 2 * num_length + 2 > nx.number_of_nodes(graph):\n raise ValueError(\"There are not enough qubits in the graph to support the computation.\")\n\n graph = graph.copy()\n\n register_a = []\n register_b = []\n\n # set the node at start, and assign the carry_ancilla to this node.\n node = start\n carry_ancilla = node\n neighbors = list(graph.neighbors(node))\n\n idx = 0\n while idx < 2 * num_length:\n # remove the last assigned node to ensure it is not reassigned.\n last_node = node\n graph.remove_node(last_node)\n\n # crawl to an arbitrary neighbor node if possible. If not, the assignment has failed.\n if len(neighbors) == 0:\n raise ValueError(\"Encountered dead end; assignment failed.\")\n node = neighbors[0]\n neighbors = list(graph.neighbors(node))\n\n # alternate between assigning nodes to the b register and a register, starting with b\n if (idx % 2) == 0:\n register_b.append(node)\n else:\n register_a.append(node)\n\n idx += 1\n # assign the z_ancilla to a neighbor of the last assignment to a\n z_ancilla = next(graph.neighbors(node))\n\n return register_a, register_b, carry_ancilla, z_ancilla"},"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 assign(self, starts):\n # Initialize the set of open and closed nodes, and the connection map\n open_set, closed_set = starts, set()\n \n # Initialize a map of assignments and associated profits\n profits = {s:0 for s in starts}\n \n while open_set:\n\n # Explore the most promising node\n current = max(open_set, key=lambda n: profits[n])\n \n # Move the current node from the open set to the closed set\n open_set.remove(current)\n closed_set.add(current)\n \n # Track if assignment is complete\n assignment_finished = True\n \n # Determine all possible next assignment steps\n for agent in self.agents:\n # Determine possible tasks the agent may be assigned to\n poss_tasks = self.assign_agent(agent, current)\n \n # If assignments are possible, the assignment is not complete\n if poss_tasks: assignment_finished = False\n \n for task in poss_tasks:\n # Determine next assignment step\n next_dict = dict(current)\n next_dict[agent] = next_dict[agent] | {task}\n next_assignment = frozendict(next_dict)\n \n # If we have already explored this assignment, continue\n if next_assignment in closed_set:\n continue\n # Else add the assignment to the open set\n else:\n open_set.add(next_assignment)\n profits[next_assignment] = self.calc_profit(next_assignment)\n \n # If assignment is finished, add it to finished assignments\n if assignment_finished:\n \n # Check if assignment is also complete\n if self.complete and not self.is_complete(current):\n continue\n \n self.finished_assignments[current] = profits[current]\n \n # Update current fair / max profit and print if applicable\n # Procedure for fair profit (max profit tiebreaker)\n if self.fair:\n cur_fair_profit = self.calc_fair_profit(current)\n if ((cur_fair_profit > self.fair_profit) or \n (cur_fair_profit == self.fair_profit and\n profits[current] > self.max_profit)):\n self.fair_profit = cur_fair_profit\n self.max_profit = profits[current]\n self.print_assignment(current, profits[current])\n elif (self.verbose and profits[current] >= self.max_profit\n and cur_fair_profit >= self.fair_profit):\n self.print_assignment(current, profits[current])\n # Procedure for maximum profit\n else:\n if profits[current] > self.max_profit:\n self.max_profit = profits[current]\n self.print_assignment(current, profits[current])\n elif self.verbose and profits[current] >= self.max_profit:\n self.print_assignment(current, profits[current])","def prepare_initial_nodes(x_start, x_end, nodes_y):\n nodes_x = [float(x_start + ((x_end - x_start) / (len(nodes_y) - 1)) * i) for i in range(0, len(nodes_y))]\n nodes_y = [float(y) for y in nodes_y]\n print(nodes_x)\n print(nodes_y)\n nodes = list(zip(nodes_x, nodes_y))\n return nodes","def add_resets_edges(graph, start):\n for node in graph.nodes:\n neighbors = list(graph[node])\n if neighbors == [node]:\n graph.add_edge(node, start, label=\"RESET / \")","def _reset_node_ids(self, start_id: int):\n\n add_id = start_id - self.min_node_id()\n for tree_idx, _ in enumerate(self.nodes):\n self.nodes[tree_idx].nodes['id'] += add_id\n self.edges[tree_idx] += add_id","def start(self):\n self.id_oi = 1\n self.param_target_distances = [5, 30]\n self.cells_no_links = [cell for cell in self.cell_list if cell.id != self.id_oi]\n self.cell_oi = [cell for cell in self.cell_list if cell.id == self.id_oi][0]","def setup_ant(self):\n self.visited_nodes[1:] = []\n self.actual_node = self.start_pos","def assign(self):\n\n for s in self.spots:\n if self.cells[s[:2]] == 0:\n label = find_nearest_region(self.cells, *s[:2])\n else:\n label = self.cells[s[:2]]\n\n s.region = label","def _assign_by_bfs(self, start, worker, initial_sizes, spread_limits,\n keys_to_assign, assigned_record, graph=None):\n if initial_sizes[worker] <= 0:\n return\n\n graph = graph or self._graph\n if self._assign_graph is None:\n undigraph = self._assign_graph = graph.build_undirected()\n else:\n undigraph = self._assign_graph\n\n assigned = 0\n spread_range = 0\n for v in undigraph.bfs(start=start, visit_predicate='all'):\n op_key = v.op.key\n if op_key in assigned_record:\n continue\n spread_range += 1\n if op_key not in keys_to_assign:\n continue\n assigned_record[op_key] = worker\n assigned += 1\n if spread_range >= spread_limits[worker] \\\n or assigned >= initial_sizes[worker]:\n break\n initial_sizes[worker] -= assigned","def starting_nodes(self):\n return self.starting_nodes_ #abstract requires this exists!","def prepare(self):\n if self._ready_nodes is not None:\n raise ValueError(\"cannot prepare() more than once\")\n\n self._ready_nodes = [\n i.node for i in self._node2info.values() if i.npredecessors == 0\n ]\n # ready_nodes is set before we look for cycles on purpose:\n # if the user wants to catch the CycleError, that's fine,\n # they can continue using the instance to grab as many\n # nodes as possible before cycles block more progress\n cycle = self._find_cycle()\n if cycle:\n raise CycleError(f\"nodes are in a cycle\", cycle)","def __init__(self, start_node):\n self.start_node = start_node","def to_start(self, node):\n if node in self.graph:\n if node in self.keep_index_backward:\n for pred in self.keep_index_backward[node]:\n self.to_start(pred)\n\n if node in self.graph:\n self.start.append(node)\n self.graph.remove_node(node)\n\n if node in self.keep_index_forward:\n for succ in self.keep_index_forward[node]:\n self.to_start(succ)\n self.logger.debug('%s %s\\t(to_start: %s)', self.start, self.end, node)","def start_new_graph(self):\n self.nodes = {}\n self.reset_graph()","def relations_from(self, start_node):","def _calc_worker_assign_limits(self, initial_count, occupied=None):\n occupied = occupied or dict()\n actual_count = initial_count - sum(occupied.values())\n\n endpoint_res = sorted(self._worker_slots.items(), key=operator.itemgetter(1),\n reverse=True)\n\n endpoints = [t[0] for t in endpoint_res]\n endpoint_cores = np.array([t[1] for t in endpoint_res]).astype(np.float32)\n\n # remove assigned nodes from limitations\n counts = initial_count * endpoint_cores / endpoint_cores.sum()\n for idx, ep in enumerate(endpoints):\n counts[idx] = max(0, counts[idx] - occupied.get(ep, 0))\n\n # all assigned, nothing to do\n if counts.sum() == 0:\n return dict((ep, 0) for ep in endpoints)\n\n counts = (actual_count * counts / counts.sum()).astype(np.int32)\n\n # assign remaining nodes\n pos = 0\n rest = actual_count - counts.sum()\n while rest > 0:\n counts[pos] += 1\n rest -= 1\n pos = (pos + 1) % len(counts)\n return dict(zip(endpoints, counts))","def assign_initial_flow_acc(traps, start_nodes, rows, cols):\n\n nr_of_nodes = int(rows * cols)\n # Get indices of the trap nodes that are starting indices\n starting_trap_nodes = np.array(start_nodes[start_nodes >= nr_of_nodes])\n\n # Initialize accumulation flow array, and calculate the size of each trap\n acc_flow = np.zeros(rows * cols + len(traps), dtype=int)\n trap_sizes = np.asarray([len(t) for t in traps])\n\n one_or_trap_size = np.ones(len(acc_flow), dtype=int)\n one_or_trap_size[nr_of_nodes:] = trap_sizes\n\n # Assign flow to the starting trap nodes, and the other starting nodes\n acc_flow[starting_trap_nodes] = trap_sizes[starting_trap_nodes - nr_of_nodes]\n acc_flow[np.setdiff1d(start_nodes, starting_trap_nodes)] = 1\n\n return acc_flow, one_or_trap_size","def floodFill(nodes, start = None):\n queue = deque()\n if start is not None:\n start.dist = 0.\n queue.append(start)\n\n for i, node in nodes.items():\n if node.dist == 0.:\n queue.append(node)\n\n for node in shiftDeque(queue):\n node.in_deque = False\n for neigh in node.neighbors:\n dist = neigh.dist + node.dist \n \n if neigh.node.dist > dist:\n neigh.node.dist = dist\n if not neigh.node.in_deque:\n queue.append(neigh.node)\n neigh.node.in_deque = True","def on_start(self):\n if not self.neighbors_vars:\n # If we don't have any neighbor, simply select the best value\n # for us and be done with it !\n vals, cost = self._compute_best_value()\n value = random.choice(vals)\n self.value_selection(value, cost)\n if self.logger.isEnabledFor(logging.INFO):\n self.logger.info(\n f\"No neighbors: stop immediately with value {value} - {cost}\"\n )\n self.finished()\n\n else:\n # At start, we don't have any information to compute the cost,\n # simply use None\n if self.variable.initial_value is None:\n self.value_selection(random.choice(self.variable.domain), None)\n if self.logger.isEnabledFor(logging.INFO):\n self.logger.info(\n f\"Select random initial value {self.current_value} \"\n )\n\n else:\n self.value_selection(self.variable.initial_value, None)\n if self.logger.isEnabledFor(logging.INFO):\n self.logger.info(f\"Select initial value {self.current_value}\")\n\n self._send_value()\n self._enter_state(\"value\")","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 find_reachable_nodes_from(self, start_node, **kwargs):\r\n\t\treturn BreadthFirstTraverser(start_node, **kwargs)","def initialize_sets(self):\n for block in self.blocks:\n # Insert phi nodes from SSA stage into the assignments of the block\n for phi in block.phis:\n block.gen.setdefault(phi, []).insert(0, phi)\n\n # Update the kill set with the variables that are assigned to in\n # the block\n block.kill = set(block.gen)\n block.output = set(block.gen)\n #for entry in block.bound:\n # block.i_kill |= self.assmts[entry].bit\n\n for assmts in self.assmts.itervalues():\n self.entry_point.i_gen |= assmts.bit\n self.entry_point.i_output = self.entry_point.i_gen","def set_starting_pos(self):\n if self.start and self.is_unoccupied(*self.start):\n self.current_pos = self.start[:]\n else:\n self.set_random_pos('starting')","def _step(self):\n if self.best_unexplored_lower_bound < self.best_upper_bound:\n\n # Select a Node\n self._active_node = self._pop_node_with_best_lower_bound()\n\n # Reporting\n if self._reporting:\n print(self.report)\n\n # Select a Vertex\n unassigned_vertex_chosen = self._choose_unassigned_vertex_highest_degree()\n\n # Branch\n self._active_node.construct_children_nodes(\n unassigned_vertex_chosen,\n self._terminals_by_vertex[unassigned_vertex_chosen],\n )\n\n # NB: we do not need to worry about duplicate nodes\n # the nodes are constructed by forcing an assignment of\n # vertices to terminals. Thus, the resulting partitions\n # can never be identical\n self._unexplored_nodes += self._active_node.children\n self._all_nodes += self._active_node.children\n\n else:\n # if there are no unassigned vertices, we are at a leaf node\n self._done = True","def activate_nodes(graph, nodes, record_to=None):\n for agent in nodes:\n graph.nodes[agent][\"agent\"].activate()\n if record_to is not None:\n # |= is union + assignment\n record_to |= set(nodes)","def set_node_positions(self):","def move_start_node(self, x, y):","def starting_nodes(self):\n # Level 0 nodes in a directed graph will have 1 or more out_edges but no in_edges\n nodes_with_outs = set(e[0] for e in self.G2.out_edges())\n nodes_with_ins = set(e[1] for e in self.G2.in_edges())\n return nodes_with_outs - nodes_with_ins","def nodes(self, nodes):\n self.nodes_ = nodes\n self.last_sequence_ind = int(self.nodes_.shape[0] - 1)\n logging.debug(\n \"Segment - Nodes {n_shape} set.\".format(n_shape=self.nodes_.shape)\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)","def _set_start(self, coordinates):\n self._start = coordinates","def set_start_pos(self, start_pos):\n if self.is_pos_valid(start_pos):\n self.start_pos = start_pos\n self.set_curr_pos(start_pos)\n self.curr_map = self.get_curr_visible_map(self.start_pos)\n if self.dstar:\n self.dstar_curr_map = self.get_curr_dstar_visible_map(\n self.start_pos)\n self.pos_history = [start_pos]\n # update state map\n self.state_map[0, 0] = self.get_state_map()\n # self.state_map[0, 1] = self.curr_map\n else:\n print (\"[MESSAGE] WARNING: The position is not valid, nothing\"\n \" changes. (by set_start_pos)\")","def set_nodes(self, nodes_list):\n try:\n self.node_from = nodes_list[self.node_from_code]\n self.node_from.add_line(self)\n self.node_to = nodes_list[self.node_to_code]\n self.node_to.add_line(self)\n except AttributeError:\n raise Exception('line %r has no node(s)!' % self)","def starting_values(self, resids: NDArray) -> NDArray:","def enable_start_new_path(self):\n self.final_node_reached = False","def set_neighbor(self):\n for node in self.node:\n for other in self.node:\n if other.id != node.id and distance.euclidean(node.location, other.location) <= node.com_ran:\n node.neighbor.append(other.id)","def visit_nodes(self, node, initial):\n #L.debug(\"visit_nodes %s %s\", node, initial)\n mapping = dict(initial)\n for visit_node in reversed(node.precedes()):\n sources = tuple(mapping[s] for s in visit_node.sources)\n mapping[visit_node] = self.visit_node(visit_node, sources)\n return mapping[node]","def start_region(self):\n x = self.last_x\n y = self.last_y\n (region_id, start, end) = self.region_model.find_region(x)\n if region_id is not None:\n self.region_id = region_id\n if (x-start) < (end-x):\n self.region_edge = end\n else:\n self.region_edge = start\n self.region_model.adjust_region(self.region_id, x, self.region_edge)\n else:\n self.region_edge = x\n self.region_id = self.region_model.region_id\n self.region_model.region_id += 1","def A_Star(start, goal, final_occupancy_grid):\n x, y = np.mgrid[0:45:1, 0:42:1]\n pos = np.empty(x.shape + (2,))\n pos[:, :, 0] = x;\n pos[:, :, 1] = y\n pos = np.reshape(pos, (x.shape[0] * x.shape[1], 2))\n coords = list([(int(x[0]), int(x[1])) for x in pos])\n\n # Define the heuristic:\n # h: dictionary containing the distance to goal ignoring obstacles for all coordinates in the grid (heuristic function)\n h = np.linalg.norm(pos - goal, axis=1)\n h = dict(zip(coords, h))\n\n # Check if the start and goal are within the boundaries of the map\n for point in [start, goal]:\n\n if point[0] < 0 and point[0] >= final_occupancy_grid.shape[0]:\n raise Exception('Start node/goal node is not contained in the map')\n\n if point[1] < 0 and point[1] >= final_occupancy_grid.shape[1]:\n raise Exception('Start node/goal node is not contained in the map')\n\n # check if start and goal nodes correspond to free spaces\n if final_occupancy_grid[start[0], start[1]]:\n raise Exception('Start node is not traversable')\n\n if final_occupancy_grid[goal[0], goal[1]]:\n raise Exception('Goal node is not traversable')\n\n # get the possible movements\n movements = _get_movements_8n()\n\n # The set of visited nodes that need to be (re-)expanded, i.e. for which the neighbors need to be explored\n # Initially, only the start node is known.\n openSet = [start]\n\n # The set of visited nodes that no longer need to be expanded.\n closedSet = []\n\n # For node n, cameFrom[n] is the node immediately preceding it on the cheapest path from start to n currently known.\n cameFrom = dict()\n\n # For node n, gScore[n] is the cost of the cheapest path from start to n currently known.\n gScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\n gScore[start] = 0\n\n # For node n, fScore[n] := gScore[n] + h(n). map with default value of Infinity\n fScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\n fScore[start] = h[start]\n\n # while there are still elements to investigate\n while openSet != []:\n\n # the node in openSet having the lowest fScore[] value\n fScore_openSet = {key: val for (key, val) in fScore.items() if key in openSet}\n current = min(fScore_openSet, key=fScore_openSet.get)\n del fScore_openSet\n\n # If the goal is reached, reconstruct and return the obtained path\n if current == goal:\n return reconstruct_path(cameFrom, current)\n\n openSet.remove(current)\n closedSet.append(current)\n\n # for each neighbor of current:\n for dx, dy, deltacost in movements:\n\n neighbor = (current[0] + dx, current[1] + dy)\n\n # if the node is not in the map, skip\n if (neighbor[0] >= final_occupancy_grid.shape[0]) or (neighbor[1] >= final_occupancy_grid.shape[1]) or (\n neighbor[0] < 0) or (neighbor[1] < 0):\n continue\n\n # if the node is occupied, skip\n if (final_occupancy_grid[neighbor[0], neighbor[1]]):\n continue\n\n # if the has already been visited, skip\n if (neighbor in closedSet):\n continue\n # d(current,neighbor) is the weight of the edge from current to neighbor\n # tentative_gScore is the distance from start to the neighbor through current\n tentative_gScore = gScore[current] + deltacost\n\n if neighbor not in openSet:\n openSet.append(neighbor)\n\n if tentative_gScore < gScore[neighbor]:\n # This path to neighbor is better than any previous one. Record it!\n cameFrom[neighbor] = current\n gScore[neighbor] = tentative_gScore\n fScore[neighbor] = gScore[neighbor] + h[neighbor]\n\n # Open set is empty but goal was never reached\n print(\"No path found to goal\")\n return []","def __init__(self, start_edges=None):\n self.adj_list = dict()\n\n # populate graph with initial vertices and edges (if provided)\n # before using, implement add_vertex() and add_edge() methods\n if start_edges is not None:\n for u, v in start_edges:\n self.add_edge(u, v)","def connectNodes(imgR,nodes,start,goal):\n alphabet = string.ascii_lowercase\n nodeConnections = [[] for i in range(len(nodes)+2)]\n for index, node in enumerate(nodes):\n paths = adjPaths(imgR,node)\n for path in paths:\n result = checkPath(imgR,nodes,node,path)\n if not result == 0: \n nIndex = nodes.index(result)\n nodeConnections[index+1].append(alphabet[nIndex+1])\n paths = adjPaths(imgR,start) # add start to nodes\n for path in paths:\n result = checkPath(imgR,nodes,start,path)\n if not result == 0: \n nIndex = nodes.index(result)\n nodeConnections[0].append(alphabet[nIndex+1])\n for node in nodeConnections[0]:\n nodeConnections[alphabet.index(node)].append(alphabet[0])\n paths = adjPaths(imgR,goal) # add goal to nodes\n for path in paths:\n result = checkPath(imgR,nodes,goal,path)\n if not result == 0: \n nIndex = nodes.index(result)\n nodeConnections[len(nodeConnections)-1].append(alphabet[nIndex+1])\n for node in nodeConnections[len(nodeConnections)-1]:\n nodeConnections[alphabet.index(node)].append(alphabet[len(nodeConnections)-1])\n return [alphabet[i] for i in range(len(nodes)+2)], nodeConnections","def AssignCpuRegOrMarkForSpilling(assign_to: List[ir.Reg],\n cpu_reg_mask_first_choice: int,\n cpu_reg_mask_second_choice: int):\n # print (f\"@@ AssignCpuRegOrMarkForSpilling {len(assign_to)} {cpu_reg_mask_first_choice:x} {cpu_reg_mask_second_choice:x}\")\n mask = cpu_reg_mask_first_choice\n pos = 0\n for reg in assign_to:\n if mask == 0 and cpu_reg_mask_second_choice != 0:\n mask = cpu_reg_mask_second_choice\n cpu_reg_mask_second_choice = 0\n pos = 0\n if mask == 0:\n reg.cpu_reg = ir.StackSlot()\n continue\n while ((1 << pos) & mask) == 0: pos += 1\n assert reg.cpu_reg is None\n reg.cpu_reg = _KIND_TO_CPU_REG_LIST[reg.kind][pos]\n mask &= ~(1 << pos)\n pos += 1","def on_start(self):\n\n if not self._neighbors:\n # If a variable has no neighbors, we must select its final value immediately\n # as it will never receive any message.\n value, cost = optimal_cost_value(self._variable, self._mode)\n self.value_selection(value, cost)\n\n if self.logger.isEnabledFor(logging.INFO):\n self.logger.info(\n f\"Select initial value {self.current_value} \"\n f\"based on cost function for var {self._variable.name}\"\n )\n self.finished()\n\n else:\n # The variable has neighbors: select a value, which might change\n # once we receive messages.\n if self.variable.initial_value is None:\n self.value_selection(random.choice(self.variable.domain), None)\n if self.logger.isEnabledFor(logging.INFO):\n self.logger.info(\n f\"Select initial random value {self.current_value}\"\n )\n else:\n self.value_selection(self.variable.initial_value, None)\n if self.logger.isEnabledFor(logging.INFO):\n self.logger.info(f\"Select initial value {self.current_value}\")\n self._wait_for_values()","def dfs_helper(self, start_node):\n ret_list = [start_node.value]\n\n start_node.visited = True\n for edge in start_node.edges:\n if not edge.node_to.visited:\n edge.node_to.visited = True\n ret_list.extend(self.dfs_helper(edge.node_to))\n\n return ret_list","def solve_csp(nodes, arcs, max_steps):\n\n nodes = list(nodes)\n print 'nodes:', nodes\n\n node_values_dict = dict(zip(nodes, '2'*len(set(nodes))))\n print 'initial random assignment', node_values_dict\n indexes = np.arange(len(nodes))\n\n graph = {}\n for arc in arcs:\n if not arc[0] in graph:\n graph[arc[0]] = []\n if not arc[1] in graph:\n graph[arc[1]] = []\n graph[arc[0]].append(arc[1])\n graph[arc[1]].append(arc[0])\n for i in indexes:\n if i in graph:\n continue\n else:\n graph[i] = []\n graph = dict(sorted(graph.items()))\n print 'graph:', graph\n\n domain = [i for i in np.arange(1, 10, 1)]\n print 'initial domain for each node:', domain\n\n superAdjacency ={}\n for i in np.arange(len(nodes)):\n superAdjacency[i] = []\n superAdjacency[i].append(nodes[i])\n superAdjacency[i].append(node_values_dict[nodes[i]])\n superAdjacency[i].append(graph[i])\n superAdjacency[i].append(domain)\n\n print 'superAdjacency', superAdjacency\n\n def getNodeType(superAdjacency, index):\n return list(superAdjacency[index])[0]\n\n def getCurrentAssignment(superAdjacency, index):\n return list(superAdjacency[index])[1]\n\n def getCurrentAssignmentForList(superAdjacency, indexList):\n return [int(list(superAdjacency[index])[1]) for index in indexList]\n\n def getSolution(superAdjacency):\n return [int(list(superAdjacency[index])[1]) for index in superAdjacency]\n\n def getNeighbours(superAdjacency, index):\n return list(superAdjacency[index])[2]\n\n def getDomain(superAdjacency, index):\n return list(superAdjacency[index])[3]\n\n def updateSuperAdjacency(superAdjacency, nodeType, newValue):\n updateList =[]\n for i in superAdjacency:\n if str(getNodeType(superAdjacency, i)) == nodeType:\n updateList.append(i)\n for i in updateList:\n superAdjacency[i][1] = newValue\n\n def isSolution():\n return graphConstraints(superAdjacency)\n\n def graphConstraints(superAdjacency):\n graphEval = []\n\n for index in superAdjacency:\n neighbours = getNeighbours(superAdjacency, index)\n nodeType = getNodeType(superAdjacency, index)\n\n if nodeType == 'T':\n graphEval.append(int(str(eval(str(\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]))\n elif nodeType == 'C':\n return 'NA'\n elif nodeType == 'S':\n graphEval.append(int(str(eval(str(\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]))\n elif nodeType == 'H':\n graphEval.append(int(str(np.sum(\n getCurrentAssignmentForList(superAdjacency, neighbours)))[0]))\n if nodeType == 'P':\n graphEval.append(int(str(np.sum(\n getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]))\n\n currentAssignment = [item[1] for item in superAdjacency.values()]\n difference = map(sub, currentAssignment, graphEval)\n\n if sum(difference) == 0:\n return True\n else:\n return difference\n\n def findConflictVariable(superAdjacency, lastUpdateNode):\n node_conflict_count = {}\n for node in node_values_dict:\n node_conflict_count[node] = 0\n for index in superAdjacency:\n neighbours = getNeighbours(superAdjacency, index)\n nodeType = getNodeType(superAdjacency, index)\n if nodeType == 'T':\n try:\n if getCurrentAssignment(superAdjacency, index) != \\\n int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n elif nodeType == 'S':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n elif nodeType == 'H':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n if nodeType == 'P':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n choices = [k for k, v in node_conflict_count.items() if v > 0]\n if len(choices) > 0:\n updateNode = random.choice(choices)\n\n if updateNode == lastUpdateNode:\n choices.pop(choices.index(updateNode))\n try:\n lastUpdateNode = random.choice(choices)\n return lastUpdateNode, lastUpdateNode\n except:\n return lastUpdateNode, lastUpdateNode\n else:\n lastUpdateNode = updateNode\n return updateNode, lastUpdateNode\n else:\n return 'NA', 'NA'\n\n\n\n def valueForConflictedVariable(superAdjacency, var):\n for index in superAdjacency:\n nodeType = getNodeType(superAdjacency, index)\n neighbours = getNeighbours(superAdjacency, index)\n if not neighbours:\n continue\n elif str(nodeType) == str(var):\n domain = getDomain(superAdjacency, index)\n\n choice = random.choice(domain)\n if nodeType == 'T':\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0])\n elif nodeType == 'S':\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0])\n elif nodeType == 'H':\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0])\n if nodeType == 'P':\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0])\n\n choice = int(choice)\n if choice % 2 == 0:\n return choice\n else:\n return choice\n\n def min_conflicts(nodes, arcs, max_steps):\n lastUpdateNode = ''\n for i in range(max_steps):\n if isSolution() == True:\n return\n var, lastUpdateNode = findConflictVariable(superAdjacency, lastUpdateNode)\n if var != 'NA':\n value = valueForConflictedVariable(superAdjacency, var)\n updateSuperAdjacency(superAdjacency, var, value)\n node_values_dict[var] = value\n else:\n pass\n\n return\n\n min_conflicts(nodes, arcs, max_steps)\n node_values = getSolution(superAdjacency)\n return node_values","def discover(self) -> int:\n\n # Get sensor data\n no_wall_in_front = not self.is_wall_in_front()\n no_wall_in_left = not self.is_wall_in_left()\n no_wall_in_right = not self.is_wall_in_right()\n\n # get neighboring tiles\n # Get current and neighboring points\n this_point: tuple = self.stack[-1]\n front_point = self.tile_in_the_direction(self.direction)\n right_point = self.tile_in_the_direction((self.direction + 1) % 4)\n left_point = self.tile_in_the_direction((self.direction - 1) % 4)\n\n # mark this point as discovered\n self.visited.add(this_point)\n\n # Check if this is center tile\n if self.is_ground_center():\n self.center = this_point\n\n # Record all possible turns and add to the graph\n if no_wall_in_front:\n self.add_edge_between(front_point, this_point)\n if no_wall_in_left:\n self.add_edge_between(left_point, this_point)\n if no_wall_in_right:\n self.add_edge_between(right_point, this_point)\n\n # For each choice it can take\n for choice in self.graph[this_point]:\n # If choice was not discovered before, do it\n if choice not in self.visited:\n self.stack.append(choice)\n break\n else:\n # No undiscovered nodes near robot (No choice to make)\n # Start to backtrack\n self.stack.pop()\n if not self.stack:\n # Came back to initial position\n # Start second half\n return SimulationRunStatus.RESUME_SIMULATION\n choice = self.stack[-1]\n\n if choice == front_point:\n self.go_forward()\n elif choice == left_point:\n self.go_to_left()\n elif choice == right_point:\n self.go_to_right()\n else:\n self.go_backward()","def build_constellation(edges, start, visited):\n num_points = edges.shape[0]\n constellation = set()\n nodes = [start]\n while nodes:\n point = nodes.pop()\n visited.add(point)\n\n for other in range(num_points):\n if edges[point, other] and other not in constellation:\n constellation.add(other)\n nodes.append(other)\n\n return constellation","def assign_passengers(self):\n\n # Update the state of the parallel server after every assignment.\n self.parallel_server.update_state()\n\n # While the assignment agent's queue is not empty and there is space\n # to assign passengers in the parallel block...\n while self.parallel_server.has_space_in_a_server_queue is True and \\\n len(self.queue) > 0:\n\n # Pop the first passenger in line and assign to the shortest queue.\n tmp = self.queue.popleft()\n self.parallel_server.min_queue.queue.append(tmp)\n\n # Update the state of the parallel server after every assignment.\n self.parallel_server.update_state()","def update_intersections(self, start_node, end_node):\n\n # paths is a list that will contains a list of shortest paths (list of nodes)\n try:\n path = nx.shortest_path(self.map, start_node, end_node)\n for node in range(len(path)-1):\n start = path[node]\n end = path[node+1]\n self.map.nodes[start]['count'] += 1\n self.map.nodes[end]['count'] += 1\n self.map.edges[start, end, 0]['count'] += 1\n except:\n print(\"Cannot find path between, \", start_node, end_node)\n \n\n # increment edge count for an edge denoted by path","def _assign_reg_vals(self, sess):\n with self.graph.as_default():\n for nn in range(self.num_networks):\n self.networks[nn].assign_reg_vals(sess)","def shortest_path(self, from_node):\n\n\t\t# add the final nodes when algorithm goes past the target prediction time \n\t\tif self.get_real_time(from_node.time) >= self.target:\n\t\t\tself.g.add_node(from_node, usage_cost=0, best_action=None, max_demand=self.starting_max_demand)\n\t\t\treturn\n\n\t\t#create the action set (0 is for do nothing, 1 is for cooling, 2 is for heating)\n\t\taction_set = self.safety.safety_actions(from_node.temps)\n\t\t\n\t\t#iterate for each available action\n\t\tfor action in action_set:\n\t\t\t\n\t\t\t# predict temperature and energy consumption of action\n\t\t\tnew_temperature = []\n\t\t\tconsumption = []\n\t\t\tfor i in range(self.noZones):\n\t\t\t\tnew_temperature.append(self.th.next_temperature(from_node.temps[i], action[i], zone=i))\n\t\t\t\tconsumption.append(self.energy.calc_cost(action[i], from_node.time/self.interval))\n\t\t\t\t\n\t\t\tif self.safety.safety_check(new_temperature) and len(action_set) > 1:\n\t\t\t\tcontinue\n\n\t\t\t# create the node that describes the predicted data\n\t\t\tnew_node = Node(\n\t\t\t\ttemps=new_temperature,\n\t\t\t\ttime=from_node.time + self.interval\n\t\t\t)\n\n\t\t\t# calculate interval costs\n\t\t\tdemand_balancer = (((self.target - self.get_real_time(from_node.time/self.interval)).total_seconds() / 60) / self.billing_period)\n\t\t\tinterval_usage_cost = sum(consumption) + self.interval_usage[int(from_node.time/self.interval)]\n\t\t\tinterval_demand = self.interval_demand[int(from_node.time/self.interval)]\n\n\t\t\t#calculate interval discomfort\n\t\t\tdiscomfort = [0] * self.noZones\n\n\t\t\tfor i in range(self.noZones):\n\t\t\t\tdiscomfort[i] = self.disc.disc(new_temperature[i], self.occ.occ(from_node.time/self.interval), from_node.time)\n\n\t\t\t# create node if the new node is not allready in graph\n\t\t\t# recursively run shortest path for the new node\n\t\t\tif new_node not in self.g:\n\t\t\t\tself.g.add_node(new_node, usage_cost=np.inf, best_action=None, max_demand=np.inf)\n\t\t\t\tself.shortest_path(new_node)\n\n\t\t\t# calculate path costs\n\t\t\tthis_path_demand = max(self.g.node[new_node]['max_demand'], interval_demand)\n\t\t\tthis_path_demand_cost = demand_balancer * this_path_demand\n\n\t\t\tinterval_overall_cost = ((1 - self.l) * (interval_usage_cost + this_path_demand_cost)) + (self.l * (sum(discomfort)))\n\n\t\t\tthis_path_cost = self.g.node[new_node]['usage_cost'] + interval_overall_cost\n\n\t\t\t# add the edge connecting this state to the previous\n\t\t\tself.g.add_edge(from_node, new_node, action=action)\n\n\t\t\t# choose the shortest path\n\t\t\tif this_path_cost <= self.g.node[from_node]['usage_cost']:\n\t\t\t\tif this_path_cost == self.g.node[from_node]['usage_cost'] and self.g.node[from_node]['best_action'] == '0':\n\t\t\t\t\tcontinue\n\t\t\t\tself.g.add_node(from_node, best_action=new_node, usage_cost=this_path_cost, max_demand=this_path_demand)","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 startCoordination(self):\n if not self.isGasBoiler():\n\n self.log_message('ID {0}: Start of Remainder Multicast Optimization'.format(self.CommID))\n #select initial schedule\n #print len(self.EFluctuationCurve)\n self.selectBestSchedule(self.EFluctuationCurve)\n\n #calc remainder\n remainder = [0 for i in range(len(self.EFluctuationCurve))]\n for t in range(len(self.EFluctuationCurve)):\n remainder[t] = self.EFluctuationCurve[t] + self.EConsumptionChosenSchedule[t]\n #save initial global minimum\n if self.OPTcriterion == 'maxmindiff':\n criterion = max(remainder) - min(remainder)\n elif self.OPTcriterion == 'absremainder':\n criterion = 0\n for a in range(len(remainder)):\n criterion += abs(remainder[a])\n #max_min_diff = max(remainder) - min(remainder)\n self.origins.append(copy.deepcopy(self.CommID))\n self.globalMin.append(copy.deepcopy(criterion)) #save minimum for origin self\n self.globalMinSchedIdx.append(copy.deepcopy(self.chosenScheduleIndex))\n self.pathLengths.append(1)\n self.min_path.append(copy.deepcopy(self.CommID))\n self.min_path_schedules.append(copy.deepcopy(self.chosenScheduleIndex))\n\n # send 'remainder' message to all neighbors\n # 'remainder' message has the following structure\n # ['remainder', origin, remainder_curve, path, path_schedules]\n for n in range(len(self.Neighbors)):\n data = ['remainder', copy.deepcopy(self.CommID), copy.deepcopy(remainder), copy.deepcopy([self.CommID]), copy.deepcopy([self.chosenScheduleIndex])]\n self.sendMessage(self.Neighbors[n], 70, data)\n else:\n print 'ID {0}: ERROR! Unable to start Remainder Multicast Optimization, because I am a gas boiler BES!'.format(self.CommID)\n\n return","def start_all_nodes(self):\n for node in self.nodes:\n node.start()","def startup(self):\n for v in self.virt_nodes:\n v.create()\n \n \"\"\" scan for nodes \"\"\"\n self.scan_for_nodes()\n \n \"\"\" connect to all nodes and call setup \"\"\"\n for n in self.scan_nodes:\n n.connect()\n \n ''' list of open addresses for the node '''\n oalist = []\n \n ''' if the multicast interface is defined use it as open address '''\n if self.mcast_interface != \"\":\n oalist.append(self.mcast_interface)\n \n ''' open the connection to the default address of the slave '''\n oalist.append(socket.gethostbyname(socket.gethostname()))\n \n ''' read the monitor node list '''\n monitor_list = open(os.path.join(self.workdir, \"monitor-nodes.txt\"), \"r\")\n for maddress in monitor_list.readlines():\n oalist.append(maddress.strip())\n \n ''' call the setup procedure '''\n n.setup(oalist)","def node_assignment(edge_index: nb.int64[:,:],\n edge_label: nb.int64[:],\n n: nb.int64) -> nb.int64[:]:\n # Loop over on edges, reset the group IDs of connected node\n on_edges = edge_index[np.where(edge_label)[0]]\n return union_find(on_edges, n)[0]","def create_graph_network(start_node, connections):\n graph = nx.Graph()\n graph.add_node(start_node)\n print(connections.index)\n graph.add_nodes_from(connections.index)\n edge_list = list(zip(itertools.repeat(start_node), connections.index))\n print(\"edge list is \", edge_list)\n graph.add_edges_from(edge_list)\n for i in graph.edges():\n graph[i[0]][i[1]]['weight'] = connections.loc[i[1]]['count']\n # graph[i[0]][i[1]]['proposal_number'] = connections.loc[i[1]]['proposal_number']\n # graph[i[0]][i[1]]['institution'] = connections.loc[i[1]]['institution']\n # graph[i[0]][i[1]]['proposal_title'] = connections.loc[i[1]]['proposal_title']\n # graph[i[0]][i[1]]['project_status'] = connections.loc[i[1]]['project_status']\n\n # Adding random position data to the graph.\n # pos = nx.spring_layout(graph, k=1)\n pos = nx.circular_layout(graph)\n nx.set_node_attributes(graph, 'pos', pos)\n return graph","def __initilization(self,node_set):\n \n print \"*********************************\"\n \n for x in node_set:\n x.node_vol=np.transpose(np.matrix([cmath.exp(0), cmath.exp(complex(0,math.pi*2/3)), cmath.exp(complex(0,-math.pi*2/3))]))\n \n print \"Forward/Backward Algorithm Initialization Done!\"","def __init__(self,\n start,\n goal,\n expand_dis=3.0,\n goal_sample_rate=5,\n ):\n self.start = self.Node(start[0], start[1])\n self.end = self.Node(goal[0], goal[1])\n self.expand_dis = expand_dis\n self.goal_sample_rate = goal_sample_rate\n \n self.stepLength = 50\n self.path_resolution = 1\n self.obstaclelist = []\n self.node_list = []","def markIsland(self, start_position, grid):\n queue = Queue()\n queue.put(start_position)\n\n y, x = start_position\n self.visited[y][x] = 1 # visited\n\n while not queue.empty():\n print(queue.queue)\n # iterate the nodes which are already in the queue\n for _ in range(queue.qsize()):\n y, x = queue.get()\n for x_dir, y_dir in toSearch:\n new_x = x + x_dir\n new_y = y + y_dir\n\n # make sure the pixel to search is in the range of the grid\n if 0 <= new_x < self.width and 0 <= new_y < self.length:\n if self.visited[new_y][new_x] == 0:\n if grid[new_y][new_x] == '1':\n queue.put((new_y, new_x))\n self.visited[new_y][new_x] = 1","def __init__(self, nodes: Set[Node], edges: Set[Edge]):\n super().__init__()\n self.nodes = nodes\n for edge in edges:\n self.add_edge(edge)\n self.leaves = {node for node in self.nodes if self.degree_out(node) == 0}\n root_nodes = self.nodes - self.leaves\n root_edges = {edge for edge in self.edges if edge.node_to not in self.leaves}\n self.root_graph = Mask(root_nodes, root_edges, self)","def mappossiblemoves(self,nodeStart):\n destinations = [set() for ix in range(game.DICEMAX+1)]\n destinations[0] = set([nodeStart])\n routes = [[nodeStart]]\n #\n # TODO: Not convinced this adds anything more than it harms in this fn.\n #if self.hasEnteredRoomYet:\n # GAMEBOARD = game.TRIMMEDNODES\n #else:\n GAMEBOARD = game.BOARDNODES\n #\n for diceRoll in range(1,game.DICEMAX+1):\n newRoutes = []\n for route in routes:\n for nextLoc in GAMEBOARD[route[-1]]:\n if not nextLoc in route:\n # This location has not yet been visited by this route\n if nextLoc in game.ALLOWEDROOMNODES:\n # Location is a room - can move into it regardless\n # of population, but not move further. We can also\n # use any longer roll to move here by this route\n for thisRoll in range(diceRoll,game.DICEMAX+1):\n destinations[thisRoll].add(nextLoc)\n else:\n # Location is a square - can only move into it if\n # unoccupied, but can move further once there.\n if not nextLoc in self.charLocations:\n # Unoccupied (could check against \n # charLocations[1:] since we're the piece moving\n # but a nextLoc = charLocations[0] would be\n # rejected by being already in the route anyway)\n newRoute = list(route)\n newRoute.append(nextLoc)\n newRoutes.append(newRoute)\n destinations[diceRoll].add(nextLoc)\n routes = newRoutes\n #\n return [list(destSet) for destSet in destinations]","def __init__(self):\n self.start = Node('-1')","def choose_cell_to_assign(self):\r\n min_domain = 10\r\n max_degree = -1\r\n chosen_row = None\r\n chosen_col = None\r\n for row in range(9):\r\n for col in range(9):\r\n if self.puzzle[row][col] == 0:\r\n domain_size = len(self.grid[row][col].domain)\r\n if domain_size < min_domain:\r\n min_domain = domain_size\r\n chosen_row = row\r\n chosen_col = col\r\n elif domain_size == min_domain:\r\n degree = len(self.grid[row][col].neighbors)\r\n if degree > max_degree:\r\n max_degree = degree\r\n chosen_row = row\r\n chosen_col = col\r\n return self.grid[chosen_row][chosen_col]","def a_star(self, start_xy, end_xy):\n start_node = Node(start_xy, end_xy, self.graph_start_xy)\n start_node.shortest_dist = 0\n start_node.update_total_cost()\n pq = []\n pq.append(start_node)\n heapify(pq)\n stack = []\n while pq:\n current_node = heappop(pq)\n if (current_node.coord_xy == end_xy).all():\n print(\"it's done \")\n iterator = current_node\n while iterator:\n stack.append(iterator.coord_xy)\n iterator = iterator.prev_node\n break\n\n for neighbour, dist in current_node.connections:\n neighbouring_node = Node(neighbour, end_xy, self.graph_start_xy)\n if current_node.shortest_dist + dist < neighbouring_node.shortest_dist:\n neighbouring_node.shortest_dist = current_node.shortest_dist + dist\n neighbouring_node.update_total_cost()\n neighbouring_node.prev_node = current_node\n heappush(pq, neighbouring_node)\n return stack","def get_subgraph_between_nodes(self, start, end):\n nodes = set()\n nodes.add(start)\n\n to_visit = set()\n to_visit.add(start)\n\n while len(to_visit) > 0:\n current_visit = copy.copy(to_visit)\n for tv in current_visit:\n to_visit.remove(tv)\n if tv is not end:\n for s in self.successors(tv):\n to_visit.add(s)\n nodes.add(s)\n\n nodes.add(end)\n\n return self.subgraph(nodes)","def buildNodesDict(self):\n # Get relevant nodes from TANA ca_jc, intersect with BUS_ROUTE_TRAVERSAL_EDGES.\n # Then get the X,Y for the features.\n arcpy.env.workspace = PublicTransit.WORKING_GDB\n arcpy.AddXY_management(PublicTransit.RELEVANT_NODES)\n nodes = arcpy.SearchCursor(PublicTransit.RELEVANT_NODES, \"\", \"\",\n \"ID_hash; POINT_X; POINT_Y\", \"\")\n self.nodesDict = dict()\n numNodes = int(arcpy.GetCount_management(PublicTransit.RELEVANT_NODES).getOutput(0))\n print \"Found %d nodes\" % numNodes\n for node in nodes:\n self.nodesDict[node.ID_hash] = Node(node.ID_hash, node.POINT_X, node.POINT_Y)\n del node\n del nodes","def assign_nodes_to_edges(nodes, edges):\n\n from scipy.spatial import cKDTree\n \n edges_arr = np.vstack(edges)\n kdt_nodes = cKDTree(nodes)\n\n # closest node id and discard computed distances ('_,')\n _, pairs = kdt_nodes.query(x=edges_arr, k=1)\n # refactor list of successive ids for start and end of edges into 2D array\n pairs = np.vstack((pairs[::2], pairs[1::2])).T\n\n new_edges = []\n for pair in pairs[:,:]:\n new_edges.append(np.array(nodes[pair]))\n \n return new_edges, pairs","def generate_nodes(self):\n \n # For all state nodes\n node = 0\n \n for i in range(self.x0_n):\n for j in range(self.x1_n):\n for k in range(self.x2_n):\n \n # State\n x = np.array([ self.xd[0][i] , self.xd[1][j] , self.xd[2][k] ])\n \n # State and grid index based on node #\n self.nodes_state[node,:] = x\n self.nodes_index[node,:] = np.array([i,j,k])\n \n # Node # based on index ijk\n self.x_grid2node[i,j,k] = node\n \n # Increment node number\n node = node + 1","def a_star_planning(start_x, start_y, goal_x, goal_y, id):\n # extract the index of start node, goal node and obstacles\n start = Point(round(start_x/grid_size), round(start_y/grid_size), 0.0, -1, [0,0,0])\n goal = Point(round(goal_x/grid_size), round(goal_y/grid_size), 0.0, -1, [0,0,0])\n if not_legal(goal, id):\n print ('not a legal goal')\n return False\n \n # time.sleep(10)\n\n # create the open list and close list to store nodes\n openset, closeset = deque(), deque()\n openset.append(start)\n\n while True:\n # find out the min f node to explore\n\n current_node = min(openset,\n key=lambda node: node.g + calculate_heuristic(node,goal))\n\n # pltplt.plot(current_node.x, current_node.y, \"b*\")\n if len(closeset) % 10 == 0:\n plt.pause(0.001)\n\n if current_node.x == goal.x and current_node.y == goal.y:\n print(\"Congratulations! You have found the goal!\")\n goal.parent = current_node\n break\n\n # Remove it from the open list\n openset.remove(current_node)\n # Add it to the close list\n closeset.append(current_node)\n\n # Explore the neighbour\n for motion in motions:\n if motion == current_node.parent_motion:\n turn_cost = 0\n elif (motion[0] == -1 * current_node.parent_motion[0]) and (motion[1] == -1 * current_node.parent_motion[1]):\n turn_cost = 1.5\n else:\n turn_cost = 1\n\n node = Point(current_node.x + motion[0],\n current_node.y + motion[1],\n current_node.g + motion[2] + turn_cost,\n current_node,\n motion,\n )\n\n # ignore it if it is in the close list\n flag = False\n for item in closeset:\n if item.x == node.x and item.y == node.y:\n flag = True\n break\n if flag:\n continue\n # ignore it if it is obstacle\n\n if not_legal(node, id):\n continue\n # update its parent if it is the open list\n flag = True\n for item in openset:\n if item.x == node.x and item.y == node.y:\n flag = False\n # if closer, update the parent\n if node.g <= item.g:\n item.g = node.g\n item.parent = node.parent\n item.parent_motion = node.parent_motion\n break\n # add to the open list if it is not in the open list\n if flag:\n openset.append(node)\n\n # generate the final path\n while True:\n route = deque()\n route.append(goal)\n plt.plot(goal.x, goal.y, \"rx\")\n if goal.parent == -1:\n break\n else:\n goal = goal.parent\n route.appendleft(goal)\n # return route\n # return False\n if NEED_DRAW:\n # draw map\n for i in range(map.gridwidth):\n for j in range(map.gridheight):\n if map.grid[1,i,j] >0:\n plt.plot(i, j, \"xc\")\n\n plt.plot(start.x, start.y, \"ro\")\n plt.plot(goal.x, goal.y, \"go\")\n\n for goal in route:\n plt.plot(goal.x, goal.y, \"rx\")\n plt.show()","def relabel_nodes(graph: BaseGraph, mapping: Dict) -> None:\n relabel_nodes(graph.graph, mapping, copy=False)","def neighbor(self, start):\n x = start[0] + random.uniform(-20, 20)\n y = start[1] + random.uniform(-20, 20)\n x = max(min(x, xbounds[1]), xbounds[0])\n y = max(min(y, ybounds[1]), ybounds[0])\n return [x,y]","def a_star(self, start, final):\n self.speed_setting_season()\n cost_so_far = {}\n frontier = PriorityQueue()\n parents = {}\n frontier.put(start, 0)\n cost_so_far[start] = 0\n f_value = {}\n f_value[start] = self.grid.heuristic(start[0], start[1], final[0], final[1])\n final_path_list = []\n while not frontier.empty():\n actual_node = frontier.get()\n final_path_list = []\n if actual_node == final:\n curr = final\n while curr != start:\n final_path_list.insert(0, curr)\n curr = parents[curr]\n final_path_list.insert(0, start)\n break\n potential_neighbors = self.grid.neighbors(int(actual_node[0]), int(actual_node[1]))\n for neighbor in potential_neighbors:\n g_value = cost_so_far[actual_node] + self.grid.cost_g(actual_node[0], actual_node[1],\n neighbor[0],\n neighbor[1])\n h_value = self.grid.heuristic(neighbor[0], neighbor[1], final[0], final[1])\n if neighbor not in cost_so_far or g_value + h_value < f_value[neighbor]:\n cost_so_far[neighbor] = g_value\n f_value[neighbor] = g_value + h_value\n frontier.put(neighbor, g_value + h_value)\n parents[neighbor] = actual_node\n print(\"found path from: \" + str(start) + \" to: \" + str(final))\n return final_path_list","def make_complete_graph (num_nodes) :\n graph = dict ()\n if (num_nodes < 1) :\n return graph\n\n for node_ind in range (num_nodes) :\n # create a set containing nodes adjacent to node node_ind\n # node node_ind of the complete graph will have edges to all other nodes except itself\n adj_nodes = range (num_nodes) # list containing numbers from 0 - num_nodes-1\n adj_nodes.remove(node_ind)\n graph[node_ind] = set(adj_nodes)\n\n return graph","def set_start_coords(self, x:int, y:int) -> None:\r\n self.start_x = x\r\n self.start_y = y","def watchdog_patrol_restart(self, nodes, percentage, alpha=0, rand=random.Random(), start=None):\n\n G = self\n if start:\n path = [start]\n else:\n path = [rand.choices(nodes)]\n\n while len(path) < 1 or random.random() > percentage:\n cur = path [-1]\n if len(G[cur]) > 0:\n if rand.random() >= alpha:\n add_node = rand.choice(G[cur])\n while add_node == cur:\n add_node = rand.choice(G[cur])\n path.append(add_node)\n else:\n path.append(path[0])\n else:\n break\n return path\n\n #neighbors = []\n # for n in G[cur]\n # neighbors.extend(G[n])\n #if len(G[cur]) > 0:\n # add decision maker node","def A_Star(start, goal, final_occupancy_grid):\n x, y = np.mgrid[0:LENGTH:1, 0:WIDTH:1]\n pos = np.empty(x.shape + (2,))\n # x.shape = (LENGTH,WIDTH)\n # x.shape + (2,) = (LENGTH,WIDTH,2)\n pos[:, :, 0] = x\n pos[:, :, 1] = y\n # pos.shape = (1890, 2)\n pos = np.reshape(pos, (x.shape[0] * x.shape[1], 2))\n coords = list([(int(x[0]), int(x[1])) for x in pos])\n # Define the heuristic:\n # h: dictionary containing the distance to goal ignoring obstacles for all coordinates in the grid (heuristic function)\n h = np.linalg.norm(pos - goal, axis=1)\n # If axis is an integer, it specifies the axis of x along which to compute the vector norms\n # axis = 1: h.shape = 1890\n # axis = 0: h.shape = 2\n h = dict(zip(coords, h))\n\n # Check if the start and goal are within the boundaries of the map\n for point in [start, goal]:\n\n if point[0] < 0 and point[0] >= final_occupancy_grid.shape[0]:\n raise Exception('Start node/goal node is not contained in the map')\n\n if point[1] < 0 and point[1] >= final_occupancy_grid.shape[1]:\n raise Exception('Start node/goal node is not contained in the map')\n\n # check if start and goal nodes correspond to free spaces\n if final_occupancy_grid[start[0], start[1]]:\n raise Exception('Start node is not traversable')\n\n if final_occupancy_grid[goal[0], goal[1]]:\n raise Exception('Goal node is not traversable')\n\n # get the possible movements\n movements = get_movements_8n()\n\n # The set of visited nodes that need to be (re-)expanded, i.e. for which the neighbors need to be explored\n # Initially, only the start node is known.\n openSet = [start]\n\n # The set of visited nodes that no longer need to be expanded.\n closedSet = []\n\n # For node n, cameFrom[n] is the node immediately preceding it on the cheapest path from start to n currently known.\n cameFrom = dict()\n\n # For node n, gScore[n] is the cost of the cheapest path from start to n currently known.\n gScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\n gScore[start] = 0\n\n # For node n, fScore[n] := gScore[n] + h(n). map with default value of Infinity\n fScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\n fScore[start] = h[start]\n\n # while there are still elements to investigate\n while openSet != []:\n\n # the node in openSet having the lowest fScore[] value\n fScore_openSet = {key: val for (key, val) in fScore.items() if key in openSet}\n current = min(fScore_openSet, key=fScore_openSet.get)\n del fScore_openSet\n\n # If the goal is reached, reconstruct and return the obtained path\n if current == goal:\n # print(\"Path\", closedSet)\n return reconstruct_path(cameFrom, current)\n\n openSet.remove(current)\n closedSet.append(current)\n\n # for each neighbor of current:\n for dx, dy, deltacost in movements:\n\n neighbor = (current[0] + dx, current[1] + dy)\n\n # if the node is not in the map, skip\n if (neighbor[0] >= final_occupancy_grid.shape[0]) or (neighbor[1] >= final_occupancy_grid.shape[1]) or (\n neighbor[0] < 0) or (neighbor[1] < 0):\n continue\n\n # if the node is occupied, skip\n if (final_occupancy_grid[neighbor[0], neighbor[1]]):\n continue\n\n # if the has already been visited, skip\n if (neighbor in closedSet):\n continue\n # d(current,neighbor) is the weight of the edge from current to neighbor\n # tentative_gScore is the distance from start to the neighbor through current\n tentative_gScore = gScore[current] + deltacost\n\n if neighbor not in openSet:\n openSet.append(neighbor)\n\n if tentative_gScore < gScore[neighbor]:\n # This path to neighbor is better than any previous one. Record it!\n cameFrom[neighbor] = current\n gScore[neighbor] = tentative_gScore\n fScore[neighbor] = gScore[neighbor] + h[neighbor]\n\n # Open set is empty but goal was never reached\n print(\"No path found to goal\")\n return [], closedSet","def reset_initial_values(self):\n #### TODO: move reset conditions to /sim\n self.sim_time = 0.0\n self._prev_sim_time = None\n\n for name, node in self.nodes(Junction):\n node._head = None\n node._demand = None\n node._pressure = None\n node._leak_demand = None\n node._leak_status = False\n node._is_isolated = False\n\n for name, node in self.nodes(Tank):\n node._head = node.init_level+node.elevation\n node._prev_head = node.head\n node._demand = None\n node._leak_demand = None\n node._leak_status = False\n node._is_isolated = False\n\n for name, node in self.nodes(Reservoir):\n node._head = None # node.head_timeseries.base_value\n node._demand = None\n node._leak_demand = None\n node._is_isolated = False\n\n for name, link in self.links(Pipe):\n link._user_status = link.initial_status\n link._setting = link.initial_setting\n link._internal_status = LinkStatus.Active\n link._is_isolated = False\n link._flow = None\n link._prev_setting = None\n\n for name, link in self.links(Pump):\n link._user_status = link.initial_status\n link._setting = link.initial_setting\n link._internal_status = LinkStatus.Active\n link._is_isolated = False\n link._flow = None\n if isinstance(link, PowerPump):\n link.power = link._base_power\n link._prev_setting = None\n\n for name, link in self.links(Valve):\n link._user_status = link.initial_status\n link._setting = link.initial_setting\n link._internal_status = LinkStatus.Active\n link._is_isolated = False\n link._flow = None\n link._prev_setting = None\n\n for name, control in self.controls():\n control._reset()","def _update_nodes_ids(self, change=None):\n self._nodes_filter.val_range = self.nodes_range\n self.nodes_ids = self._nodes_filter.val_ids\n self._update_edges_filtered(change)","def initialize(self):\n self.currState = self.startState","def dfs(g: nx.Graph, start_node: Any) -> str:\n\n way = []\n stack = [start_node]\n y = {node: [] for node in g.nodes}\n while stack:\n elem = stack.pop()\n way.append(elem)\n for node in list(g.neighbors(elem)):\n if node not in way:\n stack.append(node)\n y[node].extend((*y[elem], elem))\n print(y)\n return \"\".join(way)","def reset_graph(self):\n self.nodes = {}\n self.add_node(self.initial_state)\n self.add_node(self.final_state)","def connect(self, node1, node2):\n self.neighbour1 = node1\n self.neighbour2 = node2","def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n\n loc_map = {}\n drop_off_dict = {}\n num_home_visited = 0\n\n \"\"\"\n for i in range(len(list_of_locations)):\n loc_map[i] = list_of_locations[0]\n \"\"\"\n\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\n start = list_of_locations.index(starting_car_location)\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\n num_homes = len(list_of_homes)\n\n car_path = []\n all_paths = dict(nx.all_pairs_dijkstra(graph))\n visited = set()\n\n #print(start)\n car_path.append(start)\n current_node = start\n\n if start in home_indexes:\n visited.add(start)\n drop_off_dict[start] = [start]\n num_home_visited += 1\n\n while num_home_visited < num_homes:\n dist_dict = all_paths.get(current_node)[0]\n paths_dict = all_paths.get(current_node)[1]\n\n dist_dict = {k:v for (k,v) in dist_dict.items() if k not in visited and k in home_indexes}\n min_dist = min(dist_dict.values())\n min_list = [k for k in dist_dict.keys() if dist_dict[k] <= min_dist]\n #print(dist_dict.values())\n target = min_list[0]\n drop_off_dict[target] = [target]\n #print(target+1)\n #print(target)\n car_path.pop()\n car_path.extend(paths_dict[target])\n\n visited.add(target)\n current_node = target\n num_home_visited += 1\n\n paths_dict = all_paths.get(current_node)[1]\n car_path.pop()\n car_path.extend(paths_dict[start])\n #print((drop_off_dict.keys()))\n #car_path = [start, ...., start]\n #drop_off_dict = {drop_off_loc: [home1, home2, ...] }\n\n return car_path, drop_off_dict","def setup_nodes(server_node, road_node, road_segment_point):\n\n # Create working server node data subset excluding unneeded fields\n snode = [{'id': i,\n 'shapeid': item['shapeid'],\n 'x': float(item['x']),\n 'y': float(item['y']),\n 'nearest_pt': None,\n 'nearest_pt_sl_dist': float(\"inf\"),\n 'color_num': (int(item['shapeid']) + CM_OFFSET) % NUM_COLORS}\n for i, item in enumerate(server_node)]\n\n # Create working road node data subset excluding unneeded fields\n # (note: road nodes consist of junctions and road ends)\n rnode = []\n prev_coord = []\n for i, item in enumerate(road_node):\n if [item['x'], item['y']] not in prev_coord: # exclude duplicates\n rnode.append({'id': i,\n 'shapeid': item['shapeid'],\n 'x': float(item['x']),\n 'y': float(item['y']),\n 'best_server': None,\n 'color_num': GREY})\n prev_coord.append([item['x'], item['y']])\n\n # Create working road point data subset excluding unneeded fields\n rpoint = []\n point = 0\n for i in range(len(road_segment_point)):\n id = road_segment_point[i]['shapeid']\n rpoint.append({'id': i,\n 'shapeid': id,\n 'point': point,\n 'x': float(road_segment_point[i]['x']),\n 'y': float(road_segment_point[i]['y']),\n 'lowest_cost': float(\"inf\"),\n 'best_server': None,\n 'color_num': GREY})\n if i < len(road_segment_point) - 1:\n id_next = road_segment_point[i + 1]['shapeid']\n if id == id_next:\n point += 1\n else:\n point = 0\n\n # Convert adjacent road segment endpoints to lines (x1, y1) to (x2, y2)\n rseg = []\n line = 0\n seg = 0\n for i in range(len(rpoint[:-1])):\n id = rpoint[i]['shapeid']\n id_next = rpoint[i + 1]['shapeid']\n if id == id_next:\n rseg.append({'id': line,\n 'shapeid': id,\n 'segment': seg,\n 'point1': rpoint[i]['id'],\n 'x1': float(rpoint[i]['x']),\n 'y1': float(rpoint[i]['y']),\n 'point2': rpoint[i + 1]['id'],\n 'x2': float(rpoint[i + 1]['x']),\n 'y2': float(rpoint[i + 1]['y']),\n 'best_server': None,\n 'color_num': GREY})\n line += 1\n seg += 1\n else:\n seg = 0\n\n return snode, rnode, rpoint, rseg","def generate_nodes(self):\n \n # For all state nodes\n node = 0\n \n for i in range(self.x0_n):\n for j in range(self.x1_n):\n \n # State\n x = np.array([ self.xd[0][i] , self.xd[1][j] ])\n \n # State and grid index based on node #\n self.nodes_state[node,:] = x\n self.nodes_index[node,:] = np.array([i,j])\n \n # Node # based on index ij\n self.x_grid2node[i,j] = node\n\n # Increment node number\n node = node + 1","def start_one_step(self):\r\n new_infected_list = []\r\n old_infected_list = copy.deepcopy(self.infected_list)\r\n new_recovered_list = []\r\n old_recovered_list = copy.deepcopy(self.recovered_list)\r\n # For each infected node\r\n for infected_nid in old_infected_list:\r\n infected_node = self.node_dict[infected_nid]\r\n # For each neighbor\r\n for dst_nid in infected_node.get_dst_nid_list(self.graph):\r\n dst_node = self.node_dict[dst_nid]\r\n # Infect susceptible nodes with probability [p]\r\n if dst_node.state is NodeState.SUSCEPTIBLE and random.random() < self.p:\r\n dst_node.infected(self.i)\r\n new_infected_list.append(dst_nid)\r\n\r\n # Minus 1 turn of (remaining) infected days for all infected nodes\r\n infected_node.minus_one_state_day()\r\n # If infected node is recovered\r\n if infected_node.check_finish_infection():\r\n # Infected node get recovered\r\n infected_node.recovered(self.r)\r\n # Remove from infected list\r\n self.infected_list.remove(infected_nid)\r\n # Append to recovered list\r\n new_recovered_list.append(infected_nid)\r\n\r\n # Add newly infected nodes into infected list\r\n self.infected_list += new_infected_list\r\n\r\n # For each recovered node\r\n for recovered_nid in old_recovered_list:\r\n recovered_node = self.node_dict[recovered_nid]\r\n # Minus 1 turn of (remaining) recovered days for all recovered nodes\r\n recovered_node.minus_one_state_day()\r\n # If infected node is recovered\r\n if recovered_node.check_finish_recovery():\r\n # Recovered node get recovered\r\n recovered_node.susceptible()\r\n # Remove from recovered list\r\n self.recovered_list.remove(recovered_nid)\r\n\r\n # Add newly recovered nodes into recovered list\r\n self.recovered_list += new_recovered_list","def __init__(self, initial_node):\n self.__nodes = MinPriorityQueue({initial_node : initial_node.estimate})","def __init__(self, node_number, all_nodes):\n self.self_host = 'localhost'\n self.base_port = 5000\n self.self_port = self.base_port + node_number\n self.other_nodes = [(self.self_host, p)\n for p in range(self.base_port + 1, self.base_port + all_nodes + 1)\n if p != self.self_port]\n self.other_nodes_len = all_nodes - 1\n self.current_node = 0","def init(self):\n self.padre = self.id\n self.sinVisitar = [] \n self.visited = False\n print (\"inicializo algoritmo\")\n for i in range (len(self.neighbors)): #De esta forma se pueden manipular las listas por aparte\n self.sinVisitar.append(self.neighbors[i])","def initnodes(self):\n newnodes = self.config[\"nodes\"]\n newpynodes = self.config[\"pynodes\"]\n logging.info('Loading initial nodes: {}'.format(newnodes))\n logging.info('Loading initial python nodes: {}'.format(newpynodes))\n for node in newnodes:\n self.runnode(node)\n for node in newpynodes:\n self.runnode(node, True)","def start(self, wait=False):\n start_nodes = self._get_start_nodes()\n\n for node in start_nodes:\n if not node.init_generator:\n self.queue.put((node, (), {}))\n else:\n node_copy = copy.deepcopy(node)\n node_copy.init_generator = None\n for args, kwargs in node.init_generator:\n print(args, kwargs)\n self.queue.put((node_copy, args, kwargs))\n\n if wait:\n self.wait_for_completion()","def dijkstras(occupancy_map,x_spacing,y_spacing,start,goal):\n ROWS, COLS = occupancy_map.shape\n #convert physical location to index in the grid\n startNode = locToIndex(start, x_spacing, y_spacing)\n startingNodeLoc = indexToLoc(startNode, x_spacing, y_spacing)\n initialcost = math.sqrt((startingNodeLoc[0] - start[0])**2 + (startingNodeLoc[1] - start[1])**2)\n goalNode = locToIndex(goal, x_spacing, y_spacing)\n \n freelist = np.where(occupancy_map == 0)\n if occupancy_map[startNode[0], startNode[1]] != 0:\n #raise ValueError(\"start : ({}, {}) invalid, is an obstacle\".format(startNode[0], startNode[1]))\n startNode = findValidNode(startNode, start, occupancy_map, x_spacing, y_spacing)\n if occupancy_map[goalNode[0], goalNode[1]] != 0:\n #raise ValueError(\"goal: ({}, {}) invalid, is an obstacle\".format(goalNode[0], goalNode[1]))\n goalNode = findValidNode(goalNode, goal, occupancy_map, x_spacing, y_spacing)\n candidate = [ [sys.float_info.max, \n i, (freelist[0][i], freelist[1][i])] for i in range(len(freelist[0]))] \n visited = set([])\n queue = PriorityQueue(candidate)\n paths = {}\n found = False\n\n #update initial cost\n queue.remove(startNode)\n queue.insert(startNode, initialcost)\n paths[startNode] = None\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, 0, 1, queue, paths, x_spacing, y_spacing, initialcost)\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, 0, -1, queue, paths, x_spacing, y_spacing, initialcost)\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, 1, 0, queue, paths, x_spacing, y_spacing, initialcost)\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, -1, 0, queue, paths, x_spacing, y_spacing, initialcost)\n while queue.size() > 0:\n priority, current = queue.pop()\n if current == goalNode:\n found = True\n break\n #not reaching goal node yet, for each of its neighbor, update the weight\n visited.add(current)\n update(occupancy_map, ROWS, COLS, current, 0, 1, priority, queue, paths, visited, x_spacing, y_spacing)\n update(occupancy_map, ROWS, COLS, current, 0, -1, priority, queue, paths, visited, x_spacing, y_spacing)\n update(occupancy_map, ROWS, COLS, current, 1, 0, priority, queue, paths, visited, x_spacing, y_spacing)\n update(occupancy_map, ROWS, COLS, current, -1, 0, priority, queue, paths, visited, x_spacing, y_spacing)\n \n if not found:\n raise ValueError(\"fail to find shortest path\")\n node = goalNode\n shortestpath = []\n while node is not None:\n shortestpath.append(node)\n node = paths[node]\n #shortestpath.append(startNode)\n #print (startNode)\n #print ('*', list(reversed(shortestpath)))\n #print (goalNode)\n p = list(reversed([ indexToLoc(n, x_spacing, y_spacing) for n in shortestpath]))\n #start and final position may not fall on center of the grid\n if abs(p[0][0] - start[0]) > 0.0005 or abs(p[0][1] - start[1]) > 0.0005:\n p.insert(0, [start[0][0], start[1][0]])\n if abs(p[-1][0] - goal[0]) > 0.0005 or abs(p[-1][1] - goal[1]) > 0.0005:\n p.append([goal[0][0], goal[1][0]])\n res = np.array(p)\n print (res)\n return res","def complete_graph(self):\n root_nodes = set()\n\n for name, a_block in self.wf['action'].items():\n\n a_block['name'] = name\n\n for n in a_block.get('needs', []):\n if not self.wf['action'][n].get('next', None):\n self.wf['action'][n]['next'] = set()\n self.wf['action'][n]['next'].add(name)\n\n if not a_block.get('needs', None):\n root_nodes.add(name)\n\n self.wf['root'] = root_nodes","def rr2_assign_ports():\n print('******* Assigning ports')\n for device in ci_addrs.switches_rr1_12:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_rr1_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr')\n for device in ci_addrs.switches_rr2_12:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_rr2_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr')\n assign_ports_n5k34()","def update_cell_nodes(self):\n self.cells['nodes'] = -1\n\n for c in range(self.Ncells()):\n # consider two edges at a time, and find the common node\n for i,(ja,jb) in enumerate(circular_pairs(self.cell_to_edges(c))):\n for n in self.edges['nodes'][ja,:]: \n if n in self.edges['nodes'][jb]:\n self.cells['nodes'][c,i] = n\n break","def dijkstra(self,start):\n path_weight = {i : float('inf') for i in range(self.n)}\n path_weight[start] = 0\n previous = {i : float('nan') for i in range(self.n)}\n remaining = PriorityQueue()\n for node,priority in path_weight.items():\n remaining.put((priority,node))\n\n while not remaining.empty():\n priority,node = remaining.get()\n for tgt,weight in self.edges[node].items():\n possibleNewWeight = path_weight[node] + weight\n if (possibleNewWeight < path_weight[tgt]):\n path_weight[tgt] = possibleNewWeight\n previous[tgt] = node\n \n return path_weight, previous","def readjust_node_id(self, lowerbound = 1):\n for i in range(lowerbound, len(self.nodes)):\n if self.nodes[i]:\n self.nodes[i].node_id = i","def __init__(self, initial_state):\n self.initial_state = initial_state\n self.final_state = [1, 2, 3, 8, 0, 4, 7, 6, 5]\n self.nodes = {}\n self.add_node(self.initial_state)\n self.add_node(self.final_state)\n self.results = []","def startTreeBasedCoord(self):\n self.log_message('ID {0} starts Load Propagation Optimization'.format(self.CommID))\n #self.MsgReceiveCount_interval = 0\n #self.MsgSendCount_interval = 0\n\n self.noOfTimesteps = (self.toTime - self.fromTime) / self.stepSize + 1\n\n # calculate pool of schedules (also saved in self.schedules) and schedule load curves\n if self.getTER1() != 0: # if not a gas boiler\n self.calcSchedulePool(self.fromTime, self.toTime)\n self.calcScheduleConsumptionCurves()\n\n if not self.Parent: #root node\n random.seed() # initialize pseudo random number generator\n\n\n\n # leave nodes select initial best schedule from schedule pool based on fluctuations curve and propagate their load to parent\n if not self.Children:\n #self.ChildrenProcessed = [0 for x in range(len(self.Children))]\n if self.getTER1() != 0: # not a gas boiler\n self.selectBestSchedule(copy.deepcopy(self.ERemainderLocal))\n self.setSOC(self.SOCEnd[self.chosenScheduleIndex])\n self.setStateModlvl(self.chosenSchedule[-1])\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(self.EConsumptionChosenSchedule)])\n else:\n zeros = [0 for x in range(len(self.ERemainderLocal))]\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(zeros)])\n\n else: # if not a leave node\n self.EConsumptionChildCurves = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\n self.EConsumptionChildCurvesRec = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\n self.noOfConsumptionCurvesReceived = 0\n #self.ChildLoadCurvesChosen = [0 for x in range(len(self.Children))]\n return","def __init__(self, start_time, end_time):\n self._start = start_time\n self._end = end_time\n self._nodes = dict()\n self._edges = dict()\n self._names = set()\n self.current = None"],"string":"[\n \"def assign(self, starts):\\n # Initialize the set of open and closed nodes, and the connection map\\n open_set, closed_set = starts, set()\\n \\n # Initialize a map of assignments and associated profits\\n profits = {s:0 for s in starts}\\n \\n while open_set:\\n\\n # Explore the most promising node\\n current = max(open_set, key=lambda n: profits[n])\\n \\n # Move the current node from the open set to the closed set\\n open_set.remove(current)\\n closed_set.add(current)\\n \\n # Track if assignment is complete\\n assignment_finished = True\\n \\n # Determine all possible next assignment steps\\n for agent in self.agents:\\n # Determine possible tasks the agent may be assigned to\\n poss_tasks = self.assign_agent(agent, current)\\n \\n # If assignments are possible, the assignment is not complete\\n if poss_tasks: assignment_finished = False\\n \\n for task in poss_tasks:\\n # Determine next assignment step\\n next_dict = dict(current)\\n next_dict[agent] = next_dict[agent] | {task}\\n next_assignment = frozendict(next_dict)\\n \\n # If we have already explored this assignment, continue\\n if next_assignment in closed_set:\\n continue\\n # Else add the assignment to the open set\\n else:\\n open_set.add(next_assignment)\\n profits[next_assignment] = self.calc_profit(next_assignment)\\n \\n # If assignment is finished, add it to finished assignments\\n if assignment_finished:\\n \\n # Check if assignment is also complete\\n if self.complete and not self.is_complete(current):\\n continue\\n \\n self.finished_assignments[current] = profits[current]\\n \\n # Update current fair / max profit and print if applicable\\n # Procedure for fair profit (max profit tiebreaker)\\n if self.fair:\\n cur_fair_profit = self.calc_fair_profit(current)\\n if ((cur_fair_profit > self.fair_profit) or \\n (cur_fair_profit == self.fair_profit and\\n profits[current] > self.max_profit)):\\n self.fair_profit = cur_fair_profit\\n self.max_profit = profits[current]\\n self.print_assignment(current, profits[current])\\n elif (self.verbose and profits[current] >= self.max_profit\\n and cur_fair_profit >= self.fair_profit):\\n self.print_assignment(current, profits[current])\\n # Procedure for maximum profit\\n else:\\n if profits[current] > self.max_profit:\\n self.max_profit = profits[current]\\n self.print_assignment(current, profits[current])\\n elif self.verbose and profits[current] >= self.max_profit:\\n self.print_assignment(current, profits[current])\",\n \"def prepare_initial_nodes(x_start, x_end, nodes_y):\\n nodes_x = [float(x_start + ((x_end - x_start) / (len(nodes_y) - 1)) * i) for i in range(0, len(nodes_y))]\\n nodes_y = [float(y) for y in nodes_y]\\n print(nodes_x)\\n print(nodes_y)\\n nodes = list(zip(nodes_x, nodes_y))\\n return nodes\",\n \"def add_resets_edges(graph, start):\\n for node in graph.nodes:\\n neighbors = list(graph[node])\\n if neighbors == [node]:\\n graph.add_edge(node, start, label=\\\"RESET / \\\")\",\n \"def _reset_node_ids(self, start_id: int):\\n\\n add_id = start_id - self.min_node_id()\\n for tree_idx, _ in enumerate(self.nodes):\\n self.nodes[tree_idx].nodes['id'] += add_id\\n self.edges[tree_idx] += add_id\",\n \"def start(self):\\n self.id_oi = 1\\n self.param_target_distances = [5, 30]\\n self.cells_no_links = [cell for cell in self.cell_list if cell.id != self.id_oi]\\n self.cell_oi = [cell for cell in self.cell_list if cell.id == self.id_oi][0]\",\n \"def setup_ant(self):\\n self.visited_nodes[1:] = []\\n self.actual_node = self.start_pos\",\n \"def assign(self):\\n\\n for s in self.spots:\\n if self.cells[s[:2]] == 0:\\n label = find_nearest_region(self.cells, *s[:2])\\n else:\\n label = self.cells[s[:2]]\\n\\n s.region = label\",\n \"def _assign_by_bfs(self, start, worker, initial_sizes, spread_limits,\\n keys_to_assign, assigned_record, graph=None):\\n if initial_sizes[worker] <= 0:\\n return\\n\\n graph = graph or self._graph\\n if self._assign_graph is None:\\n undigraph = self._assign_graph = graph.build_undirected()\\n else:\\n undigraph = self._assign_graph\\n\\n assigned = 0\\n spread_range = 0\\n for v in undigraph.bfs(start=start, visit_predicate='all'):\\n op_key = v.op.key\\n if op_key in assigned_record:\\n continue\\n spread_range += 1\\n if op_key not in keys_to_assign:\\n continue\\n assigned_record[op_key] = worker\\n assigned += 1\\n if spread_range >= spread_limits[worker] \\\\\\n or assigned >= initial_sizes[worker]:\\n break\\n initial_sizes[worker] -= assigned\",\n \"def starting_nodes(self):\\n return self.starting_nodes_ #abstract requires this exists!\",\n \"def prepare(self):\\n if self._ready_nodes is not None:\\n raise ValueError(\\\"cannot prepare() more than once\\\")\\n\\n self._ready_nodes = [\\n i.node for i in self._node2info.values() if i.npredecessors == 0\\n ]\\n # ready_nodes is set before we look for cycles on purpose:\\n # if the user wants to catch the CycleError, that's fine,\\n # they can continue using the instance to grab as many\\n # nodes as possible before cycles block more progress\\n cycle = self._find_cycle()\\n if cycle:\\n raise CycleError(f\\\"nodes are in a cycle\\\", cycle)\",\n \"def __init__(self, start_node):\\n self.start_node = start_node\",\n \"def to_start(self, node):\\n if node in self.graph:\\n if node in self.keep_index_backward:\\n for pred in self.keep_index_backward[node]:\\n self.to_start(pred)\\n\\n if node in self.graph:\\n self.start.append(node)\\n self.graph.remove_node(node)\\n\\n if node in self.keep_index_forward:\\n for succ in self.keep_index_forward[node]:\\n self.to_start(succ)\\n self.logger.debug('%s %s\\\\t(to_start: %s)', self.start, self.end, node)\",\n \"def start_new_graph(self):\\n self.nodes = {}\\n self.reset_graph()\",\n \"def relations_from(self, start_node):\",\n \"def _calc_worker_assign_limits(self, initial_count, occupied=None):\\n occupied = occupied or dict()\\n actual_count = initial_count - sum(occupied.values())\\n\\n endpoint_res = sorted(self._worker_slots.items(), key=operator.itemgetter(1),\\n reverse=True)\\n\\n endpoints = [t[0] for t in endpoint_res]\\n endpoint_cores = np.array([t[1] for t in endpoint_res]).astype(np.float32)\\n\\n # remove assigned nodes from limitations\\n counts = initial_count * endpoint_cores / endpoint_cores.sum()\\n for idx, ep in enumerate(endpoints):\\n counts[idx] = max(0, counts[idx] - occupied.get(ep, 0))\\n\\n # all assigned, nothing to do\\n if counts.sum() == 0:\\n return dict((ep, 0) for ep in endpoints)\\n\\n counts = (actual_count * counts / counts.sum()).astype(np.int32)\\n\\n # assign remaining nodes\\n pos = 0\\n rest = actual_count - counts.sum()\\n while rest > 0:\\n counts[pos] += 1\\n rest -= 1\\n pos = (pos + 1) % len(counts)\\n return dict(zip(endpoints, counts))\",\n \"def assign_initial_flow_acc(traps, start_nodes, rows, cols):\\n\\n nr_of_nodes = int(rows * cols)\\n # Get indices of the trap nodes that are starting indices\\n starting_trap_nodes = np.array(start_nodes[start_nodes >= nr_of_nodes])\\n\\n # Initialize accumulation flow array, and calculate the size of each trap\\n acc_flow = np.zeros(rows * cols + len(traps), dtype=int)\\n trap_sizes = np.asarray([len(t) for t in traps])\\n\\n one_or_trap_size = np.ones(len(acc_flow), dtype=int)\\n one_or_trap_size[nr_of_nodes:] = trap_sizes\\n\\n # Assign flow to the starting trap nodes, and the other starting nodes\\n acc_flow[starting_trap_nodes] = trap_sizes[starting_trap_nodes - nr_of_nodes]\\n acc_flow[np.setdiff1d(start_nodes, starting_trap_nodes)] = 1\\n\\n return acc_flow, one_or_trap_size\",\n \"def floodFill(nodes, start = None):\\n queue = deque()\\n if start is not None:\\n start.dist = 0.\\n queue.append(start)\\n\\n for i, node in nodes.items():\\n if node.dist == 0.:\\n queue.append(node)\\n\\n for node in shiftDeque(queue):\\n node.in_deque = False\\n for neigh in node.neighbors:\\n dist = neigh.dist + node.dist \\n \\n if neigh.node.dist > dist:\\n neigh.node.dist = dist\\n if not neigh.node.in_deque:\\n queue.append(neigh.node)\\n neigh.node.in_deque = True\",\n \"def on_start(self):\\n if not self.neighbors_vars:\\n # If we don't have any neighbor, simply select the best value\\n # for us and be done with it !\\n vals, cost = self._compute_best_value()\\n value = random.choice(vals)\\n self.value_selection(value, cost)\\n if self.logger.isEnabledFor(logging.INFO):\\n self.logger.info(\\n f\\\"No neighbors: stop immediately with value {value} - {cost}\\\"\\n )\\n self.finished()\\n\\n else:\\n # At start, we don't have any information to compute the cost,\\n # simply use None\\n if self.variable.initial_value is None:\\n self.value_selection(random.choice(self.variable.domain), None)\\n if self.logger.isEnabledFor(logging.INFO):\\n self.logger.info(\\n f\\\"Select random initial value {self.current_value} \\\"\\n )\\n\\n else:\\n self.value_selection(self.variable.initial_value, None)\\n if self.logger.isEnabledFor(logging.INFO):\\n self.logger.info(f\\\"Select initial value {self.current_value}\\\")\\n\\n self._send_value()\\n self._enter_state(\\\"value\\\")\",\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 find_reachable_nodes_from(self, start_node, **kwargs):\\r\\n\\t\\treturn BreadthFirstTraverser(start_node, **kwargs)\",\n \"def initialize_sets(self):\\n for block in self.blocks:\\n # Insert phi nodes from SSA stage into the assignments of the block\\n for phi in block.phis:\\n block.gen.setdefault(phi, []).insert(0, phi)\\n\\n # Update the kill set with the variables that are assigned to in\\n # the block\\n block.kill = set(block.gen)\\n block.output = set(block.gen)\\n #for entry in block.bound:\\n # block.i_kill |= self.assmts[entry].bit\\n\\n for assmts in self.assmts.itervalues():\\n self.entry_point.i_gen |= assmts.bit\\n self.entry_point.i_output = self.entry_point.i_gen\",\n \"def set_starting_pos(self):\\n if self.start and self.is_unoccupied(*self.start):\\n self.current_pos = self.start[:]\\n else:\\n self.set_random_pos('starting')\",\n \"def _step(self):\\n if self.best_unexplored_lower_bound < self.best_upper_bound:\\n\\n # Select a Node\\n self._active_node = self._pop_node_with_best_lower_bound()\\n\\n # Reporting\\n if self._reporting:\\n print(self.report)\\n\\n # Select a Vertex\\n unassigned_vertex_chosen = self._choose_unassigned_vertex_highest_degree()\\n\\n # Branch\\n self._active_node.construct_children_nodes(\\n unassigned_vertex_chosen,\\n self._terminals_by_vertex[unassigned_vertex_chosen],\\n )\\n\\n # NB: we do not need to worry about duplicate nodes\\n # the nodes are constructed by forcing an assignment of\\n # vertices to terminals. Thus, the resulting partitions\\n # can never be identical\\n self._unexplored_nodes += self._active_node.children\\n self._all_nodes += self._active_node.children\\n\\n else:\\n # if there are no unassigned vertices, we are at a leaf node\\n self._done = True\",\n \"def activate_nodes(graph, nodes, record_to=None):\\n for agent in nodes:\\n graph.nodes[agent][\\\"agent\\\"].activate()\\n if record_to is not None:\\n # |= is union + assignment\\n record_to |= set(nodes)\",\n \"def set_node_positions(self):\",\n \"def move_start_node(self, x, y):\",\n \"def starting_nodes(self):\\n # Level 0 nodes in a directed graph will have 1 or more out_edges but no in_edges\\n nodes_with_outs = set(e[0] for e in self.G2.out_edges())\\n nodes_with_ins = set(e[1] for e in self.G2.in_edges())\\n return nodes_with_outs - nodes_with_ins\",\n \"def nodes(self, nodes):\\n self.nodes_ = nodes\\n self.last_sequence_ind = int(self.nodes_.shape[0] - 1)\\n logging.debug(\\n \\\"Segment - Nodes {n_shape} set.\\\".format(n_shape=self.nodes_.shape)\\n )\",\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 _set_start(self, coordinates):\\n self._start = coordinates\",\n \"def set_start_pos(self, start_pos):\\n if self.is_pos_valid(start_pos):\\n self.start_pos = start_pos\\n self.set_curr_pos(start_pos)\\n self.curr_map = self.get_curr_visible_map(self.start_pos)\\n if self.dstar:\\n self.dstar_curr_map = self.get_curr_dstar_visible_map(\\n self.start_pos)\\n self.pos_history = [start_pos]\\n # update state map\\n self.state_map[0, 0] = self.get_state_map()\\n # self.state_map[0, 1] = self.curr_map\\n else:\\n print (\\\"[MESSAGE] WARNING: The position is not valid, nothing\\\"\\n \\\" changes. (by set_start_pos)\\\")\",\n \"def set_nodes(self, nodes_list):\\n try:\\n self.node_from = nodes_list[self.node_from_code]\\n self.node_from.add_line(self)\\n self.node_to = nodes_list[self.node_to_code]\\n self.node_to.add_line(self)\\n except AttributeError:\\n raise Exception('line %r has no node(s)!' % self)\",\n \"def starting_values(self, resids: NDArray) -> NDArray:\",\n \"def enable_start_new_path(self):\\n self.final_node_reached = False\",\n \"def set_neighbor(self):\\n for node in self.node:\\n for other in self.node:\\n if other.id != node.id and distance.euclidean(node.location, other.location) <= node.com_ran:\\n node.neighbor.append(other.id)\",\n \"def visit_nodes(self, node, initial):\\n #L.debug(\\\"visit_nodes %s %s\\\", node, initial)\\n mapping = dict(initial)\\n for visit_node in reversed(node.precedes()):\\n sources = tuple(mapping[s] for s in visit_node.sources)\\n mapping[visit_node] = self.visit_node(visit_node, sources)\\n return mapping[node]\",\n \"def start_region(self):\\n x = self.last_x\\n y = self.last_y\\n (region_id, start, end) = self.region_model.find_region(x)\\n if region_id is not None:\\n self.region_id = region_id\\n if (x-start) < (end-x):\\n self.region_edge = end\\n else:\\n self.region_edge = start\\n self.region_model.adjust_region(self.region_id, x, self.region_edge)\\n else:\\n self.region_edge = x\\n self.region_id = self.region_model.region_id\\n self.region_model.region_id += 1\",\n \"def A_Star(start, goal, final_occupancy_grid):\\n x, y = np.mgrid[0:45:1, 0:42:1]\\n pos = np.empty(x.shape + (2,))\\n pos[:, :, 0] = x;\\n pos[:, :, 1] = y\\n pos = np.reshape(pos, (x.shape[0] * x.shape[1], 2))\\n coords = list([(int(x[0]), int(x[1])) for x in pos])\\n\\n # Define the heuristic:\\n # h: dictionary containing the distance to goal ignoring obstacles for all coordinates in the grid (heuristic function)\\n h = np.linalg.norm(pos - goal, axis=1)\\n h = dict(zip(coords, h))\\n\\n # Check if the start and goal are within the boundaries of the map\\n for point in [start, goal]:\\n\\n if point[0] < 0 and point[0] >= final_occupancy_grid.shape[0]:\\n raise Exception('Start node/goal node is not contained in the map')\\n\\n if point[1] < 0 and point[1] >= final_occupancy_grid.shape[1]:\\n raise Exception('Start node/goal node is not contained in the map')\\n\\n # check if start and goal nodes correspond to free spaces\\n if final_occupancy_grid[start[0], start[1]]:\\n raise Exception('Start node is not traversable')\\n\\n if final_occupancy_grid[goal[0], goal[1]]:\\n raise Exception('Goal node is not traversable')\\n\\n # get the possible movements\\n movements = _get_movements_8n()\\n\\n # The set of visited nodes that need to be (re-)expanded, i.e. for which the neighbors need to be explored\\n # Initially, only the start node is known.\\n openSet = [start]\\n\\n # The set of visited nodes that no longer need to be expanded.\\n closedSet = []\\n\\n # For node n, cameFrom[n] is the node immediately preceding it on the cheapest path from start to n currently known.\\n cameFrom = dict()\\n\\n # For node n, gScore[n] is the cost of the cheapest path from start to n currently known.\\n gScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\\n gScore[start] = 0\\n\\n # For node n, fScore[n] := gScore[n] + h(n). map with default value of Infinity\\n fScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\\n fScore[start] = h[start]\\n\\n # while there are still elements to investigate\\n while openSet != []:\\n\\n # the node in openSet having the lowest fScore[] value\\n fScore_openSet = {key: val for (key, val) in fScore.items() if key in openSet}\\n current = min(fScore_openSet, key=fScore_openSet.get)\\n del fScore_openSet\\n\\n # If the goal is reached, reconstruct and return the obtained path\\n if current == goal:\\n return reconstruct_path(cameFrom, current)\\n\\n openSet.remove(current)\\n closedSet.append(current)\\n\\n # for each neighbor of current:\\n for dx, dy, deltacost in movements:\\n\\n neighbor = (current[0] + dx, current[1] + dy)\\n\\n # if the node is not in the map, skip\\n if (neighbor[0] >= final_occupancy_grid.shape[0]) or (neighbor[1] >= final_occupancy_grid.shape[1]) or (\\n neighbor[0] < 0) or (neighbor[1] < 0):\\n continue\\n\\n # if the node is occupied, skip\\n if (final_occupancy_grid[neighbor[0], neighbor[1]]):\\n continue\\n\\n # if the has already been visited, skip\\n if (neighbor in closedSet):\\n continue\\n # d(current,neighbor) is the weight of the edge from current to neighbor\\n # tentative_gScore is the distance from start to the neighbor through current\\n tentative_gScore = gScore[current] + deltacost\\n\\n if neighbor not in openSet:\\n openSet.append(neighbor)\\n\\n if tentative_gScore < gScore[neighbor]:\\n # This path to neighbor is better than any previous one. Record it!\\n cameFrom[neighbor] = current\\n gScore[neighbor] = tentative_gScore\\n fScore[neighbor] = gScore[neighbor] + h[neighbor]\\n\\n # Open set is empty but goal was never reached\\n print(\\\"No path found to goal\\\")\\n return []\",\n \"def __init__(self, start_edges=None):\\n self.adj_list = dict()\\n\\n # populate graph with initial vertices and edges (if provided)\\n # before using, implement add_vertex() and add_edge() methods\\n if start_edges is not None:\\n for u, v in start_edges:\\n self.add_edge(u, v)\",\n \"def connectNodes(imgR,nodes,start,goal):\\n alphabet = string.ascii_lowercase\\n nodeConnections = [[] for i in range(len(nodes)+2)]\\n for index, node in enumerate(nodes):\\n paths = adjPaths(imgR,node)\\n for path in paths:\\n result = checkPath(imgR,nodes,node,path)\\n if not result == 0: \\n nIndex = nodes.index(result)\\n nodeConnections[index+1].append(alphabet[nIndex+1])\\n paths = adjPaths(imgR,start) # add start to nodes\\n for path in paths:\\n result = checkPath(imgR,nodes,start,path)\\n if not result == 0: \\n nIndex = nodes.index(result)\\n nodeConnections[0].append(alphabet[nIndex+1])\\n for node in nodeConnections[0]:\\n nodeConnections[alphabet.index(node)].append(alphabet[0])\\n paths = adjPaths(imgR,goal) # add goal to nodes\\n for path in paths:\\n result = checkPath(imgR,nodes,goal,path)\\n if not result == 0: \\n nIndex = nodes.index(result)\\n nodeConnections[len(nodeConnections)-1].append(alphabet[nIndex+1])\\n for node in nodeConnections[len(nodeConnections)-1]:\\n nodeConnections[alphabet.index(node)].append(alphabet[len(nodeConnections)-1])\\n return [alphabet[i] for i in range(len(nodes)+2)], nodeConnections\",\n \"def AssignCpuRegOrMarkForSpilling(assign_to: List[ir.Reg],\\n cpu_reg_mask_first_choice: int,\\n cpu_reg_mask_second_choice: int):\\n # print (f\\\"@@ AssignCpuRegOrMarkForSpilling {len(assign_to)} {cpu_reg_mask_first_choice:x} {cpu_reg_mask_second_choice:x}\\\")\\n mask = cpu_reg_mask_first_choice\\n pos = 0\\n for reg in assign_to:\\n if mask == 0 and cpu_reg_mask_second_choice != 0:\\n mask = cpu_reg_mask_second_choice\\n cpu_reg_mask_second_choice = 0\\n pos = 0\\n if mask == 0:\\n reg.cpu_reg = ir.StackSlot()\\n continue\\n while ((1 << pos) & mask) == 0: pos += 1\\n assert reg.cpu_reg is None\\n reg.cpu_reg = _KIND_TO_CPU_REG_LIST[reg.kind][pos]\\n mask &= ~(1 << pos)\\n pos += 1\",\n \"def on_start(self):\\n\\n if not self._neighbors:\\n # If a variable has no neighbors, we must select its final value immediately\\n # as it will never receive any message.\\n value, cost = optimal_cost_value(self._variable, self._mode)\\n self.value_selection(value, cost)\\n\\n if self.logger.isEnabledFor(logging.INFO):\\n self.logger.info(\\n f\\\"Select initial value {self.current_value} \\\"\\n f\\\"based on cost function for var {self._variable.name}\\\"\\n )\\n self.finished()\\n\\n else:\\n # The variable has neighbors: select a value, which might change\\n # once we receive messages.\\n if self.variable.initial_value is None:\\n self.value_selection(random.choice(self.variable.domain), None)\\n if self.logger.isEnabledFor(logging.INFO):\\n self.logger.info(\\n f\\\"Select initial random value {self.current_value}\\\"\\n )\\n else:\\n self.value_selection(self.variable.initial_value, None)\\n if self.logger.isEnabledFor(logging.INFO):\\n self.logger.info(f\\\"Select initial value {self.current_value}\\\")\\n self._wait_for_values()\",\n \"def dfs_helper(self, start_node):\\n ret_list = [start_node.value]\\n\\n start_node.visited = True\\n for edge in start_node.edges:\\n if not edge.node_to.visited:\\n edge.node_to.visited = True\\n ret_list.extend(self.dfs_helper(edge.node_to))\\n\\n return ret_list\",\n \"def solve_csp(nodes, arcs, max_steps):\\n\\n nodes = list(nodes)\\n print 'nodes:', nodes\\n\\n node_values_dict = dict(zip(nodes, '2'*len(set(nodes))))\\n print 'initial random assignment', node_values_dict\\n indexes = np.arange(len(nodes))\\n\\n graph = {}\\n for arc in arcs:\\n if not arc[0] in graph:\\n graph[arc[0]] = []\\n if not arc[1] in graph:\\n graph[arc[1]] = []\\n graph[arc[0]].append(arc[1])\\n graph[arc[1]].append(arc[0])\\n for i in indexes:\\n if i in graph:\\n continue\\n else:\\n graph[i] = []\\n graph = dict(sorted(graph.items()))\\n print 'graph:', graph\\n\\n domain = [i for i in np.arange(1, 10, 1)]\\n print 'initial domain for each node:', domain\\n\\n superAdjacency ={}\\n for i in np.arange(len(nodes)):\\n superAdjacency[i] = []\\n superAdjacency[i].append(nodes[i])\\n superAdjacency[i].append(node_values_dict[nodes[i]])\\n superAdjacency[i].append(graph[i])\\n superAdjacency[i].append(domain)\\n\\n print 'superAdjacency', superAdjacency\\n\\n def getNodeType(superAdjacency, index):\\n return list(superAdjacency[index])[0]\\n\\n def getCurrentAssignment(superAdjacency, index):\\n return list(superAdjacency[index])[1]\\n\\n def getCurrentAssignmentForList(superAdjacency, indexList):\\n return [int(list(superAdjacency[index])[1]) for index in indexList]\\n\\n def getSolution(superAdjacency):\\n return [int(list(superAdjacency[index])[1]) for index in superAdjacency]\\n\\n def getNeighbours(superAdjacency, index):\\n return list(superAdjacency[index])[2]\\n\\n def getDomain(superAdjacency, index):\\n return list(superAdjacency[index])[3]\\n\\n def updateSuperAdjacency(superAdjacency, nodeType, newValue):\\n updateList =[]\\n for i in superAdjacency:\\n if str(getNodeType(superAdjacency, i)) == nodeType:\\n updateList.append(i)\\n for i in updateList:\\n superAdjacency[i][1] = newValue\\n\\n def isSolution():\\n return graphConstraints(superAdjacency)\\n\\n def graphConstraints(superAdjacency):\\n graphEval = []\\n\\n for index in superAdjacency:\\n neighbours = getNeighbours(superAdjacency, index)\\n nodeType = getNodeType(superAdjacency, index)\\n\\n if nodeType == 'T':\\n graphEval.append(int(str(eval(str(\\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]))\\n elif nodeType == 'C':\\n return 'NA'\\n elif nodeType == 'S':\\n graphEval.append(int(str(eval(str(\\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]))\\n elif nodeType == 'H':\\n graphEval.append(int(str(np.sum(\\n getCurrentAssignmentForList(superAdjacency, neighbours)))[0]))\\n if nodeType == 'P':\\n graphEval.append(int(str(np.sum(\\n getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]))\\n\\n currentAssignment = [item[1] for item in superAdjacency.values()]\\n difference = map(sub, currentAssignment, graphEval)\\n\\n if sum(difference) == 0:\\n return True\\n else:\\n return difference\\n\\n def findConflictVariable(superAdjacency, lastUpdateNode):\\n node_conflict_count = {}\\n for node in node_values_dict:\\n node_conflict_count[node] = 0\\n for index in superAdjacency:\\n neighbours = getNeighbours(superAdjacency, index)\\n nodeType = getNodeType(superAdjacency, index)\\n if nodeType == 'T':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != \\\\\\n int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n elif nodeType == 'S':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n elif nodeType == 'H':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n if nodeType == 'P':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n choices = [k for k, v in node_conflict_count.items() if v > 0]\\n if len(choices) > 0:\\n updateNode = random.choice(choices)\\n\\n if updateNode == lastUpdateNode:\\n choices.pop(choices.index(updateNode))\\n try:\\n lastUpdateNode = random.choice(choices)\\n return lastUpdateNode, lastUpdateNode\\n except:\\n return lastUpdateNode, lastUpdateNode\\n else:\\n lastUpdateNode = updateNode\\n return updateNode, lastUpdateNode\\n else:\\n return 'NA', 'NA'\\n\\n\\n\\n def valueForConflictedVariable(superAdjacency, var):\\n for index in superAdjacency:\\n nodeType = getNodeType(superAdjacency, index)\\n neighbours = getNeighbours(superAdjacency, index)\\n if not neighbours:\\n continue\\n elif str(nodeType) == str(var):\\n domain = getDomain(superAdjacency, index)\\n\\n choice = random.choice(domain)\\n if nodeType == 'T':\\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0])\\n elif nodeType == 'S':\\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0])\\n elif nodeType == 'H':\\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0])\\n if nodeType == 'P':\\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0])\\n\\n choice = int(choice)\\n if choice % 2 == 0:\\n return choice\\n else:\\n return choice\\n\\n def min_conflicts(nodes, arcs, max_steps):\\n lastUpdateNode = ''\\n for i in range(max_steps):\\n if isSolution() == True:\\n return\\n var, lastUpdateNode = findConflictVariable(superAdjacency, lastUpdateNode)\\n if var != 'NA':\\n value = valueForConflictedVariable(superAdjacency, var)\\n updateSuperAdjacency(superAdjacency, var, value)\\n node_values_dict[var] = value\\n else:\\n pass\\n\\n return\\n\\n min_conflicts(nodes, arcs, max_steps)\\n node_values = getSolution(superAdjacency)\\n return node_values\",\n \"def discover(self) -> int:\\n\\n # Get sensor data\\n no_wall_in_front = not self.is_wall_in_front()\\n no_wall_in_left = not self.is_wall_in_left()\\n no_wall_in_right = not self.is_wall_in_right()\\n\\n # get neighboring tiles\\n # Get current and neighboring points\\n this_point: tuple = self.stack[-1]\\n front_point = self.tile_in_the_direction(self.direction)\\n right_point = self.tile_in_the_direction((self.direction + 1) % 4)\\n left_point = self.tile_in_the_direction((self.direction - 1) % 4)\\n\\n # mark this point as discovered\\n self.visited.add(this_point)\\n\\n # Check if this is center tile\\n if self.is_ground_center():\\n self.center = this_point\\n\\n # Record all possible turns and add to the graph\\n if no_wall_in_front:\\n self.add_edge_between(front_point, this_point)\\n if no_wall_in_left:\\n self.add_edge_between(left_point, this_point)\\n if no_wall_in_right:\\n self.add_edge_between(right_point, this_point)\\n\\n # For each choice it can take\\n for choice in self.graph[this_point]:\\n # If choice was not discovered before, do it\\n if choice not in self.visited:\\n self.stack.append(choice)\\n break\\n else:\\n # No undiscovered nodes near robot (No choice to make)\\n # Start to backtrack\\n self.stack.pop()\\n if not self.stack:\\n # Came back to initial position\\n # Start second half\\n return SimulationRunStatus.RESUME_SIMULATION\\n choice = self.stack[-1]\\n\\n if choice == front_point:\\n self.go_forward()\\n elif choice == left_point:\\n self.go_to_left()\\n elif choice == right_point:\\n self.go_to_right()\\n else:\\n self.go_backward()\",\n \"def build_constellation(edges, start, visited):\\n num_points = edges.shape[0]\\n constellation = set()\\n nodes = [start]\\n while nodes:\\n point = nodes.pop()\\n visited.add(point)\\n\\n for other in range(num_points):\\n if edges[point, other] and other not in constellation:\\n constellation.add(other)\\n nodes.append(other)\\n\\n return constellation\",\n \"def assign_passengers(self):\\n\\n # Update the state of the parallel server after every assignment.\\n self.parallel_server.update_state()\\n\\n # While the assignment agent's queue is not empty and there is space\\n # to assign passengers in the parallel block...\\n while self.parallel_server.has_space_in_a_server_queue is True and \\\\\\n len(self.queue) > 0:\\n\\n # Pop the first passenger in line and assign to the shortest queue.\\n tmp = self.queue.popleft()\\n self.parallel_server.min_queue.queue.append(tmp)\\n\\n # Update the state of the parallel server after every assignment.\\n self.parallel_server.update_state()\",\n \"def update_intersections(self, start_node, end_node):\\n\\n # paths is a list that will contains a list of shortest paths (list of nodes)\\n try:\\n path = nx.shortest_path(self.map, start_node, end_node)\\n for node in range(len(path)-1):\\n start = path[node]\\n end = path[node+1]\\n self.map.nodes[start]['count'] += 1\\n self.map.nodes[end]['count'] += 1\\n self.map.edges[start, end, 0]['count'] += 1\\n except:\\n print(\\\"Cannot find path between, \\\", start_node, end_node)\\n \\n\\n # increment edge count for an edge denoted by path\",\n \"def _assign_reg_vals(self, sess):\\n with self.graph.as_default():\\n for nn in range(self.num_networks):\\n self.networks[nn].assign_reg_vals(sess)\",\n \"def shortest_path(self, from_node):\\n\\n\\t\\t# add the final nodes when algorithm goes past the target prediction time \\n\\t\\tif self.get_real_time(from_node.time) >= self.target:\\n\\t\\t\\tself.g.add_node(from_node, usage_cost=0, best_action=None, max_demand=self.starting_max_demand)\\n\\t\\t\\treturn\\n\\n\\t\\t#create the action set (0 is for do nothing, 1 is for cooling, 2 is for heating)\\n\\t\\taction_set = self.safety.safety_actions(from_node.temps)\\n\\t\\t\\n\\t\\t#iterate for each available action\\n\\t\\tfor action in action_set:\\n\\t\\t\\t\\n\\t\\t\\t# predict temperature and energy consumption of action\\n\\t\\t\\tnew_temperature = []\\n\\t\\t\\tconsumption = []\\n\\t\\t\\tfor i in range(self.noZones):\\n\\t\\t\\t\\tnew_temperature.append(self.th.next_temperature(from_node.temps[i], action[i], zone=i))\\n\\t\\t\\t\\tconsumption.append(self.energy.calc_cost(action[i], from_node.time/self.interval))\\n\\t\\t\\t\\t\\n\\t\\t\\tif self.safety.safety_check(new_temperature) and len(action_set) > 1:\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# create the node that describes the predicted data\\n\\t\\t\\tnew_node = Node(\\n\\t\\t\\t\\ttemps=new_temperature,\\n\\t\\t\\t\\ttime=from_node.time + self.interval\\n\\t\\t\\t)\\n\\n\\t\\t\\t# calculate interval costs\\n\\t\\t\\tdemand_balancer = (((self.target - self.get_real_time(from_node.time/self.interval)).total_seconds() / 60) / self.billing_period)\\n\\t\\t\\tinterval_usage_cost = sum(consumption) + self.interval_usage[int(from_node.time/self.interval)]\\n\\t\\t\\tinterval_demand = self.interval_demand[int(from_node.time/self.interval)]\\n\\n\\t\\t\\t#calculate interval discomfort\\n\\t\\t\\tdiscomfort = [0] * self.noZones\\n\\n\\t\\t\\tfor i in range(self.noZones):\\n\\t\\t\\t\\tdiscomfort[i] = self.disc.disc(new_temperature[i], self.occ.occ(from_node.time/self.interval), from_node.time)\\n\\n\\t\\t\\t# create node if the new node is not allready in graph\\n\\t\\t\\t# recursively run shortest path for the new node\\n\\t\\t\\tif new_node not in self.g:\\n\\t\\t\\t\\tself.g.add_node(new_node, usage_cost=np.inf, best_action=None, max_demand=np.inf)\\n\\t\\t\\t\\tself.shortest_path(new_node)\\n\\n\\t\\t\\t# calculate path costs\\n\\t\\t\\tthis_path_demand = max(self.g.node[new_node]['max_demand'], interval_demand)\\n\\t\\t\\tthis_path_demand_cost = demand_balancer * this_path_demand\\n\\n\\t\\t\\tinterval_overall_cost = ((1 - self.l) * (interval_usage_cost + this_path_demand_cost)) + (self.l * (sum(discomfort)))\\n\\n\\t\\t\\tthis_path_cost = self.g.node[new_node]['usage_cost'] + interval_overall_cost\\n\\n\\t\\t\\t# add the edge connecting this state to the previous\\n\\t\\t\\tself.g.add_edge(from_node, new_node, action=action)\\n\\n\\t\\t\\t# choose the shortest path\\n\\t\\t\\tif this_path_cost <= self.g.node[from_node]['usage_cost']:\\n\\t\\t\\t\\tif this_path_cost == self.g.node[from_node]['usage_cost'] and self.g.node[from_node]['best_action'] == '0':\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tself.g.add_node(from_node, best_action=new_node, usage_cost=this_path_cost, max_demand=this_path_demand)\",\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 startCoordination(self):\\n if not self.isGasBoiler():\\n\\n self.log_message('ID {0}: Start of Remainder Multicast Optimization'.format(self.CommID))\\n #select initial schedule\\n #print len(self.EFluctuationCurve)\\n self.selectBestSchedule(self.EFluctuationCurve)\\n\\n #calc remainder\\n remainder = [0 for i in range(len(self.EFluctuationCurve))]\\n for t in range(len(self.EFluctuationCurve)):\\n remainder[t] = self.EFluctuationCurve[t] + self.EConsumptionChosenSchedule[t]\\n #save initial global minimum\\n if self.OPTcriterion == 'maxmindiff':\\n criterion = max(remainder) - min(remainder)\\n elif self.OPTcriterion == 'absremainder':\\n criterion = 0\\n for a in range(len(remainder)):\\n criterion += abs(remainder[a])\\n #max_min_diff = max(remainder) - min(remainder)\\n self.origins.append(copy.deepcopy(self.CommID))\\n self.globalMin.append(copy.deepcopy(criterion)) #save minimum for origin self\\n self.globalMinSchedIdx.append(copy.deepcopy(self.chosenScheduleIndex))\\n self.pathLengths.append(1)\\n self.min_path.append(copy.deepcopy(self.CommID))\\n self.min_path_schedules.append(copy.deepcopy(self.chosenScheduleIndex))\\n\\n # send 'remainder' message to all neighbors\\n # 'remainder' message has the following structure\\n # ['remainder', origin, remainder_curve, path, path_schedules]\\n for n in range(len(self.Neighbors)):\\n data = ['remainder', copy.deepcopy(self.CommID), copy.deepcopy(remainder), copy.deepcopy([self.CommID]), copy.deepcopy([self.chosenScheduleIndex])]\\n self.sendMessage(self.Neighbors[n], 70, data)\\n else:\\n print 'ID {0}: ERROR! Unable to start Remainder Multicast Optimization, because I am a gas boiler BES!'.format(self.CommID)\\n\\n return\",\n \"def start_all_nodes(self):\\n for node in self.nodes:\\n node.start()\",\n \"def startup(self):\\n for v in self.virt_nodes:\\n v.create()\\n \\n \\\"\\\"\\\" scan for nodes \\\"\\\"\\\"\\n self.scan_for_nodes()\\n \\n \\\"\\\"\\\" connect to all nodes and call setup \\\"\\\"\\\"\\n for n in self.scan_nodes:\\n n.connect()\\n \\n ''' list of open addresses for the node '''\\n oalist = []\\n \\n ''' if the multicast interface is defined use it as open address '''\\n if self.mcast_interface != \\\"\\\":\\n oalist.append(self.mcast_interface)\\n \\n ''' open the connection to the default address of the slave '''\\n oalist.append(socket.gethostbyname(socket.gethostname()))\\n \\n ''' read the monitor node list '''\\n monitor_list = open(os.path.join(self.workdir, \\\"monitor-nodes.txt\\\"), \\\"r\\\")\\n for maddress in monitor_list.readlines():\\n oalist.append(maddress.strip())\\n \\n ''' call the setup procedure '''\\n n.setup(oalist)\",\n \"def node_assignment(edge_index: nb.int64[:,:],\\n edge_label: nb.int64[:],\\n n: nb.int64) -> nb.int64[:]:\\n # Loop over on edges, reset the group IDs of connected node\\n on_edges = edge_index[np.where(edge_label)[0]]\\n return union_find(on_edges, n)[0]\",\n \"def create_graph_network(start_node, connections):\\n graph = nx.Graph()\\n graph.add_node(start_node)\\n print(connections.index)\\n graph.add_nodes_from(connections.index)\\n edge_list = list(zip(itertools.repeat(start_node), connections.index))\\n print(\\\"edge list is \\\", edge_list)\\n graph.add_edges_from(edge_list)\\n for i in graph.edges():\\n graph[i[0]][i[1]]['weight'] = connections.loc[i[1]]['count']\\n # graph[i[0]][i[1]]['proposal_number'] = connections.loc[i[1]]['proposal_number']\\n # graph[i[0]][i[1]]['institution'] = connections.loc[i[1]]['institution']\\n # graph[i[0]][i[1]]['proposal_title'] = connections.loc[i[1]]['proposal_title']\\n # graph[i[0]][i[1]]['project_status'] = connections.loc[i[1]]['project_status']\\n\\n # Adding random position data to the graph.\\n # pos = nx.spring_layout(graph, k=1)\\n pos = nx.circular_layout(graph)\\n nx.set_node_attributes(graph, 'pos', pos)\\n return graph\",\n \"def __initilization(self,node_set):\\n \\n print \\\"*********************************\\\"\\n \\n for x in node_set:\\n x.node_vol=np.transpose(np.matrix([cmath.exp(0), cmath.exp(complex(0,math.pi*2/3)), cmath.exp(complex(0,-math.pi*2/3))]))\\n \\n print \\\"Forward/Backward Algorithm Initialization Done!\\\"\",\n \"def __init__(self,\\n start,\\n goal,\\n expand_dis=3.0,\\n goal_sample_rate=5,\\n ):\\n self.start = self.Node(start[0], start[1])\\n self.end = self.Node(goal[0], goal[1])\\n self.expand_dis = expand_dis\\n self.goal_sample_rate = goal_sample_rate\\n \\n self.stepLength = 50\\n self.path_resolution = 1\\n self.obstaclelist = []\\n self.node_list = []\",\n \"def markIsland(self, start_position, grid):\\n queue = Queue()\\n queue.put(start_position)\\n\\n y, x = start_position\\n self.visited[y][x] = 1 # visited\\n\\n while not queue.empty():\\n print(queue.queue)\\n # iterate the nodes which are already in the queue\\n for _ in range(queue.qsize()):\\n y, x = queue.get()\\n for x_dir, y_dir in toSearch:\\n new_x = x + x_dir\\n new_y = y + y_dir\\n\\n # make sure the pixel to search is in the range of the grid\\n if 0 <= new_x < self.width and 0 <= new_y < self.length:\\n if self.visited[new_y][new_x] == 0:\\n if grid[new_y][new_x] == '1':\\n queue.put((new_y, new_x))\\n self.visited[new_y][new_x] = 1\",\n \"def __init__(self, nodes: Set[Node], edges: Set[Edge]):\\n super().__init__()\\n self.nodes = nodes\\n for edge in edges:\\n self.add_edge(edge)\\n self.leaves = {node for node in self.nodes if self.degree_out(node) == 0}\\n root_nodes = self.nodes - self.leaves\\n root_edges = {edge for edge in self.edges if edge.node_to not in self.leaves}\\n self.root_graph = Mask(root_nodes, root_edges, self)\",\n \"def mappossiblemoves(self,nodeStart):\\n destinations = [set() for ix in range(game.DICEMAX+1)]\\n destinations[0] = set([nodeStart])\\n routes = [[nodeStart]]\\n #\\n # TODO: Not convinced this adds anything more than it harms in this fn.\\n #if self.hasEnteredRoomYet:\\n # GAMEBOARD = game.TRIMMEDNODES\\n #else:\\n GAMEBOARD = game.BOARDNODES\\n #\\n for diceRoll in range(1,game.DICEMAX+1):\\n newRoutes = []\\n for route in routes:\\n for nextLoc in GAMEBOARD[route[-1]]:\\n if not nextLoc in route:\\n # This location has not yet been visited by this route\\n if nextLoc in game.ALLOWEDROOMNODES:\\n # Location is a room - can move into it regardless\\n # of population, but not move further. We can also\\n # use any longer roll to move here by this route\\n for thisRoll in range(diceRoll,game.DICEMAX+1):\\n destinations[thisRoll].add(nextLoc)\\n else:\\n # Location is a square - can only move into it if\\n # unoccupied, but can move further once there.\\n if not nextLoc in self.charLocations:\\n # Unoccupied (could check against \\n # charLocations[1:] since we're the piece moving\\n # but a nextLoc = charLocations[0] would be\\n # rejected by being already in the route anyway)\\n newRoute = list(route)\\n newRoute.append(nextLoc)\\n newRoutes.append(newRoute)\\n destinations[diceRoll].add(nextLoc)\\n routes = newRoutes\\n #\\n return [list(destSet) for destSet in destinations]\",\n \"def __init__(self):\\n self.start = Node('-1')\",\n \"def choose_cell_to_assign(self):\\r\\n min_domain = 10\\r\\n max_degree = -1\\r\\n chosen_row = None\\r\\n chosen_col = None\\r\\n for row in range(9):\\r\\n for col in range(9):\\r\\n if self.puzzle[row][col] == 0:\\r\\n domain_size = len(self.grid[row][col].domain)\\r\\n if domain_size < min_domain:\\r\\n min_domain = domain_size\\r\\n chosen_row = row\\r\\n chosen_col = col\\r\\n elif domain_size == min_domain:\\r\\n degree = len(self.grid[row][col].neighbors)\\r\\n if degree > max_degree:\\r\\n max_degree = degree\\r\\n chosen_row = row\\r\\n chosen_col = col\\r\\n return self.grid[chosen_row][chosen_col]\",\n \"def a_star(self, start_xy, end_xy):\\n start_node = Node(start_xy, end_xy, self.graph_start_xy)\\n start_node.shortest_dist = 0\\n start_node.update_total_cost()\\n pq = []\\n pq.append(start_node)\\n heapify(pq)\\n stack = []\\n while pq:\\n current_node = heappop(pq)\\n if (current_node.coord_xy == end_xy).all():\\n print(\\\"it's done \\\")\\n iterator = current_node\\n while iterator:\\n stack.append(iterator.coord_xy)\\n iterator = iterator.prev_node\\n break\\n\\n for neighbour, dist in current_node.connections:\\n neighbouring_node = Node(neighbour, end_xy, self.graph_start_xy)\\n if current_node.shortest_dist + dist < neighbouring_node.shortest_dist:\\n neighbouring_node.shortest_dist = current_node.shortest_dist + dist\\n neighbouring_node.update_total_cost()\\n neighbouring_node.prev_node = current_node\\n heappush(pq, neighbouring_node)\\n return stack\",\n \"def get_subgraph_between_nodes(self, start, end):\\n nodes = set()\\n nodes.add(start)\\n\\n to_visit = set()\\n to_visit.add(start)\\n\\n while len(to_visit) > 0:\\n current_visit = copy.copy(to_visit)\\n for tv in current_visit:\\n to_visit.remove(tv)\\n if tv is not end:\\n for s in self.successors(tv):\\n to_visit.add(s)\\n nodes.add(s)\\n\\n nodes.add(end)\\n\\n return self.subgraph(nodes)\",\n \"def buildNodesDict(self):\\n # Get relevant nodes from TANA ca_jc, intersect with BUS_ROUTE_TRAVERSAL_EDGES.\\n # Then get the X,Y for the features.\\n arcpy.env.workspace = PublicTransit.WORKING_GDB\\n arcpy.AddXY_management(PublicTransit.RELEVANT_NODES)\\n nodes = arcpy.SearchCursor(PublicTransit.RELEVANT_NODES, \\\"\\\", \\\"\\\",\\n \\\"ID_hash; POINT_X; POINT_Y\\\", \\\"\\\")\\n self.nodesDict = dict()\\n numNodes = int(arcpy.GetCount_management(PublicTransit.RELEVANT_NODES).getOutput(0))\\n print \\\"Found %d nodes\\\" % numNodes\\n for node in nodes:\\n self.nodesDict[node.ID_hash] = Node(node.ID_hash, node.POINT_X, node.POINT_Y)\\n del node\\n del nodes\",\n \"def assign_nodes_to_edges(nodes, edges):\\n\\n from scipy.spatial import cKDTree\\n \\n edges_arr = np.vstack(edges)\\n kdt_nodes = cKDTree(nodes)\\n\\n # closest node id and discard computed distances ('_,')\\n _, pairs = kdt_nodes.query(x=edges_arr, k=1)\\n # refactor list of successive ids for start and end of edges into 2D array\\n pairs = np.vstack((pairs[::2], pairs[1::2])).T\\n\\n new_edges = []\\n for pair in pairs[:,:]:\\n new_edges.append(np.array(nodes[pair]))\\n \\n return new_edges, pairs\",\n \"def generate_nodes(self):\\n \\n # For all state nodes\\n node = 0\\n \\n for i in range(self.x0_n):\\n for j in range(self.x1_n):\\n for k in range(self.x2_n):\\n \\n # State\\n x = np.array([ self.xd[0][i] , self.xd[1][j] , self.xd[2][k] ])\\n \\n # State and grid index based on node #\\n self.nodes_state[node,:] = x\\n self.nodes_index[node,:] = np.array([i,j,k])\\n \\n # Node # based on index ijk\\n self.x_grid2node[i,j,k] = node\\n \\n # Increment node number\\n node = node + 1\",\n \"def a_star_planning(start_x, start_y, goal_x, goal_y, id):\\n # extract the index of start node, goal node and obstacles\\n start = Point(round(start_x/grid_size), round(start_y/grid_size), 0.0, -1, [0,0,0])\\n goal = Point(round(goal_x/grid_size), round(goal_y/grid_size), 0.0, -1, [0,0,0])\\n if not_legal(goal, id):\\n print ('not a legal goal')\\n return False\\n \\n # time.sleep(10)\\n\\n # create the open list and close list to store nodes\\n openset, closeset = deque(), deque()\\n openset.append(start)\\n\\n while True:\\n # find out the min f node to explore\\n\\n current_node = min(openset,\\n key=lambda node: node.g + calculate_heuristic(node,goal))\\n\\n # pltplt.plot(current_node.x, current_node.y, \\\"b*\\\")\\n if len(closeset) % 10 == 0:\\n plt.pause(0.001)\\n\\n if current_node.x == goal.x and current_node.y == goal.y:\\n print(\\\"Congratulations! You have found the goal!\\\")\\n goal.parent = current_node\\n break\\n\\n # Remove it from the open list\\n openset.remove(current_node)\\n # Add it to the close list\\n closeset.append(current_node)\\n\\n # Explore the neighbour\\n for motion in motions:\\n if motion == current_node.parent_motion:\\n turn_cost = 0\\n elif (motion[0] == -1 * current_node.parent_motion[0]) and (motion[1] == -1 * current_node.parent_motion[1]):\\n turn_cost = 1.5\\n else:\\n turn_cost = 1\\n\\n node = Point(current_node.x + motion[0],\\n current_node.y + motion[1],\\n current_node.g + motion[2] + turn_cost,\\n current_node,\\n motion,\\n )\\n\\n # ignore it if it is in the close list\\n flag = False\\n for item in closeset:\\n if item.x == node.x and item.y == node.y:\\n flag = True\\n break\\n if flag:\\n continue\\n # ignore it if it is obstacle\\n\\n if not_legal(node, id):\\n continue\\n # update its parent if it is the open list\\n flag = True\\n for item in openset:\\n if item.x == node.x and item.y == node.y:\\n flag = False\\n # if closer, update the parent\\n if node.g <= item.g:\\n item.g = node.g\\n item.parent = node.parent\\n item.parent_motion = node.parent_motion\\n break\\n # add to the open list if it is not in the open list\\n if flag:\\n openset.append(node)\\n\\n # generate the final path\\n while True:\\n route = deque()\\n route.append(goal)\\n plt.plot(goal.x, goal.y, \\\"rx\\\")\\n if goal.parent == -1:\\n break\\n else:\\n goal = goal.parent\\n route.appendleft(goal)\\n # return route\\n # return False\\n if NEED_DRAW:\\n # draw map\\n for i in range(map.gridwidth):\\n for j in range(map.gridheight):\\n if map.grid[1,i,j] >0:\\n plt.plot(i, j, \\\"xc\\\")\\n\\n plt.plot(start.x, start.y, \\\"ro\\\")\\n plt.plot(goal.x, goal.y, \\\"go\\\")\\n\\n for goal in route:\\n plt.plot(goal.x, goal.y, \\\"rx\\\")\\n plt.show()\",\n \"def relabel_nodes(graph: BaseGraph, mapping: Dict) -> None:\\n relabel_nodes(graph.graph, mapping, copy=False)\",\n \"def neighbor(self, start):\\n x = start[0] + random.uniform(-20, 20)\\n y = start[1] + random.uniform(-20, 20)\\n x = max(min(x, xbounds[1]), xbounds[0])\\n y = max(min(y, ybounds[1]), ybounds[0])\\n return [x,y]\",\n \"def a_star(self, start, final):\\n self.speed_setting_season()\\n cost_so_far = {}\\n frontier = PriorityQueue()\\n parents = {}\\n frontier.put(start, 0)\\n cost_so_far[start] = 0\\n f_value = {}\\n f_value[start] = self.grid.heuristic(start[0], start[1], final[0], final[1])\\n final_path_list = []\\n while not frontier.empty():\\n actual_node = frontier.get()\\n final_path_list = []\\n if actual_node == final:\\n curr = final\\n while curr != start:\\n final_path_list.insert(0, curr)\\n curr = parents[curr]\\n final_path_list.insert(0, start)\\n break\\n potential_neighbors = self.grid.neighbors(int(actual_node[0]), int(actual_node[1]))\\n for neighbor in potential_neighbors:\\n g_value = cost_so_far[actual_node] + self.grid.cost_g(actual_node[0], actual_node[1],\\n neighbor[0],\\n neighbor[1])\\n h_value = self.grid.heuristic(neighbor[0], neighbor[1], final[0], final[1])\\n if neighbor not in cost_so_far or g_value + h_value < f_value[neighbor]:\\n cost_so_far[neighbor] = g_value\\n f_value[neighbor] = g_value + h_value\\n frontier.put(neighbor, g_value + h_value)\\n parents[neighbor] = actual_node\\n print(\\\"found path from: \\\" + str(start) + \\\" to: \\\" + str(final))\\n return final_path_list\",\n \"def make_complete_graph (num_nodes) :\\n graph = dict ()\\n if (num_nodes < 1) :\\n return graph\\n\\n for node_ind in range (num_nodes) :\\n # create a set containing nodes adjacent to node node_ind\\n # node node_ind of the complete graph will have edges to all other nodes except itself\\n adj_nodes = range (num_nodes) # list containing numbers from 0 - num_nodes-1\\n adj_nodes.remove(node_ind)\\n graph[node_ind] = set(adj_nodes)\\n\\n return graph\",\n \"def set_start_coords(self, x:int, y:int) -> None:\\r\\n self.start_x = x\\r\\n self.start_y = y\",\n \"def watchdog_patrol_restart(self, nodes, percentage, alpha=0, rand=random.Random(), start=None):\\n\\n G = self\\n if start:\\n path = [start]\\n else:\\n path = [rand.choices(nodes)]\\n\\n while len(path) < 1 or random.random() > percentage:\\n cur = path [-1]\\n if len(G[cur]) > 0:\\n if rand.random() >= alpha:\\n add_node = rand.choice(G[cur])\\n while add_node == cur:\\n add_node = rand.choice(G[cur])\\n path.append(add_node)\\n else:\\n path.append(path[0])\\n else:\\n break\\n return path\\n\\n #neighbors = []\\n # for n in G[cur]\\n # neighbors.extend(G[n])\\n #if len(G[cur]) > 0:\\n # add decision maker node\",\n \"def A_Star(start, goal, final_occupancy_grid):\\n x, y = np.mgrid[0:LENGTH:1, 0:WIDTH:1]\\n pos = np.empty(x.shape + (2,))\\n # x.shape = (LENGTH,WIDTH)\\n # x.shape + (2,) = (LENGTH,WIDTH,2)\\n pos[:, :, 0] = x\\n pos[:, :, 1] = y\\n # pos.shape = (1890, 2)\\n pos = np.reshape(pos, (x.shape[0] * x.shape[1], 2))\\n coords = list([(int(x[0]), int(x[1])) for x in pos])\\n # Define the heuristic:\\n # h: dictionary containing the distance to goal ignoring obstacles for all coordinates in the grid (heuristic function)\\n h = np.linalg.norm(pos - goal, axis=1)\\n # If axis is an integer, it specifies the axis of x along which to compute the vector norms\\n # axis = 1: h.shape = 1890\\n # axis = 0: h.shape = 2\\n h = dict(zip(coords, h))\\n\\n # Check if the start and goal are within the boundaries of the map\\n for point in [start, goal]:\\n\\n if point[0] < 0 and point[0] >= final_occupancy_grid.shape[0]:\\n raise Exception('Start node/goal node is not contained in the map')\\n\\n if point[1] < 0 and point[1] >= final_occupancy_grid.shape[1]:\\n raise Exception('Start node/goal node is not contained in the map')\\n\\n # check if start and goal nodes correspond to free spaces\\n if final_occupancy_grid[start[0], start[1]]:\\n raise Exception('Start node is not traversable')\\n\\n if final_occupancy_grid[goal[0], goal[1]]:\\n raise Exception('Goal node is not traversable')\\n\\n # get the possible movements\\n movements = get_movements_8n()\\n\\n # The set of visited nodes that need to be (re-)expanded, i.e. for which the neighbors need to be explored\\n # Initially, only the start node is known.\\n openSet = [start]\\n\\n # The set of visited nodes that no longer need to be expanded.\\n closedSet = []\\n\\n # For node n, cameFrom[n] is the node immediately preceding it on the cheapest path from start to n currently known.\\n cameFrom = dict()\\n\\n # For node n, gScore[n] is the cost of the cheapest path from start to n currently known.\\n gScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\\n gScore[start] = 0\\n\\n # For node n, fScore[n] := gScore[n] + h(n). map with default value of Infinity\\n fScore = dict(zip(coords, [np.inf for x in range(len(coords))]))\\n fScore[start] = h[start]\\n\\n # while there are still elements to investigate\\n while openSet != []:\\n\\n # the node in openSet having the lowest fScore[] value\\n fScore_openSet = {key: val for (key, val) in fScore.items() if key in openSet}\\n current = min(fScore_openSet, key=fScore_openSet.get)\\n del fScore_openSet\\n\\n # If the goal is reached, reconstruct and return the obtained path\\n if current == goal:\\n # print(\\\"Path\\\", closedSet)\\n return reconstruct_path(cameFrom, current)\\n\\n openSet.remove(current)\\n closedSet.append(current)\\n\\n # for each neighbor of current:\\n for dx, dy, deltacost in movements:\\n\\n neighbor = (current[0] + dx, current[1] + dy)\\n\\n # if the node is not in the map, skip\\n if (neighbor[0] >= final_occupancy_grid.shape[0]) or (neighbor[1] >= final_occupancy_grid.shape[1]) or (\\n neighbor[0] < 0) or (neighbor[1] < 0):\\n continue\\n\\n # if the node is occupied, skip\\n if (final_occupancy_grid[neighbor[0], neighbor[1]]):\\n continue\\n\\n # if the has already been visited, skip\\n if (neighbor in closedSet):\\n continue\\n # d(current,neighbor) is the weight of the edge from current to neighbor\\n # tentative_gScore is the distance from start to the neighbor through current\\n tentative_gScore = gScore[current] + deltacost\\n\\n if neighbor not in openSet:\\n openSet.append(neighbor)\\n\\n if tentative_gScore < gScore[neighbor]:\\n # This path to neighbor is better than any previous one. Record it!\\n cameFrom[neighbor] = current\\n gScore[neighbor] = tentative_gScore\\n fScore[neighbor] = gScore[neighbor] + h[neighbor]\\n\\n # Open set is empty but goal was never reached\\n print(\\\"No path found to goal\\\")\\n return [], closedSet\",\n \"def reset_initial_values(self):\\n #### TODO: move reset conditions to /sim\\n self.sim_time = 0.0\\n self._prev_sim_time = None\\n\\n for name, node in self.nodes(Junction):\\n node._head = None\\n node._demand = None\\n node._pressure = None\\n node._leak_demand = None\\n node._leak_status = False\\n node._is_isolated = False\\n\\n for name, node in self.nodes(Tank):\\n node._head = node.init_level+node.elevation\\n node._prev_head = node.head\\n node._demand = None\\n node._leak_demand = None\\n node._leak_status = False\\n node._is_isolated = False\\n\\n for name, node in self.nodes(Reservoir):\\n node._head = None # node.head_timeseries.base_value\\n node._demand = None\\n node._leak_demand = None\\n node._is_isolated = False\\n\\n for name, link in self.links(Pipe):\\n link._user_status = link.initial_status\\n link._setting = link.initial_setting\\n link._internal_status = LinkStatus.Active\\n link._is_isolated = False\\n link._flow = None\\n link._prev_setting = None\\n\\n for name, link in self.links(Pump):\\n link._user_status = link.initial_status\\n link._setting = link.initial_setting\\n link._internal_status = LinkStatus.Active\\n link._is_isolated = False\\n link._flow = None\\n if isinstance(link, PowerPump):\\n link.power = link._base_power\\n link._prev_setting = None\\n\\n for name, link in self.links(Valve):\\n link._user_status = link.initial_status\\n link._setting = link.initial_setting\\n link._internal_status = LinkStatus.Active\\n link._is_isolated = False\\n link._flow = None\\n link._prev_setting = None\\n\\n for name, control in self.controls():\\n control._reset()\",\n \"def _update_nodes_ids(self, change=None):\\n self._nodes_filter.val_range = self.nodes_range\\n self.nodes_ids = self._nodes_filter.val_ids\\n self._update_edges_filtered(change)\",\n \"def initialize(self):\\n self.currState = self.startState\",\n \"def dfs(g: nx.Graph, start_node: Any) -> str:\\n\\n way = []\\n stack = [start_node]\\n y = {node: [] for node in g.nodes}\\n while stack:\\n elem = stack.pop()\\n way.append(elem)\\n for node in list(g.neighbors(elem)):\\n if node not in way:\\n stack.append(node)\\n y[node].extend((*y[elem], elem))\\n print(y)\\n return \\\"\\\".join(way)\",\n \"def reset_graph(self):\\n self.nodes = {}\\n self.add_node(self.initial_state)\\n self.add_node(self.final_state)\",\n \"def connect(self, node1, node2):\\n self.neighbour1 = node1\\n self.neighbour2 = node2\",\n \"def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n\\n loc_map = {}\\n drop_off_dict = {}\\n num_home_visited = 0\\n\\n \\\"\\\"\\\"\\n for i in range(len(list_of_locations)):\\n loc_map[i] = list_of_locations[0]\\n \\\"\\\"\\\"\\n\\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\\n start = list_of_locations.index(starting_car_location)\\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\\n num_homes = len(list_of_homes)\\n\\n car_path = []\\n all_paths = dict(nx.all_pairs_dijkstra(graph))\\n visited = set()\\n\\n #print(start)\\n car_path.append(start)\\n current_node = start\\n\\n if start in home_indexes:\\n visited.add(start)\\n drop_off_dict[start] = [start]\\n num_home_visited += 1\\n\\n while num_home_visited < num_homes:\\n dist_dict = all_paths.get(current_node)[0]\\n paths_dict = all_paths.get(current_node)[1]\\n\\n dist_dict = {k:v for (k,v) in dist_dict.items() if k not in visited and k in home_indexes}\\n min_dist = min(dist_dict.values())\\n min_list = [k for k in dist_dict.keys() if dist_dict[k] <= min_dist]\\n #print(dist_dict.values())\\n target = min_list[0]\\n drop_off_dict[target] = [target]\\n #print(target+1)\\n #print(target)\\n car_path.pop()\\n car_path.extend(paths_dict[target])\\n\\n visited.add(target)\\n current_node = target\\n num_home_visited += 1\\n\\n paths_dict = all_paths.get(current_node)[1]\\n car_path.pop()\\n car_path.extend(paths_dict[start])\\n #print((drop_off_dict.keys()))\\n #car_path = [start, ...., start]\\n #drop_off_dict = {drop_off_loc: [home1, home2, ...] }\\n\\n return car_path, drop_off_dict\",\n \"def setup_nodes(server_node, road_node, road_segment_point):\\n\\n # Create working server node data subset excluding unneeded fields\\n snode = [{'id': i,\\n 'shapeid': item['shapeid'],\\n 'x': float(item['x']),\\n 'y': float(item['y']),\\n 'nearest_pt': None,\\n 'nearest_pt_sl_dist': float(\\\"inf\\\"),\\n 'color_num': (int(item['shapeid']) + CM_OFFSET) % NUM_COLORS}\\n for i, item in enumerate(server_node)]\\n\\n # Create working road node data subset excluding unneeded fields\\n # (note: road nodes consist of junctions and road ends)\\n rnode = []\\n prev_coord = []\\n for i, item in enumerate(road_node):\\n if [item['x'], item['y']] not in prev_coord: # exclude duplicates\\n rnode.append({'id': i,\\n 'shapeid': item['shapeid'],\\n 'x': float(item['x']),\\n 'y': float(item['y']),\\n 'best_server': None,\\n 'color_num': GREY})\\n prev_coord.append([item['x'], item['y']])\\n\\n # Create working road point data subset excluding unneeded fields\\n rpoint = []\\n point = 0\\n for i in range(len(road_segment_point)):\\n id = road_segment_point[i]['shapeid']\\n rpoint.append({'id': i,\\n 'shapeid': id,\\n 'point': point,\\n 'x': float(road_segment_point[i]['x']),\\n 'y': float(road_segment_point[i]['y']),\\n 'lowest_cost': float(\\\"inf\\\"),\\n 'best_server': None,\\n 'color_num': GREY})\\n if i < len(road_segment_point) - 1:\\n id_next = road_segment_point[i + 1]['shapeid']\\n if id == id_next:\\n point += 1\\n else:\\n point = 0\\n\\n # Convert adjacent road segment endpoints to lines (x1, y1) to (x2, y2)\\n rseg = []\\n line = 0\\n seg = 0\\n for i in range(len(rpoint[:-1])):\\n id = rpoint[i]['shapeid']\\n id_next = rpoint[i + 1]['shapeid']\\n if id == id_next:\\n rseg.append({'id': line,\\n 'shapeid': id,\\n 'segment': seg,\\n 'point1': rpoint[i]['id'],\\n 'x1': float(rpoint[i]['x']),\\n 'y1': float(rpoint[i]['y']),\\n 'point2': rpoint[i + 1]['id'],\\n 'x2': float(rpoint[i + 1]['x']),\\n 'y2': float(rpoint[i + 1]['y']),\\n 'best_server': None,\\n 'color_num': GREY})\\n line += 1\\n seg += 1\\n else:\\n seg = 0\\n\\n return snode, rnode, rpoint, rseg\",\n \"def generate_nodes(self):\\n \\n # For all state nodes\\n node = 0\\n \\n for i in range(self.x0_n):\\n for j in range(self.x1_n):\\n \\n # State\\n x = np.array([ self.xd[0][i] , self.xd[1][j] ])\\n \\n # State and grid index based on node #\\n self.nodes_state[node,:] = x\\n self.nodes_index[node,:] = np.array([i,j])\\n \\n # Node # based on index ij\\n self.x_grid2node[i,j] = node\\n\\n # Increment node number\\n node = node + 1\",\n \"def start_one_step(self):\\r\\n new_infected_list = []\\r\\n old_infected_list = copy.deepcopy(self.infected_list)\\r\\n new_recovered_list = []\\r\\n old_recovered_list = copy.deepcopy(self.recovered_list)\\r\\n # For each infected node\\r\\n for infected_nid in old_infected_list:\\r\\n infected_node = self.node_dict[infected_nid]\\r\\n # For each neighbor\\r\\n for dst_nid in infected_node.get_dst_nid_list(self.graph):\\r\\n dst_node = self.node_dict[dst_nid]\\r\\n # Infect susceptible nodes with probability [p]\\r\\n if dst_node.state is NodeState.SUSCEPTIBLE and random.random() < self.p:\\r\\n dst_node.infected(self.i)\\r\\n new_infected_list.append(dst_nid)\\r\\n\\r\\n # Minus 1 turn of (remaining) infected days for all infected nodes\\r\\n infected_node.minus_one_state_day()\\r\\n # If infected node is recovered\\r\\n if infected_node.check_finish_infection():\\r\\n # Infected node get recovered\\r\\n infected_node.recovered(self.r)\\r\\n # Remove from infected list\\r\\n self.infected_list.remove(infected_nid)\\r\\n # Append to recovered list\\r\\n new_recovered_list.append(infected_nid)\\r\\n\\r\\n # Add newly infected nodes into infected list\\r\\n self.infected_list += new_infected_list\\r\\n\\r\\n # For each recovered node\\r\\n for recovered_nid in old_recovered_list:\\r\\n recovered_node = self.node_dict[recovered_nid]\\r\\n # Minus 1 turn of (remaining) recovered days for all recovered nodes\\r\\n recovered_node.minus_one_state_day()\\r\\n # If infected node is recovered\\r\\n if recovered_node.check_finish_recovery():\\r\\n # Recovered node get recovered\\r\\n recovered_node.susceptible()\\r\\n # Remove from recovered list\\r\\n self.recovered_list.remove(recovered_nid)\\r\\n\\r\\n # Add newly recovered nodes into recovered list\\r\\n self.recovered_list += new_recovered_list\",\n \"def __init__(self, initial_node):\\n self.__nodes = MinPriorityQueue({initial_node : initial_node.estimate})\",\n \"def __init__(self, node_number, all_nodes):\\n self.self_host = 'localhost'\\n self.base_port = 5000\\n self.self_port = self.base_port + node_number\\n self.other_nodes = [(self.self_host, p)\\n for p in range(self.base_port + 1, self.base_port + all_nodes + 1)\\n if p != self.self_port]\\n self.other_nodes_len = all_nodes - 1\\n self.current_node = 0\",\n \"def init(self):\\n self.padre = self.id\\n self.sinVisitar = [] \\n self.visited = False\\n print (\\\"inicializo algoritmo\\\")\\n for i in range (len(self.neighbors)): #De esta forma se pueden manipular las listas por aparte\\n self.sinVisitar.append(self.neighbors[i])\",\n \"def initnodes(self):\\n newnodes = self.config[\\\"nodes\\\"]\\n newpynodes = self.config[\\\"pynodes\\\"]\\n logging.info('Loading initial nodes: {}'.format(newnodes))\\n logging.info('Loading initial python nodes: {}'.format(newpynodes))\\n for node in newnodes:\\n self.runnode(node)\\n for node in newpynodes:\\n self.runnode(node, True)\",\n \"def start(self, wait=False):\\n start_nodes = self._get_start_nodes()\\n\\n for node in start_nodes:\\n if not node.init_generator:\\n self.queue.put((node, (), {}))\\n else:\\n node_copy = copy.deepcopy(node)\\n node_copy.init_generator = None\\n for args, kwargs in node.init_generator:\\n print(args, kwargs)\\n self.queue.put((node_copy, args, kwargs))\\n\\n if wait:\\n self.wait_for_completion()\",\n \"def dijkstras(occupancy_map,x_spacing,y_spacing,start,goal):\\n ROWS, COLS = occupancy_map.shape\\n #convert physical location to index in the grid\\n startNode = locToIndex(start, x_spacing, y_spacing)\\n startingNodeLoc = indexToLoc(startNode, x_spacing, y_spacing)\\n initialcost = math.sqrt((startingNodeLoc[0] - start[0])**2 + (startingNodeLoc[1] - start[1])**2)\\n goalNode = locToIndex(goal, x_spacing, y_spacing)\\n \\n freelist = np.where(occupancy_map == 0)\\n if occupancy_map[startNode[0], startNode[1]] != 0:\\n #raise ValueError(\\\"start : ({}, {}) invalid, is an obstacle\\\".format(startNode[0], startNode[1]))\\n startNode = findValidNode(startNode, start, occupancy_map, x_spacing, y_spacing)\\n if occupancy_map[goalNode[0], goalNode[1]] != 0:\\n #raise ValueError(\\\"goal: ({}, {}) invalid, is an obstacle\\\".format(goalNode[0], goalNode[1]))\\n goalNode = findValidNode(goalNode, goal, occupancy_map, x_spacing, y_spacing)\\n candidate = [ [sys.float_info.max, \\n i, (freelist[0][i], freelist[1][i])] for i in range(len(freelist[0]))] \\n visited = set([])\\n queue = PriorityQueue(candidate)\\n paths = {}\\n found = False\\n\\n #update initial cost\\n queue.remove(startNode)\\n queue.insert(startNode, initialcost)\\n paths[startNode] = None\\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, 0, 1, queue, paths, x_spacing, y_spacing, initialcost)\\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, 0, -1, queue, paths, x_spacing, y_spacing, initialcost)\\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, 1, 0, queue, paths, x_spacing, y_spacing, initialcost)\\n updateInitial(occupancy_map, ROWS, COLS, start, startNode, -1, 0, queue, paths, x_spacing, y_spacing, initialcost)\\n while queue.size() > 0:\\n priority, current = queue.pop()\\n if current == goalNode:\\n found = True\\n break\\n #not reaching goal node yet, for each of its neighbor, update the weight\\n visited.add(current)\\n update(occupancy_map, ROWS, COLS, current, 0, 1, priority, queue, paths, visited, x_spacing, y_spacing)\\n update(occupancy_map, ROWS, COLS, current, 0, -1, priority, queue, paths, visited, x_spacing, y_spacing)\\n update(occupancy_map, ROWS, COLS, current, 1, 0, priority, queue, paths, visited, x_spacing, y_spacing)\\n update(occupancy_map, ROWS, COLS, current, -1, 0, priority, queue, paths, visited, x_spacing, y_spacing)\\n \\n if not found:\\n raise ValueError(\\\"fail to find shortest path\\\")\\n node = goalNode\\n shortestpath = []\\n while node is not None:\\n shortestpath.append(node)\\n node = paths[node]\\n #shortestpath.append(startNode)\\n #print (startNode)\\n #print ('*', list(reversed(shortestpath)))\\n #print (goalNode)\\n p = list(reversed([ indexToLoc(n, x_spacing, y_spacing) for n in shortestpath]))\\n #start and final position may not fall on center of the grid\\n if abs(p[0][0] - start[0]) > 0.0005 or abs(p[0][1] - start[1]) > 0.0005:\\n p.insert(0, [start[0][0], start[1][0]])\\n if abs(p[-1][0] - goal[0]) > 0.0005 or abs(p[-1][1] - goal[1]) > 0.0005:\\n p.append([goal[0][0], goal[1][0]])\\n res = np.array(p)\\n print (res)\\n return res\",\n \"def complete_graph(self):\\n root_nodes = set()\\n\\n for name, a_block in self.wf['action'].items():\\n\\n a_block['name'] = name\\n\\n for n in a_block.get('needs', []):\\n if not self.wf['action'][n].get('next', None):\\n self.wf['action'][n]['next'] = set()\\n self.wf['action'][n]['next'].add(name)\\n\\n if not a_block.get('needs', None):\\n root_nodes.add(name)\\n\\n self.wf['root'] = root_nodes\",\n \"def rr2_assign_ports():\\n print('******* Assigning ports')\\n for device in ci_addrs.switches_rr1_12:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_rr1_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr')\\n for device in ci_addrs.switches_rr2_12:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_rr2_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr')\\n assign_ports_n5k34()\",\n \"def update_cell_nodes(self):\\n self.cells['nodes'] = -1\\n\\n for c in range(self.Ncells()):\\n # consider two edges at a time, and find the common node\\n for i,(ja,jb) in enumerate(circular_pairs(self.cell_to_edges(c))):\\n for n in self.edges['nodes'][ja,:]: \\n if n in self.edges['nodes'][jb]:\\n self.cells['nodes'][c,i] = n\\n break\",\n \"def dijkstra(self,start):\\n path_weight = {i : float('inf') for i in range(self.n)}\\n path_weight[start] = 0\\n previous = {i : float('nan') for i in range(self.n)}\\n remaining = PriorityQueue()\\n for node,priority in path_weight.items():\\n remaining.put((priority,node))\\n\\n while not remaining.empty():\\n priority,node = remaining.get()\\n for tgt,weight in self.edges[node].items():\\n possibleNewWeight = path_weight[node] + weight\\n if (possibleNewWeight < path_weight[tgt]):\\n path_weight[tgt] = possibleNewWeight\\n previous[tgt] = node\\n \\n return path_weight, previous\",\n \"def readjust_node_id(self, lowerbound = 1):\\n for i in range(lowerbound, len(self.nodes)):\\n if self.nodes[i]:\\n self.nodes[i].node_id = i\",\n \"def __init__(self, initial_state):\\n self.initial_state = initial_state\\n self.final_state = [1, 2, 3, 8, 0, 4, 7, 6, 5]\\n self.nodes = {}\\n self.add_node(self.initial_state)\\n self.add_node(self.final_state)\\n self.results = []\",\n \"def startTreeBasedCoord(self):\\n self.log_message('ID {0} starts Load Propagation Optimization'.format(self.CommID))\\n #self.MsgReceiveCount_interval = 0\\n #self.MsgSendCount_interval = 0\\n\\n self.noOfTimesteps = (self.toTime - self.fromTime) / self.stepSize + 1\\n\\n # calculate pool of schedules (also saved in self.schedules) and schedule load curves\\n if self.getTER1() != 0: # if not a gas boiler\\n self.calcSchedulePool(self.fromTime, self.toTime)\\n self.calcScheduleConsumptionCurves()\\n\\n if not self.Parent: #root node\\n random.seed() # initialize pseudo random number generator\\n\\n\\n\\n # leave nodes select initial best schedule from schedule pool based on fluctuations curve and propagate their load to parent\\n if not self.Children:\\n #self.ChildrenProcessed = [0 for x in range(len(self.Children))]\\n if self.getTER1() != 0: # not a gas boiler\\n self.selectBestSchedule(copy.deepcopy(self.ERemainderLocal))\\n self.setSOC(self.SOCEnd[self.chosenScheduleIndex])\\n self.setStateModlvl(self.chosenSchedule[-1])\\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(self.EConsumptionChosenSchedule)])\\n else:\\n zeros = [0 for x in range(len(self.ERemainderLocal))]\\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(zeros)])\\n\\n else: # if not a leave node\\n self.EConsumptionChildCurves = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\\n self.EConsumptionChildCurvesRec = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\\n self.noOfConsumptionCurvesReceived = 0\\n #self.ChildLoadCurvesChosen = [0 for x in range(len(self.Children))]\\n return\",\n \"def __init__(self, start_time, end_time):\\n self._start = start_time\\n self._end = end_time\\n self._nodes = dict()\\n self._edges = dict()\\n self._names = set()\\n self.current = None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62554306","0.5982689","0.5950736","0.5790706","0.5765575","0.5628461","0.5544183","0.55432373","0.55188954","0.550841","0.54753715","0.5472471","0.5345496","0.5322016","0.53219366","0.5297514","0.5297507","0.5270394","0.52688956","0.5244919","0.52377003","0.52275443","0.5215441","0.52091354","0.5204116","0.51988524","0.5162609","0.5137793","0.5129784","0.5120673","0.51193184","0.5106516","0.51061475","0.5103707","0.51018363","0.5099355","0.50906086","0.5068162","0.5063984","0.5060495","0.50570273","0.50500786","0.5042079","0.5029937","0.5009752","0.5004896","0.49962425","0.49949044","0.49921772","0.49903917","0.49849305","0.49592113","0.49485585","0.4942934","0.49204952","0.49182272","0.4914316","0.49093264","0.49063808","0.49052387","0.49026337","0.48975748","0.48974267","0.48899186","0.48894954","0.48843965","0.48819697","0.4881181","0.4880662","0.48805895","0.48775563","0.48745012","0.48707402","0.48689857","0.4868532","0.48652413","0.48613736","0.4858103","0.48578584","0.48572776","0.4851858","0.48508525","0.48499146","0.4849373","0.484685","0.48460847","0.4844434","0.48424953","0.4838473","0.48374373","0.48357657","0.48286852","0.48234752","0.48183033","0.481316","0.48120713","0.4812008","0.4810222","0.48099595","0.48034313"],"string":"[\n \"0.62554306\",\n \"0.5982689\",\n \"0.5950736\",\n \"0.5790706\",\n \"0.5765575\",\n \"0.5628461\",\n \"0.5544183\",\n \"0.55432373\",\n \"0.55188954\",\n \"0.550841\",\n \"0.54753715\",\n \"0.5472471\",\n \"0.5345496\",\n \"0.5322016\",\n \"0.53219366\",\n \"0.5297514\",\n \"0.5297507\",\n \"0.5270394\",\n \"0.52688956\",\n \"0.5244919\",\n \"0.52377003\",\n \"0.52275443\",\n \"0.5215441\",\n \"0.52091354\",\n \"0.5204116\",\n \"0.51988524\",\n \"0.5162609\",\n \"0.5137793\",\n \"0.5129784\",\n \"0.5120673\",\n \"0.51193184\",\n \"0.5106516\",\n \"0.51061475\",\n \"0.5103707\",\n \"0.51018363\",\n \"0.5099355\",\n \"0.50906086\",\n \"0.5068162\",\n \"0.5063984\",\n \"0.5060495\",\n \"0.50570273\",\n \"0.50500786\",\n \"0.5042079\",\n \"0.5029937\",\n \"0.5009752\",\n \"0.5004896\",\n \"0.49962425\",\n \"0.49949044\",\n \"0.49921772\",\n \"0.49903917\",\n \"0.49849305\",\n \"0.49592113\",\n \"0.49485585\",\n \"0.4942934\",\n \"0.49204952\",\n \"0.49182272\",\n \"0.4914316\",\n \"0.49093264\",\n \"0.49063808\",\n \"0.49052387\",\n \"0.49026337\",\n \"0.48975748\",\n \"0.48974267\",\n \"0.48899186\",\n \"0.48894954\",\n \"0.48843965\",\n \"0.48819697\",\n \"0.4881181\",\n \"0.4880662\",\n \"0.48805895\",\n \"0.48775563\",\n \"0.48745012\",\n \"0.48707402\",\n \"0.48689857\",\n \"0.4868532\",\n \"0.48652413\",\n \"0.48613736\",\n \"0.4858103\",\n \"0.48578584\",\n \"0.48572776\",\n \"0.4851858\",\n \"0.48508525\",\n \"0.48499146\",\n \"0.4849373\",\n \"0.484685\",\n \"0.48460847\",\n \"0.4844434\",\n \"0.48424953\",\n \"0.4838473\",\n \"0.48374373\",\n \"0.48357657\",\n \"0.48286852\",\n \"0.48234752\",\n \"0.48183033\",\n \"0.481316\",\n \"0.48120713\",\n \"0.4812008\",\n \"0.4810222\",\n \"0.48099595\",\n \"0.48034313\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6497673"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74295,"cells":{"query":{"kind":"string","value":"Searches for a layout among the given qubits for the two nbit registers and two additional ancilla that matches the simple layout given in figure 4 of [CDKM96]_. This method ignores any considerations of physical characteristics of the qc aside from the qubit layout. An error is thrown if the appropriate layout is not found."},"document":{"kind":"string","value":"def get_qubit_registers_for_adder(qc: QuantumComputer, num_length: int,\n qubits: Optional[Sequence[int]] = None)\\\n -> Tuple[Sequence[int], Sequence[int], int, int]:\n if qubits is None:\n unavailable = [] # assume this means all qubits in qc are available\n else:\n unavailable = [qubit for qubit in qc.qubits() if qubit not in qubits]\n\n graph = qc.qubit_topology().copy()\n for qubit in unavailable:\n graph.remove_node(qubit)\n\n # network x only provides subgraph isomorphism, but we want a subgraph monomorphism, i.e. we\n # specifically want to match the edges desired_layout with some subgraph of graph. To\n # accomplish this, we swap the nodes and edges of graph by making a line graph.\n line_graph = nx.line_graph(graph)\n\n # We want a path of n nodes, which has n-1 edges. Since we are matching edges of graph with\n # nodes of layout we make a layout of n-1 nodes.\n num_desired_nodes = 2 * num_length + 2\n desired_layout = nx.path_graph(num_desired_nodes - 1)\n\n g_matcher = nx.algorithms.isomorphism.GraphMatcher(line_graph, desired_layout)\n\n try:\n # pick out a subgraph isomorphic to the desired_layout if one exists\n # this is an isomorphic mapping from edges in graph (equivalently nodes of line_graph) to\n # nodes in desired_layout (equivalently edges of a path graph with one more node)\n edge_iso = next(g_matcher.subgraph_isomorphisms_iter())\n except IndexError:\n raise Exception(\"An appropriate layout for the qubits could not be found among the \"\n \"provided qubits.\")\n\n # pick out the edges of the isomorphism from the original graph\n subgraph = nx.Graph(graph.edge_subgraph(edge_iso.keys()))\n\n # pick out an endpoint of our path to start the assignment\n start_node = -1\n for node in subgraph.nodes:\n if subgraph.degree(node) == 1: # found an endpoint\n start_node = node\n break\n\n return assign_registers_to_line_or_cycle(start_node, subgraph, num_length)"},"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 assert_mapping_consistency(layout):\n values = sorted(layout.values())\n keys = list(layout)\n ref_keys = [\"q\" + str(i) for i in range(len(keys))]\n if keys != ref_keys:\n raise PlacementError(\"Some physical qubits in the layout may be missing or duplicated.\")\n if values != list(range(len(values))):\n raise PlacementError(\"Some logical qubits in the layout may be missing or duplicated.\")","def is_packed_layout(layout):\n if layout == \"NCHW\":\n return False\n if \"n\" in layout and \"c\" in layout:\n return True\n return False","def assert_placement(circuit: Circuit, layout: dict) -> bool:\n assert_mapping_consistency(layout)\n if circuit.nqubits > len(layout):\n raise PlacementError(\"Layout can't be used on circuit. The circuit requires more qubits.\")\n if circuit.nqubits < len(layout):\n raise PlacementError(\"Layout can't be used on circuit. Ancillary extra qubits need to be added to the circuit.\")","def get_qconfig_sequences_constrained_by_trace_order(\n self,\n possible_qconfigs_sequence_in_trace_order: List[List[QuantizerConfig]],\n indices_for_bitwidth_adjustment_only: Set[int],\n ) -> Tuple[List[QConfigSequenceForHAWQToEvaluate], List[CoveringQConfigSequenceForQuantNoiseCalculation]]:\n if len(possible_qconfigs_sequence_in_trace_order) != len(self._traces_order):\n raise ValueError(\"The size of the qconfig space and the traces do not match!\")\n retval = [] # type: List[QConfigSequenceForHAWQToEvaluate]\n observed_qconfs_in_retval = [OrderedDict() for _ in range(len(self._traces_order))]\n for bitwidth_sequence in self._bitwidth_sequences:\n current_qconfig_sequence_in_trace_order = [] # type: QConfigSequenceForHAWQToEvaluate\n for trace_idx, bitwidth in enumerate(bitwidth_sequence):\n if trace_idx in indices_for_bitwidth_adjustment_only:\n bitwidth_adjusted_default_qconfig = deepcopy(\n possible_qconfigs_sequence_in_trace_order[trace_idx][0]\n )\n bitwidth_adjusted_default_qconfig.num_bits = bitwidth\n qconfig = bitwidth_adjusted_default_qconfig\n else:\n # TODO: do a selection based on strategy (\"exhaustive\" = add all available configurations,\n # \"preset\" = do a selection based on a certain preset, \"first\" = select first match (as below),\n # \"custom\" = use a custom selection function to be passed as arg to the HAWQ initializer\n # OR: do non-bitwidth disambiguation higher up the stack, make sure that the qconfig\n # space at this spot only has 1 qconfig option for each bitwidth.\n possible_qconfigs_for_current_trace_idx = possible_qconfigs_sequence_in_trace_order[trace_idx]\n first_closest_qconfig = self._select_first_closest_bitwidth_qconfig(\n possible_qconfigs_for_current_trace_idx, bitwidth\n )\n qconfig = deepcopy(first_closest_qconfig)\n\n current_qconfig_sequence_in_trace_order.append(qconfig)\n observed_qconfs_in_retval[trace_idx][qconfig] = qconfig\n retval.append(current_qconfig_sequence_in_trace_order)\n return self._deduplicate(retval), self._generate_covering_qconfig_sequences(observed_qconfs_in_retval)","def check_input(self, layout, gui=True):\n print(\"**** Check Inputs ****\")\n diffusion_available = False\n diffusion_json_available = False\n bvecs_available = False\n bvals_available = False\n valid_inputs = False\n\n if self.global_conf.subject_session == \"\":\n subject = self.subject\n else:\n subject = \"_\".join((self.subject, self.global_conf.subject_session))\n\n subjid = self.subject.split(\"-\")[1]\n\n try:\n layout = BIDSLayout(self.base_directory)\n for subj in layout.get_subjects():\n self.global_conf.subjects.append(\"sub-\" + str(subj))\n\n print(\"> Looking for....\")\n\n if self.global_conf.subject_session == \"\":\n\n dwi_file = self.get_file(layout, subject=subjid, suffix=\"dwi\", extension=\"nii.gz\")\n if dwi_file is None:\n print(\"ERROR : Diffusion image not found for subject %s.\" % subjid)\n return\n\n json_file = self.get_file(layout, subject=subjid, suffix=\"dwi\", extension=\"json\")\n if json_file is None:\n json_file = \"NotFound\"\n print(\n \"WARNING : Diffusion json sidecar not found for subject %s.\"\n % subjid\n )\n\n bval_file = self.get_file(layout, subject=subjid, suffix=\"dwi\", extension=\"bval\")\n if bval_file is None:\n print(\n \"ERROR : Diffusion bval image not found for subject %s.\"\n % subjid\n )\n return\n\n bvec_file = self.get_file(layout, subject=subjid, suffix=\"dwi\", extension=\"bvec\")\n if bvec_file is None:\n print(\n \"ERROR : Diffusion bvec image not found for subject %s.\"\n % subjid\n )\n return\n else:\n sessid = self.global_conf.subject_session.split(\"-\")[1]\n\n dwi_file = self.get_file(layout, subject=subjid, suffix=\"dwi\", extension=\"nii.gz\", session=sessid)\n if dwi_file is None:\n print(\n \"ERROR : Diffusion image not found for subject %s, session %s.\"\n % (subjid, sessid)\n )\n return\n\n json_file = self.get_file(\n layout, subject=subjid, suffix=\"dwi\", extension=\"json\", session=sessid\n )\n if json_file is None:\n json_file = \"NotFound\"\n print(\n \"WARNING : Diffusion json sidecar not found for subject %s, session %s.\"\n % (subjid, self.global_conf.subject_session)\n )\n\n bval_file = self.get_file(\n layout, subject=subjid, suffix=\"dwi\", extension=\"bval\", session=sessid\n )\n if bval_file is None:\n print(\n \"ERROR : Diffusion bval image not found for subject %s, session %s.\"\n % (subjid, self.global_conf.subject_session)\n )\n return\n\n bvec_file = self.get_file(\n layout, subject=subjid, suffix=\"dwi\", extension=\"bvec\", session=sessid\n )\n if bvec_file is None:\n print(\n \"ERROR : Diffusion bvec image not found for subject %s, session %s.\"\n % (subjid, self.global_conf.subject_session)\n )\n return\n\n print(\"... dwi_file : %s\" % dwi_file)\n print(\"... json_file : %s\" % json_file)\n print(\"... bvecs_file : %s\" % bvec_file)\n print(\"... bvals_file : %s\" % bval_file)\n\n if os.path.isfile(dwi_file):\n diffusion_available = True\n\n except Exception as e:\n print(f\"Invalid BIDS dataset.\\n\\n\\t{e}\\n\\nPlease see documentation for more details.\")\n return\n\n if os.path.isfile(json_file):\n diffusion_json_available = True\n if os.path.isfile(bval_file):\n bvals_available = True\n if os.path.isfile(bvec_file):\n bvecs_available = True\n\n if diffusion_available:\n if bvals_available and bvecs_available:\n self.stages[\n \"Diffusion\"\n ].config.diffusion_imaging_model_choices = self.diffusion_imaging_model\n\n # Copy diffusion data to derivatives / cmp / subject / dwi\n if self.global_conf.subject_session == \"\":\n out_dwi_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n \"dwi\",\n subject + \"_desc-cmp_dwi.nii.gz\",\n )\n out_bval_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n \"dwi\",\n subject + \"_desc-cmp_dwi.bval\",\n )\n out_bvec_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n \"dwi\",\n subject + \"_desc-cmp_dwi.bvec\",\n )\n else:\n out_dwi_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n self.global_conf.subject_session,\n \"dwi\",\n subject + \"_desc-cmp_dwi.nii.gz\",\n )\n out_bval_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n self.global_conf.subject_session,\n \"dwi\",\n subject + \"_desc-cmp_dwi.bval\",\n )\n out_bvec_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n self.global_conf.subject_session,\n \"dwi\",\n subject + \"_desc-cmp_dwi.bvec\",\n )\n\n if not os.path.isfile(out_dwi_file):\n shutil.copy(src=dwi_file, dst=out_dwi_file)\n if not os.path.isfile(out_bvec_file):\n shutil.copy(src=bvec_file, dst=out_bvec_file)\n if not os.path.isfile(out_bval_file):\n shutil.copy(src=bval_file, dst=out_bval_file)\n\n valid_inputs = True\n input_message = \"Inputs check finished successfully.\\n\" +\\\n \"Diffusion and morphological data available.\"\n\n if diffusion_json_available:\n if self.global_conf.subject_session == \"\":\n out_json_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n \"dwi\",\n self.subject + \"_desc-cmp_dwi.json\",\n )\n else:\n out_json_file = os.path.join(\n self.output_directory,\n __cmp_directory__,\n self.subject,\n self.global_conf.subject_session,\n \"dwi\",\n self.subject\n + \"_\"\n + self.global_conf.subject_session\n + \"_desc-cmp_dwi.json\",\n )\n\n if not os.path.isfile(out_json_file):\n shutil.copy(src=json_file, dst=out_json_file)\n else:\n input_message = \"Error during inputs check.\\nDiffusion bvec or bval files not available.\"\n else:\n if self.global_conf.subject_session == \"\":\n input_message = (\n \"Error during inputs check. No diffusion data available in folder \"\n + os.path.join(self.base_directory, self.subject, \"dwi\")\n + \"!\"\n )\n else:\n input_message = (\n \"Error during inputs check. No diffusion data available in folder \"\n + os.path.join(\n self.base_directory,\n self.subject,\n self.global_conf.subject_session,\n \"dwi\",\n )\n + \"!\"\n )\n\n if gui:\n print(input_message)\n self.global_conf.diffusion_imaging_model = self.diffusion_imaging_model\n\n self.stages[\n \"Registration\"\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\n self.stages[\n \"Diffusion\"\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\n else:\n print(input_message)\n self.global_conf.diffusion_imaging_model = self.diffusion_imaging_model\n\n self.stages[\n \"Registration\"\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\n self.stages[\n \"Diffusion\"\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\n\n if diffusion_available:\n valid_inputs = True\n else:\n print(\n \"ERROR : Missing required inputs.Please see documentation for more details.\"\n )\n\n return valid_inputs","def test_read_layout():\n\n layout = read_layout(layout_path=f\"{test_data}/test_mwa.txt\")\n\n assert layout.shape[0] == 3\n assert layout[0][0] == -1.497849999999999966e02\n assert layout[1][0] == 2.658140000000000214e02\n assert layout[2][0] == 3.770110000000000241e02","def intersect_hint(self, sq, hh):\n if not self.hints_prepped:\n self.reset_hints()\n self.hints_prepped=1\n #~ self._hints[sq]=self._hints[sq].intersection(hh)\n pos=self.local2global(sq)\n #~ self._global_hints[pos]=self._global_hints[pos].intersection(hh)\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n #~ bad=0\n #~ for h in hh:\n #~ if 'IN'==h[0]:\n #~ bad=1\n #~ break\n #~ if 'OUT'==h[1]:\n #~ bad=1\n #~ break\n #~ if bad:\n #~ for h in hh:\n #~ if 'IN'==h[0]:\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[1]==h[1]]\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[1]==h[1]]\n #~ if 'OUT'==h[1]:\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[0]==h[0]]\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[0]==h[0]]\n #~ if h in self._global_hints[pos]:\n #~ self._global_hints[pos].remove(h)\n #~ self._hints[sq].remove(h)\n #~ else:\n self._hints[sq]=self._hints[sq].intersection(hh)\n self._global_hints[pos]=self._global_hints[pos].intersection(hh)","def main():\n\n cages = [\n \"AABCCD\",\n \"EFBCGD\",\n \"EFFHGI\",\n \"EJJHGI\",\n \"EKJHGL\",\n \"KKJLLL\",\n ]\n\n peaks = [\n (0, 1),\n (0, 2),\n (1, 3),\n (1, 4),\n (1, 5),\n (2, 1),\n (2, 3),\n (3, 0),\n (3, 5),\n (4, 2),\n (5, 1),\n (5, 4),\n ]\n\n extract = {\n \"A\": (5, 2),\n \"B\": (0, 3),\n \"C\": (3, 2),\n \"D\": (1, 4),\n \"E\": (0, 1),\n \"F\": (1, 5),\n \"G\": (4, 2),\n \"H\": (3, 5),\n \"I\": (1, 0),\n \"J\": (5, 5),\n \"K\": (3, 4),\n \"L\": (5, 1),\n \"M\": (0, 5),\n \"N\": (4, 4),\n }\n\n def answer(sg):\n solved_grid = sg.solved_grid()\n s = \"\"\n s += chr(64 + solved_grid[extract[\"A\"]] + solved_grid[extract[\"B\"]])\n s += chr(64 + solved_grid[extract[\"C\"]] + solved_grid[extract[\"D\"]])\n s += chr(64 + solved_grid[extract[\"E\"]] + solved_grid[extract[\"F\"]] + solved_grid[extract[\"G\"]])\n s += chr(64 + solved_grid[extract[\"H\"]] + solved_grid[extract[\"I\"]])\n s += chr(64 + solved_grid[extract[\"J\"]] + solved_grid[extract[\"K\"]] + solved_grid[extract[\"L\"]])\n s += chr(64 + solved_grid[extract[\"M\"]] + solved_grid[extract[\"N\"]])\n return s\n\n sym = grilops.make_number_range_symbol_set(1, 6)\n lattice = grilops.get_square_lattice(6)\n sg = grilops.SymbolGrid(lattice, sym)\n\n add_sudoku_constraints(sg)\n\n # Constrain regions to match the cages and be rooted at the peaks.\n cage_label_to_region_id = {}\n for py, px in peaks:\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\n\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\n for y, x in lattice.points:\n sg.solver.add(\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\n\n # Within each region, a parent cell must have a greater value than a child\n # cell, so that the values increase as you approach the root cell (the peak).\n for p in lattice.points:\n for n in sg.edge_sharing_neighbors(p):\n sg.solver.add(Implies(\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\n n.symbol > sg.grid[p]\n ))\n\n if sg.solve():\n sg.print()\n print()\n print(answer(sg))\n while not sg.is_unique():\n print()\n print(\"Alternate solution\")\n sg.print()\n print()\n print(answer(sg))\n else:\n print(\"No solution\")","def _get_numpy_layout(numpy_arr, second_arr=None):\n\n # Return the second array order if the first is ambiguous\n if numpy_arr.flags.c_contiguous and numpy_arr.flags.f_contiguous and second_arr is not None:\n if second_arr.flags.c_contiguous:\n return LAYOUT_CODE_C, numpy_arr.shape[1]\n elif second_arr.flags.f_contiguous:\n return LAYOUT_CODE_F, numpy_arr.shape[0]\n\n # Return the first order array otherwise\n elif numpy_arr.flags.c_contiguous:\n return LAYOUT_CODE_C, numpy_arr.shape[1]\n elif numpy_arr.flags.f_contiguous:\n return LAYOUT_CODE_F, numpy_arr.shape[0]\n elif not numpy_arr.flags.contiguous:\n raise ValueError(\"Array is not contiguous\")\n else:\n raise ValueError(\"Array layout check has failed for unknown reason\")","def test_three_qubit(self):\n np.random.seed(0)\n v = QuantumRegister(3, 'v') # virtual qubits\n coupling = CouplingMap([[0, 1], [1, 2]])\n from_layout = Layout({v[0]: 0, v[1]: 1, v[2]: 2})\n to_layout = Layout({v[0]: 2, v[1]: 0, v[2]: 1})\n ltpass = LayoutTransformation(coupling_map=coupling,\n from_layout=from_layout,\n to_layout=to_layout)\n qc = QuantumCircuit(3) # input (empty) physical circuit\n dag = circuit_to_dag(qc)\n q = dag.qubits()\n output_dag = ltpass.run(dag)\n # output_dag.draw()\n # Check that only two swaps were performed\n self.assertCountEqual([\"swap\"] * 2, [op.name for op in output_dag.topological_op_nodes()])\n # And check that the swaps were first performed on {q0,q1} then on {q1,q2}.\n self.assertEqual([frozenset([q[0], q[1]]), frozenset([q[1], q[2]])],\n [frozenset(op.qargs) for op in output_dag.topological_op_nodes()])","def make_full_layout(d: AttentionMask) -> np.ndarray:\n\n if not d.is_head_specific:\n u = np.reshape(d.global_layout, [d.n_query_block, d.n_key_block, 1, 1])\n r = product(range(d.n_query_block), range(d.n_key_block))\n v = np.array([d.block_layout(None, 0, i, j, 0) for i, j in r])\n v = np.reshape(v, [d.n_query_block, d.n_key_block, d.block_size, d.block_size])\n\n w = u * v\n w = np.transpose(w, [0, 2, 1, 3])\n w = np.reshape(w, [d.query_context_size, d.key_context_size])\n return w\n else:\n if len(d.global_layout.shape) == 2:\n u = np.reshape(d.global_layout, [1, d.n_query_block, d.n_key_block, 1, 1])\n u = np.tile(u, [d.n_head, 1, 1, 1, 1])\n elif len(d.global_layout.shape) == 3:\n u = np.reshape(d.global_layout, [d.n_head, d.n_query_block, d.n_key_block, 1, 1])\n else:\n raise RuntimeError()\n\n s = product(range(d.n_head), range(d.n_query_block), range(d.n_key_block))\n v = np.array([d.block_layout(None, i, j, k, 0) for i, j, k in s])\n v = np.reshape(v, [d.n_head, d.n_query_block, d.n_key_block, d.block_size, d.block_size])\n\n w = u * v\n w = np.transpose(w, [0, 1, 3, 2, 4])\n w = np.reshape(w, [d.n_head, d.query_context_size, d.key_context_size])\n return w","def solve_sudoku(self, grid_basic_format):\n raise NotImplementedError(\"Solve sudoku method not implemented in Base Class\")","def detect_layouts(self, lscpu_output=None):\n stdout = self.detect_layout_lscpu(lscpu_output)\n rows = [row for row in stdout.strip().split('\\n') if not row.startswith('#')]\n layouts = [list(map(any2int, row.split(',')[2:4])) for row in rows]\n numa_layout, socket_layout = zip(*layouts)\n self.numa_layout = dict(enumerate(numa_layout))\n self.socket_layout = dict(enumerate(socket_layout))","def test_weyl_specialize_general(self, aaa=0.456, bbb=0.345, ccc=0.123):\n a, b, c = aaa, bbb, ccc\n for da, db, dc in DELTAS:\n for k1l, k1r, k2l, k2r in K1K2SB:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n self.check_two_qubit_weyl_specialization(\n k1 @ Ud(a + da, b + db, c + dc) @ k2,\n 0.999,\n TwoQubitWeylGeneral,\n {\"rz\": 8, \"ry\": 4, \"rxx\": 1, \"ryy\": 1, \"rzz\": 1},\n )","def adopt_global_hints(self,board):\n global_hints={}\n for sq in self.allsqs:\n self.intersect_hint(sq, board.global_hints[self.local2global(sq)])\n return\n #~ for pos,hints in self.raw_global_hints.items():\n #~ bad=False\n #~ for il in board.ilrooms:\n #~ if pos in il.orig_gatesqs:\n #~ bad=True\n #~ if bad:\n #~ continue\n #not sure if this is necessary. if i have hints, it should be ok.\n #~ orighints=hints\n #~ newhints=set()\n #~ for hint in hints:\n #~ if hint[0]=='IN':\n #~ opendvs=board.getopendv_loc(pos)\n #~ indvs=[(dv+2)%4 for dv in opendvs if dv!=hint[1]]\n #~ for indv in indvs:\n #~ newhints.add((indv,hint[1]))\n #~ elif hint[1]=='OUT':\n #~ if hint[0]=='OUT':\n #~ indvs=[n for n in [0,1,2,3] if add(pos,(n+2)%4) not in self.orig_allsqs and board.isopen(add(pos,(n+2)%4))]\n #~ outdvs=[n for n in [0,1,2,3] if add(pos,n) not in self.orig_allsqs and board.isopen(add(pos,n))]\n #~ for i in indvs:\n #~ for o in outdvs:\n #~ if (i+2)%4==o:\n #~ continue\n #~ newhints.add((i,o))\n #~ else:\n #~ opendvs=board.getopendv_loc(pos)\n #~ outdvs=[dv for dv in opendvs if dv != (hint[0]+2)%4]\n #~ for outdv in outdvs:\n #~ newhints.add((hint[0],outdv))\n #~ else:\n #~ newhints.add(hint)\n #~ global_hints[pos]=newhints\n #~ self.global_hints=global_hints","def npa_constraints(\n assemblage: dict[tuple[int, int], cvxpy.Variable], k: int | str = 1, referee_dim: int = 1\n) -> list[cvxpy.constraints.constraint.Constraint]:\n a_out, a_in, b_out, b_in = _get_nonlocal_game_params(assemblage, referee_dim)\n\n words = _gen_words(k, a_out, a_in, b_out, b_in)\n dim = len(words)\n\n r_var = cvxpy.Variable((referee_dim * dim, referee_dim * dim), PSD=True, name=\"R\")\n # Normalization.\n norm = sum(r_var[i * dim, i * dim] for i in range(referee_dim))\n constraints = [norm == 1]\n\n seen = {}\n for i in range(dim):\n for j in range(i, dim):\n w_i, w_j = words[i], words[j]\n w_i = tuple(reversed(w_i))\n word = _reduce(w_i + w_j)\n\n sub_mat = r_var[i::dim, j::dim]\n # if i = 0 we would consider (ε, ε) as an empty word.\n if i != 0 and _is_zero(word):\n constraints.append(sub_mat == 0)\n\n elif _is_meas(word):\n s_a, s_b = word\n constraints.append(\n sub_mat\n == assemblage[s_a.question, s_b.question][\n s_a.answer * referee_dim : (s_a.answer + 1) * referee_dim,\n s_b.answer * referee_dim : (s_b.answer + 1) * referee_dim,\n ]\n )\n\n elif _is_meas_on_one_player(word):\n symbol = word[0]\n if symbol.player == \"Alice\":\n sum_all_bob_meas = sum(\n assemblage[symbol.question, 0][\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for b_ans in range(b_out)\n )\n\n constraints.append(sub_mat == sum_all_bob_meas)\n\n if symbol.player == \"Bob\":\n sum_all_alice_meas = sum(\n assemblage[0, symbol.question][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\n ]\n for a_ans in range(a_out)\n )\n\n constraints.append(sub_mat == sum_all_alice_meas)\n\n elif word in seen:\n old_i, old_j = seen[word]\n old_sub_mat = r_var[old_i::dim, old_j::dim]\n constraints.append(sub_mat == old_sub_mat)\n\n else:\n seen[word] = (i, j)\n\n # now we impose constraints to the assemblage operator\n for x_alice_in in range(a_in):\n for y_bob_in in range(b_in):\n sum_all_meas_and_trace = 0\n for a_ans in range(a_out):\n for b_ans in range(b_out):\n sum_all_meas_and_trace += sum(\n assemblage[x_alice_in, y_bob_in][\n i + a_ans * referee_dim, i + b_ans * referee_dim\n ]\n for i in range(referee_dim)\n )\n\n # r x r sub - block is PSD since it's an unnormalized quantum state.\n constraints.append(\n assemblage[x_alice_in, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n >> 0\n )\n\n constraints.append(sum_all_meas_and_trace == 1)\n\n # Bob marginal consistency\n for y_bob_in in range(b_in):\n for b_ans in range(b_out):\n sum_first_question = sum(\n assemblage[0, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for a_ans in range(a_out)\n )\n\n for x_alice_in in range(1, a_in):\n sum_cur_question = sum(\n assemblage[x_alice_in, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for a_ans in range(a_out)\n )\n\n constraints.append(sum_first_question == sum_cur_question)\n\n # Alice marginal consistency\n for x_alice_in in range(a_in):\n for a_ans in range(a_out):\n sum_first_question = sum(\n assemblage[x_alice_in, 0][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for b_ans in range(b_out)\n )\n\n for y_bob_in in range(1, b_in):\n sum_cur_question = sum(\n assemblage[x_alice_in, y_bob_in][\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\n ]\n for b_ans in range(b_out)\n )\n\n constraints.append(sum_first_question == sum_cur_question)\n\n return constraints","def modify_hints_based_on_allsols(self):\n #~ if self.hashid=='92580481c330e7057171d5f5b0f5ba84x003x006':\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n if self.all_sols is None or self.all_sols=='timeout':\n #should restore all hints!\n #untested, or timeout so we know nothing\n self.reset_hints()\n return\n if self.all_sols==[]:\n #has no sol. so start/end must be here.\n self.reset_hints()\n return\n hints={}\n for sq in self.sqs:\n hints[sq]=set()\n for gsq in self.gatesqs:\n hints[gsq]=set()\n for s in self.all_sols:\n for sg in s:\n start,sindv,path,covered,end=sg\n covered=('IN',)+(start,)+covered+('OUT',)\n if start==end:\n hints[start].add(('OUT','OUT'))\n else:\n for ii,sq in enumerate(covered):\n if sq=='IN':\n continue\n if sq=='OUT':\n continue\n indv=makevec2(covered[ii-1],covered[ii])\n outdv=makevec2(covered[ii],covered[ii+1])\n hints[sq].add((indv,outdv))\n\n for sq in self.sqs:\n #~ print self.hints(sq)\n #~ print hints[sq]\n #~ print self._hints[sq]\n bad=self.intersect_hint(sq, hints[sq])\n #~ if len(self.all_sols)==1:\n #~ if len(self._hints[sq])!=1:\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n if bad:return 1\n for gsq in self.gatesqs:\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n bad=self.intersect_enter_hint(gsq, hints[gsq])\n if bad:return bad\n #should return the actual bad sq - it may be better!\n bad=self.intersect_exit_hint(gsq, hints[gsq])\n if bad:return bad\n #~ if len(hints[gsq])==1:\n #~ if len(self._hints[gsq])!=1:\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'","def q2(puzzle):\n mysudoku = build_csp(puzzle)\n mysudoku.ac3_algorithm()\n solution = mysudoku.backtracking_search()\n return solution, mysudoku","def create_pcb_from_3dlayout(\n self,\n component_name,\n project_name,\n design_name,\n resolution=2,\n extenttype=\"Bounding Box\",\n outlinepolygon=\"\",\n close_linked_project_after_import=True,\n custom_x_resolution=None,\n custom_y_resolution=None,\n ):\n if project_name == self.project_name:\n project_name = \"This Project*\"\n link_data = [project_name, design_name, \"<--EDB Layout Data-->\", False, False]\n status = self.create_ipk_3dcomponent_pcb(\n component_name,\n link_data,\n \"\",\n resolution,\n extenttype=extenttype,\n outlinepolygon=outlinepolygon,\n custom_x_resolution=custom_x_resolution,\n custom_y_resolution=custom_y_resolution,\n )\n\n if close_linked_project_after_import and \".aedt\" in project_name:\n prjname = os.path.splitext(os.path.basename(project_name))[0]\n self.close_project(prjname, saveproject=False)\n self.logger.glb.info(\"PCB component correctly created in Icepak.\")\n return status","def _get_layout(nstim, length=None, height=None, layout='square'):\r\n if layout == 'square':\r\n if np.floor(np.sqrt(nstim))**2 != nstim:\r\n n = int(np.ceil(np.sqrt(nstim/2.)))\r\n m = int(np.ceil(nstim/n))\r\n else:\r\n # M is a perfect square\r\n m = int(np.sqrt(nstim))\r\n n = m\r\n elif layout == 'sqrt':\r\n # if length != height, partly account for this so stimuli aren't so distorted. \r\n # could remove the extra square root to fully accommodate\r\n n = int(np.sqrt(nstim*np.sqrt(height/length)))\r\n m = int(np.ceil(nstim/n))\r\n else:\r\n n, m = layout\r\n return n, m","def validate_raw_block_layout(raw_block_layout):\n\n # Confirm that each layer is a list of block specifications where\n # each block specification has length 2 (i.e. block_name,num_repeats)\n for raw_layer_layout in raw_block_layout:\n for raw_block_spec in raw_layer_layout.split('-'):\n if len(raw_block_spec.split(',')) != 2:\n raise Exception(INVALID_BLOCK_SPEC_ERR.format(raw_block_spec))","def block_layout(\n self, blk_shape: Any, head_idx: int, query_idx: int, key_idx: int, blk_idx: int\n ) -> np.ndarray:\n\n m = np.ones([self.block_size, self.block_size], dtype=np.bool)\n\n if query_idx >= self.first_pad_query_block_idx:\n n_pad = min(\n self.block_size,\n (query_idx + 1) * self.block_size - (self.query_context_size - self.n_query_pad),\n )\n assert n_pad > 0\n m[self.block_size - n_pad :] = False\n if key_idx >= self.first_pad_key_block_idx:\n n_pad = min(\n self.block_size,\n (key_idx + 1) * self.block_size - (self.key_context_size - self.n_key_pad),\n )\n assert n_pad > 0\n m[:, self.block_size - n_pad :] = False\n\n return m & self._block_layout(blk_shape, head_idx, query_idx, key_idx, blk_idx)","def find_something(self, break_func, Q1, Q2):\n if break_func(self._galaxy[Q1][Q2]):\n return Q1, Q2\n for i in range(0, 8):\n for j in range(0, 8):\n if break_func(self._galaxy[i][j]):\n return i, j\n return None","def generate_field_layout(gcr, collector_area, L_min, neighbor_order,\n aspect_ratio=None, offset=None, rotation=None,\n layout_type=None, plot=True): # noqa: E501\n # Consider special layouts which can be defined only by GCR\n if layout_type == 'square':\n aspect_ratio = 1\n offset = 0\n rotation = 0\n # Diagonal layout is the square layout rotated 45 degrees\n elif layout_type == 'diagonal':\n aspect_ratio = 1\n offset = 0\n rotation = 45\n # Hexagonal layouts are defined by an aspect ratio=0.866 and offset=-0.5\n elif layout_type == 'hexagonal_n_s':\n aspect_ratio = np.sqrt(3)/2\n offset = -0.5\n rotation = 0\n # The hexagonal E-W layout is the hexagonal N-S layout rotated 90 degrees\n elif layout_type == 'hexagonal_e_w':\n aspect_ratio = np.sqrt(3)/2\n offset = -0.5\n rotation = 90\n elif layout_type is not None:\n raise ValueError('The layout type specified was not recognized.')\n elif ((aspect_ratio is None) or (offset is None) or (rotation is None)):\n raise ValueError('Aspect ratio, offset, and rotation needs to be '\n 'specified when no layout type has not been selected')\n\n # Check parameters are within their ranges\n if aspect_ratio < np.sqrt(1-offset**2):\n raise ValueError('Aspect ratio is too low and not feasible')\n if aspect_ratio > collector_area/(gcr*L_min**2):\n raise ValueError('Apsect ratio is too high and not feasible')\n if (offset < -0.5) | (offset >= 0.5):\n raise ValueError('The specified offset is outside the valid range.')\n if (rotation < 0) | (rotation >= np.pi):\n raise ValueError('The specified rotation is outside the valid range.')\n # Check if mimimum and maximum ground cover ratios are exceded\n gcr_max = collector_area / (L_min**2 * np.sqrt(1-offset**2))\n if (gcr < 0) or (gcr > gcr_max):\n raise ValueError('Maximum ground cover ratio exceded.')\n # Check if Lmin is physically possible given the collector area.\n if (L_min < np.sqrt(4*collector_area/np.pi)):\n raise ValueError('Lmin is not physically possible.')\n\n N = 1 + 2 * neighbor_order # Number of collectors along each side\n\n # Generation of X and Y arrays with coordinates\n X = np.tile(np.arange(int(-N/2), int(N/2)+1), N)\n Y = np.repeat(np.arange(int(-N/2), int(N/2)+1), N)\n # Remove reference collector point (origin)\n X = np.delete(X, int(N**2/2))\n Y = np.delete(Y, int(N**2/2))\n\n # Add offset and implement aspect ratio. Note that it is important to first\n # calculate offset as it relies on the original X array.\n Y = Y + offset*X\n X = X * aspect_ratio\n # Apply field rotation\n X, Y = _rotate_origin(X, Y, rotation)\n # Calculate and apply the scaling factor based on GCR\n scaling = np.sqrt(collector_area / (gcr * aspect_ratio))\n X, Y = X*scaling, Y*scaling\n\n # Calculate distance and angle of shading trackers relative to the center\n tracker_distance = np.sqrt(X**2 + Y**2)\n # The relative azimuth is defined clockwise eastwards from north\n relative_azimuth = np.mod(450-np.rad2deg(np.arctan2(Y, X)), 360)\n\n # Visualize layout\n if plot:\n _plot_field_layout(X, Y, L_min)\n\n return X, Y, tracker_distance, relative_azimuth","def test_queue_region_with_rss_rule_combination(self):\n self.verify(self.nic in [\"fortville_eagle\", \"fortville_spirit\",\n \"fortville_spirit_single\", \"fortpark_TLV\", \"fortville_25g\"], \"NIC Unsupported: \" + str(self.nic))\n self.pmdout.start_testpmd(\"%s\" % self.cores, \"--rxq=16 --txq=16 --port-topology=chained\")\n self.dut.send_expect(\"port config all rss all\", \"testpmd> \", 120)\n self.dut.send_expect(\"set fwd rxonly\", \"testpmd> \", 120)\n self.dut.send_expect(\"set verbose 1\", \"testpmd> \", 120)\n self.dut.send_expect(\"start\", \"testpmd> \", 120)\n time.sleep(2)\n\n # Set a queue region.\n self.dut.send_expect(\n \"set port 0 queue-region region_id 0 queue_start_index 1 queue_num 1\", \"testpmd> \")\n self.dut.send_expect(\n \"set port 0 queue-region region_id 0 flowtype 31\", \"testpmd> \")\n self.dut.send_expect(\n \"set port 0 queue-region flush on\", \"testpmd> \")\n # send the packets and verify the results\n rss_queue = [\"1\"]\n self.send_and_check(self.pkt2, rss_queue)\n\n # Create a RSS queue rule.\n self.dut.send_expect(\n \"flow create 0 ingress pattern end actions rss queues 6 7 end / end\", \"testpmd> \")\n # send the packets and verify the results\n rss_queue = [\"1\"]\n self.send_and_check(self.pkt2, rss_queue)\n\n # destroy the queue region.\n self.dut.send_expect(\n \"set port 0 queue-region flush off\", \"testpmd> \")\n # send the packets and verify the results\n rss_queue = [\"6\", \"7\"]\n self.send_and_check(self.pkt2, rss_queue)","def buildInterface(self, idx = 0, z_1 = 1, z_2 = 1, d = 2.5,\\\n verbose = 1, vacuum = 0, translation = None,\\\n surface = None, anchor = \"@\", ab = True):\n\n if verbose > 0:\n self.printInterfaces(idx = idx, anchor = anchor)\n\n \"\"\"Get the distance between the top atom and the top of the cell\"\"\"\n if ab:\n B1, B2 = self.getAB()\n void = B1[2, 2] - np.max(self.pos_1[:, 2] / self.base_1[2, 2] * B1[2, 2])\n else:\n void = self.base_1[2, 2] - np.max(self.pos_1[:, 2])\n d -= void\n\n \"\"\"The strained new basis\"\"\"\n F = np.zeros((3, 3))\n F[2, 2] = self.base_1[2, 2] * z_1 + self.base_2[2, 2] * z_2 + d\n F[0:2, 0:2] = self.cell_1[idx, :, :]\n \n \"\"\"Parameters for the alternative base if specified\"\"\"\n if ab:\n F_ab = np.zeros((3, 3))\n F_ab[:2, :2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\n F_ab[2, 2] = B1[2, 2] * z_1 + B2[2, 2] * z_2 + d\n\n \"\"\"The unstrained new basis\"\"\"\n D = np.zeros((3, 3))\n D[2, 2] = self.base_2[2, 2] * z_2\n D[0:2, 0:2] = self.cell_2[idx, :, :]\n\n \"\"\"Parameters for the alternative base if specified\"\"\"\n if ab:\n D_ab = np.zeros((3, 3))\n D_ab[:2, :2] = np.matmul(B2[:2, :2], self.rep_2[idx, :, :])\n D_ab[2, 2] = B2[2, 2] * z_2\n\n \"\"\"Working on interface A\"\"\"\n \"\"\"Set up the bottom interface with the correct repetitions\"\"\"\n rep_1 = np.zeros((3, 4))\n rep_1[0:2, 0:2] = self.rep_1[idx, :, :]\n rep_1[:, 2] = np.sum(rep_1, axis = 1)\n\n \"\"\"Set all hi-lo limits for the cell repetitions\"\"\"\n h = 2\n rep_1 = [rep_1[0, :].min() - h, rep_1[0, :].max() + h,\\\n rep_1[1, :].min() - h, rep_1[1, :].max() + h,\\\n 0, z_1 - 1]\n\n \"\"\"Extend the cell as spcefied\"\"\"\n pos_1_ext, spec_1, mass_1 = ut.extendCell(base = self.base_1, rep = rep_1,\\\n pos = self.pos_1.T, spec = self.spec_1,\\\n mass = self.mass_1)\n\n \"\"\"Working on interface B\"\"\" \n \"\"\"Set up the top interface with the correct repetitions and rotation\"\"\"\n rep_2 = np.zeros((3, 4))\n rep_2[0:2, 0:2] = self.rep_2[idx, :, :]\n rep_2[:, 2] = np.sum(rep_2, axis = 1)\n\n \"\"\"Set all hi-lo limits for the cell repetitions\"\"\"\n h = 2\n rep_2 = [rep_2[0, :].min() - h, rep_2[0, :].max() + h,\\\n rep_2[1, :].min() - h, rep_2[1, :].max() + h,\\\n 0, z_2 - 1]\n\n \"\"\"Extend the cell as specified\"\"\"\n pos_2_ext, spec_2, mass_2 = ut.extendCell(base = self.base_2, rep = rep_2,\\\n pos = self.pos_2.T, spec = self.spec_2,\\\n mass = self.mass_2)\n\n \"\"\"Initial rotation\"\"\"\n initRot = np.deg2rad(self.ang[idx])\n\n \"\"\"Rotate the positions pos_rot = R*pos\"\"\"\n pos_2_ext_rot = ut.rotate(pos_2_ext, initRot, verbose = verbose - 1)\n\n \"\"\"Convert to direct coordinates in the unstrained D base\"\"\"\n pos_2_d_D = np.matmul(np.linalg.inv(D), pos_2_ext_rot)\n\n \"\"\"Convert the cell back to Cartesian using the strained basis.\n But with the Z parameter as in the D cell or as the Z in the \n alternative base if specified\"\"\"\n temp_F = F.copy()\n if ab:\n temp_F[2, 2] = B2[2, 2] * z_2\n else:\n temp_F[2, 2] = D[2, 2]\n pos_2_F = np.matmul(temp_F, pos_2_d_D)\n\n \"\"\"If using an alternative base fix the hight of the bottom cell\"\"\"\n if ab:\n temp_F = F.copy()\n temp_F[2, 2] = self.base_1[2, 2] * z_1\n pos_1_d = np.matmul(np.linalg.inv(temp_F), pos_1_ext)\n temp_F[2, 2] = B1[2, 2] * z_1\n pos_1_ext = np.matmul(temp_F, pos_1_d)\n\n \"\"\"Combine the positions of the two cells\"\"\"\n pos = np.zeros((3, pos_1_ext.shape[1] + pos_2_F.shape[1]))\n pos[:, :pos_1_ext.shape[1]] = pos_1_ext\n\n \"\"\"Shift Z positions of top cell to (cell_A + d)\"\"\"\n if ab:\n height = B1[2, 2] * z_1 + d\n else:\n height = self.base_1[2, 2] * z_1 + d\n\n pos_2_F[2, :] = pos_2_F[2, :] + height\n pos[:, pos_1_ext.shape[1]:] = pos_2_F\n\n \"\"\"If a translation is specified shift (x,y) coordinates of top cell accordingly\"\"\" \n if translation is not None:\n T = ut.getTranslation(translation, surface, verbose = verbose)[0]\n cT = np.matmul(self.base_1, T)\n pos[:, pos_1_ext.shape[1]:] = pos[:, pos_1_ext.shape[1]:] + cT[:, np.newaxis]\n if verbose: \n string = \"Translation [%.2f, %.2f, %.2f] (C) or [%.2f, %.2f, %.2f] (D)\"\\\n % (cT[0], cT[1], cT[2], T[0], T[1], T[2])\n ut.infoPrint(string)\n\n \"\"\"Convert the entire new cell to direct coordinates, add d above as well\"\"\"\n if ab:\n F[2, 2] = B1[2, 2] * z_1 + d + B2[2, 2] * z_2 + d\n else:\n F[2, 2] += d\n pos_d = np.matmul(np.linalg.inv(F), pos)\n\n \"\"\"Change the base if an alternative base is used\"\"\"\n if ab:\n F[:2, :2] = F_ab[:2, :2]\n\n \"\"\"Remove all positions outside [0, 1)\"\"\"\n pos_d = np.round(pos_d, 8)\n F = np.round(F, 8)\n\n keep = np.all(pos_d < 1, axis = 0) * np.all(pos_d >= 0, axis = 0)\n pos_d = pos_d[:, keep]\n species = np.concatenate((spec_1, spec_2))[keep]\n mass = np.concatenate((mass_1, mass_2))[keep]\n\n \"\"\"Return to cartesian coordinates and change shape to (...,3)\"\"\"\n pos = np.matmul(F, pos_d).T\n\n \"\"\"Add vacuum if specified\"\"\"\n F[2, 2] = F[2, 2] + vacuum\n if verbose: \n string = \"Z-distance fixed (between,above): %.2f | Vacuum added (above): %.2f\"\\\n % (d + void, vacuum)\n ut.infoPrint(string)\n if ab:\n string = \"Interface constructed with an alternative base\"\n ut.infoPrint(string)\n\n return F, pos, species, mass","def solveit(static_arr):\n arr = np.asarray(static_arr)\n if arr.shape != (9, 9):\n raise ValueError('Sudoku array must be 9x9')\n\n if np.all(arr) or is_solved(arr):\n return arr\n\n possnum = [[], [], []]\n\n for i in iter1d:\n possnum[0].append(wantset - set(arr[:, i])) # Each row\n possnum[1].append(wantset - set(arr[i, :])) # Each col\n\n # Each 3x3 block\n for j in iterblock:\n for i in iterblock:\n possnum[2].append(wantset - set(arr[j:j+3, i:i+3].ravel()))\n\n yy, xx = np.where(arr == 0)\n possd = np.empty((9, 9), dtype=object)\n possd.fill(None)\n minnum = 99\n minpos = None\n\n for i, idx in enumerate(zip(yy, xx)):\n iy, ix = idx\n iq = (ix // 3) + ((iy // 3) * 3)\n num_for_cell = possnum[0][ix] & possnum[1][iy] & possnum[2][iq]\n n_match = len(num_for_cell)\n if n_match > 0:\n possd[idx] = num_for_cell\n if n_match < minnum:\n minnum = n_match\n minpos = idx\n\n # print('Starting at {} with {} possibilities'.format(minpos, minnum))\n n = list(possd[minpos])[0]\n arr[minpos] = n\n possd[minpos] = None\n yy, xx = possd.nonzero()\n for idx in zip(yy, xx):\n if n in possd[idx]:\n possd[idx].remove(n)\n\n return solveit(arr)","def check_topology(self, ninputs, noutputs):\n return _spacegrant_swig.G3RUH_descramble_sptr_check_topology(self, ninputs, noutputs)","def test_make_layout():\n raw = hcp.read_raw(data_type='rest', **hcp_params).crop(0, 1).load_data()\n raw.pick_types()\n lout = make_hcp_bti_layout(raw.info)\n assert_equal(lout.names, raw.info['ch_names'])","def numpy_IoU_xyctrs(bb1, bb2):\n\n # There should be at least one anchor, but maybe more. \n # If the number of dimensions is only 1 (so it's just\n # one anchor), reshape the array to allow the slicing\n # to work properly:\n \n if bb1.ndim == 1:\n bb1 = np.reshape(bb1, (1,) + bb1.shape)\n if bb2.ndim == 1:\n bb2 = np.reshape(bb2, (1,) + bb2.shape)\n\n # Now, n1 and n2 can represent the number of anchors:\n n_1 = bb1.shape[0]\n n_2 = bb2.shape[0]\n\n # Want the IoU for every bb1 to every bb2, so tile them into\n # long 1D arrays to allow slicing:\n bb1_arr = np.reshape(np.tile(bb1, [1, n_2]), (n_1*n_2, 4))\n bb2_arr = np.tile(bb2, [n_1, 1])\n\n\n x1 = np.max((bb1_arr[:,0] - 0.5*bb1_arr[:,2], \n bb2_arr[:,0] - 0.5*bb2_arr[:,2]),\n axis=0)\n y1 = np.max((bb1_arr[:,1] - 0.5*bb1_arr[:,3], \n bb2_arr[:,1] - 0.5*bb2_arr[:,3]),\n axis=0)\n x2 = np.min((bb1_arr[:,0] + 0.5*bb1_arr[:,2], \n bb2_arr[:,0] + 0.5*bb2_arr[:,2]),\n axis=0)\n y2 = np.min((bb1_arr[:,1] + 0.5*bb1_arr[:,3], \n bb2_arr[:,1] + 0.5*bb2_arr[:,3]),\n axis=0)\n\n w = x2 - x1\n h = y2 - y1\n\n inter = w*h\n\n aarea = (bb1_arr[:,3])* (bb1_arr[:,2])\n barea = (bb2_arr[:,3])* (bb2_arr[:,2])\n\n denom = aarea + barea - inter\n mask = (denom == 0)\n denom[mask] = 0.1\n\n IoU = inter / (denom)\n IoU[mask] = 0\n IoU[w <= 0] = 0\n IoU[h <= 0] = 0\n \n return np.squeeze(np.reshape(IoU, (n_1,n_2)))","def solve(num_wizards, num_constraints, wizards, constraints): \n global wiz_const\n wiz_const = mapConstraints(wizards, constraints)\n partial_soltns = []\n\n # counter for priority queue since it doesn't allow \n # identical priorities\n k = 0\n\n # list of wizards sorted by lowest to highest degree\n sorted_wiz = sortWizByConsts(wiz_const)\n wiz_rankings = {wiz: i for i, wiz in enumerate(sorted_wiz)}\n\n const_set = set(map(tuple, constraints))\n for i in range(4) : \n heapq.heappush(partial_soltns, (0, k, nx.DiGraph(), const_set.copy()))\n k += 1\n\n print(\"setup done, commencing solving\")\n\n while len(partial_soltns) : \n\n # for partial_soltn, const_set in partial_soltns : \n# partial_soltns.remove(partial_soltn)\n num_seen, _, partial_soltn, const_set = heapq.heappop(partial_soltns)\n const = findNextConst(partial_soltn, const_set, wiz_rankings)\n print(\"seen \" + str(len(partial_soltn)) + \"\\t num partial_solutions\\t\" + str(len(partial_soltns)))\n try : \n const_set.remove(const)\n except KeyError : \n print(\"BAD SHIT\")\n pass\n possible_arrangements = [(const[0], const[1], const[2]),\n (const[2], const[0], const[1]), \n (const[2], const[1], const[0]),\n (const[1], const[0], const[2])]\n for arr in possible_arrangements:\n soltn = partial_soltn.copy()\n a, b, c = arr\n if not (soltn.has_node(a) and soltn.has_node(b) and nx.has_path(soltn, a, b)) : \n soltn.add_edge(a, b)\n if not (soltn.has_node(b) and soltn.has_node(c) and nx.has_path(soltn, b, c)) : \n soltn.add_edge(b, c)\n # see if we violated any other constraints (seen or not seen)\n is_valid, num_wiz = validNumWiz(soltn, const_set)\n\n if is_valid and len(list(nx.simple_cycles(soltn))) == 0 :\n heapq.heappush(partial_soltns, (-len(soltn), k, soltn, const_set.copy()))\n k += 1\n # are we done?\n if num_wiz == num_wizards :\n print(\"FINAL SOLUTION (found without processing all constraints but validating against them)\")\n ordering = list(nx.topological_sort(soltn))\n finishEverything(ordering, constraints)\n return ordering\n if foundCompleteOrdering(heapq.heappop(partial_soltns)) : \n print(\"FINAL SOLUTION\")\n ordering = list(nx.topological_sort(soltn))\n finishEverything(ordering, constraints)\n return ordering\n print(\"NO SOLUTION FOUND\")\n return \"\"","def UKIDSS_match(t, RA_main, DEC_main,\n c_graph=True, width=0.0004, w_units=\"degrees\",\n DES_box=False):\n\n import numpy as np\n import match_lists\n import sqlutil\n from astropy.table import Table, vstack\n\n db, host, user, password, table = rd_config_wsdb()\n\n if w_units == \"arcsecs\":\n width = width / 3600.0\n\n cols = [\"RA_UKIDSS\", \"DEC_UKIDSS\", \"Y_UKIDSS\", \"Y_ERR_UKIDSS\",\n \"J_UKIDSS\", \"J_ERR_UKIDSS\", \"H_UKIDSS\", \"H_ERR_UKIDSS\",\n \"K_UKIDSS\", \"K_ERR_UKIDSS\"]\n\n try:\n for col in cols:\n t.add_empty_column(col, dtype=np.float64)\n\n except AttributeError as e:\n for col in cols:\n t[col] = np.zeros(len(t))\n\n print(get_timestamp(), get_function_name() + ';',\n get_linenumber() + ':')\n (ra_min, ra_max, dec_min, dec_max) = min_max_match(\n t[RA_main], t[DEC_main], width, DES_box=DES_box)\n\n area = ((float(ra_max) - float(ra_min)) *\n (float(dec_max) - float(dec_min)))\n print('area in square degreesish:', area)\n\n if len(t) > 1000 and area < 2000:\n print(get_timestamp(), get_function_name() + ';',\n get_linenumber() + ':')\n (ra_min, ra_max, dec_min, dec_max) = min_max_match(\n t[RA_main], t[DEC_main], width, DES_box=DES_box)\n\n print(\"Retreiving data\")\n\n query_ukidss = \"select ra, dec, yAperMag3, yAperMag3Err, j_1AperMag3, \\\n j_1AperMag3Err, hAperMag3, hAperMag3Err, kAperMag3, \\\n kAperMag3Err FROM ukidssdr10.lassource \\\n WHERE ra > \" + ra_min + \" and ra < \" + ra_max + \" and \\\n dec > \" + dec_min + \" and dec < \" + dec_max\n\n (RA_u, DEC_u, Y, Yerr, J, Jerr, H, Herr, K,\n Kerr) = sqlutil.get(query_ukidss,\n db=db, host=host,\n user=user, password=password)\n\n print(\"Retrieved data\")\n\n if len(RA_u) == 0:\n for (i, col) in enumerate(cols):\n t[col] = [np.float64(np.nan)] * len(t)\n\n else:\n dists, inds = match_lists.match_lists(t[RA_main], t[DEC_main],\n RA_u, DEC_u, width, 1)\n\n info = [RA_u, DEC_u, Y, Yerr, J, Jerr, H, Herr, K, Kerr]\n\n match = np.where((inds != len(RA_u)))[0]\n no_match = np.where((inds == len(RA_u)))[0]\n\n for (i, col) in enumerate(cols):\n t[col][match] = info[i][inds[match]]\n t[col][no_match] = np.float64(np.nan)\n\n if len(t) <= 1000:\n n = 0\n\n while n < len(t):\n RA = t[RA_main][n]\n DEC = t[DEC_main][n]\n\n query_ukidss = \"select ra, dec, \\\n yAperMag3, yAperMag3Err, \\\n j_1AperMag3,j_1AperMag3Err, \\\n hAperMag3, hAperMag3Err, \\\n kAperMag3, kAperMag3Err \\\n FROM ukidssdr10.lassource \\\n WHERE \\\n q3c_radial_query(ra, dec, \" \\\n + str(RA) + \", \" + str(DEC) + \", 0.1102)\"\n\n (RA_u, DEC_u, Y, Yerr, J, Jerr, H,\n Herr, K, Kerr) = sqlutil.get(query_ukidss,\n db=db, host=host,\n user=user, password=password)\n\n if len(RA_u) > 0:\n dists, inds = match_lists.match_lists(\n [RA], [DEC], RA_u, DEC_u, width, 1)\n j = inds[0]\n\n if j != len(RA_u):\n info = [RA_u[j], DEC_u[j], Y[j],\n Yerr[j], J[j], Jerr[j],\n H[j], Herr[j], K[j], Kerr[j]]\n\n for (k, col) in enumerate(cols):\n t[col][n] = info[k]\n\n else:\n for (k, col) in enumerate(cols):\n t[col][n] = np.float64(np.nan)\n\n else:\n for (k, col) in enumerate(cols):\n t[col][n] = np.float64(np.nan)\n\n n += 1\n\n print(\"Done UKIDSS\")\n\n if area > 2000 and len(t) > 1000:\n t.sort(RA_main)\n l1 = np.ceil(area / 1001.0)\n l = len(t) / l1\n i = 0\n\n while i < l1:\n if (i + 1) * l < len(t):\n t1 = t[i * l:(i + 1) * l]\n else:\n t1 = t[i * l:]\n\n t1 = UKIDSS_match(t1, RA_main, DEC_main, c_graph=c_graph,\n width=width, w_units=w_units, DES_box=DES_box)\n\n if i == 0:\n t_out = t1\n else:\n t_out = vstack([t_out, t1])\n\n i += 1\n\n t = t_out\n\n if c_graph:\n width = width * 3600.0\n RA_med, DEC_med = check_graph(t, RA_main, DEC_main, \"UKIDSS\", width)\n\n return t","def part1():\n camera_output = IntCodeProcessor(path='day17input.txt').execute_program()\n camera_output = ints_to_string(camera_output)\n grid = camera_output.splitlines()\n\n scaffolds = set()\n for row_index, row in enumerate(grid):\n for col_index, element in enumerate(row): \n if element == '#':\n scaffolds.add((row_index,col_index))\n\n intersections = [loc for loc in scaffolds if set(locations_adjacent_to(loc)) <= scaffolds]\n parameters = [loc[0] * loc[1] for loc in intersections]\n\n print(f'Part 1 answer: {sum(parameters)}')","def _parse_ai2d_layout(self, ai2d_ann, h, w, n_pix, node_type, node_id):\n # Process elements with bounding boxes first\n if node_type in ['text', 'arrowHeads']:\n\n # Assign coordinates to a variable\n coords = np.array(ai2d_ann[node_type][node_id]['rectangle'],\n np.int32)\n\n # Calculate element area via the cv2.boundingRect, as\n # the cv2.contourArea does not work with xy-coordinates\n (rect_x, rect_y, rect_w, rect_h) = cv2.boundingRect(coords)\n\n # Calculate element area\n area = (rect_w * rect_h) / float(n_pix)\n\n # Calculate solidity, or simply assign 1, as rectangles\n # are always solid\n solidity = 1.0\n\n # Get centre point\n centre = (int(np.round(rect_x + (rect_w / 2), decimals=0)),\n int(np.round(rect_y + (rect_h / 2), decimals=0)))\n\n # Continue to process elements with polygons\n if node_type in ['arrows', 'blobs']:\n\n # Fetch coordinates and convert to numpy array\n coords = np.array(ai2d_ann[node_type][node_id]\n ['polygon'], np.int32)\n\n # Calculate element area\n area = cv2.contourArea(coords)\n\n # Calculate convex hull and its area\n hull = cv2.convexHull(coords)\n hull_area = cv2.contourArea(hull)\n\n # Calculate solidity (area divided by convex hull area)\n try:\n\n solidity = area / hull_area\n\n except ZeroDivisionError:\n\n solidity = 0\n\n # Normalize element area by dividing by total pixel\n # count\n area = area / float(n_pix)\n\n # Calculate moments for finding the centroid\n try:\n moments = cv2.moments(coords)\n\n # Calculate centroid\n centroid_x = int(moments[\"m10\"] / moments[\"m00\"])\n centroid_y = int(moments[\"m01\"] / moments[\"m00\"])\n\n # Assign centre point to a variable\n centre = [centroid_x, centroid_y]\n\n except ZeroDivisionError:\n\n centre = [0, 0]\n\n # If the node is a group or an image constant, set the features to zero\n if node_type in ['group', 'imageConsts']:\n\n # Assign empty coordinates to a variable\n norm_coords = [0, 0]\n area = 0\n solidity = 0\n\n # Otherwise normalize coordinates to [0..1] by dividing by image width\n # and height. This must be done last to prevent error from imageConsts\n # and groups, which is caused by an absent centre point.\n else:\n\n norm_coords = np.array([centre[0] / w, centre[1] / h], np.float32)\n\n # Concatenate all layout features along axis 0\n layout_feats = np.concatenate((norm_coords, [area], [solidity]), axis=0)\n\n # Return layout feature vector\n return layout_feats","def interpret_layout(aux_layer, input, id=-1, aux_weight_decay=3e-4):\n\tif aux_layer[0] == 'cbr':\n\t\tfilters = 256\n\t\tkernel_size = (3, 3)\n\t\tstrides = (1, 1)\n\t\tif len(aux_layer) > 1:\n\t\t\tfilters = aux_layer[1]\n\t\tif len(aux_layer) > 2:\n\t\t\tkernel_size = (aux_layer[2], aux_layer[2])\n\t\tif len(aux_layer) > 3:\n\t\t\tstrides = (aux_layer[3], aux_layer[3])\n\t\tinput = _conv_bn_relu(filters=filters, kernel_size=kernel_size, strides=strides, padding=\"same\",\n\t\t\t\t\t\t\t aux_weight_decay=aux_weight_decay)(input)\n\telif aux_layer[0] == 'se':\n\t\tinput = squeeze_and_excitation_layer(input, aux_weight_decay=aux_weight_decay)\n\telif aux_layer[0] == 'inception':\n\t\tinput = inception_block_high_level(input, aux_weight_decay=aux_weight_decay)\n\telif aux_layer[0] == 'gap':\n\t\tinput = GlobalAveragePooling2D(name='gap' + str(id))(input)\n\telif aux_layer[0] == 'dense':\n\t\tunits = 768\n\t\tif len(aux_layer) > 1:\n\t\t\tunits = aux_layer[1]\n\t\tinput = Dense(units, activation='relu')(input)\n\telse:\n\t\traise ValueError\n\treturn input","def solve_sat(grid_start, size, debug=False):\n r, c = Ints(\"r c\")\n rows, cols = size\n n = len(grid_start)\n # This is the function that represents the grid\n # grid[x, y] == k means the cell at (x, y) is of color k\n grid = Function(\"grid\", IntSort(), IntSort(), IntSort())\n # This function gives Z3 the knowledge of direction of the flows\n # flow[x, y] == k means the cell at (x, y) is k-th cell of its flow\n # e.g. flow[x, y] == 0 for every (x, y) starting point of a flow\n flow = Function(\"flow\", IntSort(), IntSort(), IntSort())\n s = Solver()\n\n start_points = [a for couple in grid_start for a in couple]\n dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4 = Ints(\n \"dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4\")\n\n ### Grid constraints\n # Defined only inside the grid and values in the right range\n s.add(ForAll([r, c], Implies(And(r >= 0, r < rows,\n c >= 0, c < cols),\n And(grid(r, c) >= 0,\n grid(r, c) < n))))\n s.add(ForAll([r, c], Implies(Or(r < 0, r >= size[0],\n c < 0, c >= size[1]),\n grid(r, c) == -1)))\n # Set the initial conditions\n for i, ((x1, y1), (x2, y2)) in enumerate(grid_start):\n s.add(grid(x1, y1) == i)\n s.add(grid(x2, y2) == i)\n # Other constraints\n # There must not be any squares of the same color\n # Square\n s.assert_and_track(\n ForAll([r, c],\n Implies(And(r >= 0, r < rows - 1, c >= 0, c < cols - 1),\n Not(And(grid(r, c) == grid(r , c+1),\n grid(r, c) == grid(r+1, c+1),\n grid(r, c) == grid(r+1, c ))))),\n \"Square\")\n\n # The number of adjacent (non diagonal) of the same color is exactly 2 for\n # normal cells and exactly 1 for starting points\n for i in range(rows):\n for j in range(cols):\n if (i, j) in start_points:\n K = 1\n else:\n K = 2\n # 4 directions 4_0\n if i > 0 and i < rows - 1 and j > 0 and j < cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i-1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j+1), 1, 0)\n + If(grid(i, j) == grid(i+1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j-1), 1, 0)),\n \"dir_4_0_K_{}_i_j_{}_{}\".format(K, i, j))\n # 3 directions 3_1\n if i > 0 and i < rows - 1 and j == 0 and j < cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i-1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j+1), 1, 0)\n + If(grid(i, j) == grid(i+1, j ), 1, 0)),\n \"dir_3_1_K_{}_i_j_{}_{}\".format(K, i, j))\n # 3 directions 3_2\n if i == 0 and i < rows - 1 and j > 0 and j < cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i , j+1), 1, 0)\n + If(grid(i, j) == grid(i+1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j-1), 1, 0)),\n \"dir_3_2_K_{}_i_j_{}_{}\".format(K, i, j))\n # 3 directions 3_3\n if i > 0 and i < rows - 1 and j > 0 and j == cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i+1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j-1), 1, 0)\n + If(grid(i, j) == grid(i-1, j ), 1, 0)),\n \"dir_3_3_K_{}_i_j_{}_{}\".format(K, i, j))\n # 3 directions 3_4\n if i > 0 and i == rows - 1 and j > 0 and j < cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i , j-1), 1, 0)\n + If(grid(i, j) == grid(i-1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j+1), 1, 0)),\n \"dir_3_4_K_{}_i_j_{}_{}\".format(K, i, j))\n # 2 directions 2_5\n if i > 0 and i == rows - 1 and j == 0 and j < cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i-1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j+1), 1, 0)),\n \"dir_2_5_K_{}_i_j_{}_{}\".format(K, i, j))\n # 2 directions 2_6\n if i == 0 and i < rows - 1 and j == 0 and j < cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i , j+1), 1, 0)\n + If(grid(i, j) == grid(i+1, j ), 1, 0)),\n \"dir_2_6_K_{}_i_j_{}_{}\".format(K, i, j))\n # 2 directions 2_7\n if i == 0 and i < rows - 1 and j > 0 and j == cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i+1, j ), 1, 0)\n + If(grid(i, j) == grid(i , j-1), 1, 0)),\n \"dir_2_7_K_{}_i_j_{}_{}\".format(K, i, j))\n # 2 directions 2_8\n if i > 0 and i == rows - 1 and j > 0 and j == cols - 1:\n s.assert_and_track(\n K ==\n ( If(grid(i, j) == grid(i , j-1), 1, 0)\n + If(grid(i, j) == grid(i-1, j ), 1, 0)),\n \"dir_2_8_K_{}_i_j_{}_{}\".format(K, i, j))\n\n\n ### Flow constraints\n # Defined only inside the grid and >= 0 values\n s.add(ForAll([r, c], Implies(And(r >= 0, r < rows,\n c >= 0, c < cols),\n flow(r, c) >= 0)))\n s.add(ForAll([r, c], Implies(Or(r < 0, r >= rows,\n c < 0, c >= cols),\n flow(r, c) == -1)))\n\n # Set the initial conditions\n for i, ((x1, y1), (x2, y2)) in enumerate(grid_start):\n s.add(flow(x1, y1) == 0)\n\n # For every cell that is not a starting point there must be two adjacent\n # non diagonal cells with decreasing and increasing value respectively\n for i in range(rows):\n for j in range(cols):\n if (i, j) in start_points:\n s.assert_and_track(\n Exists(\n [dx1, dy1],\n And(# Adjacent orthogonal cell\n Or((dx1 == 1), (dx1 == 0), (dx1 == -1)),\n Or((dy1 == 1), (dy1 == 0), (dy1 == -1)),\n\n Or(Not(dx1 == 0), Not(dy1 == 0)),\n # Inside the grid\n And((i + dx1) >= 0, (i + dx1) < rows,\n (j + dy1) >= 0, (j + dy1) < cols),\n # Of the same color\n grid(i, j) == grid(i + dx1, j + dy1),\n\n Or(flow(i, j) == (flow(i + dx1, j + dy1) + 1),\n flow(i, j) == (flow(i + dx1, j + dy1) - 1))\n )\n ), \"flow_starting_i_j_{}_{}\".format(i, j))\n else:\n s.assert_and_track(\n Exists(\n [dx1, dy1, dx2, dy2],\n And(# Different adjacent orthogonal cells\n Or(And(dx1 == -1, dy1 == 0), And(dx1 == 0, dy1 == 1),\n And(dx1 == 1, dy1 == 0), And(dx1 == 0, dy1 == -1)),\n Or(And(dx2 == -1, dy2 == 0), And(dx2 == 0, dy2 == 1),\n And(dx2 == 1, dy2 == 0), And(dx2 == 0, dy2 == -1)),\n\n Or(Not(dx1 == dx2), Not(dy1 == dy2)),\n # Inside the grid\n And((i + dx1) >= 0, (i + dx1) < rows,\n (j + dy1) >= 0, (j + dy1) < cols),\n And((i + dx2) >= 0, (i + dx2) < rows,\n (j + dy2) >= 0, (j + dy2) < cols),\n # Of the same color\n grid(i + dx1, j + dy1) == grid(i, j),\n grid(i + dx2, j + dy2) == grid(i, j),\n\n flow(i, j) == (flow(i + dx1, j + dy1) + 1),\n flow(i + dx2, j + dy2) == (flow(i, j) + 1)\n )\n ), \"flow_normal_i_j_{}_{}\".format(i, j))\n\n if s.check() == unsat:\n if debug:\n print()\n print(\"UNSAT\")\n for e in s.unsat_core():\n print(e)\n return None, None\n return None\n\n m = s.model()\n if debug:\n return ([[m.evaluate(grid(i, j)).as_long() for j in range(size[1])]\n for i in range(size[0])],\n [[m.evaluate(flow(i, j)).as_long() for j in range(size[1])]\n for i in range(size[0])])\n else:\n return [[m.evaluate(grid(i, j)).as_long() for j in range(size[1])]\n for i in range(size[0])]","def intersect_enter_hint(self, sq, hh):\n\n if not self.hints_prepped:\n self.reset_hints()\n self.hints_prepped=1\n pos=self.local2global(sq)\n if self.kind=='pararooms':\n from_outside_dvs=[dv for dv in range(4) if add(sq, dv+2) not in self.sqs]\n else:\n from_outside_dvs=[dv for dv in range(4) if add(sq, dv+2) not in self.allsqs]\n okwaysin=[]\n #~ if self.hashid=='bfb08f4204ceecf84767e77869cabce5x009x000':\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n for h in hh:\n if h[0]=='OUT':\n okwaysin.extend(from_outside_dvs)\n continue\n if h[0]=='IN':\n #~ okwaysin.append(h[1])\n okwaysin.extend(from_outside_dvs)\n continue\n okwaysin.append(h[0])\n okwaysin=list(set(okwaysin))\n newh=set([gh for gh in self._global_hints[pos] if gh[0] in okwaysin])\n if not newh and self._global_hints[pos]:\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n print 'promoting cause of a conflict between the rooms entry',pos\n return pos\n self._global_hints[pos]=newh\n self._hints[sq]=newh.copy()","def add_sudoku_constraints(sg):\n for y in range(6):\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for x in range(6)]))\n for x in range(6):\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for y in range(6)]))\n for z in range(6):\n top = (z // 2) * 2\n left = (z % 2) * 3\n cells = [sg.grid[Point(y, x)] for y in range(top, top + 2) for x in range(left, left + 3)]\n sg.solver.add(Distinct(*cells))","def setup_layout_constants(self):\n # determines the spacing between the edge and nmos (rail to active\n # metal or poly_to_poly spacing)\n half_gate_to_gate = 0.5 * (drc[\"poly_to_poly\"] - drc[\"minwidth_metal1\"])\n edge_to_nmos = max(drc[\"metal1_to_metal1\"] - self.nmos.active_contact_positions[0].y,\n half_gate_to_gate - self.nmos.poly_positions[0].y)\n\n # determine the position of the first transistor from the left\n self.nmos_position1 = vector(0,\n 0.5 * drc[\"minwidth_metal1\"] + edge_to_nmos)\n offset = self.nmos_position1 + vector(0,self.nmos.height)\n\n x = vector(self.nmos.active_width - self.nmos.active_contact.width, 0)\n self.nmos_position2 = x + self.nmos_position1.scale(0,1)\n\n # determines the spacing between the edge and pmos\n edge_to_pmos = max(drc[\"metal1_to_metal1\"] - self.pmos.active_contact_positions[0].y,\n half_gate_to_gate - self.pmos.poly_positions[0].y)\n self.pmos_position1 = vector(0,\n self.height - 0.5 * drc[\"minwidth_metal1\"]\n - edge_to_pmos - self.pmos.height)\n self.pmos_position2 = self.pmos_position1 + vector(self.pmos.width,0)\n\n self.well_width = max(self.pmos_position2.x + self.pmos.active_position.x\n + self.pmos.active_width\n + drc[\"active_to_body_active\"] + self.nwell_contact.width \n + drc[\"well_enclosure_active\"],\n self.nmos_position2.x + self.nmos.active_position.x \n + self.nmos.active_width \n + drc[\"active_to_body_active\"] + drc[\"well_enclosure_active\"])\n self.width = self.well_width","def _adc_info_second_pass(\n self, config_name: str, adc_name: str\n ) -> Tuple[Tuple[int, Tuple[int, ...], Dict[str, Any]], ...]:\n # ensure dataset exists for each (brd, ch) combo\n # - remove (brd, ch) combos if dataset does not exist\n # - remove brd entry if chs are NULL\n # populate 'nshotnum' and 'nt' for each board\n # - confirm all associated channels have matching shape\n # - if not, then define nshotnum = 0 and nt = 0 and warn\n #\n # get conns\n conns = self.configs[config_name][adc_name]\n new_conns = []\n\n # review connections\n for iconn, conn in enumerate(conns):\n brd = conn[0]\n chs = conn[1]\n\n # look for dataset existence\n new_chs = list(chs)\n chs_to_remove = []\n for ch in chs:\n # get datasets\n names = [\n self.construct_dataset_name(brd, ch, config_name=config_name),\n self.construct_header_dataset_name(brd, ch, config_name=config_name),\n ]\n for dset_name in names:\n if dset_name not in self.group:\n why = (\n f\"HDF5 structure unexpected...dataset '{dset_name}' \"\n f\"not found for board {brd} and channel {ch}\"\n f\"...removing combo from map\"\n )\n warn(why)\n chs_to_remove.append(ch)\n\n # ensure chs is not NULL\n chs_to_remove = list(set(chs_to_remove))\n for ch in chs_to_remove:\n new_chs.remove(ch)\n if len(new_chs) == 0:\n why = (\n f\"HDF5 structure unexpected...'Board number {brd}' does not \"\n f\"define any valid channel numbers...not adding to \"\n f\"`configs` dict\"\n )\n warn(why)\n\n # skip adding to conn list\n continue\n\n # get 'nshotnum' and 'nt' values\n chs_to_remove = []\n nshotnum = None\n nt = None\n for ch in new_chs:\n # -- examine dataset --\n dset_name = self.construct_dataset_name(brd, ch, config_name=config_name)\n dset = self.group[dset_name]\n\n # dataset should not have fields\n if dset.dtype.names is not None:\n why = (\n f\"HDF5 structure unexpected...dataset '{dset_name}' has \"\n f\"fields...not adding to `configs` dict\"\n )\n warn(why)\n chs_to_remove.append(ch)\n continue\n\n # dataset should be a 2D array\n if len(dset.shape) != 2:\n # dataset not 2D array\n why = (\n f\"HDF5 structure unexpected...dataset '{dset_name}' is \"\n f\"NOT a 2D array...not adding to `configs` dict\"\n )\n warn(why)\n chs_to_remove.append(ch)\n continue\n\n # Define and check nt\n # - should be consistent across all datasets\n if nt is None:\n nt = dset.shape[1]\n elif nt == -1:\n pass\n else:\n if nt != dset.shape[1]:\n why = (\n f\"HDF5 structure unexpected...number of time \"\n f\"sample inconsistent across all channels for \"\n f\"board {brd}...setting nt = -1\"\n )\n warn(why)\n nt = -1\n continue\n\n # Define and check nshotnum\n # - should be consistent across all datasets\n if nshotnum is None:\n nshotnum = dset.shape[0]\n elif nshotnum == -1:\n pass\n else:\n if nshotnum != dset.shape[0]:\n why = (\n f\"HDF5 structure unexpected...number of shot \"\n f\"numbers inconsistent across all channels for \"\n f\"board {brd}...setting nshotnum = -1\"\n )\n warn(why)\n nshotnum = -1\n continue\n\n # -- examine header dataset --\n hdset_name = self.construct_header_dataset_name(\n brd, ch, config_name=config_name\n )\n hdset = self.group[hdset_name]\n sn_field = self.configs[config_name][\"shotnum\"][\"dset field\"][0]\n\n # should have fields (specifically the shotnum field)\n if sn_field not in hdset.dtype.names:\n if \"Shot number\" in hdset.dtype.names and iconn == 0:\n sn_field = \"Shot number\"\n self.configs[config_name][\"shotnum\"][\"dset field\"] = (\n \"Shot number\",\n )\n else:\n why = (\n f\"HDF5 structure unexpected...dataset '{hdset_name}' \"\n f\"does NOT have expected shot number field \"\n f\"'{sn_field}'...not adding to `configs` dict\"\n )\n warn(why)\n chs_to_remove.append(ch)\n continue\n\n # shot number has incorrect shape and type\n if hdset.dtype[sn_field].shape != () or not np.issubdtype(\n hdset.dtype[sn_field], np.integer\n ):\n why = (\n f\"HDF5 structure unexpected...dataset '{hdset_name}' \"\n f\"does NOT have expected shape and dtype for a shot \"\n f\"numbers...not adding to `configs` dict\"\n )\n warn(why)\n chs_to_remove.append(ch)\n continue\n\n # both datasets (main and header) should have same\n # number of shot numbers\n if dset.shape[0] != hdset.shape[0]:\n why = (\n f\"HDF5 structure unexpected...dataset and header \"\n f\"dataset for board {brd} and channel {ch} do NOT have \"\n f\"the same number of shot numbers...not adding to \"\n f\"`configs` dict\"\n )\n warn(why)\n chs_to_remove.append(ch)\n continue\n\n # ensure chs is not NULL\n for ch in chs_to_remove:\n new_chs.remove(ch)\n if len(new_chs) == 0:\n why = (\n f\"HDF5 structure unexpected...'Board number {brd}' does not \"\n f\"define any valid channel numbers...not adding to \"\n f\"`configs` dict\"\n )\n warn(why)\n\n # skip adding to conn list\n continue\n\n # add nshotnum and nt to setup dict\n conn[2].update(\n {\n \"nshotnum\": nshotnum,\n \"nt\": nt,\n }\n )\n # append new_conns\n new_conns.append((brd, tuple(new_chs), conn[2]))\n\n return tuple(new_conns)","def get_fhd_layout_info(\n layout_file,\n telescope_name,\n latitude,\n longitude,\n altitude,\n radian_tol,\n loc_tols,\n obs_tile_names,\n run_check_acceptability=True,\n):\n layout_dict = readsav(layout_file, python_dict=True)\n layout = layout_dict[\"layout\"]\n\n layout_fields = [name.lower() for name in layout.dtype.names]\n # Try to get the telescope location from the layout file &\n # compare it to the position from the obs structure.\n arr_center = layout[\"array_center\"][0]\n layout_fields.remove(\"array_center\")\n\n xyz_telescope_frame = layout[\"coordinate_frame\"][0].decode(\"utf8\").lower()\n layout_fields.remove(\"coordinate_frame\")\n\n if xyz_telescope_frame.strip() == \"itrf\":\n # compare to lat/lon/alt\n location_latlonalt = uvutils.XYZ_from_LatLonAlt(latitude, longitude, altitude)\n latlonalt_arr_center = uvutils.LatLonAlt_from_XYZ(\n arr_center, check_acceptability=run_check_acceptability\n )\n\n # check both lat/lon/alt and xyz because of subtle differences\n # in tolerances\n if _xyz_close(location_latlonalt, arr_center, loc_tols) or _latlonalt_close(\n (latitude, longitude, altitude), latlonalt_arr_center, radian_tol, loc_tols\n ):\n telescope_location = arr_center\n else:\n # values do not agree with each other to within the tolerances.\n # this is a known issue with FHD runs on cotter uvfits\n # files for the MWA\n # compare with the known_telescopes values\n telescope_obj = uvtel.get_telescope(telescope_name)\n # start warning message\n message = (\n \"Telescope location derived from obs lat/lon/alt \"\n \"values does not match the location in the layout file.\"\n )\n\n if telescope_obj is not False:\n message += \" Using the value from known_telescopes.\"\n telescope_location = telescope_obj.telescope_location\n else:\n message += (\n \" Telescope is not in known_telescopes. \"\n \"Defaulting to using the obs derived values.\"\n )\n telescope_location = location_latlonalt\n # issue warning\n warnings.warn(message)\n else:\n telescope_location = uvutils.XYZ_from_LatLonAlt(latitude, longitude, altitude)\n\n # The FHD positions derive directly from uvfits, so they are in the rotated\n # ECEF frame and must be converted to ECEF\n rot_ecef_positions = layout[\"antenna_coords\"][0]\n layout_fields.remove(\"antenna_coords\")\n # use the longitude from the layout file because that's how the antenna\n # positions were calculated\n latitude, longitude, altitude = uvutils.LatLonAlt_from_XYZ(\n arr_center, check_acceptability=run_check_acceptability\n )\n antenna_positions = uvutils.ECEF_from_rotECEF(rot_ecef_positions, longitude)\n\n antenna_names = [ant.decode(\"utf8\") for ant in layout[\"antenna_names\"][0].tolist()]\n layout_fields.remove(\"antenna_names\")\n\n # make these 0-indexed (rather than one indexed)\n antenna_numbers = layout[\"antenna_numbers\"][0]\n layout_fields.remove(\"antenna_numbers\")\n\n Nants_telescope = int(layout[\"n_antenna\"][0])\n layout_fields.remove(\"n_antenna\")\n\n if telescope_name.lower() == \"mwa\":\n # check that obs.baseline_info.tile_names match the antenna names\n # (accounting for possible differences in white space)\n # this only applies for MWA because the tile_names come from\n # metafits files. layout[\"antenna_names\"] comes from the antenna table\n # in the uvfits file and will be used if no metafits was submitted\n if [ant.strip() for ant in obs_tile_names] != [\n ant.strip() for ant in antenna_names\n ]:\n warnings.warn(\n \"tile_names from obs structure does not match \"\n \"antenna_names from layout\"\n )\n\n gst0 = float(layout[\"gst0\"][0])\n layout_fields.remove(\"gst0\")\n\n if layout[\"ref_date\"][0] != \"\":\n rdate = layout[\"ref_date\"][0].decode(\"utf8\").lower()\n else:\n rdate = None\n layout_fields.remove(\"ref_date\")\n\n earth_omega = float(layout[\"earth_degpd\"][0])\n layout_fields.remove(\"earth_degpd\")\n\n dut1 = float(layout[\"dut1\"][0])\n layout_fields.remove(\"dut1\")\n\n timesys = layout[\"time_system\"][0].decode(\"utf8\").upper().strip()\n layout_fields.remove(\"time_system\")\n\n if \"diameters\" in layout_fields:\n diameters = np.asarray(layout[\"diameters\"])\n layout_fields.remove(\"diameters\")\n else:\n diameters = None\n\n extra_keywords = {}\n # ignore some fields, put everything else in extra_keywords\n layout_fields_ignore = [\n \"diff_utc\",\n \"pol_type\",\n \"n_pol_cal_params\",\n \"mount_type\",\n \"axis_offset\",\n \"pola\",\n \"pola_orientation\",\n \"pola_cal_params\",\n \"polb\",\n \"polb_orientation\",\n \"polb_cal_params\",\n \"beam_fwhm\",\n ]\n for field in layout_fields_ignore:\n if field in layout_fields:\n layout_fields.remove(field)\n for field in layout_fields:\n keyword = field\n if len(keyword) > 8:\n keyword = field.replace(\"_\", \"\")\n\n value = layout[field][0]\n if isinstance(value, bytes):\n value = value.decode(\"utf8\")\n\n extra_keywords[keyword.upper()] = value\n\n layout_param_dict = {\n \"telescope_location\": telescope_location,\n \"Nants_telescope\": Nants_telescope,\n \"antenna_positions\": antenna_positions,\n \"antenna_names\": antenna_names,\n \"antenna_numbers\": antenna_numbers,\n \"gst0\": gst0,\n \"rdate\": rdate,\n \"earth_omega\": earth_omega,\n \"dut1\": dut1,\n \"timesys\": timesys,\n \"diameters\": diameters,\n \"extra_keywords\": extra_keywords,\n }\n\n return layout_param_dict","def type3(sep_to_comps, dict_of_vars):\n dec_vars = dict_of_vars.keys()\n A3ineq = list()\n b3ineq = list()\n A3eq = list()\n b3eq = list()\n for s in sep_to_comps.keys():\n comps = sep_to_comps[s]\n p_set = list(powerset(comps))\n for p in p_set:\n hold_ineq = list()\n hold_eq = list()\n add_ineq = False\n if not (len(p) == len(comps)):\n add_ineq = True\n combos = list(combinations(p, 2))\n for pair in combos:\n for u in pair[0]:\n for v in pair[1]:\n uv = tuple(sorted([u, v]))\n if (uv, s) in dec_vars:\n hold_ineq.append(dict_of_vars[(uv, s)])\n else:\n combos = list(combinations(p, 2))\n for pair in combos:\n for u in pair[0]:\n for v in pair[1]:\n uv = tuple(sorted([u, v]))\n if (uv, s) in dec_vars:\n hold_eq.append(dict_of_vars[(uv, s)])\n if add_ineq:\n A3ineq.append(hold_ineq)\n b3ineq.append(len(p) - 1)\n else:\n A3eq.append(hold_eq)\n b3eq.append(len(p) - 1)\n\n A3 = sp.lil_matrix((len(A3ineq) + len(A3eq), len(dict_of_vars.keys())))\n b3 = np.zeros((len(b3ineq) + len(b3eq), ))\n row = 0\n for item in A3eq:\n for vals in item:\n A3[row, vals] = 1\n b3[row] = b3eq[row]\n row += 1\n hold = row\n for item in A3ineq:\n for vals in item:\n A3[row, vals] = 1\n b3[row] = b3ineq[row - hold]\n row += 1\n\n return A3, b3, len(b3eq)","def parse_layout(input_filename):\n with open(input_filename, 'r') as layout_file:\n height = int(layout_file.next().strip()) # = height\n layout_file.next() # = width\n n_info = int(layout_file.next().strip()) # = number of associated info pieces\n layout = \"\"\n for i in xrange(height):\n layout += layout_file.next()\n patt_info = \\\n re.compile(r\"^\\s*(?P<row>\\d+)\\s+(?P<col>\\d+)\\s+(?P<word>[\\w']+).*\")\n info_dict = {}\n for i in xrange(n_info):\n match_info = patt_info.match(layout_file.next())\n loc = ( int(match_info.group('row')), int(match_info.group('col')) )\n info_dict[loc] = match_info.group('word')\n return (layout, info_dict)","def is_valid_overlap_xy(dir_id, p1, p2, pattern_catalog, pattern_width, adjacency_directions):\n #dir_corrected = (0 - adjacency_directions[dir_id].x, 0 - adjacency_directions[dir_id].y)\n dir_corrected = (0 + adjacency_directions[dir_id].x, 0 + adjacency_directions[dir_id].y)\n dimensions = (1,0)\n not_a_number = -1\n #TODO: can probably speed this up by using the right slices, rather than rolling the whole pattern...\n #print(d, p2, p1)\n shifted = np.roll(np.pad(pattern_catalog[p2], pattern_width, mode='constant', constant_values = not_a_number), dir_corrected, dimensions)\n compare = shifted[pattern_width:pattern_width+pattern_width, pattern_width:pattern_width+pattern_width]\n left = max(0,0 + dir_corrected[0])\n right = min(pattern_width, pattern_width + dir_corrected[0])\n top = max(0,0 + dir_corrected[1])\n bottom = min(pattern_width, pattern_width + dir_corrected[1])\n a = pattern_catalog[p1][top:bottom,left:right]\n b = compare[top:bottom,left:right]\n res = np.array_equal(a,b)\n #print(f\"res: {res}\")\n return res","def parse_layout(layout):\n global index \n for lt_obj in layout:\n print(lt_obj.__class__.__name__)\n print(lt_obj.bbox)\n if isinstance(lt_obj, LTTextBox) or isinstance(lt_obj, LTTextLine):\n print(lt_obj.get_text())\n d[lt_obj.get_text().strip()]=(index,lt_obj.bbox)\n index+=1\n elif isinstance(lt_obj, LTFigure):\n parse_layout(lt_obj) # Recursive","def intersect_exit_hint(self, sq, hh):\n\n if not self.hints_prepped:\n self.reset_hints()\n self.hints_prepped=1\n pos=self.local2global(sq)\n if self.kind=='pararooms':\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.sqs]\n else:\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.allsqs]\n okwaysout=[]\n #~ if self.hashid=='bfb08f4204ceecf84767e77869cabce5x009x000':\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n for h in hh:\n if h[1]=='OUT':\n okwaysout.extend(to_outside_dvs)\n continue\n if h[0]=='IN':\n okwaysout.append(h[1])\n continue\n okwaysout.append(h[1])\n okwaysout=list(set(okwaysout))\n newh=set([gh for gh in self._global_hints[pos] if gh[1] in okwaysout])\n if not newh and self._global_hints[pos]:\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\n print 'promoting cause of a conflict between the rooms-exit',pos\n return pos\n self._global_hints[pos]=newh\n self._hints[sq]=newh.copy()","def generate_siaf_detector_layout():\n\n VIdlParity = -1\n layout = Table(dtype=['S100', 'S100', 'f4', 'i4', 'i4'] ,names=('InstrName', 'AperName', 'DetSciYAngle', 'DetSciParity', 'VIdlParity'))\n for instrument in 'NIRCam FGS NIRISS NIRSpec MIRI'.split():\n if instrument == 'NIRCam':\n for sca_name in 'A1 A3 A5 B2 B4'.split():\n layout.add_row([instrument.upper(), 'NRC{}_FULL'.format(sca_name), 0, -1, VIdlParity])\n for sca_name in 'A2 A4 B1 B3 B5'.split():\n layout.add_row([instrument.upper(), 'NRC{}_FULL'.format(sca_name), 180, -1, VIdlParity])\n for sca_name in ['NRCA2_FULL_WEDGE_RND','NRCA2_FULL_WEDGE_BAR','NRCA4_FULL_WEDGE_RND','NRCA4_FULL_WEDGE_BAR']:\n layout.add_row([instrument.upper(), '{}'.format(sca_name), 180, -1, VIdlParity])\n for sca_name in ['NRCA1_FULL_WEDGE_RND','NRCA1_FULL_WEDGE_BAR','NRCA3_FULL_WEDGE_RND','NRCA3_FULL_WEDGE_BAR','NRCA5_FULL_WEDGE_RND','NRCA5_FULL_WEDGE_BAR']:\n layout.add_row([instrument.upper(), '{}'.format(sca_name), 0, -1, VIdlParity])\n elif instrument == 'NIRISS':\n for sca_name in ['NIS_CEN']:\n layout.add_row([instrument, sca_name, 180, 1, VIdlParity])\n elif instrument == 'MIRI':\n for sca_name in ['MIRIM_FULL']:\n layout.add_row([instrument, sca_name, 0, 1, VIdlParity])\n elif instrument == 'NIRSpec':\n for sca_name in ['NRS1_FULL']:\n layout.add_row([instrument.upper(), sca_name, 0, 1, VIdlParity])\n for sca_name in ['NRS2_FULL']:\n layout.add_row([instrument.upper(), sca_name, 180, 1, VIdlParity])\n elif instrument == 'FGS':\n for sca_name in ['FGS1_FULL']:\n layout.add_row([instrument, sca_name, 180, 1, VIdlParity])\n for sca_name in ['FGS2_FULL']:\n layout.add_row([instrument, sca_name, 0, -1, VIdlParity])\n\n layout_file = os.path.join(JWST_SOURCE_DATA_ROOT, 'siaf_detector_layout.txt')\n\n layout.pprint()\n\n comments = []\n comments.append('SIAF detector layout definition file.'.format(instrument))\n comments.append('')\n comments.append('These apertures act as parent apertures of all other SI apertures and their parameters are thus inherited.')\n comments.append('')\n comments.append('Generated {} {}'.format(timestamp.isot, timestamp.scale))\n comments.append('by {}'.format(username))\n comments.append('')\n layout.meta['comments'] = comments\n layout.write(layout_file, format='ascii.fixed_width', delimiter=',',\n delimiter_pad=' ', bookend=False)","def test_find_multitable_conflicting_paths(self):\n ruleset_a = [\n Rule(priority=10, table=0,\n match=Match([('VLAN_VID', 1, None)]),\n instructions=Instructions(dup=goto1)),\n Rule(priority=10, table=0,\n match=Match([('VLAN_VID', 2, None)]),\n instructions=Instructions(dup=goto2)),\n Rule(priority=0, table=0),\n Rule(priority=20, table=1,\n match=Match([('IPV4_DST', 0, 0xFFFFFFFE)]),\n instructions=Instructions(dup=output1)),\n Rule(priority=19, table=1,\n match=Match([('IPV4_DST', 0, None)]),\n instructions=Instructions(dup=output1)),\n Rule(priority=0, table=1),\n Rule(priority=30, table=2,\n match=Match([('IPV4_DST', 0, None)]),\n instructions=Instructions()),\n Rule(priority=30, table=2,\n match=Match([('IPV4_DST', 1, None)]),\n instructions=Instructions()),\n Rule(priority=0, table=2)\n ]\n\n ruleset_b = [\n Rule(priority=14, table=0,\n match=Match([('VLAN_VID', 1, None), ('IPV4_DST', 0, None)])),\n Rule(priority=14, table=0,\n match=Match([('VLAN_VID', 1, None), ('IPV4_DST', 1, None)]),\n instructions=Instructions(dup=output1)),\n Rule(priority=14, table=0,\n match=Match([('VLAN_VID', 2, None), ('IPV4_DST', 0, None)]),\n instructions=Instructions(dup=output1)),\n Rule(priority=14, table=0,\n match=Match([('VLAN_VID', 2, None), ('IPV4_DST', 1, None)])),\n Rule(priority=0, table=0)\n ]\n\n single_a = to_single_table(ruleset_a)\n single_b = to_single_table(ruleset_b)\n norm_a = normalise(single_a)\n norm_b = normalise(single_b)\n\n result_ab = {\n (ruleset_a[0], ruleset_a[3]): frozenset([(ruleset_b[0],)]),\n (ruleset_a[1], ruleset_a[6]): frozenset([(ruleset_b[2],)])\n }\n result_ba = {\n (ruleset_b[0],): frozenset([(ruleset_a[0], ruleset_a[3])]),\n (ruleset_b[2],): frozenset([(ruleset_a[1], ruleset_a[6])])\n }\n\n equal_ab, diff_ab = check_equal(norm_a, norm_b, diff=True)\n self.assertFalse(equal_ab)\n equal_ba, diff_ba = check_equal(norm_b, norm_a, diff=True)\n self.assertFalse(equal_ba)\n\n paths_ab = find_conflicting_paths(diff_ab, single_a, single_b)\n paths_ba = find_conflicting_paths(diff_ab, single_b, single_a)\n\n self.assertEqual(paths_ab, result_ab)\n self.assertNotEqual(paths_ab, result_ba) # Sanity\n self.assertEqual(paths_ba, result_ba)","def add_layout_pins(self):\n\n # All wordlines\n # Main array wl and bl/br\n for pin_name in self.all_wordline_names:\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\n for pin in pin_list:\n self.add_layout_pin(text=pin_name,\n layer=pin.layer,\n offset=pin.ll().scale(0, 1),\n width=self.width,\n height=pin.height())\n\n # Replica wordlines (go by the row instead of replica column because we may have to add a pin\n # even though the column is in another local bitcell array)\n for (names, inst) in zip(self.rbl_wordline_names, self.dummy_row_replica_insts):\n for (wl_name, pin_name) in zip(names, self.dummy_row.get_wordline_names()):\n if wl_name in self.gnd_wordline_names:\n continue\n pin = inst.get_pin(pin_name)\n self.add_layout_pin(text=wl_name,\n layer=pin.layer,\n offset=pin.ll().scale(0, 1),\n width=self.width,\n height=pin.height())\n\n for pin_name in self.all_bitline_names:\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\n for pin in pin_list:\n self.add_layout_pin(text=pin_name,\n layer=pin.layer,\n offset=pin.ll().scale(1, 0),\n width=pin.width(),\n height=self.height)\n\n # Replica bitlines\n if len(self.rbls) > 0:\n for (names, inst) in zip(self.rbl_bitline_names, self.replica_col_insts):\n pin_names = self.replica_columns[self.rbls[0]].all_bitline_names\n for (bl_name, pin_name) in zip(names, pin_names):\n pin = inst.get_pin(pin_name)\n self.add_layout_pin(text=bl_name,\n layer=pin.layer,\n offset=pin.ll().scale(1, 0),\n width=pin.width(),\n height=self.height)","def occupied(r, c, layout):\n occupy = 0\n\n NW = (-1, -1)\n NE = (-1, 1)\n N = (-1, 0)\n W = (0, -1)\n E = (0, 1)\n SW = (1, -1)\n SE = (1, 1)\n S = (1, 0)\n\n for dirs in [NW, NE, N, W, E, SW, SE, S]:\n dr, dc = r+dirs[0], c + dirs[1]\n if (dr >= 0) and (dc >= 0) and (dr < len(layout)) and (dc < len(layout[0])):\n if layout[dr][dc] == '#':\n occupy += 1\n\n return occupy","def check_sizes(self, show=True):\n # find pixel with common RA \n comRApix = np.where((self.coords1[0]<=np.max(self.coords2[0]))&\n (self.coords1[0]>=np.min(self.coords2[0]))\n )[0]\n \n # find pixels with common DEC \n comDECpix = np.where((self.coords1[1]<=np.max(self.coords2[1]))&\n (self.coords1[1]>=np.min(self.coords2[1]))\n )[0]\n \n print('Image 1 common pixels size: ({:}, {:})'.format(comRApix.size,\n comDECpix.size))\n \n # Corner coordinates \n minRA = np.min(self.coords1[0][comRApix])\n maxRA = np.max(self.coords1[0][comRApix])\n minDEC = np.min(self.coords1[1][comDECpix])\n maxDEC = np.max(self.coords1[1][comDECpix])\n if show:\n comFrame = plt.Rectangle(xy=(minRA, minDEC), width=maxRA-minRA,\n height=maxDEC-minDEC, hatch='\\\\', fill=True,\n color='g', alpha=.3)\n fig = plt.figure(figsize=(10,10))\n ax = fig.add_subplot(111)\n ax.add_patch(comFrame)\n ax.add_patch(self.image1.plotframe(color='r'))\n ax.add_patch(self.image2.plotframe(color='b'))\n ax.annotate('Image 1', xy=(minRA,maxDEC), color='r')\n ax.plot() \n plt.show()\n \n self.boundRA = np.array([minRA, maxRA])\n self.boundDEC = np.array([minDEC, maxDEC]) \n self.bounds1 = np.array([[comRApix[0], comRApix[-1]], \n [comDECpix[0], comDECpix[-1]]])\n \n if self.image1.get_pix_area() < self.image2.get_pix_area():\n print('Image 1 have smaller pixels than 2. \\n')\n self.pix_1_smaller = True \n else:\n print('Image 2 have smaller pixels than 1. \\n')\n self.pix_1_smaller = False","def problem_8():\n\n n = 8\n x = [0] * n\n D = [list(range(n)) for _ in range(n)]\n\n # `solns` will map (x1,x2,..,x6) to a list of full solutions.\n solns = defaultdict(list)\n for i, q in enumerate(algorithm_b(x, D, n_queens_is_good)):\n key = tuple(q[:6])\n solns[key].append((i + 1, q))\n if len(solns[key]) == 2:\n soln1, soln2 = solns[key]\n print()\n print('_' * 70)\n print(f'Solutions {soln1[0]} and {soln2[0]} are a pair:')\n print()\n print_board(soln1[1])\n print()\n print_board(soln2[1])","def check_topology(self, ninputs, noutputs):\n return _spacegrant_swig.invert_bit_sptr_check_topology(self, ninputs, noutputs)","def check_constraints(Px,pk1,pk2,mu1,mu2,mu3):\n # Constraint 1: Check polarisation basis probabilities are valid.\n if (Px >= 1.0 or Px <= 0.0):\n print(\"Error! Constraint 1 < Px < 0: \", Px)\n exit(1)\n # Constraint 2: Check probability of pulse with intensity 1 is in bounds.\n if (pk1 >= 1.0 or pk1 <= 0.0):\n print(\"Error! Constraint 1 < pk1 < 0: \", pk1)\n exit(1)\n # Constraint 3: Check probability of pulse with intensity 2 is in bounds.\n if (pk2 >= 1.0 or pk2 <= 0.0):\n print(\"Error! Constraint 1 < pk2 < 0: \", pk2)\n exit(1)\n # Constraint 4: Check sum of probabilities for intensity 1 & 2 are less\n # than unity.\n if ((pk1 + pk2) >= 1.0):\n print(\"Error! Constraint (pk1 + pk2) < 1: \", pk1 + pk2)\n exit(1)\n # Constraint 5: Check value of intensity 1 is in bounds.\n if (mu1 >= 1.0 or mu1 <= 0.0):\n print(\"Error! Constraint 1 < mu1 < 0: \", mu1)\n exit(1)\n # Constraint 6: Check value of intensity 2 is in bounds.\n if (mu2 >= 1.0 or mu2 <= 0.0):\n print(\"Error! Constraint 1 < mu2 < 0: \", mu2)\n exit(1)\n # Constraint 7: Check values of all intensities are in bounds.\n if ((mu1 - mu3) <= mu2):\n print(\"Error! Constraint (mu1-mu3) > mu2: \", (mu1-mu3), mu2)\n exit(1)\n # Constraint 8: Check values of intensities 2 & 3 are in bounds.\n if (mu2 <= mu3):\n print(\"Error! Constraint mu2 > mu3: \", mu2, mu3)\n exit(1)\n return None","def _check_c(self, constraint, *variables):\n c = {c.__class__ for c in self._layout.solver.get(*variables)}\n if constraint:\n self.assertTrue(constraint in c)\n else:\n self.assertFalse(c)","def solve_one():\n first_row = input_ints()[0]\n first_matrix = []\n for _ in range(4):\n first_matrix.append(input_ints())\n first_poss = set(first_matrix[first_row-1])\n\n second_row = input_ints()[0]\n second_matrix = []\n for _ in range(4):\n second_matrix.append(input_ints())\n second_poss = set(second_matrix[second_row-1])\n \n solutions = first_poss.intersection(second_poss)\n\n if len(solutions) == 0:\n return 'Volunteer cheated!'\n elif len(solutions) > 1:\n return 'Bad magician!'\n else:\n return list(solutions)[0]","def parse_layout(self, sections, group_size):\n layout = self.layout\n for section in sections:\n for row in layout[section]:\n try:\n column = \"\".join(row).index(\"S\" * group_size)\n return (layout[section].index(row), column, section)\n except ValueError:\n # There is no room in this row\n pass\n # Could Not find an room for the group in all sections\n raise NoRoomError","def ADM_SM_QCD(nf):\n\n adm_qqp_qqp = np.array([[0, 0, 0, 0, 0, 12, 0, 0],\n [0, 0, 0, 0, 12, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 12],\n [0, 0, 0, 0, 0, 0, 12, 0],\n [0, 8/3, 0, 0, - 19/3, 5, 0, 0],\n [8/3, 0, 0, 0, 5, - 9, 0, 0],\n [0, 0, 0, 8/3, 0, 0, - 23/3, 5],\n [0, 0, 8/3, 0, 0, 0, 5, - 23/3]])\n\n adm_qqp_qqpp = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 4/3, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 4/3, 0],\n [0, 0, 0, 0, 0, 0, 0, 0]])\n\n adm_qpq_qppq = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 4/3, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 4/3]])\n\n adm_qqp_qppq = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 4/3, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 4/3],\n [0, 0, 0, 0, 0, 0, 0, 0]])\n\n adm_qpq_qqpp = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 4/3, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 4/3, 0]])\n\n adm_q_q = np.array([[4, 4, 0, - 28/3],\n [0, 0, 0, 44/3],\n [0, 0, 44/9, 0],\n [5/3, 13/3, 0, - 106/9]])\n\n adm_qqp_q = np.array([[0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 4/3],\n [0, 0, 0, 0],\n [0, 0, 4/9, 0],\n [0, 0, 0, 0]])\n\n\n adm_qpq_q = np.array([[0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 4/3],\n [0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 4/9, 0]])\n\n adm_q_qqp = np.array([[0, 0, 0, 0, 8/3, 0, 0, 0],\n [0, 0, 0, 0, 8/3, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 8/3, 0],\n [0, 0, 0, 0, 20/9, 0, 0, 0]])\n\n adm_q_qpq = np.array([[0, 0, 0, 0, 8/3, 0, 0, 0],\n [0, 0, 0, 0, 8/3, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 8/3],\n [0, 0, 0, 0, 20/9, 0, 0, 0]])\n\n adm_ud = np.hstack((adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qpq_qqpp, adm_qpq_qqpp,\\\n adm_qpq_qqpp, np.zeros((8, 24)), adm_qqp_q, adm_qpq_q, np.zeros((8,12))))\n\n adm_us = np.hstack((adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qpq_qppq, np.zeros((8,16)),\\\n adm_qpq_qqpp, adm_qpq_qqpp, np.zeros((8, 8)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q, np.zeros((8,8))))\n\n adm_uc = np.hstack((adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp, np.zeros((8,8)), adm_qpq_qppq,\\\n np.zeros((8,8)), adm_qpq_qppq, np.zeros((8, 8)), adm_qpq_qqpp, adm_qqp_q, np.zeros((8,8)), adm_qpq_q, np.zeros((8,4))))\n\n adm_ub = np.hstack((adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp, np.zeros((8,16)), adm_qpq_qppq,\\\n np.zeros((8,8)), adm_qpq_qppq, adm_qpq_qppq, adm_qqp_q, np.zeros((8,12)), adm_qpq_q))\n\n adm_ds = np.hstack((adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,16)), adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp,\\\n adm_qpq_qqpp, adm_qpq_qqpp, np.zeros((8,8)), np.zeros((8,4)), adm_qqp_q, adm_qpq_q, np.zeros((8,8))))\n\n adm_dc = np.hstack((adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp,\\\n adm_qpq_qppq, np.zeros((8,8)), adm_qpq_qqpp, np.zeros((8,4)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q, np.zeros((8,4))))\n\n adm_db = np.hstack((adm_qqp_qppq, np.zeros((8,16)), adm_qpq_qppq, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp,\\\n np.zeros((8,8)), adm_qpq_qppq, adm_qpq_qppq, np.zeros((8,4)), adm_qqp_q, np.zeros((8,8)), adm_qpq_q))\n\n adm_sc = np.hstack((np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)),\\\n adm_qqp_qqp, adm_qqp_qqpp, adm_qpq_qqpp, np.zeros((8,8)), adm_qqp_q, adm_qpq_q, np.zeros((8,4))))\n\n adm_sb = np.hstack((np.zeros((8,8)), adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq, adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq,\\\n adm_qqp_qqpp, adm_qqp_qqp, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q))\n\n adm_cb = np.hstack((np.zeros((8,16)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq,\\\n adm_qqp_qppq, adm_qpq_qppq, adm_qqp_qqp, np.zeros((8,12)), adm_qqp_q, adm_qpq_q))\n\n adm_u = np.hstack((adm_q_qqp, adm_q_qqp, adm_q_qqp, adm_q_qqp, np.zeros((4,48)), adm_q_q, np.zeros((4,16))))\n\n adm_d = np.hstack((adm_q_qpq, np.zeros((4,24)), adm_q_qqp, adm_q_qqp, adm_q_qqp, np.zeros((4,24)), np.zeros((4,4)), adm_q_q, np.zeros((4,12))))\n\n adm_s = np.hstack((np.zeros((4,8)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,16)), adm_q_qqp, adm_q_qqp, np.zeros((4,8)),\\\n np.zeros((4,8)), adm_q_q, np.zeros((4,8))))\n\n adm_c = np.hstack((np.zeros((4,16)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,8)), adm_q_qpq, np.zeros((4,8)), adm_q_qqp,\\\n np.zeros((4,12)), adm_q_q, np.zeros((4,4))))\n\n adm_b = np.hstack((np.zeros((4,24)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,8)), adm_q_qpq, adm_q_qpq, np.zeros((4,16)), adm_q_q))\n\n\n adm = np.vstack((adm_ud, adm_us, adm_uc, adm_ub, adm_ds, adm_dc, adm_db, adm_sc, adm_sb, adm_cb, adm_u, adm_d, adm_s, adm_c, adm_b))\n\n if nf == 5:\n return adm\n elif nf == 4:\n return np.delete(np.delete(adm, np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80], np.s_[96:100]], 0),\\\n np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80], np.s_[96:100]], 1)\n else:\n raise Exception(\"nf has to be 4 or 5\")","def add_layout_pins(self):\n en_offset = self.dc_inst.get_pin(\"in\").ll()\n self.add_layout_pin(text=\"en\",\n layer=\"metal1\",\n offset=en_offset.scale(1,0),\n width=self.m1_width,\n height=en_offset.y)\n\n out_offset = self.rbl_inv_inst.get_pin(\"Z\").ll()\n self.add_layout_pin(text=\"out\",\n layer=\"metal1\",\n offset=out_offset.scale(1,0),\n width=self.m1_width,\n height=out_offset.y)","def test_collect_indicator_layouts_dependencies(self, module_repo):\n expected_result = {\n (\"FeedMitreAttack\", True),\n (\"CommonTypes\", True),\n (\"CrisisManagement\", True),\n }\n\n test_input = [\n {\n \"Dummy Layout\": {\n \"typeID\": \"dummy_layout\",\n \"name\": \"Dummy Layout\",\n \"pack\": \"dummy_pack\",\n \"kind\": \"indicatorsDetails\",\n \"path\": \"dummy_path\",\n \"incident_and_indicator_types\": [\n \"MITRE ATT&CK\",\n \"Prisma Cloud Compute Cloud Discovery\",\n ],\n \"incident_and_indicator_fields\": [\n \"indicator_adminname\",\n \"indicator_jobtitle\",\n ],\n }\n }\n ]\n\n found_result = PackDependencies._collect_layouts_dependencies(\n pack_layouts=test_input,\n id_set=module_repo.id_set.read_json_as_dict(),\n )\n\n assert set(found_result) == set(expected_result)","def setup_layout(self, board_layout):\n # Create pin instances based on board layout\n self.analog = []\n for i in board_layout['analog']:\n self.analog.append(Pin(self, i))\n\n self.digital = []\n self.digital_ports = []\n for i in xrange(0, len(board_layout['digital']), 8):\n num_pins = len(board_layout['digital'][i:i+8])\n port_number = i / 8\n self.digital_ports.append(Port(self, port_number, num_pins))\n\n # Allow to access the Pin instances directly\n for port in self.digital_ports:\n self.digital += port.pins\n \n # Setup PWM pins\n for i in board_layout['pwm']:\n self.digital[i].PWM_CAPABLE = True\n\n # Disable certain ports like Rx/Tx and crystal ports\n for i in board_layout['disabled']:\n self.digital[i].mode = UNAVAILABLE\n\n # Create a dictionary of 'taken' pins. Used by the get_pin method\n self.taken = { 'analog' : dict(map(lambda p: (p.pin_number, False), self.analog)),\n 'digital' : dict(map(lambda p: (p.pin_number, False), self.digital)) }\n\n # Setup default handlers for standard incoming commands\n self.add_cmd_handler(ANALOG_MESSAGE, self._handle_analog_message)\n self.add_cmd_handler(ANALOG_MAPPING_RESPONSE, self._handle_analog_mapping_response)\n self.add_cmd_handler(DIGITAL_MESSAGE, self._handle_digital_message)\n self.add_cmd_handler(REPORT_VERSION, self._handle_report_version)\n self.add_cmd_handler(REPORT_FIRMWARE, self._handle_report_firmware)\n self.add_cmd_handler(PING_REPLY, self._handle_ping_reply)\n self.add_cmd_handler(PULSE_REPLY, self._handle_pulse_reply)\n self.add_cmd_handler(I2C_REPLY, self._handle_i2c_reply)","def linear_program_eq(self, c, A, b, lb, ub):\n if self.solver == solver_SCIPY:\n c = c.reshape((c.size,))\n b = b.reshape((b.size,))\n return scipy_linear_program_eq(c, A, b, lb, ub)\n elif self.solver == solver_GUROBI:\n return gurobi_linear_program_eq(c, A, b, lb, ub)\n else:\n raise ValueError('QP solver %s not available' % self.solver)","def ap_index_bounds(self, qa_lows, qa_highs, ap_coordinates):\n\n # Treat the first alignment area separately. Its lower bound is the first alignment point.\n qa_ap_index_lows = [0]\n\n # Starting with the second alignment point, search for the first one on the upper area\n # border or beyond it. Take it as the upper index bound.\n for ap_index, ap_value in enumerate(ap_coordinates[1:]):\n if ap_value >= qa_highs[0]:\n qa_ap_index_highs = [ap_index + 2]\n break\n\n # For interior quality areas\n for qa_index_m1, qa_low in enumerate(qa_lows[1:-1]):\n\n # The index of the quality area (qa_index) has to be increased by one because the list\n # used for the enumerator starts with the second entry.\n qa_index = qa_index_m1 + 1\n qa_high = qa_highs[qa_index]\n\n # For the lower index bound, look for the first alignment point on the lower border\n # or beyond in reversed order.\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\n if ap_value <= qa_low:\n qa_ap_index_lows.append(ap_index)\n break\n\n # For the upper index bound, look for the first alignment point on the upper border\n # or beyond.\n for ap_index, ap_value in enumerate(ap_coordinates):\n if ap_value >= qa_high:\n qa_ap_index_highs.append(ap_index + 1)\n break\n\n # The last alignment point index was removed from the search. If this is the upper bound\n # for the last inner quality area, it has not been assigned to the index_highs list. In\n # this case this list is one entry short. In this case add the index of the last alignment\n # point as the upper index bound.\n if len(qa_ap_index_highs) < len(qa_ap_index_lows):\n qa_ap_index_highs.append(len(ap_coordinates))\n\n # In analogy to the first quality area, treat the case of the last quality area separately\n # as well.\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\n if ap_value <= qa_lows[-1]:\n qa_ap_index_lows.append(ap_index)\n break\n # The upper index bound is always the last alignment point index.\n qa_ap_index_highs.append(len(ap_coordinates))\n\n return qa_ap_index_lows, qa_ap_index_highs","def test_flat_multibit():\n\n @chip\n def Not2(inputs, outputs):\n outputs.out[0] = Nand(a=inputs.in_[0], b=inputs.in_[0]).out\n outputs.out[1] = Nand(a=inputs.in_[1], b=inputs.in_[1]).out\n\n not2 = Not2.constr()\n\n assert not2.inputs() == {\"in_\": 2}\n assert not2.outputs() == {\"out\": 2}\n\n assert len(not2.wires) == 6 # TODO: how to assert on the structure?\n\n assert run(Not2, in_=0b01).out == 0b10\n assert run(Not2, in_=0b10).out == 0b01","def test_layout(self, gen_sch: bool = True) -> None:\n\n lay_params = self._info.first_params\n dsn_name = self._info.dsn_basename + '_TEST'\n\n print('create test layout')\n sch_name_param_list = self.create_dut_layouts([(dsn_name, lay_params)])\n\n if gen_sch:\n print('create test schematic')\n self.create_dut_schematics(sch_name_param_list, gen_wrappers=False)\n print('done')","def draw_layout(self):\n\n if not self.fg2d_s_short:\n raise ValueError('This template current only works if source wires of fg2d are shorted.')\n\n threshold = self.params['threshold']\n draw_boundaries = self.params['draw_boundaries']\n num_blk = self.params['num_blk']\n show_pins = self.params['show_pins']\n\n row_list = ['ptap', 'nch', 'pch', 'ntap']\n orient_list = ['R0', 'MX', 'R0', 'MX']\n thres_list = [threshold] * 4\n\n # compute number of tracks\n # note: because we're using thick wires, we need to compute space needed to\n # satisfy DRC rules\n hm_layer = self.conn_layer + 1\n num_g_tracks = [0, 0, 0, 0]\n num_gb_tracks = [0, 0, 0, 0]\n num_ds_tracks = [0, 0, 0, 0]\n\n # to draw special stack driver primitive, we need to enable dual_gate options.\n options = dict(dual_gate=True)\n row_kwargs = [{}, options, options, {}]\n if draw_boundaries:\n end_mode = 15\n else:\n end_mode = 0\n\n # specify row types\n self.set_row_types(row_list, orient_list, thres_list, draw_boundaries, end_mode,\n num_g_tracks, num_gb_tracks, num_ds_tracks, guard_ring_nf=0,\n row_kwargs=row_kwargs)\n\n # determine total number of blocks\n # draw nwell tap\n row_idx = 3\n nw_tap = self.add_laygo_primitive('sub', loc=(0, row_idx), nx=num_blk, spx=1)\n\n # draw pmos row\n row_idx = 2\n pmos = self.add_laygo_primitive('dual_stack2s', loc=(0, row_idx), nx=num_blk, spx=1)\n\n # draw nmos row\n row_idx = 1\n nmos = self.add_laygo_primitive('dual_stack2s', loc=(0, row_idx), nx=num_blk, spx=1)\n\n # draw pwell tap\n row_idx = 0\n pw_tap = self.add_laygo_primitive('sub', loc=(0, row_idx), nx=num_blk, spx=1)\n\n # compute overall block size\n self.set_laygo_size(num_col=num_blk + 4)\n self.fill_space()\n # draw boundaries and get guard ring power rail tracks\n self.draw_boundary_cells()","def test_to_qcschema(self):\n # the molecule has no coordinates so this should fail\n ethanol = Molecule.from_smiles(\"CCO\")\n with pytest.raises(InvalidConformerError):\n qcschema = ethanol.to_qcschema()\n\n # now remake the molecule from the sdf\n ethanol = Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\"))\n # make sure that requests to missing conformers are caught\n with pytest.raises(InvalidConformerError):\n qcschema = ethanol.to_qcschema(conformer=1)\n # now make a valid qcschema and check its properties\n qcschema = ethanol.to_qcschema(extras={\"test_tag\": \"test\"})\n # make sure the properties match\n charge = 0\n connectivity = [\n (0, 1, 1.0),\n (0, 4, 1.0),\n (0, 5, 1.0),\n (0, 6, 1.0),\n (1, 2, 1.0),\n (1, 7, 1.0),\n (1, 8, 1.0),\n (2, 3, 1.0),\n ]\n symbols = [\"C\", \"C\", \"O\", \"H\", \"H\", \"H\", \"H\", \"H\", \"H\"]\n\n def assert_check():\n assert charge == qcschema.molecular_charge\n assert connectivity == qcschema.connectivity\n assert symbols == qcschema.symbols.tolist()\n assert (\n qcschema.geometry.all() == ethanol.conformers[0].m_as(unit.bohr).all()\n )\n\n assert_check()\n assert qcschema.extras[\"test_tag\"] == \"test\"\n assert qcschema.extras[\n \"canonical_isomeric_explicit_hydrogen_mapped_smiles\"\n ] == ethanol.to_smiles(mapped=True)\n # # now run again with no extras passed, only cmiles entry will be present with fix-720\n qcschema = ethanol.to_qcschema()\n assert_check()\n assert qcschema.extras[\n \"canonical_isomeric_explicit_hydrogen_mapped_smiles\"\n ] == ethanol.to_smiles(mapped=True)","def draw_integ_amp(self, # type: HybridQDRBase\n col_idx, # type: int\n seg_dict, # type: Dict[str, int]\n invert=False, # type: bool\n fg_min=0, # type: int\n fg_dum=0, # type: int\n fg_sep_hm=0, # type: int\n idx_dict=None, # type: Optional[Dict[str, int]]]\n net_prefix='', # type: str\n net_suffix='', # type: str\n ):\n # type: (...) -> Tuple[Dict[str, Union[WireArray, List[WireArray]]], Dict[str, Any]]\n if idx_dict is None:\n idx_dict = {}\n\n # get layout information\n amp_info = self.qdr_info.get_integ_amp_info(seg_dict, fg_min=fg_min,\n fg_dum=fg_dum, fg_sep_hm=fg_sep_hm)\n seg_load = seg_dict.get('load', 0)\n seg_casc = seg_dict.get('casc', 0)\n seg_but = seg_dict.get('but', 0)\n seg_tsw = seg_dict.get('tsw', 0)\n en_only = seg_dict.get('en_only', False)\n en_swap = seg_dict.get('en_swap', False)\n fg_tot = amp_info['fg_tot']\n col_dict = amp_info['col_dict']\n sd_dict = amp_info['sd_dict']\n sd_dir_dict = amp_info['sd_dir_dict']\n\n ports = self._draw_integ_amp_mos(col_idx, fg_tot, seg_dict, col_dict, sd_dict, sd_dir_dict,\n net_prefix=net_prefix, net_suffix=net_suffix)\n\n # connect wires\n self.connect_to_substrate('ptap', ports['VSS'])\n # get TrackIDs\n foot_tid = self.get_wire_id('nch', 0, 'ds', wire_idx=0)\n tail_tid = self.get_wire_id('nch', 1, 'ds', wire_name='ntail')\n outn_tid = self.get_wire_id('pch', 0, 'ds2', wire_idx=0, wire_name='out')\n outp_tid = self.get_wire_id('pch', 0, 'ds2', wire_idx=1, wire_name='out')\n inn_tid = self.get_wire_id('nch', 2, 'g2', wire_idx=0, wire_name='in')\n inp_tid = self.get_wire_id('nch', 2, 'g2', wire_idx=1, wire_name='in')\n mp_tid = self.get_wire_id('pch', 1, 'ds', wire_name='ptail')\n nclk_tid = self.get_wire_id('nch', 0, 'g', wire_idx=idx_dict.get('nclk', -1))\n nen_tid = self.get_wire_id('nch', 1, 'g', wire_idx=idx_dict.get('nen', -1))\n\n # connect intermediate nodes\n foot = self.connect_to_tracks(ports['foot'], foot_tid, min_len_mode=0)\n tail = self.connect_to_tracks(ports['tail'], tail_tid, min_len_mode=0)\n # connect gates\n hm_layer = outp_tid.layer_id\n nclk = self.connect_to_tracks(ports['nclk'], nclk_tid)\n nen = self.connect_to_tracks(ports['nen'], nen_tid)\n\n out_w = outp_tid.width\n outp_idx = outp_tid.base_index\n outn_idx = outn_tid.base_index\n if invert:\n outp_warrs, outn_warrs = ports['outn'], ports['outp']\n else:\n outp_warrs, outn_warrs = ports['outp'], ports['outn']\n outp, outn = self.connect_differential_tracks(outp_warrs, outn_warrs, hm_layer,\n outp_idx, outn_idx, width=out_w)\n in_w = inp_tid.width\n inp_idx = inp_tid.base_index\n inn_idx = inn_tid.base_index\n inp, inn = self.connect_differential_tracks(ports['inp'], ports['inn'], hm_layer,\n inp_idx, inn_idx, width=in_w)\n\n ans = dict(inp=inp, inn=inn, outp=outp, outn=outn, nen3=nen, biasp=nclk,\n foot=foot, tail=tail)\n\n # draw load connections\n if seg_load > 0:\n self.connect_to_substrate('ntap', ports['VDD'])\n for name in ('pm0p', 'pm0n', 'pm1p', 'pm1n'):\n cur_ports = ports[name]\n if cur_ports[0].track_id.num > 1:\n warr = self.connect_to_tracks(cur_ports, mp_tid, min_len_mode=0)\n else:\n warr = self.connect_wires(cur_ports)[0]\n ans[name] = warr\n\n pen0_tid = self.get_wire_id('pch', 0, 'g', wire_idx=idx_dict.get('pen0', 0))\n pen1_tid = self.get_wire_id('pch', 0, 'g', wire_idx=idx_dict.get('pen1', 1))\n pclk0_tid = self.get_wire_id('pch', 1, 'g', wire_idx=idx_dict.get('pclk0', 0))\n pclk1_tid = self.get_wire_id('pch', 1, 'g', wire_idx=idx_dict.get('pclk1', 1))\n if en_only:\n gate_wires = ports['pen0'] + ports['pen1']\n pen0 = self.connect_to_tracks(gate_wires, pen1_tid)\n else:\n pen0, pen1 = self.connect_differential_tracks(ports['pen0'], ports['pen1'],\n hm_layer,\n pen0_tid.base_index,\n pen1_tid.base_index,\n width=pen0_tid.width)\n if en_swap:\n ans['clkp'] = pen1\n else:\n ans['pen2'] = pen1\n pclk0, pclk1 = self.connect_differential_tracks(ports['pclk0'], ports['pclk1'],\n hm_layer, pclk0_tid.base_index,\n pclk1_tid.base_index,\n width=pclk0_tid.width)\n if en_swap:\n ans['clkn'] = pen0\n ans['pen2'] = pclk1\n ans['pen3'] = pclk0\n else:\n ans['pen3'] = pen0\n ans['clkp'] = pclk1\n ans['clkn'] = pclk0\n\n # connect cascode if necessary\n if seg_casc > 0 or seg_but > 0:\n nm_tid = self.get_wire_id('nch', 3, 'ds', wire_name='ptail')\n nmp = ports['nmp']\n if nmp[0].track_id.num == 1:\n nmp = self.connect_wires(ports['nmp'])[0]\n nmn = self.connect_wires(ports['nmn'])[0]\n else:\n nmp = self.connect_to_tracks(ports['nmp'], nm_tid)\n nmn = self.connect_to_tracks(ports['nmn'], nm_tid)\n ans['nmp'] = nmp\n ans['nmn'] = nmn\n if seg_casc > 0:\n casc_tid = self.get_wire_id('nch', 3, 'g', wire_idx=idx_dict.get('casc', -1))\n casc = self.connect_to_tracks(ports['casc'], casc_tid)\n ans['casc'] = casc\n else:\n cascp_idx = self.get_wire_id('nch', 3, 'g', wire_idx=-1).base_index\n cascn_idx = self.get_wire_id('nch', 3, 'g', wire_idx=-2).base_index\n casc0, casc1 = self.connect_differential_tracks(ports['casc<0>'], ports['casc<1>'],\n hm_layer, cascp_idx, cascn_idx)\n ans['casc<0>'] = casc0\n ans['casc<1>'] = casc1\n\n # connect tail switch if it exists\n if seg_tsw > 0:\n nclk0_tid = self.get_wire_id('nch', 1, 'g', wire_name='clk')\n ans['nclkn'] = self.connect_to_tracks(ports['nclk0'], nclk0_tid)\n self.connect_to_substrate('ntap', ports['nvdd'])\n\n return ans, amp_info","def layout_well2index(self, layout_name):\n return {k:tuple(v) for k,v in self['well2coord'][self['layout_format'][layout_name]].items()}","def run(self, dag):\n new_dag = DAGCircuit()\n\n if self.initial_layout is None:\n if self.property_set[\"layout\"]:\n self.initial_layout = self.property_set[\"layout\"]\n else:\n self.initial_layout = Layout.generate_trivial_layout(*dag.qregs.values())\n\n if len(dag.qubits()) != len(self.initial_layout):\n raise TranspilerError('The layout does not match the amount of qubits in the DAG')\n\n if len(self.coupling_map.physical_qubits) != len(self.initial_layout):\n raise TranspilerError(\n \"Mappers require to have the layout to be the same size as the coupling map\")\n\n current_layout = self.initial_layout.copy()\n\n for layer in dag.serial_layers():\n subdag = layer['graph']\n\n for gate in subdag.twoQ_gates():\n physical_q0 = current_layout[gate.qargs[0]]\n physical_q1 = current_layout[gate.qargs[1]]\n if self.coupling_map.distance(physical_q0, physical_q1) != 1:\n # Insert a new layer with the SWAP(s).\n swap_layer = DAGCircuit()\n\n path = self.coupling_map.shortest_undirected_path(physical_q0, physical_q1)\n for swap in range(len(path) - 2):\n connected_wire_1 = path[swap]\n connected_wire_2 = path[swap + 1]\n\n qubit_1 = current_layout[connected_wire_1]\n qubit_2 = current_layout[connected_wire_2]\n\n # create qregs\n for qreg in current_layout.get_registers():\n if qreg not in swap_layer.qregs.values():\n swap_layer.add_qreg(qreg)\n\n # create the swap operation\n swap_layer.apply_operation_back(SwapGate(),\n qargs=[qubit_1, qubit_2],\n cargs=[])\n\n # layer insertion\n edge_map = current_layout.combine_into_edge_map(self.initial_layout)\n new_dag.compose_back(swap_layer, edge_map)\n\n # update current_layout\n for swap in range(len(path) - 2):\n current_layout.swap(path[swap], path[swap + 1])\n\n edge_map = current_layout.combine_into_edge_map(self.initial_layout)\n new_dag.extend_back(subdag, edge_map)\n\n return new_dag","def solve(self):\n\n # Assign variables to each quantity being solved.\n r_lookup, lookup, num = {}, {}, 0\n for element in self.elements:\n if is_wire(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n elif not is_cs(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n\n # Set up the linear algebraic equation Ax=b\n A = np.zeros((num, num))\n b = np.zeros(num)\n for row, element in lookup.items():\n if is_wire(element) and element is not self.ground:\n for two_sided in element.attached:\n if is_cs(two_sided):\n if two_sided.pos is element:\n b[row] += -1 * two_sided.current\n else:\n b[row] += two_sided.current\n else:\n if two_sided.pos is element:\n flow = 1\n else:\n flow = -1\n A[row, r_lookup[two_sided]] = flow\n elif is_vs(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n b[row] = element.voltage\n elif is_resistor(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n A[row, r_lookup[element]] = -1 * element.resistance\n\n b = b.reshape((num, 1))\n try:\n x = np.linalg.solve(A, b)\n except np.linalg.LinAlgError:\n raise CircuitError('Insufficient information to solve circuit')\n\n # Assign values to all circuit components\n for i in range(num):\n item = lookup[i]\n if is_wire(item):\n item.potential = x[i, 0]\n elif isinstance(item, DualSided):\n item.current = x[i, 0]\n\n # Mark circuit as solved\n self.been_solved = True","def q3(puzzle):\n mysudoku = build_csp(puzzle)\n mysudoku.ac3_algorithm()\n solution = mysudoku.backtracking_search(\"MRV\")\n return solution, mysudoku","def numpy_IoU_minmax(bb1, bb2):\n\n # There should be at least one anchor, but maybe more. \n # If the number of dimensions is only 1 (so it's just\n # one anchor), reshape the array to allow the slicing\n # to work properly:\n \n if bb1.ndim == 1:\n bb1 = np.reshape(bb1, (1,) + bb1.shape)\n if bb2.ndim == 1:\n bb2 = np.reshape(bb2, (1,) + bb2.shape)\n\n # Now, n1 and n2 can represent the number of anchors:\n n_1 = bb1.shape[0]\n n_2 = bb2.shape[0]\n\n\n # Want the IoU for every bb1 to every bb2, so tile them into\n # long 1D arrays to allow slicing:\n bb1_arr = np.reshape(np.tile(bb1, [1, n_2]), (n_1*n_2, 4))\n bb2_arr = np.tile(bb2, [n_1, 1])\n\n\n x1 = np.max((bb1_arr[:,0], \n bb2_arr[:,0]),\n axis=0)\n y1 = np.max((bb1_arr[:,1], \n bb2_arr[:,1]),\n axis=0)\n x2 = np.min((bb1_arr[:,2], \n bb2_arr[:,2]),\n axis=0)\n y2 = np.min((bb1_arr[:,3], \n bb2_arr[:,3]),\n axis=0)\n\n\n w = x2 - x1\n h = y2 - y1\n\n\n inter = w*h\n\n aarea = (bb1_arr[:,3] - bb1_arr[:,1])*(bb1_arr[:,2] - bb1_arr[:,0])\n barea = (bb2_arr[:,3] - bb2_arr[:,1])*(bb2_arr[:,2] - bb2_arr[:,0])\n\n\n denom = aarea + barea - inter\n # mask = (denom == 0)\n # denom[mask] = 0.1\n\n IoU = inter / (denom)\n # return IoU\n # IoU[mask] = 0\n IoU[w <= 0] = 0\n IoU[h <= 0] = 0\n \n return np.reshape(IoU, (n_1,n_2))","def test_queue_region_with_invalid_parameter(self):\n self.verify(self.nic in [\"fortville_eagle\", \"fortville_spirit\",\n \"fortville_spirit_single\", \"fortpark_TLV\", \"fortville_25g\"], \"NIC Unsupported: \" + str(self.nic))\n self.pmdout.start_testpmd(\"%s\" % self.cores, \"--rxq=16 --txq=16 --port-topology=chained\")\n self.dut.send_expect(\"set fwd rxonly\", \"testpmd> \", 120)\n self.dut.send_expect(\"set verbose 1\", \"testpmd> \", 120)\n self.dut.send_expect(\"start\", \"testpmd> \", 120)\n time.sleep(2)\n\n # Create a rss queue rule.\n self.dut.send_expect(\n \"flow create 0 ingress pattern end actions rss queues 8 10 11 12 15 end / end\", \"created\")\n # Set a queue region with invalid queue ID\n self.dut.send_expect(\n \"flow create 0 ingress pattern vlan tci is 0x2000 / end actions rss queues 8 9 end / end\", \"error\")\n # Set a queue region with discontinuous queue ID\n self.dut.send_expect(\n \"flow create 0 ingress pattern vlan tci is 0x2000 / end actions rss queues 8 10 end / end\", \"error\")\n # Set a queue region with invalid queue number\n self.dut.send_expect(\n \"flow create 0 ingress pattern vlan tci is 0x4000 / end actions rss queues 10 11 12 end / end\", \"error\")","def printInterfaces(self, idx = None, flag = None, anchor = \"\"):\n\n if idx is None:\n idx = range(self.atoms.shape[0])\n elif isinstance(idx, (int, np.integer)):\n idx = [idx]\n\n header1 = \"%-2s%6s | %3s %-9s | %5s | %5s | %-5s | %-5s | %4s %-25s | %3s %-11s | %3s %-11s \"\\\n % (\"\", \"Index\", \"\", \"Length\", \"Angle\", \"Angle\", \"Area\", \"Atoms\", \"\", \"Epsilon (*100)\",\\\n \"\", \"Lattice 1\", \"\", \"Lattice 2\")\n header2 = \"%-2s%6s | %6s, %5s | %5s | %5s | %6s | %5s | %7s,%7s,%7s,%6s | \"\\\n \"%3s,%3s,%3s,%3s | %3s,%3s,%3s,%3s\"\\\n % (\"\", \"i\", \"a1\", \"a2\", \"b1/b2\", \"a1/a2\", \"Ang^2\", \"Nr\", \"11\", \"22\", \"12\", \"mas\",\\\n \"a1x\", \"a1y\", \"a2x\", \"a2y\", \"b1x\", \"b1y\", \"b2x\", \"b2y\")\n\n div = \"=\" * len(header1)\n print(\"\\n\" + header1 + \"\\n\" + header2 + \"\\n\" + div)\n\n for i in idx:\n\n la = np.linalg.norm(self.cell_1[i, :, :], axis = 0)\n lb = np.linalg.norm(self.cell_2[i, :, :], axis = 0)\n\n aa = np.dot(self.cell_1[i, :, 0], self.cell_1[i, :, 1]) / (la[0] * la[1])\n aa = np.rad2deg(np.arccos(aa))\n\n ba = np.dot(self.cell_2[i, :, 0], self.cell_2[i, :, 1]) / (lb[0] * lb[1])\n ba = np.rad2deg(np.arccos(ba))\n\n ar = np.abs(np.sin(np.deg2rad(aa))) * la[0] * la[1]\n\n s1 = self.eps_11[i] * 100\n s2 = self.eps_22[i] * 100\n s3 = self.eps_12[i] * 100\n s4 = self.eps_mas[i] * 100\n\n ra = self.rep_1[i, :, :].flatten()\n rb = self.rep_2[i, :, :].flatten()\n\n at = self.atoms[i]\n\n if np.isin(i, flag):\n string = \"%-2s%6.0f * %6.1f,%6.1f * %5.1f * %5.1f * %6.1f * %5.0f * \"\\\n \"%7.2f,%7.2f,%7.2f,%6.2f * %3i,%3i,%3i,%3i * %3i,%3i,%3i,%3i\"\\\n % (anchor, i, la[0], la[1], ba, aa, ar, at, s1, s2, s3, s4,\\\n ra[0], ra[2], ra[1], ra[3], rb[0], rb[2], rb[1], rb[3])\n else:\n string = \"%-2s%6.0f | %6.1f,%6.1f | %5.1f | %5.1f | %6.1f | %5.0f | \"\\\n \"%7.2f,%7.2f,%7.2f,%6.2f | %3i,%3i,%3i,%3i | %3i,%3i,%3i,%3i\"\\\n % (anchor, i, la[0], la[1], ba, aa, ar, at, s1, s2, s3, s4,\\\n ra[0], ra[2], ra[1], ra[3], rb[0], rb[2], rb[1], rb[3])\n\n print(string)\n\n print(div + \"\\n\")","def test_basic_usecases():\n net = create_test_net()\n eq_types = [\"rei\", \"ward\", \"xward\"]\n for eq_type in eq_types:\n net1, net2, net3 = run_basic_usecases(eq_type)\n\n if eq_type == \"rei\":\n check_elements_amount(net1, {\"bus\": 5, \"load\": 3, \"sgen\": 2, \"shunt\": 3, \"ext_grid\": 1,\n \"line\": 3, \"impedance\": 3}, check_all_pp_elements=True)\n check_res_bus(net, net1)\n assert np.allclose(net1.bus.min_vm_pu.values,\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\n check_elements_amount(net2, {\"bus\": 3, \"load\": 3, \"sgen\": 0, \"shunt\": 3, \"ext_grid\": 0,\n \"line\": 0, \"impedance\": 3}, check_all_pp_elements=True)\n check_res_bus(net, net2)\n assert np.allclose(net2.bus.min_vm_pu.values,\n net.bus.min_vm_pu.loc[[2, 4, 3]].values, equal_nan=True)\n check_elements_amount(net3, {\"bus\": 5, \"load\": 3, \"sgen\": 2, \"shunt\": 3, \"ext_grid\": 1,\n \"line\": 3, \"impedance\": 3}, check_all_pp_elements=True)\n check_res_bus(net, net3)\n assert np.allclose(net1.bus.min_vm_pu.values,\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\n\n elif \"ward\" in eq_type:\n check_elements_amount(net1, {\"bus\": 4, \"load\": 2, \"sgen\": 2, \"ext_grid\": 1, \"line\": 3,\n eq_type: 2, \"impedance\": 1}, check_all_pp_elements=True)\n check_res_bus(net, net1)\n check_elements_amount(net2, {\"bus\": 2, \"load\": 2, \"sgen\": 0, \"ext_grid\": 0, \"line\": 0,\n eq_type: 2, \"impedance\": 1}, check_all_pp_elements=True)\n check_res_bus(net, net2)\n check_elements_amount(net3, {\"bus\": 4, \"load\": 2, \"sgen\": 2, \"ext_grid\": 1, \"line\": 3,\n eq_type: 2, \"impedance\": 1}, check_all_pp_elements=True)\n check_res_bus(net, net3)","def test_collect_generic_layouts_dependencies(self, module_repo):\n expected_result = {(\"pack_with_generic_field\", True)}\n\n test_input = [\n {\n \"Dummy Layout\": {\n \"typeID\": \"dummy_layout\",\n \"name\": \"Dummy Layout\",\n \"pack\": \"dummy_pack\",\n \"kind\": \"indicatorsDetails\",\n \"path\": \"dummy_path\",\n \"definitionId\": \"assets\",\n \"incident_and_indicator_types\": [\"generic_type_id\"],\n \"incident_and_indicator_fields\": [\"generic_field_id\"],\n }\n }\n ]\n\n found_result = PackDependencies._collect_layouts_dependencies(\n pack_layouts=test_input,\n id_set=module_repo.id_set.read_json_as_dict(),\n )\n assert set(found_result) == set(expected_result)","def test_check_map_bcs_and_added_demultiplex(self):\r\n\r\n # Combinations of bc plus added demultiplex field need to be unique\r\n # but can be duplicated if both options are being used.\r\n header, mapping_data = check_map(\r\n self.valid_mapping_data_bcs_and_added_demultiplex,\r\n barcode_type=4, added_demultiplex_field=\"Added_Demultiplex\")\r\n\r\n expected_header =\\\r\n ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\r\n 'Added_Demultiplex', 'Description']\r\n expected_mapping_data =\\\r\n [['s1', 'AAAA', 'ATTCGATART', '1', 's1_description'],\r\n ['s2', 'AAAA', 'ATTCGATART', '2', 's2_description'],\r\n ['s3', 'CCCC', 'YATGCTGCCTCCCGTAGGAGT', '1', 's3_description']]\r\n\r\n self.assertEquals(header, expected_header)\r\n self.assertEquals(mapping_data, expected_mapping_data)","def WISE_match(t, RA_main, DEC_main,\n width=0.0004, w_units=\"degrees\",\n c_graph=True, DES_box=False,\n plotfile_prefix=None, prefix=None,\n verbose=False, debug=False):\n\n import numpy as np\n import match_lists\n import sqlutil\n\n function_name = inspect.stack()[0][3]\n print()\n print('__file__ ', __file__)\n print('__name__ ', __name__)\n print('Running:', function_name)\n print('Depth of inspect stack:', len(inspect.stack()))\n if len(inspect.stack()) > 1:\n print('Caller:', inspect.stack()[1][3])\n print(time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime()))\n print()\n\n db, host, user, password, db_table = rd_config_wsdb(table='wise')\n # db_table = 'allwise.main'\n\n print(mk_timestamp(), get_function_name(), get_linenumber() + ':',\n 'Database table: ', db_table)\n\n if w_units == \"arcsecs\":\n width = width / 3600.0\n\n cols = [\"RA_WISE\", \"DEC_WISE\", \"W1\", \"W1_ERR\",\n \"W2\", \"W2_ERR\", \"W3\", \"W3_ERR\", \"W4\", \"W4_ERR\"]\n\n try:\n for col in cols:\n t.add_empty_column(col, dtype=np.float64)\n\n except AttributeError as e:\n for col in cols:\n t[col] = np.zeros(len(t))\n\n n = 0\n\n timestamp = mk_timestamp()\n lineno = str(inspect.stack()[0][2])\n print(mk_timestamp(), function_name, lineno + ':',\n 'Number of source:', len(t))\n\n ra_min, ra_max, dec_min, dec_max = min_max_match(\n t[RA_main], t[DEC_main], width, DES_box=DES_box)\n area = ((float(ra_max) - float(ra_min)) *\n (float(dec_max) - float(dec_min)))\n nsources = len(t)\n print('Area:', area, 'degrees')\n print('Size of list:', nsources)\n lineno = str(inspect.stack()[0][2])\n print(mk_timestamp(), function_name, lineno + ':',\n 'Source density:', nsources / area)\n\n if len(t) > 5000 and len(t) < 100000000:\n\n print(\"Retreiving data\")\n query_wise = \"SELECT ra, dec, \\\n w1mpro, w1sigmpro, w2mpro, w2sigmpro, \\\n w3mpro, w3sigmpro, w4mpro, w4sigmpro \\\n FROM allwise.main \\\n WHERE ra > \" + ra_min + \" and ra < \" + ra_max \\\n + \" and dec > \" + dec_min + \" and dec < \" + dec_max\n\n (RA_wise, DEC_wise, W1, W1err, W2, W2err, W3, W3err, W4, W4err) = \\\n sqlutil.get(query_wise,\n db=db, host=host, user=user, password=password)\n\n print(mk_timestamp(), function_name, lineno + ':')\n print(\"Retrieved data:\", len(RA_wise), 'rows')\n\n info = [RA_wise, DEC_wise, W1, W1err, W2, W2err, W3, W3err, W4, W4err]\n\n if len(RA_wise) == 0:\n for (i, col) in enumerate(cols):\n t[col] = [np.float64(np.nan)] * len(t)\n\n else:\n print(\"Retrieved data, matching lists\")\n dists, inds = match_lists.match_lists(\n t[RA_main], t[DEC_main], RA_wise, DEC_wise, width, 1)\n print(\"Matched lists, updating table\")\n match = np.where((inds != len(RA_wise)))[0]\n no_match = np.where((inds == len(RA_wise)))[0]\n\n for (i, col) in enumerate(cols):\n t[col][match] = info[i][inds[match]]\n t[col][no_match] = np.float64(np.nan)\n\n print(\"Table updated\")\n\n elif len(t) <= 5000:\n\n print(mk_timestamp(), function_name, lineno + ':')\n print(\"Looping through the source list:\", len(t), 'sources')\n\n time0 = time.time()\n\n while n < len(t):\n RA = t[RA_main][n]\n DEC = t[DEC_main][n]\n query = \"select ra, dec, \\\n w1mpro, w1sigmpro, w2mpro, w2sigmpro, \\\n w3mpro, w3sigmpro, w4mpro, w4sigmpro \\\n FROM allwise.main \\\n WHERE q3c_radial_query(ra, dec, \" \\\n + str(RA) + \", \" + str(DEC) + \", 0.1002)\"\n\n (RA_W, DEC_W, W1, W1err, W2, W2err, W3, W3err,\n W4, W4err) = sqlutil.get(query, db=db, host=host,\n user=user, password=password)\n\n if len(RA_W) > 0:\n (dists, inds) = match_lists.match_lists(\n [RA], [DEC], RA_W, DEC_W, width, 1)\n j = inds[0]\n\n if j != len(RA_W):\n info = [RA_W[j], DEC_W[j],\n W1[j], W1err[j], W2[j], W2err[j],\n W3[j], W3err[j], W4[j], W4err[j]]\n\n for (i, col) in enumerate(cols):\n t[col][n] = info[i]\n\n else:\n for (i, col) in enumerate(cols):\n t[col][n] = np.float64(np.nan)\n\n else:\n for (i, col) in enumerate(cols):\n t[col][n] = np.float64(np.nan)\n\n if n + 1 == 1 or n + 1 == 10 or n + 1 == 100:\n time1 = time.time()\n rate = float(n + 1) / (time1 - time0)\n lineno = str(inspect.stack()[0][2])\n print(mk_timestamp(), function_name, lineno + ':',\n 'Sources per second: ', rate, n + 1, time1 - time0)\n\n n += 1\n\n time1 = time.time()\n rate = float(n + 1) / (time1 - time0)\n lineno = str(inspect.stack()[0][2])\n print(mk_timestamp(), function_name, lineno + ':',\n 'Sources per second:', rate, n + 1, time1 - time0)\n\n elif len(t) > 1000000000:\n\n print(\"Splitting by tile\")\n tiles_all = t[\"TILENAME\"]\n tiles = set(tiles_all)\n tiles = list(tiles)\n print(len(tiles), \"distinct tiles\")\n\n t.sort(\"TILENAME\")\n tiles.sort()\n\n n = 0\n m = 0\n rows = []\n tile_rows = []\n\n while n < len(t):\n tile = tiles[m]\n if t[\"TILENAME\"][n] == tile:\n rows.append(n)\n n += 1\n else:\n tile_rows.append(rows)\n rows = []\n m += 1\n\n for rows in tile_rows:\n t1 = t.rows(rows)\n print(\"Matching\", t1[\"TILENAME\"][0], \"with length\", len(t1))\n t1 = WISE_match(t1, RA_main, DEC_main, width, c_graph=False)\n\n if tile_rows.index(rows) == 0:\n t_out = t1\n else:\n t_out.append(t1)\n t = t_out\n\n if c_graph:\n width = width * 3600.0\n (RA_med, DEC_med) = check_graph(\n t, RA_main, DEC_main, \"WISE\", width, gtype=\"square\",\n plotfile_prefix=plotfile_prefix)\n\n return t","def check_pattern(pattern, n_qubits):\n\n pattern_flat = []\n for pat in pattern:\n pattern_flat.extend(pat)\n\n if np.max(pattern_flat) >= n_qubits:\n print(\"Invalid pattern. Qubit index in the pattern exceeds the number of qubits.\")\n\n _, uni_counts = np.unique(np.array(pattern_flat), return_counts=True)\n if (uni_counts > 1).any():\n raise ValueError(\"Invalid pattern. Duplicate qubit index.\")","def getQOfPosition(self,a, b, c, d):\n '''\n the initial list of qOfPosition given by the paper \"The Secrets of Notakto\" Figure 6,\\\n the first element is the board position and second is corresponding value\n '''\n qOfPosition_List = \\\n [ #\"\"\"row 1\"\"\"\n #row 1 column 1\n [[False, False, False, False, False, False, False, False, False],c],\\\n #row 1 column 2\n [[True, False, False, False, False, False, False, False, False],1],\\\n #row 1 column 3\n [[False, True, False, False, False, False, False, False, False],1],\\\n #row 1 column 4\n [[False, False, False, False, True, False, False, False, False],c**2],\\\n #row 1 column 5\n [[True, True, False, False, False, False, False, False, False],a*d],\\\n #row 1 column 6\n [[True, False, True, False, False, False, False, False, False],b],\\\n #row 1 column 7\n [[True, False, False, False, True, False, False, False, False],b],\\\n #row 1 column 8\n [[True, False, False, False, False, True, False, False, False],b],\\\n #row 1 column 9\n [[True, False, False, False, False, False, False, False, True],a],\\\n #\"\"\"row 2\"\"\"\n #row 2 column 1\n [[False, True, False, True, False, False, False, False, False],a],\\\n #row 2 column 2\n [[False, True, False, False, True, False, False, False, False],b],\\\n #row 2 column 3\n [[False, True, False, False, False, False, False, True, False],a],\\\n #row 2 column 4 is a dead board, we will skip it \n #row 2 column 5\n [[True, True, False, True, False, False, False, False, False],b],\\\n #row 2 column 6\n [[True, True, False, False, True, False, False, False, False],a*b],\\\n #row 2 column 7\n [[True, True, False, False, False, True, False, False, False],d],\\\n #row 2 column 8\n [[True, True, False, False, False, False, True, False, False],a],\\\n #row 2 column 9\n [[True, True, False, False, False, False, False, True, False],d],\\\n #\"\"\"row 3\"\"\"\n #row 3 column 1\n [[True, True, False, False, False, False, False, False, True],d],\\\n #row 3 column 2\n [[True, False, True, False, True, False, False, False, False],a],\\\n #row 3 column 3\n [[True, False, True, False, False, False, True, False, False],a*b],\\\n #row 3 column 4\n [[True, False, True, False, False, False, False, True, False],a],\\\n #row 3 column 5\n [[True, False, False, False, True, True, False, False, False],a],\\\n #row 3 column 6 is a dead board, we will skip it \n #row 3 column 7\n [[True, False, False, False, False, True, False, True, False],1],\\\n #row 3 column 8\n [[False, True, False, True, True, False, False, False, False],a*b],\\\n #row 3 column 9\n [[False, True, False, True, False, True, False, False, False],b],\\\n #\"\"\"row 4\"\"\"\n #row 4 column 1, 2, 3, 4, 5 are all dead boards, we will skip them \n #row 4 column 6 \n [[True, True, False, True, True, False, False, False, False],a],\\\n #row 4 column 7\n [[True, True, False, True, False, True, False, False, False],a],\\\n #row 4 column 8\n [[True, True, False, True, False, False, False, False, True],a],\\\n #row 4 column 9\n [[True, True, False, False, True, True, False, False, False],b],\\\n #\"\"\"row 5\"\"\"\n #row 5 column 1\n [[True, True, False, False, True, False, True, False, False],b],\\\n #row 5 column 2,3 are dead boards\n #row 5 column 4\n [[True, True, False, False, False, True, True, False, False],b],\\\n #row 5 column 5\n [[True, True, False, False, False, True, False, True, False],a*b],\\\n #row 5 column 6 \n [[True, True, False, False, False, True, False, False, True],a*b],\\\n #row 5 column 7\n [[True, True, False, False, False, False, True, True, False],b],\\\n #row 5 column 8\n [[True, True, False, False, False, False, True, False, True],b],\\\n #row 5 column 9\n [[True, True, False, False, False, False, False, True, True],a],\\\n #\"\"\"row 6\"\"\"\n #row 6 column 1 is a dead board\n #row 6 column 2\n [[True, False, True, False, True, False, False, True, False],b],\\\n #row 6 column 3\n [[True, False, True, False, False, False, True, False, True],a],\\\n #row 6 column 4\n [[True, False, False, False, True, True, False, True, False],b],\\\n #row 6 column 5 is a dead board \n #row 6 column 6 \n [[False, True, False, True, False, True, False, True, False],a],\\\n #row 6 column 7,8,9 are dead boards\n #\"\"\"row 7\"\"\" \n #row 7 column 1-8 are dead boards\n #row 7 column 9 \n [[True, True, False, True, False, True, False, True, False],b],\\\n #\"\"\"row 8\"\"\"\n #row 8 column 1\n [[True, True, False, True, False, True, False, False, True],b],\\\n #row 8 column 2\n [[True, True, False, False, True, True, True, False, False],a],\\\n #row 8 column 3-7 are dead boards\n #row 8 column 8\n [[True, True, False, False, False, True, True, True, False],a],\\\n #row 8 column 9\n [[True, True, False, False, False, True, True, False, True],a],\\\n #\"\"\"row 9 are all dead boards\"\"\"\n #\"\"\"row 10\"\"\"\n #row 10 column 1-6, 8, 9 are dead boards \n #row 10 column 7\n [[True, True, False, True, False, True, False, True, True],a]\n #the rest are all dead boards\n ]#boundary of qOfPosition_List\n '''\n the above list doesn't consider all the situations, we need to add\\\n the rotated and reflected versions into them. we use a dictionary \\\n to store the (board, value) pair\n '''\n qOfPosition_Dict = {}\n for boardAndValue in qOfPosition_List:\n board = boardAndValue[0]\n boardValue = boardAndValue[1]\n #get the reflected version, the second one is the same as the initial one\n for i in range(2):\n board = self.reflectBoard(board)\n #get the rotated version, we need to call rotateBoard function four times\n #the fourth one is the same as initial one\n for j in range(4):\n #update the board by rotating\n board = self.rotateBoard(board)\n #transfer the board to a string for making a key\n boardKey = self.transferBoardToString(board)\n #check if the key has already existed\n if boardKey in qOfPosition_Dict:\n pass\n else:\n #if not exist, store the (boardKey, boardValue into the qOfPosition_Dict)\n qOfPosition_Dict.update({boardKey: boardValue})\n #print(len(qOfPosition_Dict))\n return qOfPosition_Dict","def updatePlotLayoutGrid(self):\n\n print('updatePlotLayoutGrid()')\n plotLayoutType = self.plotLayoutType # 1x, 1x2, 2x1, 2x2\n if plotLayoutType == '1x':\n numPlots = 1\n elif plotLayoutType == '1x2':\n numPlots = 2\n elif plotLayoutType == '2x1':\n numPlots = 2\n elif plotLayoutType == '2x2':\n numPlots = 4\n\n # remove all widgets from self.plotLayout\n n = self.plotLayout.count()\n for i in range(n):\n item = self.plotLayout.itemAt(i)\n if item is None:\n print(' warning: updatePlotLayoutGrid() got None item at step', i)\n continue\n widget = item.widget()\n print(' updatePlotLayoutGrid() removing i:', i, 'item:', type(item))\n self.plotLayout.removeWidget(widget)\n #self.plotLayout.removeItem(item)\n\n state = self.getState()\n for i in range(numPlots):\n if i==0:\n row = 0\n col = 0\n elif i==1:\n if plotLayoutType == '1x2':\n row = 0\n col = 1\n elif plotLayoutType == '2x1':\n row = 1\n col = 0\n elif plotLayoutType == '2x2':\n row = 0\n col = 1\n elif i==2:\n row = 1\n col = 0\n elif i==3:\n row = 1\n col = 1\n #\n oneCanvas = myMplCanvas(plotNumber=i)\n oneCanvas.myUpdate(state) # initial plot\n oneCanvas.signalSelectFromPlot.connect(self.slotSelectFromPlot)\n self.signalCancelSelection.connect(oneCanvas.slotCancelSelection)\n self.myPlotCanvasList[i] = oneCanvas\n\n #\n self.plotLayout.addWidget(oneCanvas, row, col)\n\n # connect each canvas to all other canvas\n for i in range(numPlots):\n iCanvas = self.myPlotCanvasList[i]\n iCanvas.signalSelectSquare.connect(self.slotSelectSquare)\n # feb 2023, I was connecting this twice and was getting 2x calls for each click\n #iCanvas.signalSelectFromPlot.connect(self.slotSelectFromPlot)\n for j in range(numPlots):\n #if i==j:\n # continue\n jCanvas = self.myPlotCanvasList[j]\n iCanvas.signalSelectFromPlot.connect(jCanvas.slotSelectInd)\n iCanvas.signalSelectSquare.connect(jCanvas.slotSelectSquare)\n\n #\n # select the firsr plot\n self.myPlotCanvasList[0].signalSelectSquare.emit(0, None) #slotSelectSquare(0)","def test_get_qasms_noname(self):\n q_program = QuantumProgram()\n qr = q_program.create_quantum_register(size=3)\n cr = q_program.create_classical_register(size=3)\n qc1 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])\n qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])\n qc1.h(qr[0])\n qc1.cx(qr[0], qr[1])\n qc1.cx(qr[1], qr[2])\n qc1.measure(qr[0], cr[0])\n qc1.measure(qr[1], cr[1])\n qc1.measure(qr[2], cr[2])\n qc2.h(qr)\n qc2.measure(qr[0], cr[0])\n qc2.measure(qr[1], cr[1])\n qc2.measure(qr[2], cr[2])\n results = dict(zip(q_program.get_circuit_names(), q_program.get_qasms()))\n qr_name_len = len(qr.name)\n cr_name_len = len(cr.name)\n self.assertEqual(len(results[qc1.name]), qr_name_len * 9 + cr_name_len * 4 + 147)\n self.assertEqual(len(results[qc2.name]), qr_name_len * 7 + cr_name_len * 4 + 137)","def test_opt_a1a2(self, nqubits):\n dim = 2**nqubits\n umat = scipy.stats.unitary_group.rvs(dim, random_state=1224)\n circ = self.qsd(umat, opt_a1=True, opt_a2=True)\n ccirc = transpile(circ, basis_gates=[\"u\", \"cx\"], optimization_level=0)\n self.assertTrue(Operator(umat) == Operator(ccirc))\n if nqubits > 2:\n self.assertEqual(\n ccirc.count_ops().get(\"cx\"),\n (23 / 48) * 4**nqubits - (3 / 2) * 2**nqubits + 4 / 3,\n )\n elif nqubits == 1:\n self.assertEqual(ccirc.count_ops().get(\"cx\", 0), 0)\n elif nqubits == 2:\n self.assertLessEqual(ccirc.count_ops().get(\"cx\", 0), 3)","def _general_get_information(self, k=None):\n ## Format k\n ks = self.get_k(k)\n idx_ks = self._get_k_indices(ks)\n ## Get iss\n iss = self.iss\n ## Format idxs\n assert(type(idx_ks) == list)\n neighs = self.get_neighs(idx_ks)\n sp_relative_pos = self.get_sp_rel_pos(idx_ks)\n self.check_output_standards(neighs, sp_relative_pos, ks, iss)\n# print '3'*50, neighs, sp_relative_pos, ks, iss\n return neighs, sp_relative_pos, ks, iss","def q1(puzzle):\n mysudoku = build_csp(puzzle)\n solution = mysudoku.backtracking_search()\n return solution, mysudoku","def test_queue_region_with_rss_rule_api(self):\n self.verify(self.nic in [\"fortville_eagle\", \"fortville_spirit\",\n \"fortville_spirit_single\", \"fortpark_TLV\", \"fortville_25g\"], \"NIC Unsupported: \" + str(self.nic))\n self.pmdout.start_testpmd(\"%s\" % self.cores, \"--rxq=16 --txq=16 --port-topology=chained\")\n self.dut.send_expect(\"set fwd rxonly\", \"testpmd> \", 120)\n self.dut.send_expect(\"set verbose 1\", \"testpmd> \", 120)\n self.dut.send_expect(\"start\", \"testpmd> \", 120)\n time.sleep(2)\n\n # Create a rss queue rule.\n self.dut.send_expect(\n \"flow create 0 ingress pattern end actions rss types tcp end queues 7 8 10 11 12 14 15 end / end\", \"created\")\n # send the packets and verify the results\n rss_queue = [\"7\", \"8\", \"10\", \"11\", \"12\", \"14\", \"15\"]\n queue1 = self.send_and_check(self.prio_pkt1, rss_queue)\n queue2 = self.send_and_check(self.prio_pkt2, rss_queue)\n queue3 = self.send_and_check(self.prio_pkt3, rss_queue)\n self.verify(queue1 == queue2 == queue3, \"the packet doesn't enter the expected RSS queue.\")\n\n # Create three queue regions.\n self.dut.send_expect(\n \"flow create 0 ingress pattern vlan tci is 0x2000 / end actions rss queues 7 8 end / end\", \"created\")\n self.dut.send_expect(\n \"flow create 0 ingress pattern vlan tci is 0x4000 / end actions rss queues 11 12 end / end\", \"created\")\n self.dut.send_expect(\n \"flow create 0 ingress pattern vlan tci is 0x6000 / end actions rss queues 15 end / end\", \"created\")\n # send the packets and verify the results\n rss_queue = [\"7\", \"8\"]\n queue1 = self.send_and_check(self.prio_pkt1, rss_queue)\n rss_queue = [\"11\", \"12\"]\n queue2 = self.send_and_check(self.prio_pkt2, rss_queue)\n rss_queue = [\"15\"]\n queue3 = self.send_and_check(self.prio_pkt3, rss_queue)\n\n # Destroy one queue region rule, all the rules become invalid.\n self.dut.send_expect(\"flow destroy 0 rule 2\", \"testpmd> \")\n rss_queue = [\"0\"]\n self.send_and_check(self.prio_pkt1, rss_queue)\n self.send_and_check(self.prio_pkt2, rss_queue)\n self.send_and_check(self.prio_pkt3, rss_queue)","def produce(self, layout, layers, parameters, cell):\n self._layers = layers\n self.cell = cell\n self._param_values = parameters\n self.layout = layout\n\n\n # cell: layout cell to place the layout\n # LayerSiN: which layer to use\n # r: radius\n # w: waveguide width\n # length units in dbu\n\n from math import pi, cos, sin\n from SiEPIC.utils import arc, arc_to_waveguide, points_per_circle, arc_wg\n\n # fetch the parameters\n dbu = self.layout.dbu\n ly = self.layout\n shapes = self.cell.shapes\n \n LayerSi = self.silayer\n LayerSiN = self.silayer_layer\n LayerPinRecN = ly.layer(self.pinrec)\n LayerDevRecN = ly.layer(self.devrec)\n \n w = int(round(self.wg_width/dbu))\n r = int(round(self.radius/dbu))\n\n # draw the quarter-circle\n x = -r\n y = r\n # layout_arc_wg_dbu(self.cell, LayerSiN, x, y, r, w, 270, 360)\n t = Trans(Trans.R0,x, y)\n self.cell.shapes(LayerSiN).insert(arc_to_waveguide(arc(r, 270, 360), w).transformed(t))\n \n # Create the pins on the waveguides, as short paths:\n from SiEPIC._globals import PIN_LENGTH as pin_length\n \n # Pin on the top side:\n p2 = [Point(0, y-pin_length/2), Point(0, y+pin_length/2)]\n p2c = Point(0, y)\n self.set_p2 = p2c\n self.p2 = p2c\n pin = Path(p2, w)\n shapes(LayerPinRecN).insert(pin)\n t = Trans(Trans.R0, 0, y)\n text = Text (\"pin2\", t)\n shape = shapes(LayerPinRecN).insert(text)\n shape.text_size = 0.4/dbu\n\n # Pin on the left side:\n p1 = [Point(pin_length/2+x,0), Point(-pin_length/2+x,0)]\n p1c = Point(x,0)\n self.set_p1 = p1c\n self.p1 = p1c\n pin = Path(p1, w)\n shapes(LayerPinRecN).insert(pin)\n t = Trans(Trans.R0, x, 0)\n text = Text (\"pin1\", t)\n shape = shapes(LayerPinRecN).insert(text)\n shape.text_size = 0.4/dbu\n\n # Create the device recognition layer -- make it 1 * wg_width away from the waveguides.\n t = Trans(Trans.R0,x, y)\n self.cell.shapes(LayerDevRecN).insert(arc_to_waveguide(arc(r, 270, 360), w*3).transformed(t))\n #layout_arc_wg_dbu(self.cell, LayerDevRecN, x, y, r, w*3, 270, 360)\n\n # Compact model information\n t = Trans(Trans.R0, x+r/10, 0)\n text = Text (\"Lumerical_INTERCONNECT_library=Design kits/EBeam\", t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100\n t = Trans(Trans.R0, x+r/10, r/4)\n text = Text ('Component=ebeam_bend_1550', t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100\n t = Trans(Trans.R0, x+r/10, r/2)\n text = Text ('Spice_param:radius=%.3fu wg_width=%.3fu'% (self.radius,self.wg_width), t)\n shape = shapes(LayerDevRecN).insert(text)\n shape.text_size = r/100","def occupied_first(r, c, layout):\n occupy = 0\n\n NW = (-1, -1)\n NE = (-1, 1)\n N = (-1, 0)\n W = (0, -1)\n E = (0, 1)\n SW = (1, -1)\n SE = (1, 1)\n S = (1, 0)\n\n for dirs in [NW, NE, N, W, E, SW, SE, S]:\n dr, dc = r+dirs[0], c + dirs[1]\n while (dr >= 0) and (dc >= 0) and (dr < len(layout)) and (dc < len(layout[0])):\n if layout[dr][dc] == '#':\n occupy += 1\n break\n elif layout[dr][dc] == 'L':\n break\n dr, dc = dr+dirs[0], dc + dirs[1]\n\n return occupy","def _valid_placement(self, i_row, i_col):\n if not self._empty_cell(i_row, i_col):\n return (False, [])\n adj_opp_cells = []\n\n if (i_row, i_col) == self._tl_cell:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_corners, \"tl\")\n elif (i_row, i_col) == self._tr_cell:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_rs_corners, \"tr\")\n elif (i_row, i_col) == self._bl_cell:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_corners, \"bl\")\n elif (i_row, i_col) == self._br_cell:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_rs_corners, \"br\")\n elif (i_row, i_col) in self._ls_cells:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_and_rs, \"ls\")\n elif (i_row, i_col) in self._ts_cells:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ts_and_bs, \"ts\")\n elif (i_row, i_col) in self._rs_cells:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_and_rs, \"rs\")\n elif (i_row, i_col) in self._bs_cells:\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ts_and_bs, \"bs\")\n else:\n self._check_inner_dirs(i_row, i_col, adj_opp_cells)\n\n #print(\"\\nFOR TESTING. adj_opp_cells: \", adj_opp_cells)\n\n if adj_opp_cells == []:\n return (False, [])\n else:\n can_place, flip_lst = self._flip_dirs(adj_opp_cells)\n return (can_place, flip_lst)","def test_ex_3_1(self):\n fact1, fact2, query, scope = parse(PROLOG_OPS, 'q(a, b)', 'r(b, c)', 'p(U, V)')\n\n compiler = Compiler()\n fact1_instrs = compiler.compile_rule(fact1, [])\n fact2_instrs = compiler.compile_rule(fact2, [])\n reg_allocation = RegisterAllocation()\n query_instrs = compiler.compile_query_m1(query, reg_allocation)\n\n wam = WAM()\n wam.load(('p', 2), self.fig_3_1_instrs)\n wam.load(('q', 2), fact1_instrs)\n wam.load(('r', 2), fact2_instrs)\n query_offset = wam.load(None, query_instrs)\n wam.p = query_offset\n\n wam.run()\n\n aU = wam.deref_reg(reg_allocation[scope.var('U')])\n self.assertEqual(wam.get_term_repr(aU), 'a')\n aV = wam.deref_reg(reg_allocation[scope.var('V')])\n self.assertEqual(wam.get_term_repr(aV), 'c')","def test_comb(pad_size = (200, 200), wire_width = 1, wire_gap = 3,\n comb_layer = 0, overlap_zigzag_layer = 1,\n comb_pad_layer = 2, comb_gnd_layer = 3,\n overlap_pad_layer = 4):\n CI = Device(\"test_comb\")\n\n # if comb_pad_layer is None: comb_pad_layer = comb_layer\n # if comb_gnd_layer is None: comb_gnd_layer = comb_layer\n # if overlap_pad_layer is None: overlap_pad_layer = overlap_zigzag_layer\n wire_spacing = wire_width + wire_gap*2\n\n # pad overlays\n overlay_padb = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = overlap_pad_layer))\n overlay_padl = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_pad_layer))\n overlay_padt = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_pad_layer))\n overlay_padr = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_gnd_layer))\n overlay_padl.xmin = 0\n overlay_padl.ymin = 0\n overlay_padb.ymax = 0\n overlay_padb.xmin = overlay_padl.xmax + pad_size[1]/5\n overlay_padr.ymin = overlay_padl.ymin\n overlay_padr.xmin = overlay_padb.xmax + pad_size[1]/5\n overlay_padt.xmin = overlay_padl.xmax + pad_size[1]/5\n overlay_padt.ymin = overlay_padl.ymax\n\n # pads\n padl = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padt = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padr = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padb = CI.add_ref(rectangle(size = pad_size, layer = overlap_zigzag_layer))\n padl_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\n pad_size[1]/2),\n layer = comb_layer))\n padr_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\n pad_size[1]/2),\n layer = comb_layer))\n padl.xmin = overlay_padl.xmin\n padl.center = [padl.center[0], overlay_padl.center[1]]\n padt.ymax = overlay_padt.ymax\n padt.center = [overlay_padt.center[0], padt.center[1]]\n padr.xmax = overlay_padr.xmax\n padr.center = [padr.center[0], overlay_padr.center[1]]\n padb.ymin = overlay_padb.ymin\n padb.center = [overlay_padb.center[0], padb.center[1]]\n padl_nub.xmin = padl.xmax\n padl_nub.center = [padl_nub.center[0], padl.center[1]]\n padr_nub.xmax = padr.xmin\n padr_nub.center = [padr_nub.center[0], padr.center[1]]\n\n # connected zig\n head = CI.add_ref(compass(size = (pad_size[0]/12, wire_width),\n layer = comb_layer))\n head.xmin = padl_nub.xmax\n head.ymax = padl_nub.ymax\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n connector.connect(port = 'W', destination = head.ports['E'])\n old_port = connector.ports['S']\n top = True\n obj = connector\n while(obj.xmax + pad_size[0]/12 < padr_nub.xmin):\n # long zig zag rectangle\n obj = CI.add_ref(compass(size = (pad_size[1]/2 - 2*wire_width,\n wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n if(top):\n # zig zag edge rectangle\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'N', destination = old_port)\n top = False\n else:\n # zig zag edge rectangle\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'S', destination = old_port)\n top = True\n # comb rectange\n comb = CI.add_ref(rectangle(\n size = ((padt.ymin - head.ymax) + pad_size[1]/2 \\\n - (wire_spacing + wire_width)/2, wire_width),\n layer = comb_layer))\n comb.rotate(90)\n comb.ymax = padt.ymin\n comb.xmax = obj.xmax - (wire_spacing + wire_width)/2\n old_port = obj.ports['E']\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n if(top): old_port = obj.ports['S']\n else: old_port = obj.ports['N']\n old_port = obj.ports['E']\n if(padr_nub.xmin-obj.xmax > 0):\n tail = CI.add_ref(compass(size = (padr_nub.xmin-obj.xmax, wire_width),\n layer = comb_layer))\n else:\n tail = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n tail.connect(port = 'W', destination = old_port)\n\n # disconnected zig\n dhead = CI.add_ref(compass(size = (padr_nub.ymin - padb.ymax - wire_width,\n wire_width),\n layer = overlap_zigzag_layer))\n dhead.rotate(90)\n dhead.ymin = padb.ymax\n dhead.xmax = tail.xmin - (wire_spacing+wire_width)/2\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n connector.connect(port = 'S', destination = dhead.ports['E'])\n old_port = connector.ports['N']\n right = True\n obj = connector\n while(obj.ymax + wire_spacing + wire_width < head.ymax):\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n if(right):\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'W', destination = old_port)\n right = False\n else:\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'E', destination = old_port)\n right = True\n old_port = obj.ports['N']\n obj = CI.add_ref(compass(\n size = (dhead.xmin - (head.xmax+head.xmin+wire_width)/2,\n wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'E', destination = old_port)\n old_port = obj.ports['W']\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'S', destination = old_port)\n if(right):\n old_port = obj.ports['W']\n else:\n old_port = obj.ports['E']\n\n return CI","def test_140707_general(self):\n spc = parser(get_file('PTSDY1_complex.txt'))\n # spc.draw_outlooks()\n outlook = spc.get_outlook('CATEGORICAL', 'TSTM')\n self.assertAlmostEqual(outlook.geometry.area, 606.33, 2)","def verify_connections_layout(comm, log, name, outputs=None):\n for conn in comm.values():\n #loop thru all connections\n if isinstance(conn, dict):\n for (key, value) in conn.items():\n #loop thru sub items of the connections\n #if sub item is a dict we found a output channel\n if isinstance(value, dict):\n if isinstance(outputs, list):\n if not key in outputs:\n log.warning(\"%s has unknown outputs '%s' in Connections.\"\n ' Valid outputs are: %s', name, key, outputs)\n else:\n #handle case where outputs is not specified\n log.warning(\"%s has unexpected outputs '%s' in Connections.\"\n ' No outputs are allowed', name, key)","def adjacency_extraction_consistent(wfc_ns, pattern_cat):\n # This is a brute force implementation. We should really use the adjacency list we've already calculated...\n legal = []\n #print(f\"pattern_cat\\n{pattern_cat}\")\n for p1, pattern1 in enumerate(pattern_cat):\n for d_index, d in enumerate(wfc_ns.adjacency_directions):\n for p2, pattern2 in enumerate(pattern_cat):\n if is_valid_overlap_xy(d, p1, p2, pattern_cat, wfc_ns.pattern_width, wfc_ns.adjacency_directions):\n legal.append((d_index, p1, p2))\n return legal","def __sudoku(A):\r\n if not sudoku_isready(A):\r\n print(\"Invalid Grid\")\r\n return None\r\n else:\r\n n = len(A)\r\n x, seen = isqrt(n), [0 for i in range(n)]\r\n for i in range(n):\r\n line = sudoku_getline(A, i)\r\n for v in line:\r\n if v in seen:\r\n return \"Invalid\"\r\n else:\r\n seen[i] = v\r\n seen = [0 for i in range(n)]\r\n for i in range(n):\r\n line = sudoku_getcol(A, i)\r\n for v in line:\r\n if v in seen:\r\n return \"Invalid\"\r\n else:\r\n seen[i] = v\r\n seen = [0 for i in range(n)]\r\n for i in range(n):\r\n line = sudoku_region_to_line(sudoku_getregion(A, i))\r\n for v in line:\r\n if v in seen:\r\n return \"Invalid\"\r\n else:\r\n seen[i] = v\r\n seen = [0 for i in range(n)]\r\n return \"Valid\"","def solution2(inp):\n rules, mticket, nearby = inp.strip().split(\"\\n\\n\")\n rules = rules.split(\"\\n\")\n nearby = nearby.split(\"\\n\")[1:]\n mticket = list(map(int, mticket.split(\"\\n\")[1].split(\",\")))\n rrules = []\n for rule in rules:\n a, b = rule.split(\" or \")\n name = a.strip().split(\":\")[0]\n r1 = a.strip().split(\" \")[-1]\n r2 = b.strip()\n def to_range(r):\n i, j = list(map(int, r.split(\"-\")))\n return range(i, j + 1)\n rrules.append((to_range(r1), to_range(r2), name))\n\n nearby = [list(map(int, ticket.split(\",\"))) for ticket in nearby]\n s = 0\n to_remove = []\n for i, ticket in enumerate(nearby):\n for v in ticket:\n valid = False\n for r in rrules:\n valid |= v in r[0] or v in r[1]\n if not valid:\n to_remove.append(i)\n nearby = list(map(lambda x: x[1], filter(lambda x: x[0] not in to_remove, enumerate(nearby))))\n indices = list(range(len(rrules)))\n keys = {}\n for rule in rrules:\n rule_idx = []\n for i in indices:\n if all(ticket[i] in rule[0] or ticket[i] in rule[1] for ticket in nearby):\n rule_idx.append(i)\n keys[rule[2]] = rule_idx\n\n stack = list(keys.items())\n def resolve(j, avail):\n f, cand = stack[j]\n for i in avail.intersection(cand):\n if len(avail) == 1:\n return [i]\n avail.remove(i)\n res = resolve(j + 1, avail)\n avail.add(i)\n if res != False:\n return [i] + res\n return False\n solver = resolve(0, set(range(len(rrules))))\n names = list(map(lambda x: x[0], stack))\n return reduce(lambda x, y: x * y, [mticket[v] for k, v in zip(names, solver) if k.startswith(\"departure\")], 1)","def _check_input(self, **kwargs):\n\n combi_a = ['nxny', 'dxdy', 'ul_corner']\n combi_b = ['nxny', 'dxdy', 'll_corner']\n if all(kwargs[k] is not None for k in combi_a):\n nx, ny = kwargs['nxny']\n dx, dy = kwargs['dxdy']\n x0, y0 = kwargs['ul_corner']\n if (dx <= 0.) or (dy >= 0.):\n raise ValueError('dxdy and input params not compatible')\n origin = 'upper-left'\n elif all(kwargs[k] is not None for k in combi_b):\n nx, ny = kwargs['nxny']\n dx, dy = kwargs['dxdy']\n x0, y0 = kwargs['ll_corner']\n if (dx <= 0.) or (dy <= 0.):\n raise ValueError('dxdy and input params not compatible')\n origin = 'lower-left'\n else:\n raise ValueError('Input params not compatible')\n\n self._nx = int(nx)\n self._ny = int(ny)\n if (self._nx <= 0) or (self._ny <= 0):\n raise ValueError('nxny not valid')\n self._dx = float(dx)\n self._dy = float(dy)\n self._x0 = float(x0)\n self._y0 = float(y0)\n self._origin = origin\n\n # Check for pixel ref\n self._pixel_ref = kwargs['pixel_ref'].lower()\n if self._pixel_ref not in ['corner', 'center']:\n raise ValueError('pixel_ref not recognized')","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 test_1_1_2D_rec_init(self): # TODO: REMOVE FUNC AFTER SPLIT\n check = [(-1.0, -2.0), (7.0, 6.0), (7.0, -2.0), (-1.0, 6.0), (3.0, 2.0)]\n nn_checks = {(-1.0, -2.0): [(7, -2), (3.0, 2.0), (-1, 6)],\n (7.0, 6.0): [(7, -2), (3.0, 2.0), (-1, 6)],\n (7.0, -2.0): [(7, 6), (3.0, 2.0), (-1, -2)]}\n init_triangulation(2, 0, check, nn_checks, bounds=[(-1, 7), (-2, 6)])"],"string":"[\n \"def assert_mapping_consistency(layout):\\n values = sorted(layout.values())\\n keys = list(layout)\\n ref_keys = [\\\"q\\\" + str(i) for i in range(len(keys))]\\n if keys != ref_keys:\\n raise PlacementError(\\\"Some physical qubits in the layout may be missing or duplicated.\\\")\\n if values != list(range(len(values))):\\n raise PlacementError(\\\"Some logical qubits in the layout may be missing or duplicated.\\\")\",\n \"def is_packed_layout(layout):\\n if layout == \\\"NCHW\\\":\\n return False\\n if \\\"n\\\" in layout and \\\"c\\\" in layout:\\n return True\\n return False\",\n \"def assert_placement(circuit: Circuit, layout: dict) -> bool:\\n assert_mapping_consistency(layout)\\n if circuit.nqubits > len(layout):\\n raise PlacementError(\\\"Layout can't be used on circuit. The circuit requires more qubits.\\\")\\n if circuit.nqubits < len(layout):\\n raise PlacementError(\\\"Layout can't be used on circuit. Ancillary extra qubits need to be added to the circuit.\\\")\",\n \"def get_qconfig_sequences_constrained_by_trace_order(\\n self,\\n possible_qconfigs_sequence_in_trace_order: List[List[QuantizerConfig]],\\n indices_for_bitwidth_adjustment_only: Set[int],\\n ) -> Tuple[List[QConfigSequenceForHAWQToEvaluate], List[CoveringQConfigSequenceForQuantNoiseCalculation]]:\\n if len(possible_qconfigs_sequence_in_trace_order) != len(self._traces_order):\\n raise ValueError(\\\"The size of the qconfig space and the traces do not match!\\\")\\n retval = [] # type: List[QConfigSequenceForHAWQToEvaluate]\\n observed_qconfs_in_retval = [OrderedDict() for _ in range(len(self._traces_order))]\\n for bitwidth_sequence in self._bitwidth_sequences:\\n current_qconfig_sequence_in_trace_order = [] # type: QConfigSequenceForHAWQToEvaluate\\n for trace_idx, bitwidth in enumerate(bitwidth_sequence):\\n if trace_idx in indices_for_bitwidth_adjustment_only:\\n bitwidth_adjusted_default_qconfig = deepcopy(\\n possible_qconfigs_sequence_in_trace_order[trace_idx][0]\\n )\\n bitwidth_adjusted_default_qconfig.num_bits = bitwidth\\n qconfig = bitwidth_adjusted_default_qconfig\\n else:\\n # TODO: do a selection based on strategy (\\\"exhaustive\\\" = add all available configurations,\\n # \\\"preset\\\" = do a selection based on a certain preset, \\\"first\\\" = select first match (as below),\\n # \\\"custom\\\" = use a custom selection function to be passed as arg to the HAWQ initializer\\n # OR: do non-bitwidth disambiguation higher up the stack, make sure that the qconfig\\n # space at this spot only has 1 qconfig option for each bitwidth.\\n possible_qconfigs_for_current_trace_idx = possible_qconfigs_sequence_in_trace_order[trace_idx]\\n first_closest_qconfig = self._select_first_closest_bitwidth_qconfig(\\n possible_qconfigs_for_current_trace_idx, bitwidth\\n )\\n qconfig = deepcopy(first_closest_qconfig)\\n\\n current_qconfig_sequence_in_trace_order.append(qconfig)\\n observed_qconfs_in_retval[trace_idx][qconfig] = qconfig\\n retval.append(current_qconfig_sequence_in_trace_order)\\n return self._deduplicate(retval), self._generate_covering_qconfig_sequences(observed_qconfs_in_retval)\",\n \"def check_input(self, layout, gui=True):\\n print(\\\"**** Check Inputs ****\\\")\\n diffusion_available = False\\n diffusion_json_available = False\\n bvecs_available = False\\n bvals_available = False\\n valid_inputs = False\\n\\n if self.global_conf.subject_session == \\\"\\\":\\n subject = self.subject\\n else:\\n subject = \\\"_\\\".join((self.subject, self.global_conf.subject_session))\\n\\n subjid = self.subject.split(\\\"-\\\")[1]\\n\\n try:\\n layout = BIDSLayout(self.base_directory)\\n for subj in layout.get_subjects():\\n self.global_conf.subjects.append(\\\"sub-\\\" + str(subj))\\n\\n print(\\\"> Looking for....\\\")\\n\\n if self.global_conf.subject_session == \\\"\\\":\\n\\n dwi_file = self.get_file(layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"nii.gz\\\")\\n if dwi_file is None:\\n print(\\\"ERROR : Diffusion image not found for subject %s.\\\" % subjid)\\n return\\n\\n json_file = self.get_file(layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"json\\\")\\n if json_file is None:\\n json_file = \\\"NotFound\\\"\\n print(\\n \\\"WARNING : Diffusion json sidecar not found for subject %s.\\\"\\n % subjid\\n )\\n\\n bval_file = self.get_file(layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"bval\\\")\\n if bval_file is None:\\n print(\\n \\\"ERROR : Diffusion bval image not found for subject %s.\\\"\\n % subjid\\n )\\n return\\n\\n bvec_file = self.get_file(layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"bvec\\\")\\n if bvec_file is None:\\n print(\\n \\\"ERROR : Diffusion bvec image not found for subject %s.\\\"\\n % subjid\\n )\\n return\\n else:\\n sessid = self.global_conf.subject_session.split(\\\"-\\\")[1]\\n\\n dwi_file = self.get_file(layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"nii.gz\\\", session=sessid)\\n if dwi_file is None:\\n print(\\n \\\"ERROR : Diffusion image not found for subject %s, session %s.\\\"\\n % (subjid, sessid)\\n )\\n return\\n\\n json_file = self.get_file(\\n layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"json\\\", session=sessid\\n )\\n if json_file is None:\\n json_file = \\\"NotFound\\\"\\n print(\\n \\\"WARNING : Diffusion json sidecar not found for subject %s, session %s.\\\"\\n % (subjid, self.global_conf.subject_session)\\n )\\n\\n bval_file = self.get_file(\\n layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"bval\\\", session=sessid\\n )\\n if bval_file is None:\\n print(\\n \\\"ERROR : Diffusion bval image not found for subject %s, session %s.\\\"\\n % (subjid, self.global_conf.subject_session)\\n )\\n return\\n\\n bvec_file = self.get_file(\\n layout, subject=subjid, suffix=\\\"dwi\\\", extension=\\\"bvec\\\", session=sessid\\n )\\n if bvec_file is None:\\n print(\\n \\\"ERROR : Diffusion bvec image not found for subject %s, session %s.\\\"\\n % (subjid, self.global_conf.subject_session)\\n )\\n return\\n\\n print(\\\"... dwi_file : %s\\\" % dwi_file)\\n print(\\\"... json_file : %s\\\" % json_file)\\n print(\\\"... bvecs_file : %s\\\" % bvec_file)\\n print(\\\"... bvals_file : %s\\\" % bval_file)\\n\\n if os.path.isfile(dwi_file):\\n diffusion_available = True\\n\\n except Exception as e:\\n print(f\\\"Invalid BIDS dataset.\\\\n\\\\n\\\\t{e}\\\\n\\\\nPlease see documentation for more details.\\\")\\n return\\n\\n if os.path.isfile(json_file):\\n diffusion_json_available = True\\n if os.path.isfile(bval_file):\\n bvals_available = True\\n if os.path.isfile(bvec_file):\\n bvecs_available = True\\n\\n if diffusion_available:\\n if bvals_available and bvecs_available:\\n self.stages[\\n \\\"Diffusion\\\"\\n ].config.diffusion_imaging_model_choices = self.diffusion_imaging_model\\n\\n # Copy diffusion data to derivatives / cmp / subject / dwi\\n if self.global_conf.subject_session == \\\"\\\":\\n out_dwi_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n \\\"dwi\\\",\\n subject + \\\"_desc-cmp_dwi.nii.gz\\\",\\n )\\n out_bval_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n \\\"dwi\\\",\\n subject + \\\"_desc-cmp_dwi.bval\\\",\\n )\\n out_bvec_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n \\\"dwi\\\",\\n subject + \\\"_desc-cmp_dwi.bvec\\\",\\n )\\n else:\\n out_dwi_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n self.global_conf.subject_session,\\n \\\"dwi\\\",\\n subject + \\\"_desc-cmp_dwi.nii.gz\\\",\\n )\\n out_bval_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n self.global_conf.subject_session,\\n \\\"dwi\\\",\\n subject + \\\"_desc-cmp_dwi.bval\\\",\\n )\\n out_bvec_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n self.global_conf.subject_session,\\n \\\"dwi\\\",\\n subject + \\\"_desc-cmp_dwi.bvec\\\",\\n )\\n\\n if not os.path.isfile(out_dwi_file):\\n shutil.copy(src=dwi_file, dst=out_dwi_file)\\n if not os.path.isfile(out_bvec_file):\\n shutil.copy(src=bvec_file, dst=out_bvec_file)\\n if not os.path.isfile(out_bval_file):\\n shutil.copy(src=bval_file, dst=out_bval_file)\\n\\n valid_inputs = True\\n input_message = \\\"Inputs check finished successfully.\\\\n\\\" +\\\\\\n \\\"Diffusion and morphological data available.\\\"\\n\\n if diffusion_json_available:\\n if self.global_conf.subject_session == \\\"\\\":\\n out_json_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n \\\"dwi\\\",\\n self.subject + \\\"_desc-cmp_dwi.json\\\",\\n )\\n else:\\n out_json_file = os.path.join(\\n self.output_directory,\\n __cmp_directory__,\\n self.subject,\\n self.global_conf.subject_session,\\n \\\"dwi\\\",\\n self.subject\\n + \\\"_\\\"\\n + self.global_conf.subject_session\\n + \\\"_desc-cmp_dwi.json\\\",\\n )\\n\\n if not os.path.isfile(out_json_file):\\n shutil.copy(src=json_file, dst=out_json_file)\\n else:\\n input_message = \\\"Error during inputs check.\\\\nDiffusion bvec or bval files not available.\\\"\\n else:\\n if self.global_conf.subject_session == \\\"\\\":\\n input_message = (\\n \\\"Error during inputs check. No diffusion data available in folder \\\"\\n + os.path.join(self.base_directory, self.subject, \\\"dwi\\\")\\n + \\\"!\\\"\\n )\\n else:\\n input_message = (\\n \\\"Error during inputs check. No diffusion data available in folder \\\"\\n + os.path.join(\\n self.base_directory,\\n self.subject,\\n self.global_conf.subject_session,\\n \\\"dwi\\\",\\n )\\n + \\\"!\\\"\\n )\\n\\n if gui:\\n print(input_message)\\n self.global_conf.diffusion_imaging_model = self.diffusion_imaging_model\\n\\n self.stages[\\n \\\"Registration\\\"\\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\\n self.stages[\\n \\\"Diffusion\\\"\\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\\n else:\\n print(input_message)\\n self.global_conf.diffusion_imaging_model = self.diffusion_imaging_model\\n\\n self.stages[\\n \\\"Registration\\\"\\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\\n self.stages[\\n \\\"Diffusion\\\"\\n ].config.diffusion_imaging_model = self.diffusion_imaging_model\\n\\n if diffusion_available:\\n valid_inputs = True\\n else:\\n print(\\n \\\"ERROR : Missing required inputs.Please see documentation for more details.\\\"\\n )\\n\\n return valid_inputs\",\n \"def test_read_layout():\\n\\n layout = read_layout(layout_path=f\\\"{test_data}/test_mwa.txt\\\")\\n\\n assert layout.shape[0] == 3\\n assert layout[0][0] == -1.497849999999999966e02\\n assert layout[1][0] == 2.658140000000000214e02\\n assert layout[2][0] == 3.770110000000000241e02\",\n \"def intersect_hint(self, sq, hh):\\n if not self.hints_prepped:\\n self.reset_hints()\\n self.hints_prepped=1\\n #~ self._hints[sq]=self._hints[sq].intersection(hh)\\n pos=self.local2global(sq)\\n #~ self._global_hints[pos]=self._global_hints[pos].intersection(hh)\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n #~ bad=0\\n #~ for h in hh:\\n #~ if 'IN'==h[0]:\\n #~ bad=1\\n #~ break\\n #~ if 'OUT'==h[1]:\\n #~ bad=1\\n #~ break\\n #~ if bad:\\n #~ for h in hh:\\n #~ if 'IN'==h[0]:\\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[1]==h[1]]\\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[1]==h[1]]\\n #~ if 'OUT'==h[1]:\\n #~ self._global_hints[pos]=[gh for gh in self._global_hints[pos] if gh[0]==h[0]]\\n #~ self._hints[sq]=[lh for lh in self._hints[sq] if lh[0]==h[0]]\\n #~ if h in self._global_hints[pos]:\\n #~ self._global_hints[pos].remove(h)\\n #~ self._hints[sq].remove(h)\\n #~ else:\\n self._hints[sq]=self._hints[sq].intersection(hh)\\n self._global_hints[pos]=self._global_hints[pos].intersection(hh)\",\n \"def main():\\n\\n cages = [\\n \\\"AABCCD\\\",\\n \\\"EFBCGD\\\",\\n \\\"EFFHGI\\\",\\n \\\"EJJHGI\\\",\\n \\\"EKJHGL\\\",\\n \\\"KKJLLL\\\",\\n ]\\n\\n peaks = [\\n (0, 1),\\n (0, 2),\\n (1, 3),\\n (1, 4),\\n (1, 5),\\n (2, 1),\\n (2, 3),\\n (3, 0),\\n (3, 5),\\n (4, 2),\\n (5, 1),\\n (5, 4),\\n ]\\n\\n extract = {\\n \\\"A\\\": (5, 2),\\n \\\"B\\\": (0, 3),\\n \\\"C\\\": (3, 2),\\n \\\"D\\\": (1, 4),\\n \\\"E\\\": (0, 1),\\n \\\"F\\\": (1, 5),\\n \\\"G\\\": (4, 2),\\n \\\"H\\\": (3, 5),\\n \\\"I\\\": (1, 0),\\n \\\"J\\\": (5, 5),\\n \\\"K\\\": (3, 4),\\n \\\"L\\\": (5, 1),\\n \\\"M\\\": (0, 5),\\n \\\"N\\\": (4, 4),\\n }\\n\\n def answer(sg):\\n solved_grid = sg.solved_grid()\\n s = \\\"\\\"\\n s += chr(64 + solved_grid[extract[\\\"A\\\"]] + solved_grid[extract[\\\"B\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"C\\\"]] + solved_grid[extract[\\\"D\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"E\\\"]] + solved_grid[extract[\\\"F\\\"]] + solved_grid[extract[\\\"G\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"H\\\"]] + solved_grid[extract[\\\"I\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"J\\\"]] + solved_grid[extract[\\\"K\\\"]] + solved_grid[extract[\\\"L\\\"]])\\n s += chr(64 + solved_grid[extract[\\\"M\\\"]] + solved_grid[extract[\\\"N\\\"]])\\n return s\\n\\n sym = grilops.make_number_range_symbol_set(1, 6)\\n lattice = grilops.get_square_lattice(6)\\n sg = grilops.SymbolGrid(lattice, sym)\\n\\n add_sudoku_constraints(sg)\\n\\n # Constrain regions to match the cages and be rooted at the peaks.\\n cage_label_to_region_id = {}\\n for py, px in peaks:\\n cage_label_to_region_id[cages[py][px]] = lattice.point_to_index((py, px))\\n\\n rc = grilops.regions.RegionConstrainer(lattice, sg.solver)\\n for y, x in lattice.points:\\n sg.solver.add(\\n rc.region_id_grid[(y, x)] == cage_label_to_region_id[cages[y][x]])\\n\\n # Within each region, a parent cell must have a greater value than a child\\n # cell, so that the values increase as you approach the root cell (the peak).\\n for p in lattice.points:\\n for n in sg.edge_sharing_neighbors(p):\\n sg.solver.add(Implies(\\n rc.edge_sharing_direction_to_index(n.direction) == rc.parent_grid[p],\\n n.symbol > sg.grid[p]\\n ))\\n\\n if sg.solve():\\n sg.print()\\n print()\\n print(answer(sg))\\n while not sg.is_unique():\\n print()\\n print(\\\"Alternate solution\\\")\\n sg.print()\\n print()\\n print(answer(sg))\\n else:\\n print(\\\"No solution\\\")\",\n \"def _get_numpy_layout(numpy_arr, second_arr=None):\\n\\n # Return the second array order if the first is ambiguous\\n if numpy_arr.flags.c_contiguous and numpy_arr.flags.f_contiguous and second_arr is not None:\\n if second_arr.flags.c_contiguous:\\n return LAYOUT_CODE_C, numpy_arr.shape[1]\\n elif second_arr.flags.f_contiguous:\\n return LAYOUT_CODE_F, numpy_arr.shape[0]\\n\\n # Return the first order array otherwise\\n elif numpy_arr.flags.c_contiguous:\\n return LAYOUT_CODE_C, numpy_arr.shape[1]\\n elif numpy_arr.flags.f_contiguous:\\n return LAYOUT_CODE_F, numpy_arr.shape[0]\\n elif not numpy_arr.flags.contiguous:\\n raise ValueError(\\\"Array is not contiguous\\\")\\n else:\\n raise ValueError(\\\"Array layout check has failed for unknown reason\\\")\",\n \"def test_three_qubit(self):\\n np.random.seed(0)\\n v = QuantumRegister(3, 'v') # virtual qubits\\n coupling = CouplingMap([[0, 1], [1, 2]])\\n from_layout = Layout({v[0]: 0, v[1]: 1, v[2]: 2})\\n to_layout = Layout({v[0]: 2, v[1]: 0, v[2]: 1})\\n ltpass = LayoutTransformation(coupling_map=coupling,\\n from_layout=from_layout,\\n to_layout=to_layout)\\n qc = QuantumCircuit(3) # input (empty) physical circuit\\n dag = circuit_to_dag(qc)\\n q = dag.qubits()\\n output_dag = ltpass.run(dag)\\n # output_dag.draw()\\n # Check that only two swaps were performed\\n self.assertCountEqual([\\\"swap\\\"] * 2, [op.name for op in output_dag.topological_op_nodes()])\\n # And check that the swaps were first performed on {q0,q1} then on {q1,q2}.\\n self.assertEqual([frozenset([q[0], q[1]]), frozenset([q[1], q[2]])],\\n [frozenset(op.qargs) for op in output_dag.topological_op_nodes()])\",\n \"def make_full_layout(d: AttentionMask) -> np.ndarray:\\n\\n if not d.is_head_specific:\\n u = np.reshape(d.global_layout, [d.n_query_block, d.n_key_block, 1, 1])\\n r = product(range(d.n_query_block), range(d.n_key_block))\\n v = np.array([d.block_layout(None, 0, i, j, 0) for i, j in r])\\n v = np.reshape(v, [d.n_query_block, d.n_key_block, d.block_size, d.block_size])\\n\\n w = u * v\\n w = np.transpose(w, [0, 2, 1, 3])\\n w = np.reshape(w, [d.query_context_size, d.key_context_size])\\n return w\\n else:\\n if len(d.global_layout.shape) == 2:\\n u = np.reshape(d.global_layout, [1, d.n_query_block, d.n_key_block, 1, 1])\\n u = np.tile(u, [d.n_head, 1, 1, 1, 1])\\n elif len(d.global_layout.shape) == 3:\\n u = np.reshape(d.global_layout, [d.n_head, d.n_query_block, d.n_key_block, 1, 1])\\n else:\\n raise RuntimeError()\\n\\n s = product(range(d.n_head), range(d.n_query_block), range(d.n_key_block))\\n v = np.array([d.block_layout(None, i, j, k, 0) for i, j, k in s])\\n v = np.reshape(v, [d.n_head, d.n_query_block, d.n_key_block, d.block_size, d.block_size])\\n\\n w = u * v\\n w = np.transpose(w, [0, 1, 3, 2, 4])\\n w = np.reshape(w, [d.n_head, d.query_context_size, d.key_context_size])\\n return w\",\n \"def solve_sudoku(self, grid_basic_format):\\n raise NotImplementedError(\\\"Solve sudoku method not implemented in Base Class\\\")\",\n \"def detect_layouts(self, lscpu_output=None):\\n stdout = self.detect_layout_lscpu(lscpu_output)\\n rows = [row for row in stdout.strip().split('\\\\n') if not row.startswith('#')]\\n layouts = [list(map(any2int, row.split(',')[2:4])) for row in rows]\\n numa_layout, socket_layout = zip(*layouts)\\n self.numa_layout = dict(enumerate(numa_layout))\\n self.socket_layout = dict(enumerate(socket_layout))\",\n \"def test_weyl_specialize_general(self, aaa=0.456, bbb=0.345, ccc=0.123):\\n a, b, c = aaa, bbb, ccc\\n for da, db, dc in DELTAS:\\n for k1l, k1r, k2l, k2r in K1K2SB:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n self.check_two_qubit_weyl_specialization(\\n k1 @ Ud(a + da, b + db, c + dc) @ k2,\\n 0.999,\\n TwoQubitWeylGeneral,\\n {\\\"rz\\\": 8, \\\"ry\\\": 4, \\\"rxx\\\": 1, \\\"ryy\\\": 1, \\\"rzz\\\": 1},\\n )\",\n \"def adopt_global_hints(self,board):\\n global_hints={}\\n for sq in self.allsqs:\\n self.intersect_hint(sq, board.global_hints[self.local2global(sq)])\\n return\\n #~ for pos,hints in self.raw_global_hints.items():\\n #~ bad=False\\n #~ for il in board.ilrooms:\\n #~ if pos in il.orig_gatesqs:\\n #~ bad=True\\n #~ if bad:\\n #~ continue\\n #not sure if this is necessary. if i have hints, it should be ok.\\n #~ orighints=hints\\n #~ newhints=set()\\n #~ for hint in hints:\\n #~ if hint[0]=='IN':\\n #~ opendvs=board.getopendv_loc(pos)\\n #~ indvs=[(dv+2)%4 for dv in opendvs if dv!=hint[1]]\\n #~ for indv in indvs:\\n #~ newhints.add((indv,hint[1]))\\n #~ elif hint[1]=='OUT':\\n #~ if hint[0]=='OUT':\\n #~ indvs=[n for n in [0,1,2,3] if add(pos,(n+2)%4) not in self.orig_allsqs and board.isopen(add(pos,(n+2)%4))]\\n #~ outdvs=[n for n in [0,1,2,3] if add(pos,n) not in self.orig_allsqs and board.isopen(add(pos,n))]\\n #~ for i in indvs:\\n #~ for o in outdvs:\\n #~ if (i+2)%4==o:\\n #~ continue\\n #~ newhints.add((i,o))\\n #~ else:\\n #~ opendvs=board.getopendv_loc(pos)\\n #~ outdvs=[dv for dv in opendvs if dv != (hint[0]+2)%4]\\n #~ for outdv in outdvs:\\n #~ newhints.add((hint[0],outdv))\\n #~ else:\\n #~ newhints.add(hint)\\n #~ global_hints[pos]=newhints\\n #~ self.global_hints=global_hints\",\n \"def npa_constraints(\\n assemblage: dict[tuple[int, int], cvxpy.Variable], k: int | str = 1, referee_dim: int = 1\\n) -> list[cvxpy.constraints.constraint.Constraint]:\\n a_out, a_in, b_out, b_in = _get_nonlocal_game_params(assemblage, referee_dim)\\n\\n words = _gen_words(k, a_out, a_in, b_out, b_in)\\n dim = len(words)\\n\\n r_var = cvxpy.Variable((referee_dim * dim, referee_dim * dim), PSD=True, name=\\\"R\\\")\\n # Normalization.\\n norm = sum(r_var[i * dim, i * dim] for i in range(referee_dim))\\n constraints = [norm == 1]\\n\\n seen = {}\\n for i in range(dim):\\n for j in range(i, dim):\\n w_i, w_j = words[i], words[j]\\n w_i = tuple(reversed(w_i))\\n word = _reduce(w_i + w_j)\\n\\n sub_mat = r_var[i::dim, j::dim]\\n # if i = 0 we would consider (ε, ε) as an empty word.\\n if i != 0 and _is_zero(word):\\n constraints.append(sub_mat == 0)\\n\\n elif _is_meas(word):\\n s_a, s_b = word\\n constraints.append(\\n sub_mat\\n == assemblage[s_a.question, s_b.question][\\n s_a.answer * referee_dim : (s_a.answer + 1) * referee_dim,\\n s_b.answer * referee_dim : (s_b.answer + 1) * referee_dim,\\n ]\\n )\\n\\n elif _is_meas_on_one_player(word):\\n symbol = word[0]\\n if symbol.player == \\\"Alice\\\":\\n sum_all_bob_meas = sum(\\n assemblage[symbol.question, 0][\\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for b_ans in range(b_out)\\n )\\n\\n constraints.append(sub_mat == sum_all_bob_meas)\\n\\n if symbol.player == \\\"Bob\\\":\\n sum_all_alice_meas = sum(\\n assemblage[0, symbol.question][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n symbol.answer * referee_dim : (symbol.answer + 1) * referee_dim,\\n ]\\n for a_ans in range(a_out)\\n )\\n\\n constraints.append(sub_mat == sum_all_alice_meas)\\n\\n elif word in seen:\\n old_i, old_j = seen[word]\\n old_sub_mat = r_var[old_i::dim, old_j::dim]\\n constraints.append(sub_mat == old_sub_mat)\\n\\n else:\\n seen[word] = (i, j)\\n\\n # now we impose constraints to the assemblage operator\\n for x_alice_in in range(a_in):\\n for y_bob_in in range(b_in):\\n sum_all_meas_and_trace = 0\\n for a_ans in range(a_out):\\n for b_ans in range(b_out):\\n sum_all_meas_and_trace += sum(\\n assemblage[x_alice_in, y_bob_in][\\n i + a_ans * referee_dim, i + b_ans * referee_dim\\n ]\\n for i in range(referee_dim)\\n )\\n\\n # r x r sub - block is PSD since it's an unnormalized quantum state.\\n constraints.append(\\n assemblage[x_alice_in, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n >> 0\\n )\\n\\n constraints.append(sum_all_meas_and_trace == 1)\\n\\n # Bob marginal consistency\\n for y_bob_in in range(b_in):\\n for b_ans in range(b_out):\\n sum_first_question = sum(\\n assemblage[0, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for a_ans in range(a_out)\\n )\\n\\n for x_alice_in in range(1, a_in):\\n sum_cur_question = sum(\\n assemblage[x_alice_in, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for a_ans in range(a_out)\\n )\\n\\n constraints.append(sum_first_question == sum_cur_question)\\n\\n # Alice marginal consistency\\n for x_alice_in in range(a_in):\\n for a_ans in range(a_out):\\n sum_first_question = sum(\\n assemblage[x_alice_in, 0][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for b_ans in range(b_out)\\n )\\n\\n for y_bob_in in range(1, b_in):\\n sum_cur_question = sum(\\n assemblage[x_alice_in, y_bob_in][\\n a_ans * referee_dim : (a_ans + 1) * referee_dim,\\n b_ans * referee_dim : (b_ans + 1) * referee_dim,\\n ]\\n for b_ans in range(b_out)\\n )\\n\\n constraints.append(sum_first_question == sum_cur_question)\\n\\n return constraints\",\n \"def modify_hints_based_on_allsols(self):\\n #~ if self.hashid=='92580481c330e7057171d5f5b0f5ba84x003x006':\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n if self.all_sols is None or self.all_sols=='timeout':\\n #should restore all hints!\\n #untested, or timeout so we know nothing\\n self.reset_hints()\\n return\\n if self.all_sols==[]:\\n #has no sol. so start/end must be here.\\n self.reset_hints()\\n return\\n hints={}\\n for sq in self.sqs:\\n hints[sq]=set()\\n for gsq in self.gatesqs:\\n hints[gsq]=set()\\n for s in self.all_sols:\\n for sg in s:\\n start,sindv,path,covered,end=sg\\n covered=('IN',)+(start,)+covered+('OUT',)\\n if start==end:\\n hints[start].add(('OUT','OUT'))\\n else:\\n for ii,sq in enumerate(covered):\\n if sq=='IN':\\n continue\\n if sq=='OUT':\\n continue\\n indv=makevec2(covered[ii-1],covered[ii])\\n outdv=makevec2(covered[ii],covered[ii+1])\\n hints[sq].add((indv,outdv))\\n\\n for sq in self.sqs:\\n #~ print self.hints(sq)\\n #~ print hints[sq]\\n #~ print self._hints[sq]\\n bad=self.intersect_hint(sq, hints[sq])\\n #~ if len(self.all_sols)==1:\\n #~ if len(self._hints[sq])!=1:\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n if bad:return 1\\n for gsq in self.gatesqs:\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n bad=self.intersect_enter_hint(gsq, hints[gsq])\\n if bad:return bad\\n #should return the actual bad sq - it may be better!\\n bad=self.intersect_exit_hint(gsq, hints[gsq])\\n if bad:return bad\\n #~ if len(hints[gsq])==1:\\n #~ if len(self._hints[gsq])!=1:\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\",\n \"def q2(puzzle):\\n mysudoku = build_csp(puzzle)\\n mysudoku.ac3_algorithm()\\n solution = mysudoku.backtracking_search()\\n return solution, mysudoku\",\n \"def create_pcb_from_3dlayout(\\n self,\\n component_name,\\n project_name,\\n design_name,\\n resolution=2,\\n extenttype=\\\"Bounding Box\\\",\\n outlinepolygon=\\\"\\\",\\n close_linked_project_after_import=True,\\n custom_x_resolution=None,\\n custom_y_resolution=None,\\n ):\\n if project_name == self.project_name:\\n project_name = \\\"This Project*\\\"\\n link_data = [project_name, design_name, \\\"<--EDB Layout Data-->\\\", False, False]\\n status = self.create_ipk_3dcomponent_pcb(\\n component_name,\\n link_data,\\n \\\"\\\",\\n resolution,\\n extenttype=extenttype,\\n outlinepolygon=outlinepolygon,\\n custom_x_resolution=custom_x_resolution,\\n custom_y_resolution=custom_y_resolution,\\n )\\n\\n if close_linked_project_after_import and \\\".aedt\\\" in project_name:\\n prjname = os.path.splitext(os.path.basename(project_name))[0]\\n self.close_project(prjname, saveproject=False)\\n self.logger.glb.info(\\\"PCB component correctly created in Icepak.\\\")\\n return status\",\n \"def _get_layout(nstim, length=None, height=None, layout='square'):\\r\\n if layout == 'square':\\r\\n if np.floor(np.sqrt(nstim))**2 != nstim:\\r\\n n = int(np.ceil(np.sqrt(nstim/2.)))\\r\\n m = int(np.ceil(nstim/n))\\r\\n else:\\r\\n # M is a perfect square\\r\\n m = int(np.sqrt(nstim))\\r\\n n = m\\r\\n elif layout == 'sqrt':\\r\\n # if length != height, partly account for this so stimuli aren't so distorted. \\r\\n # could remove the extra square root to fully accommodate\\r\\n n = int(np.sqrt(nstim*np.sqrt(height/length)))\\r\\n m = int(np.ceil(nstim/n))\\r\\n else:\\r\\n n, m = layout\\r\\n return n, m\",\n \"def validate_raw_block_layout(raw_block_layout):\\n\\n # Confirm that each layer is a list of block specifications where\\n # each block specification has length 2 (i.e. block_name,num_repeats)\\n for raw_layer_layout in raw_block_layout:\\n for raw_block_spec in raw_layer_layout.split('-'):\\n if len(raw_block_spec.split(',')) != 2:\\n raise Exception(INVALID_BLOCK_SPEC_ERR.format(raw_block_spec))\",\n \"def block_layout(\\n self, blk_shape: Any, head_idx: int, query_idx: int, key_idx: int, blk_idx: int\\n ) -> np.ndarray:\\n\\n m = np.ones([self.block_size, self.block_size], dtype=np.bool)\\n\\n if query_idx >= self.first_pad_query_block_idx:\\n n_pad = min(\\n self.block_size,\\n (query_idx + 1) * self.block_size - (self.query_context_size - self.n_query_pad),\\n )\\n assert n_pad > 0\\n m[self.block_size - n_pad :] = False\\n if key_idx >= self.first_pad_key_block_idx:\\n n_pad = min(\\n self.block_size,\\n (key_idx + 1) * self.block_size - (self.key_context_size - self.n_key_pad),\\n )\\n assert n_pad > 0\\n m[:, self.block_size - n_pad :] = False\\n\\n return m & self._block_layout(blk_shape, head_idx, query_idx, key_idx, blk_idx)\",\n \"def find_something(self, break_func, Q1, Q2):\\n if break_func(self._galaxy[Q1][Q2]):\\n return Q1, Q2\\n for i in range(0, 8):\\n for j in range(0, 8):\\n if break_func(self._galaxy[i][j]):\\n return i, j\\n return None\",\n \"def generate_field_layout(gcr, collector_area, L_min, neighbor_order,\\n aspect_ratio=None, offset=None, rotation=None,\\n layout_type=None, plot=True): # noqa: E501\\n # Consider special layouts which can be defined only by GCR\\n if layout_type == 'square':\\n aspect_ratio = 1\\n offset = 0\\n rotation = 0\\n # Diagonal layout is the square layout rotated 45 degrees\\n elif layout_type == 'diagonal':\\n aspect_ratio = 1\\n offset = 0\\n rotation = 45\\n # Hexagonal layouts are defined by an aspect ratio=0.866 and offset=-0.5\\n elif layout_type == 'hexagonal_n_s':\\n aspect_ratio = np.sqrt(3)/2\\n offset = -0.5\\n rotation = 0\\n # The hexagonal E-W layout is the hexagonal N-S layout rotated 90 degrees\\n elif layout_type == 'hexagonal_e_w':\\n aspect_ratio = np.sqrt(3)/2\\n offset = -0.5\\n rotation = 90\\n elif layout_type is not None:\\n raise ValueError('The layout type specified was not recognized.')\\n elif ((aspect_ratio is None) or (offset is None) or (rotation is None)):\\n raise ValueError('Aspect ratio, offset, and rotation needs to be '\\n 'specified when no layout type has not been selected')\\n\\n # Check parameters are within their ranges\\n if aspect_ratio < np.sqrt(1-offset**2):\\n raise ValueError('Aspect ratio is too low and not feasible')\\n if aspect_ratio > collector_area/(gcr*L_min**2):\\n raise ValueError('Apsect ratio is too high and not feasible')\\n if (offset < -0.5) | (offset >= 0.5):\\n raise ValueError('The specified offset is outside the valid range.')\\n if (rotation < 0) | (rotation >= np.pi):\\n raise ValueError('The specified rotation is outside the valid range.')\\n # Check if mimimum and maximum ground cover ratios are exceded\\n gcr_max = collector_area / (L_min**2 * np.sqrt(1-offset**2))\\n if (gcr < 0) or (gcr > gcr_max):\\n raise ValueError('Maximum ground cover ratio exceded.')\\n # Check if Lmin is physically possible given the collector area.\\n if (L_min < np.sqrt(4*collector_area/np.pi)):\\n raise ValueError('Lmin is not physically possible.')\\n\\n N = 1 + 2 * neighbor_order # Number of collectors along each side\\n\\n # Generation of X and Y arrays with coordinates\\n X = np.tile(np.arange(int(-N/2), int(N/2)+1), N)\\n Y = np.repeat(np.arange(int(-N/2), int(N/2)+1), N)\\n # Remove reference collector point (origin)\\n X = np.delete(X, int(N**2/2))\\n Y = np.delete(Y, int(N**2/2))\\n\\n # Add offset and implement aspect ratio. Note that it is important to first\\n # calculate offset as it relies on the original X array.\\n Y = Y + offset*X\\n X = X * aspect_ratio\\n # Apply field rotation\\n X, Y = _rotate_origin(X, Y, rotation)\\n # Calculate and apply the scaling factor based on GCR\\n scaling = np.sqrt(collector_area / (gcr * aspect_ratio))\\n X, Y = X*scaling, Y*scaling\\n\\n # Calculate distance and angle of shading trackers relative to the center\\n tracker_distance = np.sqrt(X**2 + Y**2)\\n # The relative azimuth is defined clockwise eastwards from north\\n relative_azimuth = np.mod(450-np.rad2deg(np.arctan2(Y, X)), 360)\\n\\n # Visualize layout\\n if plot:\\n _plot_field_layout(X, Y, L_min)\\n\\n return X, Y, tracker_distance, relative_azimuth\",\n \"def test_queue_region_with_rss_rule_combination(self):\\n self.verify(self.nic in [\\\"fortville_eagle\\\", \\\"fortville_spirit\\\",\\n \\\"fortville_spirit_single\\\", \\\"fortpark_TLV\\\", \\\"fortville_25g\\\"], \\\"NIC Unsupported: \\\" + str(self.nic))\\n self.pmdout.start_testpmd(\\\"%s\\\" % self.cores, \\\"--rxq=16 --txq=16 --port-topology=chained\\\")\\n self.dut.send_expect(\\\"port config all rss all\\\", \\\"testpmd> \\\", 120)\\n self.dut.send_expect(\\\"set fwd rxonly\\\", \\\"testpmd> \\\", 120)\\n self.dut.send_expect(\\\"set verbose 1\\\", \\\"testpmd> \\\", 120)\\n self.dut.send_expect(\\\"start\\\", \\\"testpmd> \\\", 120)\\n time.sleep(2)\\n\\n # Set a queue region.\\n self.dut.send_expect(\\n \\\"set port 0 queue-region region_id 0 queue_start_index 1 queue_num 1\\\", \\\"testpmd> \\\")\\n self.dut.send_expect(\\n \\\"set port 0 queue-region region_id 0 flowtype 31\\\", \\\"testpmd> \\\")\\n self.dut.send_expect(\\n \\\"set port 0 queue-region flush on\\\", \\\"testpmd> \\\")\\n # send the packets and verify the results\\n rss_queue = [\\\"1\\\"]\\n self.send_and_check(self.pkt2, rss_queue)\\n\\n # Create a RSS queue rule.\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern end actions rss queues 6 7 end / end\\\", \\\"testpmd> \\\")\\n # send the packets and verify the results\\n rss_queue = [\\\"1\\\"]\\n self.send_and_check(self.pkt2, rss_queue)\\n\\n # destroy the queue region.\\n self.dut.send_expect(\\n \\\"set port 0 queue-region flush off\\\", \\\"testpmd> \\\")\\n # send the packets and verify the results\\n rss_queue = [\\\"6\\\", \\\"7\\\"]\\n self.send_and_check(self.pkt2, rss_queue)\",\n \"def buildInterface(self, idx = 0, z_1 = 1, z_2 = 1, d = 2.5,\\\\\\n verbose = 1, vacuum = 0, translation = None,\\\\\\n surface = None, anchor = \\\"@\\\", ab = True):\\n\\n if verbose > 0:\\n self.printInterfaces(idx = idx, anchor = anchor)\\n\\n \\\"\\\"\\\"Get the distance between the top atom and the top of the cell\\\"\\\"\\\"\\n if ab:\\n B1, B2 = self.getAB()\\n void = B1[2, 2] - np.max(self.pos_1[:, 2] / self.base_1[2, 2] * B1[2, 2])\\n else:\\n void = self.base_1[2, 2] - np.max(self.pos_1[:, 2])\\n d -= void\\n\\n \\\"\\\"\\\"The strained new basis\\\"\\\"\\\"\\n F = np.zeros((3, 3))\\n F[2, 2] = self.base_1[2, 2] * z_1 + self.base_2[2, 2] * z_2 + d\\n F[0:2, 0:2] = self.cell_1[idx, :, :]\\n \\n \\\"\\\"\\\"Parameters for the alternative base if specified\\\"\\\"\\\"\\n if ab:\\n F_ab = np.zeros((3, 3))\\n F_ab[:2, :2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\\n F_ab[2, 2] = B1[2, 2] * z_1 + B2[2, 2] * z_2 + d\\n\\n \\\"\\\"\\\"The unstrained new basis\\\"\\\"\\\"\\n D = np.zeros((3, 3))\\n D[2, 2] = self.base_2[2, 2] * z_2\\n D[0:2, 0:2] = self.cell_2[idx, :, :]\\n\\n \\\"\\\"\\\"Parameters for the alternative base if specified\\\"\\\"\\\"\\n if ab:\\n D_ab = np.zeros((3, 3))\\n D_ab[:2, :2] = np.matmul(B2[:2, :2], self.rep_2[idx, :, :])\\n D_ab[2, 2] = B2[2, 2] * z_2\\n\\n \\\"\\\"\\\"Working on interface A\\\"\\\"\\\"\\n \\\"\\\"\\\"Set up the bottom interface with the correct repetitions\\\"\\\"\\\"\\n rep_1 = np.zeros((3, 4))\\n rep_1[0:2, 0:2] = self.rep_1[idx, :, :]\\n rep_1[:, 2] = np.sum(rep_1, axis = 1)\\n\\n \\\"\\\"\\\"Set all hi-lo limits for the cell repetitions\\\"\\\"\\\"\\n h = 2\\n rep_1 = [rep_1[0, :].min() - h, rep_1[0, :].max() + h,\\\\\\n rep_1[1, :].min() - h, rep_1[1, :].max() + h,\\\\\\n 0, z_1 - 1]\\n\\n \\\"\\\"\\\"Extend the cell as spcefied\\\"\\\"\\\"\\n pos_1_ext, spec_1, mass_1 = ut.extendCell(base = self.base_1, rep = rep_1,\\\\\\n pos = self.pos_1.T, spec = self.spec_1,\\\\\\n mass = self.mass_1)\\n\\n \\\"\\\"\\\"Working on interface B\\\"\\\"\\\" \\n \\\"\\\"\\\"Set up the top interface with the correct repetitions and rotation\\\"\\\"\\\"\\n rep_2 = np.zeros((3, 4))\\n rep_2[0:2, 0:2] = self.rep_2[idx, :, :]\\n rep_2[:, 2] = np.sum(rep_2, axis = 1)\\n\\n \\\"\\\"\\\"Set all hi-lo limits for the cell repetitions\\\"\\\"\\\"\\n h = 2\\n rep_2 = [rep_2[0, :].min() - h, rep_2[0, :].max() + h,\\\\\\n rep_2[1, :].min() - h, rep_2[1, :].max() + h,\\\\\\n 0, z_2 - 1]\\n\\n \\\"\\\"\\\"Extend the cell as specified\\\"\\\"\\\"\\n pos_2_ext, spec_2, mass_2 = ut.extendCell(base = self.base_2, rep = rep_2,\\\\\\n pos = self.pos_2.T, spec = self.spec_2,\\\\\\n mass = self.mass_2)\\n\\n \\\"\\\"\\\"Initial rotation\\\"\\\"\\\"\\n initRot = np.deg2rad(self.ang[idx])\\n\\n \\\"\\\"\\\"Rotate the positions pos_rot = R*pos\\\"\\\"\\\"\\n pos_2_ext_rot = ut.rotate(pos_2_ext, initRot, verbose = verbose - 1)\\n\\n \\\"\\\"\\\"Convert to direct coordinates in the unstrained D base\\\"\\\"\\\"\\n pos_2_d_D = np.matmul(np.linalg.inv(D), pos_2_ext_rot)\\n\\n \\\"\\\"\\\"Convert the cell back to Cartesian using the strained basis.\\n But with the Z parameter as in the D cell or as the Z in the \\n alternative base if specified\\\"\\\"\\\"\\n temp_F = F.copy()\\n if ab:\\n temp_F[2, 2] = B2[2, 2] * z_2\\n else:\\n temp_F[2, 2] = D[2, 2]\\n pos_2_F = np.matmul(temp_F, pos_2_d_D)\\n\\n \\\"\\\"\\\"If using an alternative base fix the hight of the bottom cell\\\"\\\"\\\"\\n if ab:\\n temp_F = F.copy()\\n temp_F[2, 2] = self.base_1[2, 2] * z_1\\n pos_1_d = np.matmul(np.linalg.inv(temp_F), pos_1_ext)\\n temp_F[2, 2] = B1[2, 2] * z_1\\n pos_1_ext = np.matmul(temp_F, pos_1_d)\\n\\n \\\"\\\"\\\"Combine the positions of the two cells\\\"\\\"\\\"\\n pos = np.zeros((3, pos_1_ext.shape[1] + pos_2_F.shape[1]))\\n pos[:, :pos_1_ext.shape[1]] = pos_1_ext\\n\\n \\\"\\\"\\\"Shift Z positions of top cell to (cell_A + d)\\\"\\\"\\\"\\n if ab:\\n height = B1[2, 2] * z_1 + d\\n else:\\n height = self.base_1[2, 2] * z_1 + d\\n\\n pos_2_F[2, :] = pos_2_F[2, :] + height\\n pos[:, pos_1_ext.shape[1]:] = pos_2_F\\n\\n \\\"\\\"\\\"If a translation is specified shift (x,y) coordinates of top cell accordingly\\\"\\\"\\\" \\n if translation is not None:\\n T = ut.getTranslation(translation, surface, verbose = verbose)[0]\\n cT = np.matmul(self.base_1, T)\\n pos[:, pos_1_ext.shape[1]:] = pos[:, pos_1_ext.shape[1]:] + cT[:, np.newaxis]\\n if verbose: \\n string = \\\"Translation [%.2f, %.2f, %.2f] (C) or [%.2f, %.2f, %.2f] (D)\\\"\\\\\\n % (cT[0], cT[1], cT[2], T[0], T[1], T[2])\\n ut.infoPrint(string)\\n\\n \\\"\\\"\\\"Convert the entire new cell to direct coordinates, add d above as well\\\"\\\"\\\"\\n if ab:\\n F[2, 2] = B1[2, 2] * z_1 + d + B2[2, 2] * z_2 + d\\n else:\\n F[2, 2] += d\\n pos_d = np.matmul(np.linalg.inv(F), pos)\\n\\n \\\"\\\"\\\"Change the base if an alternative base is used\\\"\\\"\\\"\\n if ab:\\n F[:2, :2] = F_ab[:2, :2]\\n\\n \\\"\\\"\\\"Remove all positions outside [0, 1)\\\"\\\"\\\"\\n pos_d = np.round(pos_d, 8)\\n F = np.round(F, 8)\\n\\n keep = np.all(pos_d < 1, axis = 0) * np.all(pos_d >= 0, axis = 0)\\n pos_d = pos_d[:, keep]\\n species = np.concatenate((spec_1, spec_2))[keep]\\n mass = np.concatenate((mass_1, mass_2))[keep]\\n\\n \\\"\\\"\\\"Return to cartesian coordinates and change shape to (...,3)\\\"\\\"\\\"\\n pos = np.matmul(F, pos_d).T\\n\\n \\\"\\\"\\\"Add vacuum if specified\\\"\\\"\\\"\\n F[2, 2] = F[2, 2] + vacuum\\n if verbose: \\n string = \\\"Z-distance fixed (between,above): %.2f | Vacuum added (above): %.2f\\\"\\\\\\n % (d + void, vacuum)\\n ut.infoPrint(string)\\n if ab:\\n string = \\\"Interface constructed with an alternative base\\\"\\n ut.infoPrint(string)\\n\\n return F, pos, species, mass\",\n \"def solveit(static_arr):\\n arr = np.asarray(static_arr)\\n if arr.shape != (9, 9):\\n raise ValueError('Sudoku array must be 9x9')\\n\\n if np.all(arr) or is_solved(arr):\\n return arr\\n\\n possnum = [[], [], []]\\n\\n for i in iter1d:\\n possnum[0].append(wantset - set(arr[:, i])) # Each row\\n possnum[1].append(wantset - set(arr[i, :])) # Each col\\n\\n # Each 3x3 block\\n for j in iterblock:\\n for i in iterblock:\\n possnum[2].append(wantset - set(arr[j:j+3, i:i+3].ravel()))\\n\\n yy, xx = np.where(arr == 0)\\n possd = np.empty((9, 9), dtype=object)\\n possd.fill(None)\\n minnum = 99\\n minpos = None\\n\\n for i, idx in enumerate(zip(yy, xx)):\\n iy, ix = idx\\n iq = (ix // 3) + ((iy // 3) * 3)\\n num_for_cell = possnum[0][ix] & possnum[1][iy] & possnum[2][iq]\\n n_match = len(num_for_cell)\\n if n_match > 0:\\n possd[idx] = num_for_cell\\n if n_match < minnum:\\n minnum = n_match\\n minpos = idx\\n\\n # print('Starting at {} with {} possibilities'.format(minpos, minnum))\\n n = list(possd[minpos])[0]\\n arr[minpos] = n\\n possd[minpos] = None\\n yy, xx = possd.nonzero()\\n for idx in zip(yy, xx):\\n if n in possd[idx]:\\n possd[idx].remove(n)\\n\\n return solveit(arr)\",\n \"def check_topology(self, ninputs, noutputs):\\n return _spacegrant_swig.G3RUH_descramble_sptr_check_topology(self, ninputs, noutputs)\",\n \"def test_make_layout():\\n raw = hcp.read_raw(data_type='rest', **hcp_params).crop(0, 1).load_data()\\n raw.pick_types()\\n lout = make_hcp_bti_layout(raw.info)\\n assert_equal(lout.names, raw.info['ch_names'])\",\n \"def numpy_IoU_xyctrs(bb1, bb2):\\n\\n # There should be at least one anchor, but maybe more. \\n # If the number of dimensions is only 1 (so it's just\\n # one anchor), reshape the array to allow the slicing\\n # to work properly:\\n \\n if bb1.ndim == 1:\\n bb1 = np.reshape(bb1, (1,) + bb1.shape)\\n if bb2.ndim == 1:\\n bb2 = np.reshape(bb2, (1,) + bb2.shape)\\n\\n # Now, n1 and n2 can represent the number of anchors:\\n n_1 = bb1.shape[0]\\n n_2 = bb2.shape[0]\\n\\n # Want the IoU for every bb1 to every bb2, so tile them into\\n # long 1D arrays to allow slicing:\\n bb1_arr = np.reshape(np.tile(bb1, [1, n_2]), (n_1*n_2, 4))\\n bb2_arr = np.tile(bb2, [n_1, 1])\\n\\n\\n x1 = np.max((bb1_arr[:,0] - 0.5*bb1_arr[:,2], \\n bb2_arr[:,0] - 0.5*bb2_arr[:,2]),\\n axis=0)\\n y1 = np.max((bb1_arr[:,1] - 0.5*bb1_arr[:,3], \\n bb2_arr[:,1] - 0.5*bb2_arr[:,3]),\\n axis=0)\\n x2 = np.min((bb1_arr[:,0] + 0.5*bb1_arr[:,2], \\n bb2_arr[:,0] + 0.5*bb2_arr[:,2]),\\n axis=0)\\n y2 = np.min((bb1_arr[:,1] + 0.5*bb1_arr[:,3], \\n bb2_arr[:,1] + 0.5*bb2_arr[:,3]),\\n axis=0)\\n\\n w = x2 - x1\\n h = y2 - y1\\n\\n inter = w*h\\n\\n aarea = (bb1_arr[:,3])* (bb1_arr[:,2])\\n barea = (bb2_arr[:,3])* (bb2_arr[:,2])\\n\\n denom = aarea + barea - inter\\n mask = (denom == 0)\\n denom[mask] = 0.1\\n\\n IoU = inter / (denom)\\n IoU[mask] = 0\\n IoU[w <= 0] = 0\\n IoU[h <= 0] = 0\\n \\n return np.squeeze(np.reshape(IoU, (n_1,n_2)))\",\n \"def solve(num_wizards, num_constraints, wizards, constraints): \\n global wiz_const\\n wiz_const = mapConstraints(wizards, constraints)\\n partial_soltns = []\\n\\n # counter for priority queue since it doesn't allow \\n # identical priorities\\n k = 0\\n\\n # list of wizards sorted by lowest to highest degree\\n sorted_wiz = sortWizByConsts(wiz_const)\\n wiz_rankings = {wiz: i for i, wiz in enumerate(sorted_wiz)}\\n\\n const_set = set(map(tuple, constraints))\\n for i in range(4) : \\n heapq.heappush(partial_soltns, (0, k, nx.DiGraph(), const_set.copy()))\\n k += 1\\n\\n print(\\\"setup done, commencing solving\\\")\\n\\n while len(partial_soltns) : \\n\\n # for partial_soltn, const_set in partial_soltns : \\n# partial_soltns.remove(partial_soltn)\\n num_seen, _, partial_soltn, const_set = heapq.heappop(partial_soltns)\\n const = findNextConst(partial_soltn, const_set, wiz_rankings)\\n print(\\\"seen \\\" + str(len(partial_soltn)) + \\\"\\\\t num partial_solutions\\\\t\\\" + str(len(partial_soltns)))\\n try : \\n const_set.remove(const)\\n except KeyError : \\n print(\\\"BAD SHIT\\\")\\n pass\\n possible_arrangements = [(const[0], const[1], const[2]),\\n (const[2], const[0], const[1]), \\n (const[2], const[1], const[0]),\\n (const[1], const[0], const[2])]\\n for arr in possible_arrangements:\\n soltn = partial_soltn.copy()\\n a, b, c = arr\\n if not (soltn.has_node(a) and soltn.has_node(b) and nx.has_path(soltn, a, b)) : \\n soltn.add_edge(a, b)\\n if not (soltn.has_node(b) and soltn.has_node(c) and nx.has_path(soltn, b, c)) : \\n soltn.add_edge(b, c)\\n # see if we violated any other constraints (seen or not seen)\\n is_valid, num_wiz = validNumWiz(soltn, const_set)\\n\\n if is_valid and len(list(nx.simple_cycles(soltn))) == 0 :\\n heapq.heappush(partial_soltns, (-len(soltn), k, soltn, const_set.copy()))\\n k += 1\\n # are we done?\\n if num_wiz == num_wizards :\\n print(\\\"FINAL SOLUTION (found without processing all constraints but validating against them)\\\")\\n ordering = list(nx.topological_sort(soltn))\\n finishEverything(ordering, constraints)\\n return ordering\\n if foundCompleteOrdering(heapq.heappop(partial_soltns)) : \\n print(\\\"FINAL SOLUTION\\\")\\n ordering = list(nx.topological_sort(soltn))\\n finishEverything(ordering, constraints)\\n return ordering\\n print(\\\"NO SOLUTION FOUND\\\")\\n return \\\"\\\"\",\n \"def UKIDSS_match(t, RA_main, DEC_main,\\n c_graph=True, width=0.0004, w_units=\\\"degrees\\\",\\n DES_box=False):\\n\\n import numpy as np\\n import match_lists\\n import sqlutil\\n from astropy.table import Table, vstack\\n\\n db, host, user, password, table = rd_config_wsdb()\\n\\n if w_units == \\\"arcsecs\\\":\\n width = width / 3600.0\\n\\n cols = [\\\"RA_UKIDSS\\\", \\\"DEC_UKIDSS\\\", \\\"Y_UKIDSS\\\", \\\"Y_ERR_UKIDSS\\\",\\n \\\"J_UKIDSS\\\", \\\"J_ERR_UKIDSS\\\", \\\"H_UKIDSS\\\", \\\"H_ERR_UKIDSS\\\",\\n \\\"K_UKIDSS\\\", \\\"K_ERR_UKIDSS\\\"]\\n\\n try:\\n for col in cols:\\n t.add_empty_column(col, dtype=np.float64)\\n\\n except AttributeError as e:\\n for col in cols:\\n t[col] = np.zeros(len(t))\\n\\n print(get_timestamp(), get_function_name() + ';',\\n get_linenumber() + ':')\\n (ra_min, ra_max, dec_min, dec_max) = min_max_match(\\n t[RA_main], t[DEC_main], width, DES_box=DES_box)\\n\\n area = ((float(ra_max) - float(ra_min)) *\\n (float(dec_max) - float(dec_min)))\\n print('area in square degreesish:', area)\\n\\n if len(t) > 1000 and area < 2000:\\n print(get_timestamp(), get_function_name() + ';',\\n get_linenumber() + ':')\\n (ra_min, ra_max, dec_min, dec_max) = min_max_match(\\n t[RA_main], t[DEC_main], width, DES_box=DES_box)\\n\\n print(\\\"Retreiving data\\\")\\n\\n query_ukidss = \\\"select ra, dec, yAperMag3, yAperMag3Err, j_1AperMag3, \\\\\\n j_1AperMag3Err, hAperMag3, hAperMag3Err, kAperMag3, \\\\\\n kAperMag3Err FROM ukidssdr10.lassource \\\\\\n WHERE ra > \\\" + ra_min + \\\" and ra < \\\" + ra_max + \\\" and \\\\\\n dec > \\\" + dec_min + \\\" and dec < \\\" + dec_max\\n\\n (RA_u, DEC_u, Y, Yerr, J, Jerr, H, Herr, K,\\n Kerr) = sqlutil.get(query_ukidss,\\n db=db, host=host,\\n user=user, password=password)\\n\\n print(\\\"Retrieved data\\\")\\n\\n if len(RA_u) == 0:\\n for (i, col) in enumerate(cols):\\n t[col] = [np.float64(np.nan)] * len(t)\\n\\n else:\\n dists, inds = match_lists.match_lists(t[RA_main], t[DEC_main],\\n RA_u, DEC_u, width, 1)\\n\\n info = [RA_u, DEC_u, Y, Yerr, J, Jerr, H, Herr, K, Kerr]\\n\\n match = np.where((inds != len(RA_u)))[0]\\n no_match = np.where((inds == len(RA_u)))[0]\\n\\n for (i, col) in enumerate(cols):\\n t[col][match] = info[i][inds[match]]\\n t[col][no_match] = np.float64(np.nan)\\n\\n if len(t) <= 1000:\\n n = 0\\n\\n while n < len(t):\\n RA = t[RA_main][n]\\n DEC = t[DEC_main][n]\\n\\n query_ukidss = \\\"select ra, dec, \\\\\\n yAperMag3, yAperMag3Err, \\\\\\n j_1AperMag3,j_1AperMag3Err, \\\\\\n hAperMag3, hAperMag3Err, \\\\\\n kAperMag3, kAperMag3Err \\\\\\n FROM ukidssdr10.lassource \\\\\\n WHERE \\\\\\n q3c_radial_query(ra, dec, \\\" \\\\\\n + str(RA) + \\\", \\\" + str(DEC) + \\\", 0.1102)\\\"\\n\\n (RA_u, DEC_u, Y, Yerr, J, Jerr, H,\\n Herr, K, Kerr) = sqlutil.get(query_ukidss,\\n db=db, host=host,\\n user=user, password=password)\\n\\n if len(RA_u) > 0:\\n dists, inds = match_lists.match_lists(\\n [RA], [DEC], RA_u, DEC_u, width, 1)\\n j = inds[0]\\n\\n if j != len(RA_u):\\n info = [RA_u[j], DEC_u[j], Y[j],\\n Yerr[j], J[j], Jerr[j],\\n H[j], Herr[j], K[j], Kerr[j]]\\n\\n for (k, col) in enumerate(cols):\\n t[col][n] = info[k]\\n\\n else:\\n for (k, col) in enumerate(cols):\\n t[col][n] = np.float64(np.nan)\\n\\n else:\\n for (k, col) in enumerate(cols):\\n t[col][n] = np.float64(np.nan)\\n\\n n += 1\\n\\n print(\\\"Done UKIDSS\\\")\\n\\n if area > 2000 and len(t) > 1000:\\n t.sort(RA_main)\\n l1 = np.ceil(area / 1001.0)\\n l = len(t) / l1\\n i = 0\\n\\n while i < l1:\\n if (i + 1) * l < len(t):\\n t1 = t[i * l:(i + 1) * l]\\n else:\\n t1 = t[i * l:]\\n\\n t1 = UKIDSS_match(t1, RA_main, DEC_main, c_graph=c_graph,\\n width=width, w_units=w_units, DES_box=DES_box)\\n\\n if i == 0:\\n t_out = t1\\n else:\\n t_out = vstack([t_out, t1])\\n\\n i += 1\\n\\n t = t_out\\n\\n if c_graph:\\n width = width * 3600.0\\n RA_med, DEC_med = check_graph(t, RA_main, DEC_main, \\\"UKIDSS\\\", width)\\n\\n return t\",\n \"def part1():\\n camera_output = IntCodeProcessor(path='day17input.txt').execute_program()\\n camera_output = ints_to_string(camera_output)\\n grid = camera_output.splitlines()\\n\\n scaffolds = set()\\n for row_index, row in enumerate(grid):\\n for col_index, element in enumerate(row): \\n if element == '#':\\n scaffolds.add((row_index,col_index))\\n\\n intersections = [loc for loc in scaffolds if set(locations_adjacent_to(loc)) <= scaffolds]\\n parameters = [loc[0] * loc[1] for loc in intersections]\\n\\n print(f'Part 1 answer: {sum(parameters)}')\",\n \"def _parse_ai2d_layout(self, ai2d_ann, h, w, n_pix, node_type, node_id):\\n # Process elements with bounding boxes first\\n if node_type in ['text', 'arrowHeads']:\\n\\n # Assign coordinates to a variable\\n coords = np.array(ai2d_ann[node_type][node_id]['rectangle'],\\n np.int32)\\n\\n # Calculate element area via the cv2.boundingRect, as\\n # the cv2.contourArea does not work with xy-coordinates\\n (rect_x, rect_y, rect_w, rect_h) = cv2.boundingRect(coords)\\n\\n # Calculate element area\\n area = (rect_w * rect_h) / float(n_pix)\\n\\n # Calculate solidity, or simply assign 1, as rectangles\\n # are always solid\\n solidity = 1.0\\n\\n # Get centre point\\n centre = (int(np.round(rect_x + (rect_w / 2), decimals=0)),\\n int(np.round(rect_y + (rect_h / 2), decimals=0)))\\n\\n # Continue to process elements with polygons\\n if node_type in ['arrows', 'blobs']:\\n\\n # Fetch coordinates and convert to numpy array\\n coords = np.array(ai2d_ann[node_type][node_id]\\n ['polygon'], np.int32)\\n\\n # Calculate element area\\n area = cv2.contourArea(coords)\\n\\n # Calculate convex hull and its area\\n hull = cv2.convexHull(coords)\\n hull_area = cv2.contourArea(hull)\\n\\n # Calculate solidity (area divided by convex hull area)\\n try:\\n\\n solidity = area / hull_area\\n\\n except ZeroDivisionError:\\n\\n solidity = 0\\n\\n # Normalize element area by dividing by total pixel\\n # count\\n area = area / float(n_pix)\\n\\n # Calculate moments for finding the centroid\\n try:\\n moments = cv2.moments(coords)\\n\\n # Calculate centroid\\n centroid_x = int(moments[\\\"m10\\\"] / moments[\\\"m00\\\"])\\n centroid_y = int(moments[\\\"m01\\\"] / moments[\\\"m00\\\"])\\n\\n # Assign centre point to a variable\\n centre = [centroid_x, centroid_y]\\n\\n except ZeroDivisionError:\\n\\n centre = [0, 0]\\n\\n # If the node is a group or an image constant, set the features to zero\\n if node_type in ['group', 'imageConsts']:\\n\\n # Assign empty coordinates to a variable\\n norm_coords = [0, 0]\\n area = 0\\n solidity = 0\\n\\n # Otherwise normalize coordinates to [0..1] by dividing by image width\\n # and height. This must be done last to prevent error from imageConsts\\n # and groups, which is caused by an absent centre point.\\n else:\\n\\n norm_coords = np.array([centre[0] / w, centre[1] / h], np.float32)\\n\\n # Concatenate all layout features along axis 0\\n layout_feats = np.concatenate((norm_coords, [area], [solidity]), axis=0)\\n\\n # Return layout feature vector\\n return layout_feats\",\n \"def interpret_layout(aux_layer, input, id=-1, aux_weight_decay=3e-4):\\n\\tif aux_layer[0] == 'cbr':\\n\\t\\tfilters = 256\\n\\t\\tkernel_size = (3, 3)\\n\\t\\tstrides = (1, 1)\\n\\t\\tif len(aux_layer) > 1:\\n\\t\\t\\tfilters = aux_layer[1]\\n\\t\\tif len(aux_layer) > 2:\\n\\t\\t\\tkernel_size = (aux_layer[2], aux_layer[2])\\n\\t\\tif len(aux_layer) > 3:\\n\\t\\t\\tstrides = (aux_layer[3], aux_layer[3])\\n\\t\\tinput = _conv_bn_relu(filters=filters, kernel_size=kernel_size, strides=strides, padding=\\\"same\\\",\\n\\t\\t\\t\\t\\t\\t\\t aux_weight_decay=aux_weight_decay)(input)\\n\\telif aux_layer[0] == 'se':\\n\\t\\tinput = squeeze_and_excitation_layer(input, aux_weight_decay=aux_weight_decay)\\n\\telif aux_layer[0] == 'inception':\\n\\t\\tinput = inception_block_high_level(input, aux_weight_decay=aux_weight_decay)\\n\\telif aux_layer[0] == 'gap':\\n\\t\\tinput = GlobalAveragePooling2D(name='gap' + str(id))(input)\\n\\telif aux_layer[0] == 'dense':\\n\\t\\tunits = 768\\n\\t\\tif len(aux_layer) > 1:\\n\\t\\t\\tunits = aux_layer[1]\\n\\t\\tinput = Dense(units, activation='relu')(input)\\n\\telse:\\n\\t\\traise ValueError\\n\\treturn input\",\n \"def solve_sat(grid_start, size, debug=False):\\n r, c = Ints(\\\"r c\\\")\\n rows, cols = size\\n n = len(grid_start)\\n # This is the function that represents the grid\\n # grid[x, y] == k means the cell at (x, y) is of color k\\n grid = Function(\\\"grid\\\", IntSort(), IntSort(), IntSort())\\n # This function gives Z3 the knowledge of direction of the flows\\n # flow[x, y] == k means the cell at (x, y) is k-th cell of its flow\\n # e.g. flow[x, y] == 0 for every (x, y) starting point of a flow\\n flow = Function(\\\"flow\\\", IntSort(), IntSort(), IntSort())\\n s = Solver()\\n\\n start_points = [a for couple in grid_start for a in couple]\\n dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4 = Ints(\\n \\\"dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4\\\")\\n\\n ### Grid constraints\\n # Defined only inside the grid and values in the right range\\n s.add(ForAll([r, c], Implies(And(r >= 0, r < rows,\\n c >= 0, c < cols),\\n And(grid(r, c) >= 0,\\n grid(r, c) < n))))\\n s.add(ForAll([r, c], Implies(Or(r < 0, r >= size[0],\\n c < 0, c >= size[1]),\\n grid(r, c) == -1)))\\n # Set the initial conditions\\n for i, ((x1, y1), (x2, y2)) in enumerate(grid_start):\\n s.add(grid(x1, y1) == i)\\n s.add(grid(x2, y2) == i)\\n # Other constraints\\n # There must not be any squares of the same color\\n # Square\\n s.assert_and_track(\\n ForAll([r, c],\\n Implies(And(r >= 0, r < rows - 1, c >= 0, c < cols - 1),\\n Not(And(grid(r, c) == grid(r , c+1),\\n grid(r, c) == grid(r+1, c+1),\\n grid(r, c) == grid(r+1, c ))))),\\n \\\"Square\\\")\\n\\n # The number of adjacent (non diagonal) of the same color is exactly 2 for\\n # normal cells and exactly 1 for starting points\\n for i in range(rows):\\n for j in range(cols):\\n if (i, j) in start_points:\\n K = 1\\n else:\\n K = 2\\n # 4 directions 4_0\\n if i > 0 and i < rows - 1 and j > 0 and j < cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i-1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j+1), 1, 0)\\n + If(grid(i, j) == grid(i+1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j-1), 1, 0)),\\n \\\"dir_4_0_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 3 directions 3_1\\n if i > 0 and i < rows - 1 and j == 0 and j < cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i-1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j+1), 1, 0)\\n + If(grid(i, j) == grid(i+1, j ), 1, 0)),\\n \\\"dir_3_1_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 3 directions 3_2\\n if i == 0 and i < rows - 1 and j > 0 and j < cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i , j+1), 1, 0)\\n + If(grid(i, j) == grid(i+1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j-1), 1, 0)),\\n \\\"dir_3_2_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 3 directions 3_3\\n if i > 0 and i < rows - 1 and j > 0 and j == cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i+1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j-1), 1, 0)\\n + If(grid(i, j) == grid(i-1, j ), 1, 0)),\\n \\\"dir_3_3_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 3 directions 3_4\\n if i > 0 and i == rows - 1 and j > 0 and j < cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i , j-1), 1, 0)\\n + If(grid(i, j) == grid(i-1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j+1), 1, 0)),\\n \\\"dir_3_4_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 2 directions 2_5\\n if i > 0 and i == rows - 1 and j == 0 and j < cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i-1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j+1), 1, 0)),\\n \\\"dir_2_5_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 2 directions 2_6\\n if i == 0 and i < rows - 1 and j == 0 and j < cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i , j+1), 1, 0)\\n + If(grid(i, j) == grid(i+1, j ), 1, 0)),\\n \\\"dir_2_6_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 2 directions 2_7\\n if i == 0 and i < rows - 1 and j > 0 and j == cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i+1, j ), 1, 0)\\n + If(grid(i, j) == grid(i , j-1), 1, 0)),\\n \\\"dir_2_7_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n # 2 directions 2_8\\n if i > 0 and i == rows - 1 and j > 0 and j == cols - 1:\\n s.assert_and_track(\\n K ==\\n ( If(grid(i, j) == grid(i , j-1), 1, 0)\\n + If(grid(i, j) == grid(i-1, j ), 1, 0)),\\n \\\"dir_2_8_K_{}_i_j_{}_{}\\\".format(K, i, j))\\n\\n\\n ### Flow constraints\\n # Defined only inside the grid and >= 0 values\\n s.add(ForAll([r, c], Implies(And(r >= 0, r < rows,\\n c >= 0, c < cols),\\n flow(r, c) >= 0)))\\n s.add(ForAll([r, c], Implies(Or(r < 0, r >= rows,\\n c < 0, c >= cols),\\n flow(r, c) == -1)))\\n\\n # Set the initial conditions\\n for i, ((x1, y1), (x2, y2)) in enumerate(grid_start):\\n s.add(flow(x1, y1) == 0)\\n\\n # For every cell that is not a starting point there must be two adjacent\\n # non diagonal cells with decreasing and increasing value respectively\\n for i in range(rows):\\n for j in range(cols):\\n if (i, j) in start_points:\\n s.assert_and_track(\\n Exists(\\n [dx1, dy1],\\n And(# Adjacent orthogonal cell\\n Or((dx1 == 1), (dx1 == 0), (dx1 == -1)),\\n Or((dy1 == 1), (dy1 == 0), (dy1 == -1)),\\n\\n Or(Not(dx1 == 0), Not(dy1 == 0)),\\n # Inside the grid\\n And((i + dx1) >= 0, (i + dx1) < rows,\\n (j + dy1) >= 0, (j + dy1) < cols),\\n # Of the same color\\n grid(i, j) == grid(i + dx1, j + dy1),\\n\\n Or(flow(i, j) == (flow(i + dx1, j + dy1) + 1),\\n flow(i, j) == (flow(i + dx1, j + dy1) - 1))\\n )\\n ), \\\"flow_starting_i_j_{}_{}\\\".format(i, j))\\n else:\\n s.assert_and_track(\\n Exists(\\n [dx1, dy1, dx2, dy2],\\n And(# Different adjacent orthogonal cells\\n Or(And(dx1 == -1, dy1 == 0), And(dx1 == 0, dy1 == 1),\\n And(dx1 == 1, dy1 == 0), And(dx1 == 0, dy1 == -1)),\\n Or(And(dx2 == -1, dy2 == 0), And(dx2 == 0, dy2 == 1),\\n And(dx2 == 1, dy2 == 0), And(dx2 == 0, dy2 == -1)),\\n\\n Or(Not(dx1 == dx2), Not(dy1 == dy2)),\\n # Inside the grid\\n And((i + dx1) >= 0, (i + dx1) < rows,\\n (j + dy1) >= 0, (j + dy1) < cols),\\n And((i + dx2) >= 0, (i + dx2) < rows,\\n (j + dy2) >= 0, (j + dy2) < cols),\\n # Of the same color\\n grid(i + dx1, j + dy1) == grid(i, j),\\n grid(i + dx2, j + dy2) == grid(i, j),\\n\\n flow(i, j) == (flow(i + dx1, j + dy1) + 1),\\n flow(i + dx2, j + dy2) == (flow(i, j) + 1)\\n )\\n ), \\\"flow_normal_i_j_{}_{}\\\".format(i, j))\\n\\n if s.check() == unsat:\\n if debug:\\n print()\\n print(\\\"UNSAT\\\")\\n for e in s.unsat_core():\\n print(e)\\n return None, None\\n return None\\n\\n m = s.model()\\n if debug:\\n return ([[m.evaluate(grid(i, j)).as_long() for j in range(size[1])]\\n for i in range(size[0])],\\n [[m.evaluate(flow(i, j)).as_long() for j in range(size[1])]\\n for i in range(size[0])])\\n else:\\n return [[m.evaluate(grid(i, j)).as_long() for j in range(size[1])]\\n for i in range(size[0])]\",\n \"def intersect_enter_hint(self, sq, hh):\\n\\n if not self.hints_prepped:\\n self.reset_hints()\\n self.hints_prepped=1\\n pos=self.local2global(sq)\\n if self.kind=='pararooms':\\n from_outside_dvs=[dv for dv in range(4) if add(sq, dv+2) not in self.sqs]\\n else:\\n from_outside_dvs=[dv for dv in range(4) if add(sq, dv+2) not in self.allsqs]\\n okwaysin=[]\\n #~ if self.hashid=='bfb08f4204ceecf84767e77869cabce5x009x000':\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n for h in hh:\\n if h[0]=='OUT':\\n okwaysin.extend(from_outside_dvs)\\n continue\\n if h[0]=='IN':\\n #~ okwaysin.append(h[1])\\n okwaysin.extend(from_outside_dvs)\\n continue\\n okwaysin.append(h[0])\\n okwaysin=list(set(okwaysin))\\n newh=set([gh for gh in self._global_hints[pos] if gh[0] in okwaysin])\\n if not newh and self._global_hints[pos]:\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n print 'promoting cause of a conflict between the rooms entry',pos\\n return pos\\n self._global_hints[pos]=newh\\n self._hints[sq]=newh.copy()\",\n \"def add_sudoku_constraints(sg):\\n for y in range(6):\\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for x in range(6)]))\\n for x in range(6):\\n sg.solver.add(Distinct(*[sg.grid[Point(y, x)] for y in range(6)]))\\n for z in range(6):\\n top = (z // 2) * 2\\n left = (z % 2) * 3\\n cells = [sg.grid[Point(y, x)] for y in range(top, top + 2) for x in range(left, left + 3)]\\n sg.solver.add(Distinct(*cells))\",\n \"def setup_layout_constants(self):\\n # determines the spacing between the edge and nmos (rail to active\\n # metal or poly_to_poly spacing)\\n half_gate_to_gate = 0.5 * (drc[\\\"poly_to_poly\\\"] - drc[\\\"minwidth_metal1\\\"])\\n edge_to_nmos = max(drc[\\\"metal1_to_metal1\\\"] - self.nmos.active_contact_positions[0].y,\\n half_gate_to_gate - self.nmos.poly_positions[0].y)\\n\\n # determine the position of the first transistor from the left\\n self.nmos_position1 = vector(0,\\n 0.5 * drc[\\\"minwidth_metal1\\\"] + edge_to_nmos)\\n offset = self.nmos_position1 + vector(0,self.nmos.height)\\n\\n x = vector(self.nmos.active_width - self.nmos.active_contact.width, 0)\\n self.nmos_position2 = x + self.nmos_position1.scale(0,1)\\n\\n # determines the spacing between the edge and pmos\\n edge_to_pmos = max(drc[\\\"metal1_to_metal1\\\"] - self.pmos.active_contact_positions[0].y,\\n half_gate_to_gate - self.pmos.poly_positions[0].y)\\n self.pmos_position1 = vector(0,\\n self.height - 0.5 * drc[\\\"minwidth_metal1\\\"]\\n - edge_to_pmos - self.pmos.height)\\n self.pmos_position2 = self.pmos_position1 + vector(self.pmos.width,0)\\n\\n self.well_width = max(self.pmos_position2.x + self.pmos.active_position.x\\n + self.pmos.active_width\\n + drc[\\\"active_to_body_active\\\"] + self.nwell_contact.width \\n + drc[\\\"well_enclosure_active\\\"],\\n self.nmos_position2.x + self.nmos.active_position.x \\n + self.nmos.active_width \\n + drc[\\\"active_to_body_active\\\"] + drc[\\\"well_enclosure_active\\\"])\\n self.width = self.well_width\",\n \"def _adc_info_second_pass(\\n self, config_name: str, adc_name: str\\n ) -> Tuple[Tuple[int, Tuple[int, ...], Dict[str, Any]], ...]:\\n # ensure dataset exists for each (brd, ch) combo\\n # - remove (brd, ch) combos if dataset does not exist\\n # - remove brd entry if chs are NULL\\n # populate 'nshotnum' and 'nt' for each board\\n # - confirm all associated channels have matching shape\\n # - if not, then define nshotnum = 0 and nt = 0 and warn\\n #\\n # get conns\\n conns = self.configs[config_name][adc_name]\\n new_conns = []\\n\\n # review connections\\n for iconn, conn in enumerate(conns):\\n brd = conn[0]\\n chs = conn[1]\\n\\n # look for dataset existence\\n new_chs = list(chs)\\n chs_to_remove = []\\n for ch in chs:\\n # get datasets\\n names = [\\n self.construct_dataset_name(brd, ch, config_name=config_name),\\n self.construct_header_dataset_name(brd, ch, config_name=config_name),\\n ]\\n for dset_name in names:\\n if dset_name not in self.group:\\n why = (\\n f\\\"HDF5 structure unexpected...dataset '{dset_name}' \\\"\\n f\\\"not found for board {brd} and channel {ch}\\\"\\n f\\\"...removing combo from map\\\"\\n )\\n warn(why)\\n chs_to_remove.append(ch)\\n\\n # ensure chs is not NULL\\n chs_to_remove = list(set(chs_to_remove))\\n for ch in chs_to_remove:\\n new_chs.remove(ch)\\n if len(new_chs) == 0:\\n why = (\\n f\\\"HDF5 structure unexpected...'Board number {brd}' does not \\\"\\n f\\\"define any valid channel numbers...not adding to \\\"\\n f\\\"`configs` dict\\\"\\n )\\n warn(why)\\n\\n # skip adding to conn list\\n continue\\n\\n # get 'nshotnum' and 'nt' values\\n chs_to_remove = []\\n nshotnum = None\\n nt = None\\n for ch in new_chs:\\n # -- examine dataset --\\n dset_name = self.construct_dataset_name(brd, ch, config_name=config_name)\\n dset = self.group[dset_name]\\n\\n # dataset should not have fields\\n if dset.dtype.names is not None:\\n why = (\\n f\\\"HDF5 structure unexpected...dataset '{dset_name}' has \\\"\\n f\\\"fields...not adding to `configs` dict\\\"\\n )\\n warn(why)\\n chs_to_remove.append(ch)\\n continue\\n\\n # dataset should be a 2D array\\n if len(dset.shape) != 2:\\n # dataset not 2D array\\n why = (\\n f\\\"HDF5 structure unexpected...dataset '{dset_name}' is \\\"\\n f\\\"NOT a 2D array...not adding to `configs` dict\\\"\\n )\\n warn(why)\\n chs_to_remove.append(ch)\\n continue\\n\\n # Define and check nt\\n # - should be consistent across all datasets\\n if nt is None:\\n nt = dset.shape[1]\\n elif nt == -1:\\n pass\\n else:\\n if nt != dset.shape[1]:\\n why = (\\n f\\\"HDF5 structure unexpected...number of time \\\"\\n f\\\"sample inconsistent across all channels for \\\"\\n f\\\"board {brd}...setting nt = -1\\\"\\n )\\n warn(why)\\n nt = -1\\n continue\\n\\n # Define and check nshotnum\\n # - should be consistent across all datasets\\n if nshotnum is None:\\n nshotnum = dset.shape[0]\\n elif nshotnum == -1:\\n pass\\n else:\\n if nshotnum != dset.shape[0]:\\n why = (\\n f\\\"HDF5 structure unexpected...number of shot \\\"\\n f\\\"numbers inconsistent across all channels for \\\"\\n f\\\"board {brd}...setting nshotnum = -1\\\"\\n )\\n warn(why)\\n nshotnum = -1\\n continue\\n\\n # -- examine header dataset --\\n hdset_name = self.construct_header_dataset_name(\\n brd, ch, config_name=config_name\\n )\\n hdset = self.group[hdset_name]\\n sn_field = self.configs[config_name][\\\"shotnum\\\"][\\\"dset field\\\"][0]\\n\\n # should have fields (specifically the shotnum field)\\n if sn_field not in hdset.dtype.names:\\n if \\\"Shot number\\\" in hdset.dtype.names and iconn == 0:\\n sn_field = \\\"Shot number\\\"\\n self.configs[config_name][\\\"shotnum\\\"][\\\"dset field\\\"] = (\\n \\\"Shot number\\\",\\n )\\n else:\\n why = (\\n f\\\"HDF5 structure unexpected...dataset '{hdset_name}' \\\"\\n f\\\"does NOT have expected shot number field \\\"\\n f\\\"'{sn_field}'...not adding to `configs` dict\\\"\\n )\\n warn(why)\\n chs_to_remove.append(ch)\\n continue\\n\\n # shot number has incorrect shape and type\\n if hdset.dtype[sn_field].shape != () or not np.issubdtype(\\n hdset.dtype[sn_field], np.integer\\n ):\\n why = (\\n f\\\"HDF5 structure unexpected...dataset '{hdset_name}' \\\"\\n f\\\"does NOT have expected shape and dtype for a shot \\\"\\n f\\\"numbers...not adding to `configs` dict\\\"\\n )\\n warn(why)\\n chs_to_remove.append(ch)\\n continue\\n\\n # both datasets (main and header) should have same\\n # number of shot numbers\\n if dset.shape[0] != hdset.shape[0]:\\n why = (\\n f\\\"HDF5 structure unexpected...dataset and header \\\"\\n f\\\"dataset for board {brd} and channel {ch} do NOT have \\\"\\n f\\\"the same number of shot numbers...not adding to \\\"\\n f\\\"`configs` dict\\\"\\n )\\n warn(why)\\n chs_to_remove.append(ch)\\n continue\\n\\n # ensure chs is not NULL\\n for ch in chs_to_remove:\\n new_chs.remove(ch)\\n if len(new_chs) == 0:\\n why = (\\n f\\\"HDF5 structure unexpected...'Board number {brd}' does not \\\"\\n f\\\"define any valid channel numbers...not adding to \\\"\\n f\\\"`configs` dict\\\"\\n )\\n warn(why)\\n\\n # skip adding to conn list\\n continue\\n\\n # add nshotnum and nt to setup dict\\n conn[2].update(\\n {\\n \\\"nshotnum\\\": nshotnum,\\n \\\"nt\\\": nt,\\n }\\n )\\n # append new_conns\\n new_conns.append((brd, tuple(new_chs), conn[2]))\\n\\n return tuple(new_conns)\",\n \"def get_fhd_layout_info(\\n layout_file,\\n telescope_name,\\n latitude,\\n longitude,\\n altitude,\\n radian_tol,\\n loc_tols,\\n obs_tile_names,\\n run_check_acceptability=True,\\n):\\n layout_dict = readsav(layout_file, python_dict=True)\\n layout = layout_dict[\\\"layout\\\"]\\n\\n layout_fields = [name.lower() for name in layout.dtype.names]\\n # Try to get the telescope location from the layout file &\\n # compare it to the position from the obs structure.\\n arr_center = layout[\\\"array_center\\\"][0]\\n layout_fields.remove(\\\"array_center\\\")\\n\\n xyz_telescope_frame = layout[\\\"coordinate_frame\\\"][0].decode(\\\"utf8\\\").lower()\\n layout_fields.remove(\\\"coordinate_frame\\\")\\n\\n if xyz_telescope_frame.strip() == \\\"itrf\\\":\\n # compare to lat/lon/alt\\n location_latlonalt = uvutils.XYZ_from_LatLonAlt(latitude, longitude, altitude)\\n latlonalt_arr_center = uvutils.LatLonAlt_from_XYZ(\\n arr_center, check_acceptability=run_check_acceptability\\n )\\n\\n # check both lat/lon/alt and xyz because of subtle differences\\n # in tolerances\\n if _xyz_close(location_latlonalt, arr_center, loc_tols) or _latlonalt_close(\\n (latitude, longitude, altitude), latlonalt_arr_center, radian_tol, loc_tols\\n ):\\n telescope_location = arr_center\\n else:\\n # values do not agree with each other to within the tolerances.\\n # this is a known issue with FHD runs on cotter uvfits\\n # files for the MWA\\n # compare with the known_telescopes values\\n telescope_obj = uvtel.get_telescope(telescope_name)\\n # start warning message\\n message = (\\n \\\"Telescope location derived from obs lat/lon/alt \\\"\\n \\\"values does not match the location in the layout file.\\\"\\n )\\n\\n if telescope_obj is not False:\\n message += \\\" Using the value from known_telescopes.\\\"\\n telescope_location = telescope_obj.telescope_location\\n else:\\n message += (\\n \\\" Telescope is not in known_telescopes. \\\"\\n \\\"Defaulting to using the obs derived values.\\\"\\n )\\n telescope_location = location_latlonalt\\n # issue warning\\n warnings.warn(message)\\n else:\\n telescope_location = uvutils.XYZ_from_LatLonAlt(latitude, longitude, altitude)\\n\\n # The FHD positions derive directly from uvfits, so they are in the rotated\\n # ECEF frame and must be converted to ECEF\\n rot_ecef_positions = layout[\\\"antenna_coords\\\"][0]\\n layout_fields.remove(\\\"antenna_coords\\\")\\n # use the longitude from the layout file because that's how the antenna\\n # positions were calculated\\n latitude, longitude, altitude = uvutils.LatLonAlt_from_XYZ(\\n arr_center, check_acceptability=run_check_acceptability\\n )\\n antenna_positions = uvutils.ECEF_from_rotECEF(rot_ecef_positions, longitude)\\n\\n antenna_names = [ant.decode(\\\"utf8\\\") for ant in layout[\\\"antenna_names\\\"][0].tolist()]\\n layout_fields.remove(\\\"antenna_names\\\")\\n\\n # make these 0-indexed (rather than one indexed)\\n antenna_numbers = layout[\\\"antenna_numbers\\\"][0]\\n layout_fields.remove(\\\"antenna_numbers\\\")\\n\\n Nants_telescope = int(layout[\\\"n_antenna\\\"][0])\\n layout_fields.remove(\\\"n_antenna\\\")\\n\\n if telescope_name.lower() == \\\"mwa\\\":\\n # check that obs.baseline_info.tile_names match the antenna names\\n # (accounting for possible differences in white space)\\n # this only applies for MWA because the tile_names come from\\n # metafits files. layout[\\\"antenna_names\\\"] comes from the antenna table\\n # in the uvfits file and will be used if no metafits was submitted\\n if [ant.strip() for ant in obs_tile_names] != [\\n ant.strip() for ant in antenna_names\\n ]:\\n warnings.warn(\\n \\\"tile_names from obs structure does not match \\\"\\n \\\"antenna_names from layout\\\"\\n )\\n\\n gst0 = float(layout[\\\"gst0\\\"][0])\\n layout_fields.remove(\\\"gst0\\\")\\n\\n if layout[\\\"ref_date\\\"][0] != \\\"\\\":\\n rdate = layout[\\\"ref_date\\\"][0].decode(\\\"utf8\\\").lower()\\n else:\\n rdate = None\\n layout_fields.remove(\\\"ref_date\\\")\\n\\n earth_omega = float(layout[\\\"earth_degpd\\\"][0])\\n layout_fields.remove(\\\"earth_degpd\\\")\\n\\n dut1 = float(layout[\\\"dut1\\\"][0])\\n layout_fields.remove(\\\"dut1\\\")\\n\\n timesys = layout[\\\"time_system\\\"][0].decode(\\\"utf8\\\").upper().strip()\\n layout_fields.remove(\\\"time_system\\\")\\n\\n if \\\"diameters\\\" in layout_fields:\\n diameters = np.asarray(layout[\\\"diameters\\\"])\\n layout_fields.remove(\\\"diameters\\\")\\n else:\\n diameters = None\\n\\n extra_keywords = {}\\n # ignore some fields, put everything else in extra_keywords\\n layout_fields_ignore = [\\n \\\"diff_utc\\\",\\n \\\"pol_type\\\",\\n \\\"n_pol_cal_params\\\",\\n \\\"mount_type\\\",\\n \\\"axis_offset\\\",\\n \\\"pola\\\",\\n \\\"pola_orientation\\\",\\n \\\"pola_cal_params\\\",\\n \\\"polb\\\",\\n \\\"polb_orientation\\\",\\n \\\"polb_cal_params\\\",\\n \\\"beam_fwhm\\\",\\n ]\\n for field in layout_fields_ignore:\\n if field in layout_fields:\\n layout_fields.remove(field)\\n for field in layout_fields:\\n keyword = field\\n if len(keyword) > 8:\\n keyword = field.replace(\\\"_\\\", \\\"\\\")\\n\\n value = layout[field][0]\\n if isinstance(value, bytes):\\n value = value.decode(\\\"utf8\\\")\\n\\n extra_keywords[keyword.upper()] = value\\n\\n layout_param_dict = {\\n \\\"telescope_location\\\": telescope_location,\\n \\\"Nants_telescope\\\": Nants_telescope,\\n \\\"antenna_positions\\\": antenna_positions,\\n \\\"antenna_names\\\": antenna_names,\\n \\\"antenna_numbers\\\": antenna_numbers,\\n \\\"gst0\\\": gst0,\\n \\\"rdate\\\": rdate,\\n \\\"earth_omega\\\": earth_omega,\\n \\\"dut1\\\": dut1,\\n \\\"timesys\\\": timesys,\\n \\\"diameters\\\": diameters,\\n \\\"extra_keywords\\\": extra_keywords,\\n }\\n\\n return layout_param_dict\",\n \"def type3(sep_to_comps, dict_of_vars):\\n dec_vars = dict_of_vars.keys()\\n A3ineq = list()\\n b3ineq = list()\\n A3eq = list()\\n b3eq = list()\\n for s in sep_to_comps.keys():\\n comps = sep_to_comps[s]\\n p_set = list(powerset(comps))\\n for p in p_set:\\n hold_ineq = list()\\n hold_eq = list()\\n add_ineq = False\\n if not (len(p) == len(comps)):\\n add_ineq = True\\n combos = list(combinations(p, 2))\\n for pair in combos:\\n for u in pair[0]:\\n for v in pair[1]:\\n uv = tuple(sorted([u, v]))\\n if (uv, s) in dec_vars:\\n hold_ineq.append(dict_of_vars[(uv, s)])\\n else:\\n combos = list(combinations(p, 2))\\n for pair in combos:\\n for u in pair[0]:\\n for v in pair[1]:\\n uv = tuple(sorted([u, v]))\\n if (uv, s) in dec_vars:\\n hold_eq.append(dict_of_vars[(uv, s)])\\n if add_ineq:\\n A3ineq.append(hold_ineq)\\n b3ineq.append(len(p) - 1)\\n else:\\n A3eq.append(hold_eq)\\n b3eq.append(len(p) - 1)\\n\\n A3 = sp.lil_matrix((len(A3ineq) + len(A3eq), len(dict_of_vars.keys())))\\n b3 = np.zeros((len(b3ineq) + len(b3eq), ))\\n row = 0\\n for item in A3eq:\\n for vals in item:\\n A3[row, vals] = 1\\n b3[row] = b3eq[row]\\n row += 1\\n hold = row\\n for item in A3ineq:\\n for vals in item:\\n A3[row, vals] = 1\\n b3[row] = b3ineq[row - hold]\\n row += 1\\n\\n return A3, b3, len(b3eq)\",\n \"def parse_layout(input_filename):\\n with open(input_filename, 'r') as layout_file:\\n height = int(layout_file.next().strip()) # = height\\n layout_file.next() # = width\\n n_info = int(layout_file.next().strip()) # = number of associated info pieces\\n layout = \\\"\\\"\\n for i in xrange(height):\\n layout += layout_file.next()\\n patt_info = \\\\\\n re.compile(r\\\"^\\\\s*(?P<row>\\\\d+)\\\\s+(?P<col>\\\\d+)\\\\s+(?P<word>[\\\\w']+).*\\\")\\n info_dict = {}\\n for i in xrange(n_info):\\n match_info = patt_info.match(layout_file.next())\\n loc = ( int(match_info.group('row')), int(match_info.group('col')) )\\n info_dict[loc] = match_info.group('word')\\n return (layout, info_dict)\",\n \"def is_valid_overlap_xy(dir_id, p1, p2, pattern_catalog, pattern_width, adjacency_directions):\\n #dir_corrected = (0 - adjacency_directions[dir_id].x, 0 - adjacency_directions[dir_id].y)\\n dir_corrected = (0 + adjacency_directions[dir_id].x, 0 + adjacency_directions[dir_id].y)\\n dimensions = (1,0)\\n not_a_number = -1\\n #TODO: can probably speed this up by using the right slices, rather than rolling the whole pattern...\\n #print(d, p2, p1)\\n shifted = np.roll(np.pad(pattern_catalog[p2], pattern_width, mode='constant', constant_values = not_a_number), dir_corrected, dimensions)\\n compare = shifted[pattern_width:pattern_width+pattern_width, pattern_width:pattern_width+pattern_width]\\n left = max(0,0 + dir_corrected[0])\\n right = min(pattern_width, pattern_width + dir_corrected[0])\\n top = max(0,0 + dir_corrected[1])\\n bottom = min(pattern_width, pattern_width + dir_corrected[1])\\n a = pattern_catalog[p1][top:bottom,left:right]\\n b = compare[top:bottom,left:right]\\n res = np.array_equal(a,b)\\n #print(f\\\"res: {res}\\\")\\n return res\",\n \"def parse_layout(layout):\\n global index \\n for lt_obj in layout:\\n print(lt_obj.__class__.__name__)\\n print(lt_obj.bbox)\\n if isinstance(lt_obj, LTTextBox) or isinstance(lt_obj, LTTextLine):\\n print(lt_obj.get_text())\\n d[lt_obj.get_text().strip()]=(index,lt_obj.bbox)\\n index+=1\\n elif isinstance(lt_obj, LTFigure):\\n parse_layout(lt_obj) # Recursive\",\n \"def intersect_exit_hint(self, sq, hh):\\n\\n if not self.hints_prepped:\\n self.reset_hints()\\n self.hints_prepped=1\\n pos=self.local2global(sq)\\n if self.kind=='pararooms':\\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.sqs]\\n else:\\n to_outside_dvs=[dv for dv in range(4) if add(sq, dv) not in self.allsqs]\\n okwaysout=[]\\n #~ if self.hashid=='bfb08f4204ceecf84767e77869cabce5x009x000':\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n for h in hh:\\n if h[1]=='OUT':\\n okwaysout.extend(to_outside_dvs)\\n continue\\n if h[0]=='IN':\\n okwaysout.append(h[1])\\n continue\\n okwaysout.append(h[1])\\n okwaysout=list(set(okwaysout))\\n newh=set([gh for gh in self._global_hints[pos] if gh[1] in okwaysout])\\n if not newh and self._global_hints[pos]:\\n #~ import ipdb;ipdb.set_trace();print 'ipdb!'\\n print 'promoting cause of a conflict between the rooms-exit',pos\\n return pos\\n self._global_hints[pos]=newh\\n self._hints[sq]=newh.copy()\",\n \"def generate_siaf_detector_layout():\\n\\n VIdlParity = -1\\n layout = Table(dtype=['S100', 'S100', 'f4', 'i4', 'i4'] ,names=('InstrName', 'AperName', 'DetSciYAngle', 'DetSciParity', 'VIdlParity'))\\n for instrument in 'NIRCam FGS NIRISS NIRSpec MIRI'.split():\\n if instrument == 'NIRCam':\\n for sca_name in 'A1 A3 A5 B2 B4'.split():\\n layout.add_row([instrument.upper(), 'NRC{}_FULL'.format(sca_name), 0, -1, VIdlParity])\\n for sca_name in 'A2 A4 B1 B3 B5'.split():\\n layout.add_row([instrument.upper(), 'NRC{}_FULL'.format(sca_name), 180, -1, VIdlParity])\\n for sca_name in ['NRCA2_FULL_WEDGE_RND','NRCA2_FULL_WEDGE_BAR','NRCA4_FULL_WEDGE_RND','NRCA4_FULL_WEDGE_BAR']:\\n layout.add_row([instrument.upper(), '{}'.format(sca_name), 180, -1, VIdlParity])\\n for sca_name in ['NRCA1_FULL_WEDGE_RND','NRCA1_FULL_WEDGE_BAR','NRCA3_FULL_WEDGE_RND','NRCA3_FULL_WEDGE_BAR','NRCA5_FULL_WEDGE_RND','NRCA5_FULL_WEDGE_BAR']:\\n layout.add_row([instrument.upper(), '{}'.format(sca_name), 0, -1, VIdlParity])\\n elif instrument == 'NIRISS':\\n for sca_name in ['NIS_CEN']:\\n layout.add_row([instrument, sca_name, 180, 1, VIdlParity])\\n elif instrument == 'MIRI':\\n for sca_name in ['MIRIM_FULL']:\\n layout.add_row([instrument, sca_name, 0, 1, VIdlParity])\\n elif instrument == 'NIRSpec':\\n for sca_name in ['NRS1_FULL']:\\n layout.add_row([instrument.upper(), sca_name, 0, 1, VIdlParity])\\n for sca_name in ['NRS2_FULL']:\\n layout.add_row([instrument.upper(), sca_name, 180, 1, VIdlParity])\\n elif instrument == 'FGS':\\n for sca_name in ['FGS1_FULL']:\\n layout.add_row([instrument, sca_name, 180, 1, VIdlParity])\\n for sca_name in ['FGS2_FULL']:\\n layout.add_row([instrument, sca_name, 0, -1, VIdlParity])\\n\\n layout_file = os.path.join(JWST_SOURCE_DATA_ROOT, 'siaf_detector_layout.txt')\\n\\n layout.pprint()\\n\\n comments = []\\n comments.append('SIAF detector layout definition file.'.format(instrument))\\n comments.append('')\\n comments.append('These apertures act as parent apertures of all other SI apertures and their parameters are thus inherited.')\\n comments.append('')\\n comments.append('Generated {} {}'.format(timestamp.isot, timestamp.scale))\\n comments.append('by {}'.format(username))\\n comments.append('')\\n layout.meta['comments'] = comments\\n layout.write(layout_file, format='ascii.fixed_width', delimiter=',',\\n delimiter_pad=' ', bookend=False)\",\n \"def test_find_multitable_conflicting_paths(self):\\n ruleset_a = [\\n Rule(priority=10, table=0,\\n match=Match([('VLAN_VID', 1, None)]),\\n instructions=Instructions(dup=goto1)),\\n Rule(priority=10, table=0,\\n match=Match([('VLAN_VID', 2, None)]),\\n instructions=Instructions(dup=goto2)),\\n Rule(priority=0, table=0),\\n Rule(priority=20, table=1,\\n match=Match([('IPV4_DST', 0, 0xFFFFFFFE)]),\\n instructions=Instructions(dup=output1)),\\n Rule(priority=19, table=1,\\n match=Match([('IPV4_DST', 0, None)]),\\n instructions=Instructions(dup=output1)),\\n Rule(priority=0, table=1),\\n Rule(priority=30, table=2,\\n match=Match([('IPV4_DST', 0, None)]),\\n instructions=Instructions()),\\n Rule(priority=30, table=2,\\n match=Match([('IPV4_DST', 1, None)]),\\n instructions=Instructions()),\\n Rule(priority=0, table=2)\\n ]\\n\\n ruleset_b = [\\n Rule(priority=14, table=0,\\n match=Match([('VLAN_VID', 1, None), ('IPV4_DST', 0, None)])),\\n Rule(priority=14, table=0,\\n match=Match([('VLAN_VID', 1, None), ('IPV4_DST', 1, None)]),\\n instructions=Instructions(dup=output1)),\\n Rule(priority=14, table=0,\\n match=Match([('VLAN_VID', 2, None), ('IPV4_DST', 0, None)]),\\n instructions=Instructions(dup=output1)),\\n Rule(priority=14, table=0,\\n match=Match([('VLAN_VID', 2, None), ('IPV4_DST', 1, None)])),\\n Rule(priority=0, table=0)\\n ]\\n\\n single_a = to_single_table(ruleset_a)\\n single_b = to_single_table(ruleset_b)\\n norm_a = normalise(single_a)\\n norm_b = normalise(single_b)\\n\\n result_ab = {\\n (ruleset_a[0], ruleset_a[3]): frozenset([(ruleset_b[0],)]),\\n (ruleset_a[1], ruleset_a[6]): frozenset([(ruleset_b[2],)])\\n }\\n result_ba = {\\n (ruleset_b[0],): frozenset([(ruleset_a[0], ruleset_a[3])]),\\n (ruleset_b[2],): frozenset([(ruleset_a[1], ruleset_a[6])])\\n }\\n\\n equal_ab, diff_ab = check_equal(norm_a, norm_b, diff=True)\\n self.assertFalse(equal_ab)\\n equal_ba, diff_ba = check_equal(norm_b, norm_a, diff=True)\\n self.assertFalse(equal_ba)\\n\\n paths_ab = find_conflicting_paths(diff_ab, single_a, single_b)\\n paths_ba = find_conflicting_paths(diff_ab, single_b, single_a)\\n\\n self.assertEqual(paths_ab, result_ab)\\n self.assertNotEqual(paths_ab, result_ba) # Sanity\\n self.assertEqual(paths_ba, result_ba)\",\n \"def add_layout_pins(self):\\n\\n # All wordlines\\n # Main array wl and bl/br\\n for pin_name in self.all_wordline_names:\\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\\n for pin in pin_list:\\n self.add_layout_pin(text=pin_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(0, 1),\\n width=self.width,\\n height=pin.height())\\n\\n # Replica wordlines (go by the row instead of replica column because we may have to add a pin\\n # even though the column is in another local bitcell array)\\n for (names, inst) in zip(self.rbl_wordline_names, self.dummy_row_replica_insts):\\n for (wl_name, pin_name) in zip(names, self.dummy_row.get_wordline_names()):\\n if wl_name in self.gnd_wordline_names:\\n continue\\n pin = inst.get_pin(pin_name)\\n self.add_layout_pin(text=wl_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(0, 1),\\n width=self.width,\\n height=pin.height())\\n\\n for pin_name in self.all_bitline_names:\\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\\n for pin in pin_list:\\n self.add_layout_pin(text=pin_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(1, 0),\\n width=pin.width(),\\n height=self.height)\\n\\n # Replica bitlines\\n if len(self.rbls) > 0:\\n for (names, inst) in zip(self.rbl_bitline_names, self.replica_col_insts):\\n pin_names = self.replica_columns[self.rbls[0]].all_bitline_names\\n for (bl_name, pin_name) in zip(names, pin_names):\\n pin = inst.get_pin(pin_name)\\n self.add_layout_pin(text=bl_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(1, 0),\\n width=pin.width(),\\n height=self.height)\",\n \"def occupied(r, c, layout):\\n occupy = 0\\n\\n NW = (-1, -1)\\n NE = (-1, 1)\\n N = (-1, 0)\\n W = (0, -1)\\n E = (0, 1)\\n SW = (1, -1)\\n SE = (1, 1)\\n S = (1, 0)\\n\\n for dirs in [NW, NE, N, W, E, SW, SE, S]:\\n dr, dc = r+dirs[0], c + dirs[1]\\n if (dr >= 0) and (dc >= 0) and (dr < len(layout)) and (dc < len(layout[0])):\\n if layout[dr][dc] == '#':\\n occupy += 1\\n\\n return occupy\",\n \"def check_sizes(self, show=True):\\n # find pixel with common RA \\n comRApix = np.where((self.coords1[0]<=np.max(self.coords2[0]))&\\n (self.coords1[0]>=np.min(self.coords2[0]))\\n )[0]\\n \\n # find pixels with common DEC \\n comDECpix = np.where((self.coords1[1]<=np.max(self.coords2[1]))&\\n (self.coords1[1]>=np.min(self.coords2[1]))\\n )[0]\\n \\n print('Image 1 common pixels size: ({:}, {:})'.format(comRApix.size,\\n comDECpix.size))\\n \\n # Corner coordinates \\n minRA = np.min(self.coords1[0][comRApix])\\n maxRA = np.max(self.coords1[0][comRApix])\\n minDEC = np.min(self.coords1[1][comDECpix])\\n maxDEC = np.max(self.coords1[1][comDECpix])\\n if show:\\n comFrame = plt.Rectangle(xy=(minRA, minDEC), width=maxRA-minRA,\\n height=maxDEC-minDEC, hatch='\\\\\\\\', fill=True,\\n color='g', alpha=.3)\\n fig = plt.figure(figsize=(10,10))\\n ax = fig.add_subplot(111)\\n ax.add_patch(comFrame)\\n ax.add_patch(self.image1.plotframe(color='r'))\\n ax.add_patch(self.image2.plotframe(color='b'))\\n ax.annotate('Image 1', xy=(minRA,maxDEC), color='r')\\n ax.plot() \\n plt.show()\\n \\n self.boundRA = np.array([minRA, maxRA])\\n self.boundDEC = np.array([minDEC, maxDEC]) \\n self.bounds1 = np.array([[comRApix[0], comRApix[-1]], \\n [comDECpix[0], comDECpix[-1]]])\\n \\n if self.image1.get_pix_area() < self.image2.get_pix_area():\\n print('Image 1 have smaller pixels than 2. \\\\n')\\n self.pix_1_smaller = True \\n else:\\n print('Image 2 have smaller pixels than 1. \\\\n')\\n self.pix_1_smaller = False\",\n \"def problem_8():\\n\\n n = 8\\n x = [0] * n\\n D = [list(range(n)) for _ in range(n)]\\n\\n # `solns` will map (x1,x2,..,x6) to a list of full solutions.\\n solns = defaultdict(list)\\n for i, q in enumerate(algorithm_b(x, D, n_queens_is_good)):\\n key = tuple(q[:6])\\n solns[key].append((i + 1, q))\\n if len(solns[key]) == 2:\\n soln1, soln2 = solns[key]\\n print()\\n print('_' * 70)\\n print(f'Solutions {soln1[0]} and {soln2[0]} are a pair:')\\n print()\\n print_board(soln1[1])\\n print()\\n print_board(soln2[1])\",\n \"def check_topology(self, ninputs, noutputs):\\n return _spacegrant_swig.invert_bit_sptr_check_topology(self, ninputs, noutputs)\",\n \"def check_constraints(Px,pk1,pk2,mu1,mu2,mu3):\\n # Constraint 1: Check polarisation basis probabilities are valid.\\n if (Px >= 1.0 or Px <= 0.0):\\n print(\\\"Error! Constraint 1 < Px < 0: \\\", Px)\\n exit(1)\\n # Constraint 2: Check probability of pulse with intensity 1 is in bounds.\\n if (pk1 >= 1.0 or pk1 <= 0.0):\\n print(\\\"Error! Constraint 1 < pk1 < 0: \\\", pk1)\\n exit(1)\\n # Constraint 3: Check probability of pulse with intensity 2 is in bounds.\\n if (pk2 >= 1.0 or pk2 <= 0.0):\\n print(\\\"Error! Constraint 1 < pk2 < 0: \\\", pk2)\\n exit(1)\\n # Constraint 4: Check sum of probabilities for intensity 1 & 2 are less\\n # than unity.\\n if ((pk1 + pk2) >= 1.0):\\n print(\\\"Error! Constraint (pk1 + pk2) < 1: \\\", pk1 + pk2)\\n exit(1)\\n # Constraint 5: Check value of intensity 1 is in bounds.\\n if (mu1 >= 1.0 or mu1 <= 0.0):\\n print(\\\"Error! Constraint 1 < mu1 < 0: \\\", mu1)\\n exit(1)\\n # Constraint 6: Check value of intensity 2 is in bounds.\\n if (mu2 >= 1.0 or mu2 <= 0.0):\\n print(\\\"Error! Constraint 1 < mu2 < 0: \\\", mu2)\\n exit(1)\\n # Constraint 7: Check values of all intensities are in bounds.\\n if ((mu1 - mu3) <= mu2):\\n print(\\\"Error! Constraint (mu1-mu3) > mu2: \\\", (mu1-mu3), mu2)\\n exit(1)\\n # Constraint 8: Check values of intensities 2 & 3 are in bounds.\\n if (mu2 <= mu3):\\n print(\\\"Error! Constraint mu2 > mu3: \\\", mu2, mu3)\\n exit(1)\\n return None\",\n \"def _check_c(self, constraint, *variables):\\n c = {c.__class__ for c in self._layout.solver.get(*variables)}\\n if constraint:\\n self.assertTrue(constraint in c)\\n else:\\n self.assertFalse(c)\",\n \"def solve_one():\\n first_row = input_ints()[0]\\n first_matrix = []\\n for _ in range(4):\\n first_matrix.append(input_ints())\\n first_poss = set(first_matrix[first_row-1])\\n\\n second_row = input_ints()[0]\\n second_matrix = []\\n for _ in range(4):\\n second_matrix.append(input_ints())\\n second_poss = set(second_matrix[second_row-1])\\n \\n solutions = first_poss.intersection(second_poss)\\n\\n if len(solutions) == 0:\\n return 'Volunteer cheated!'\\n elif len(solutions) > 1:\\n return 'Bad magician!'\\n else:\\n return list(solutions)[0]\",\n \"def parse_layout(self, sections, group_size):\\n layout = self.layout\\n for section in sections:\\n for row in layout[section]:\\n try:\\n column = \\\"\\\".join(row).index(\\\"S\\\" * group_size)\\n return (layout[section].index(row), column, section)\\n except ValueError:\\n # There is no room in this row\\n pass\\n # Could Not find an room for the group in all sections\\n raise NoRoomError\",\n \"def ADM_SM_QCD(nf):\\n\\n adm_qqp_qqp = np.array([[0, 0, 0, 0, 0, 12, 0, 0],\\n [0, 0, 0, 0, 12, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 12],\\n [0, 0, 0, 0, 0, 0, 12, 0],\\n [0, 8/3, 0, 0, - 19/3, 5, 0, 0],\\n [8/3, 0, 0, 0, 5, - 9, 0, 0],\\n [0, 0, 0, 8/3, 0, 0, - 23/3, 5],\\n [0, 0, 8/3, 0, 0, 0, 5, - 23/3]])\\n\\n adm_qqp_qqpp = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 4/3, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0]])\\n\\n adm_qpq_qppq = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 4/3]])\\n\\n adm_qqp_qppq = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 4/3],\\n [0, 0, 0, 0, 0, 0, 0, 0]])\\n\\n adm_qpq_qqpp = np.array([[0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 4/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 4/3, 0]])\\n\\n adm_q_q = np.array([[4, 4, 0, - 28/3],\\n [0, 0, 0, 44/3],\\n [0, 0, 44/9, 0],\\n [5/3, 13/3, 0, - 106/9]])\\n\\n adm_qqp_q = np.array([[0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 4/3],\\n [0, 0, 0, 0],\\n [0, 0, 4/9, 0],\\n [0, 0, 0, 0]])\\n\\n\\n adm_qpq_q = np.array([[0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 0, 4/3],\\n [0, 0, 0, 0],\\n [0, 0, 0, 0],\\n [0, 0, 4/9, 0]])\\n\\n adm_q_qqp = np.array([[0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 8/3, 0],\\n [0, 0, 0, 0, 20/9, 0, 0, 0]])\\n\\n adm_q_qpq = np.array([[0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 8/3, 0, 0, 0],\\n [0, 0, 0, 0, 0, 0, 0, 8/3],\\n [0, 0, 0, 0, 20/9, 0, 0, 0]])\\n\\n adm_ud = np.hstack((adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qpq_qqpp, adm_qpq_qqpp,\\\\\\n adm_qpq_qqpp, np.zeros((8, 24)), adm_qqp_q, adm_qpq_q, np.zeros((8,12))))\\n\\n adm_us = np.hstack((adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qpq_qppq, np.zeros((8,16)),\\\\\\n adm_qpq_qqpp, adm_qpq_qqpp, np.zeros((8, 8)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q, np.zeros((8,8))))\\n\\n adm_uc = np.hstack((adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp, np.zeros((8,8)), adm_qpq_qppq,\\\\\\n np.zeros((8,8)), adm_qpq_qppq, np.zeros((8, 8)), adm_qpq_qqpp, adm_qqp_q, np.zeros((8,8)), adm_qpq_q, np.zeros((8,4))))\\n\\n adm_ub = np.hstack((adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp, np.zeros((8,16)), adm_qpq_qppq,\\\\\\n np.zeros((8,8)), adm_qpq_qppq, adm_qpq_qppq, adm_qqp_q, np.zeros((8,12)), adm_qpq_q))\\n\\n adm_ds = np.hstack((adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,16)), adm_qqp_qqp, adm_qqp_qqpp, adm_qqp_qqpp,\\\\\\n adm_qpq_qqpp, adm_qpq_qqpp, np.zeros((8,8)), np.zeros((8,4)), adm_qqp_q, adm_qpq_q, np.zeros((8,8))))\\n\\n adm_dc = np.hstack((adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qqpp, adm_qqp_qqp, adm_qqp_qqpp,\\\\\\n adm_qpq_qppq, np.zeros((8,8)), adm_qpq_qqpp, np.zeros((8,4)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q, np.zeros((8,4))))\\n\\n adm_db = np.hstack((adm_qqp_qppq, np.zeros((8,16)), adm_qpq_qppq, adm_qqp_qqpp, adm_qqp_qqpp, adm_qqp_qqp,\\\\\\n np.zeros((8,8)), adm_qpq_qppq, adm_qpq_qppq, np.zeros((8,4)), adm_qqp_q, np.zeros((8,8)), adm_qpq_q))\\n\\n adm_sc = np.hstack((np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)),\\\\\\n adm_qqp_qqp, adm_qqp_qqpp, adm_qpq_qqpp, np.zeros((8,8)), adm_qqp_q, adm_qpq_q, np.zeros((8,4))))\\n\\n adm_sb = np.hstack((np.zeros((8,8)), adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq, adm_qqp_qppq, np.zeros((8,8)), adm_qpq_qppq,\\\\\\n adm_qqp_qqpp, adm_qqp_qqp, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_q, np.zeros((8,4)), adm_qpq_q))\\n\\n adm_cb = np.hstack((np.zeros((8,16)), adm_qqp_qppq, adm_qpq_qppq, np.zeros((8,8)), adm_qqp_qppq, adm_qpq_qppq,\\\\\\n adm_qqp_qppq, adm_qpq_qppq, adm_qqp_qqp, np.zeros((8,12)), adm_qqp_q, adm_qpq_q))\\n\\n adm_u = np.hstack((adm_q_qqp, adm_q_qqp, adm_q_qqp, adm_q_qqp, np.zeros((4,48)), adm_q_q, np.zeros((4,16))))\\n\\n adm_d = np.hstack((adm_q_qpq, np.zeros((4,24)), adm_q_qqp, adm_q_qqp, adm_q_qqp, np.zeros((4,24)), np.zeros((4,4)), adm_q_q, np.zeros((4,12))))\\n\\n adm_s = np.hstack((np.zeros((4,8)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,16)), adm_q_qqp, adm_q_qqp, np.zeros((4,8)),\\\\\\n np.zeros((4,8)), adm_q_q, np.zeros((4,8))))\\n\\n adm_c = np.hstack((np.zeros((4,16)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,8)), adm_q_qpq, np.zeros((4,8)), adm_q_qqp,\\\\\\n np.zeros((4,12)), adm_q_q, np.zeros((4,4))))\\n\\n adm_b = np.hstack((np.zeros((4,24)), adm_q_qpq, np.zeros((4,16)), adm_q_qpq, np.zeros((4,8)), adm_q_qpq, adm_q_qpq, np.zeros((4,16)), adm_q_q))\\n\\n\\n adm = np.vstack((adm_ud, adm_us, adm_uc, adm_ub, adm_ds, adm_dc, adm_db, adm_sc, adm_sb, adm_cb, adm_u, adm_d, adm_s, adm_c, adm_b))\\n\\n if nf == 5:\\n return adm\\n elif nf == 4:\\n return np.delete(np.delete(adm, np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80], np.s_[96:100]], 0),\\\\\\n np.r_[np.s_[24:32], np.s_[48:56], np.s_[64:80], np.s_[96:100]], 1)\\n else:\\n raise Exception(\\\"nf has to be 4 or 5\\\")\",\n \"def add_layout_pins(self):\\n en_offset = self.dc_inst.get_pin(\\\"in\\\").ll()\\n self.add_layout_pin(text=\\\"en\\\",\\n layer=\\\"metal1\\\",\\n offset=en_offset.scale(1,0),\\n width=self.m1_width,\\n height=en_offset.y)\\n\\n out_offset = self.rbl_inv_inst.get_pin(\\\"Z\\\").ll()\\n self.add_layout_pin(text=\\\"out\\\",\\n layer=\\\"metal1\\\",\\n offset=out_offset.scale(1,0),\\n width=self.m1_width,\\n height=out_offset.y)\",\n \"def test_collect_indicator_layouts_dependencies(self, module_repo):\\n expected_result = {\\n (\\\"FeedMitreAttack\\\", True),\\n (\\\"CommonTypes\\\", True),\\n (\\\"CrisisManagement\\\", True),\\n }\\n\\n test_input = [\\n {\\n \\\"Dummy Layout\\\": {\\n \\\"typeID\\\": \\\"dummy_layout\\\",\\n \\\"name\\\": \\\"Dummy Layout\\\",\\n \\\"pack\\\": \\\"dummy_pack\\\",\\n \\\"kind\\\": \\\"indicatorsDetails\\\",\\n \\\"path\\\": \\\"dummy_path\\\",\\n \\\"incident_and_indicator_types\\\": [\\n \\\"MITRE ATT&CK\\\",\\n \\\"Prisma Cloud Compute Cloud Discovery\\\",\\n ],\\n \\\"incident_and_indicator_fields\\\": [\\n \\\"indicator_adminname\\\",\\n \\\"indicator_jobtitle\\\",\\n ],\\n }\\n }\\n ]\\n\\n found_result = PackDependencies._collect_layouts_dependencies(\\n pack_layouts=test_input,\\n id_set=module_repo.id_set.read_json_as_dict(),\\n )\\n\\n assert set(found_result) == set(expected_result)\",\n \"def setup_layout(self, board_layout):\\n # Create pin instances based on board layout\\n self.analog = []\\n for i in board_layout['analog']:\\n self.analog.append(Pin(self, i))\\n\\n self.digital = []\\n self.digital_ports = []\\n for i in xrange(0, len(board_layout['digital']), 8):\\n num_pins = len(board_layout['digital'][i:i+8])\\n port_number = i / 8\\n self.digital_ports.append(Port(self, port_number, num_pins))\\n\\n # Allow to access the Pin instances directly\\n for port in self.digital_ports:\\n self.digital += port.pins\\n \\n # Setup PWM pins\\n for i in board_layout['pwm']:\\n self.digital[i].PWM_CAPABLE = True\\n\\n # Disable certain ports like Rx/Tx and crystal ports\\n for i in board_layout['disabled']:\\n self.digital[i].mode = UNAVAILABLE\\n\\n # Create a dictionary of 'taken' pins. Used by the get_pin method\\n self.taken = { 'analog' : dict(map(lambda p: (p.pin_number, False), self.analog)),\\n 'digital' : dict(map(lambda p: (p.pin_number, False), self.digital)) }\\n\\n # Setup default handlers for standard incoming commands\\n self.add_cmd_handler(ANALOG_MESSAGE, self._handle_analog_message)\\n self.add_cmd_handler(ANALOG_MAPPING_RESPONSE, self._handle_analog_mapping_response)\\n self.add_cmd_handler(DIGITAL_MESSAGE, self._handle_digital_message)\\n self.add_cmd_handler(REPORT_VERSION, self._handle_report_version)\\n self.add_cmd_handler(REPORT_FIRMWARE, self._handle_report_firmware)\\n self.add_cmd_handler(PING_REPLY, self._handle_ping_reply)\\n self.add_cmd_handler(PULSE_REPLY, self._handle_pulse_reply)\\n self.add_cmd_handler(I2C_REPLY, self._handle_i2c_reply)\",\n \"def linear_program_eq(self, c, A, b, lb, ub):\\n if self.solver == solver_SCIPY:\\n c = c.reshape((c.size,))\\n b = b.reshape((b.size,))\\n return scipy_linear_program_eq(c, A, b, lb, ub)\\n elif self.solver == solver_GUROBI:\\n return gurobi_linear_program_eq(c, A, b, lb, ub)\\n else:\\n raise ValueError('QP solver %s not available' % self.solver)\",\n \"def ap_index_bounds(self, qa_lows, qa_highs, ap_coordinates):\\n\\n # Treat the first alignment area separately. Its lower bound is the first alignment point.\\n qa_ap_index_lows = [0]\\n\\n # Starting with the second alignment point, search for the first one on the upper area\\n # border or beyond it. Take it as the upper index bound.\\n for ap_index, ap_value in enumerate(ap_coordinates[1:]):\\n if ap_value >= qa_highs[0]:\\n qa_ap_index_highs = [ap_index + 2]\\n break\\n\\n # For interior quality areas\\n for qa_index_m1, qa_low in enumerate(qa_lows[1:-1]):\\n\\n # The index of the quality area (qa_index) has to be increased by one because the list\\n # used for the enumerator starts with the second entry.\\n qa_index = qa_index_m1 + 1\\n qa_high = qa_highs[qa_index]\\n\\n # For the lower index bound, look for the first alignment point on the lower border\\n # or beyond in reversed order.\\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\\n if ap_value <= qa_low:\\n qa_ap_index_lows.append(ap_index)\\n break\\n\\n # For the upper index bound, look for the first alignment point on the upper border\\n # or beyond.\\n for ap_index, ap_value in enumerate(ap_coordinates):\\n if ap_value >= qa_high:\\n qa_ap_index_highs.append(ap_index + 1)\\n break\\n\\n # The last alignment point index was removed from the search. If this is the upper bound\\n # for the last inner quality area, it has not been assigned to the index_highs list. In\\n # this case this list is one entry short. In this case add the index of the last alignment\\n # point as the upper index bound.\\n if len(qa_ap_index_highs) < len(qa_ap_index_lows):\\n qa_ap_index_highs.append(len(ap_coordinates))\\n\\n # In analogy to the first quality area, treat the case of the last quality area separately\\n # as well.\\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\\n if ap_value <= qa_lows[-1]:\\n qa_ap_index_lows.append(ap_index)\\n break\\n # The upper index bound is always the last alignment point index.\\n qa_ap_index_highs.append(len(ap_coordinates))\\n\\n return qa_ap_index_lows, qa_ap_index_highs\",\n \"def test_flat_multibit():\\n\\n @chip\\n def Not2(inputs, outputs):\\n outputs.out[0] = Nand(a=inputs.in_[0], b=inputs.in_[0]).out\\n outputs.out[1] = Nand(a=inputs.in_[1], b=inputs.in_[1]).out\\n\\n not2 = Not2.constr()\\n\\n assert not2.inputs() == {\\\"in_\\\": 2}\\n assert not2.outputs() == {\\\"out\\\": 2}\\n\\n assert len(not2.wires) == 6 # TODO: how to assert on the structure?\\n\\n assert run(Not2, in_=0b01).out == 0b10\\n assert run(Not2, in_=0b10).out == 0b01\",\n \"def test_layout(self, gen_sch: bool = True) -> None:\\n\\n lay_params = self._info.first_params\\n dsn_name = self._info.dsn_basename + '_TEST'\\n\\n print('create test layout')\\n sch_name_param_list = self.create_dut_layouts([(dsn_name, lay_params)])\\n\\n if gen_sch:\\n print('create test schematic')\\n self.create_dut_schematics(sch_name_param_list, gen_wrappers=False)\\n print('done')\",\n \"def draw_layout(self):\\n\\n if not self.fg2d_s_short:\\n raise ValueError('This template current only works if source wires of fg2d are shorted.')\\n\\n threshold = self.params['threshold']\\n draw_boundaries = self.params['draw_boundaries']\\n num_blk = self.params['num_blk']\\n show_pins = self.params['show_pins']\\n\\n row_list = ['ptap', 'nch', 'pch', 'ntap']\\n orient_list = ['R0', 'MX', 'R0', 'MX']\\n thres_list = [threshold] * 4\\n\\n # compute number of tracks\\n # note: because we're using thick wires, we need to compute space needed to\\n # satisfy DRC rules\\n hm_layer = self.conn_layer + 1\\n num_g_tracks = [0, 0, 0, 0]\\n num_gb_tracks = [0, 0, 0, 0]\\n num_ds_tracks = [0, 0, 0, 0]\\n\\n # to draw special stack driver primitive, we need to enable dual_gate options.\\n options = dict(dual_gate=True)\\n row_kwargs = [{}, options, options, {}]\\n if draw_boundaries:\\n end_mode = 15\\n else:\\n end_mode = 0\\n\\n # specify row types\\n self.set_row_types(row_list, orient_list, thres_list, draw_boundaries, end_mode,\\n num_g_tracks, num_gb_tracks, num_ds_tracks, guard_ring_nf=0,\\n row_kwargs=row_kwargs)\\n\\n # determine total number of blocks\\n # draw nwell tap\\n row_idx = 3\\n nw_tap = self.add_laygo_primitive('sub', loc=(0, row_idx), nx=num_blk, spx=1)\\n\\n # draw pmos row\\n row_idx = 2\\n pmos = self.add_laygo_primitive('dual_stack2s', loc=(0, row_idx), nx=num_blk, spx=1)\\n\\n # draw nmos row\\n row_idx = 1\\n nmos = self.add_laygo_primitive('dual_stack2s', loc=(0, row_idx), nx=num_blk, spx=1)\\n\\n # draw pwell tap\\n row_idx = 0\\n pw_tap = self.add_laygo_primitive('sub', loc=(0, row_idx), nx=num_blk, spx=1)\\n\\n # compute overall block size\\n self.set_laygo_size(num_col=num_blk + 4)\\n self.fill_space()\\n # draw boundaries and get guard ring power rail tracks\\n self.draw_boundary_cells()\",\n \"def test_to_qcschema(self):\\n # the molecule has no coordinates so this should fail\\n ethanol = Molecule.from_smiles(\\\"CCO\\\")\\n with pytest.raises(InvalidConformerError):\\n qcschema = ethanol.to_qcschema()\\n\\n # now remake the molecule from the sdf\\n ethanol = Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\"))\\n # make sure that requests to missing conformers are caught\\n with pytest.raises(InvalidConformerError):\\n qcschema = ethanol.to_qcschema(conformer=1)\\n # now make a valid qcschema and check its properties\\n qcschema = ethanol.to_qcschema(extras={\\\"test_tag\\\": \\\"test\\\"})\\n # make sure the properties match\\n charge = 0\\n connectivity = [\\n (0, 1, 1.0),\\n (0, 4, 1.0),\\n (0, 5, 1.0),\\n (0, 6, 1.0),\\n (1, 2, 1.0),\\n (1, 7, 1.0),\\n (1, 8, 1.0),\\n (2, 3, 1.0),\\n ]\\n symbols = [\\\"C\\\", \\\"C\\\", \\\"O\\\", \\\"H\\\", \\\"H\\\", \\\"H\\\", \\\"H\\\", \\\"H\\\", \\\"H\\\"]\\n\\n def assert_check():\\n assert charge == qcschema.molecular_charge\\n assert connectivity == qcschema.connectivity\\n assert symbols == qcschema.symbols.tolist()\\n assert (\\n qcschema.geometry.all() == ethanol.conformers[0].m_as(unit.bohr).all()\\n )\\n\\n assert_check()\\n assert qcschema.extras[\\\"test_tag\\\"] == \\\"test\\\"\\n assert qcschema.extras[\\n \\\"canonical_isomeric_explicit_hydrogen_mapped_smiles\\\"\\n ] == ethanol.to_smiles(mapped=True)\\n # # now run again with no extras passed, only cmiles entry will be present with fix-720\\n qcschema = ethanol.to_qcschema()\\n assert_check()\\n assert qcschema.extras[\\n \\\"canonical_isomeric_explicit_hydrogen_mapped_smiles\\\"\\n ] == ethanol.to_smiles(mapped=True)\",\n \"def draw_integ_amp(self, # type: HybridQDRBase\\n col_idx, # type: int\\n seg_dict, # type: Dict[str, int]\\n invert=False, # type: bool\\n fg_min=0, # type: int\\n fg_dum=0, # type: int\\n fg_sep_hm=0, # type: int\\n idx_dict=None, # type: Optional[Dict[str, int]]]\\n net_prefix='', # type: str\\n net_suffix='', # type: str\\n ):\\n # type: (...) -> Tuple[Dict[str, Union[WireArray, List[WireArray]]], Dict[str, Any]]\\n if idx_dict is None:\\n idx_dict = {}\\n\\n # get layout information\\n amp_info = self.qdr_info.get_integ_amp_info(seg_dict, fg_min=fg_min,\\n fg_dum=fg_dum, fg_sep_hm=fg_sep_hm)\\n seg_load = seg_dict.get('load', 0)\\n seg_casc = seg_dict.get('casc', 0)\\n seg_but = seg_dict.get('but', 0)\\n seg_tsw = seg_dict.get('tsw', 0)\\n en_only = seg_dict.get('en_only', False)\\n en_swap = seg_dict.get('en_swap', False)\\n fg_tot = amp_info['fg_tot']\\n col_dict = amp_info['col_dict']\\n sd_dict = amp_info['sd_dict']\\n sd_dir_dict = amp_info['sd_dir_dict']\\n\\n ports = self._draw_integ_amp_mos(col_idx, fg_tot, seg_dict, col_dict, sd_dict, sd_dir_dict,\\n net_prefix=net_prefix, net_suffix=net_suffix)\\n\\n # connect wires\\n self.connect_to_substrate('ptap', ports['VSS'])\\n # get TrackIDs\\n foot_tid = self.get_wire_id('nch', 0, 'ds', wire_idx=0)\\n tail_tid = self.get_wire_id('nch', 1, 'ds', wire_name='ntail')\\n outn_tid = self.get_wire_id('pch', 0, 'ds2', wire_idx=0, wire_name='out')\\n outp_tid = self.get_wire_id('pch', 0, 'ds2', wire_idx=1, wire_name='out')\\n inn_tid = self.get_wire_id('nch', 2, 'g2', wire_idx=0, wire_name='in')\\n inp_tid = self.get_wire_id('nch', 2, 'g2', wire_idx=1, wire_name='in')\\n mp_tid = self.get_wire_id('pch', 1, 'ds', wire_name='ptail')\\n nclk_tid = self.get_wire_id('nch', 0, 'g', wire_idx=idx_dict.get('nclk', -1))\\n nen_tid = self.get_wire_id('nch', 1, 'g', wire_idx=idx_dict.get('nen', -1))\\n\\n # connect intermediate nodes\\n foot = self.connect_to_tracks(ports['foot'], foot_tid, min_len_mode=0)\\n tail = self.connect_to_tracks(ports['tail'], tail_tid, min_len_mode=0)\\n # connect gates\\n hm_layer = outp_tid.layer_id\\n nclk = self.connect_to_tracks(ports['nclk'], nclk_tid)\\n nen = self.connect_to_tracks(ports['nen'], nen_tid)\\n\\n out_w = outp_tid.width\\n outp_idx = outp_tid.base_index\\n outn_idx = outn_tid.base_index\\n if invert:\\n outp_warrs, outn_warrs = ports['outn'], ports['outp']\\n else:\\n outp_warrs, outn_warrs = ports['outp'], ports['outn']\\n outp, outn = self.connect_differential_tracks(outp_warrs, outn_warrs, hm_layer,\\n outp_idx, outn_idx, width=out_w)\\n in_w = inp_tid.width\\n inp_idx = inp_tid.base_index\\n inn_idx = inn_tid.base_index\\n inp, inn = self.connect_differential_tracks(ports['inp'], ports['inn'], hm_layer,\\n inp_idx, inn_idx, width=in_w)\\n\\n ans = dict(inp=inp, inn=inn, outp=outp, outn=outn, nen3=nen, biasp=nclk,\\n foot=foot, tail=tail)\\n\\n # draw load connections\\n if seg_load > 0:\\n self.connect_to_substrate('ntap', ports['VDD'])\\n for name in ('pm0p', 'pm0n', 'pm1p', 'pm1n'):\\n cur_ports = ports[name]\\n if cur_ports[0].track_id.num > 1:\\n warr = self.connect_to_tracks(cur_ports, mp_tid, min_len_mode=0)\\n else:\\n warr = self.connect_wires(cur_ports)[0]\\n ans[name] = warr\\n\\n pen0_tid = self.get_wire_id('pch', 0, 'g', wire_idx=idx_dict.get('pen0', 0))\\n pen1_tid = self.get_wire_id('pch', 0, 'g', wire_idx=idx_dict.get('pen1', 1))\\n pclk0_tid = self.get_wire_id('pch', 1, 'g', wire_idx=idx_dict.get('pclk0', 0))\\n pclk1_tid = self.get_wire_id('pch', 1, 'g', wire_idx=idx_dict.get('pclk1', 1))\\n if en_only:\\n gate_wires = ports['pen0'] + ports['pen1']\\n pen0 = self.connect_to_tracks(gate_wires, pen1_tid)\\n else:\\n pen0, pen1 = self.connect_differential_tracks(ports['pen0'], ports['pen1'],\\n hm_layer,\\n pen0_tid.base_index,\\n pen1_tid.base_index,\\n width=pen0_tid.width)\\n if en_swap:\\n ans['clkp'] = pen1\\n else:\\n ans['pen2'] = pen1\\n pclk0, pclk1 = self.connect_differential_tracks(ports['pclk0'], ports['pclk1'],\\n hm_layer, pclk0_tid.base_index,\\n pclk1_tid.base_index,\\n width=pclk0_tid.width)\\n if en_swap:\\n ans['clkn'] = pen0\\n ans['pen2'] = pclk1\\n ans['pen3'] = pclk0\\n else:\\n ans['pen3'] = pen0\\n ans['clkp'] = pclk1\\n ans['clkn'] = pclk0\\n\\n # connect cascode if necessary\\n if seg_casc > 0 or seg_but > 0:\\n nm_tid = self.get_wire_id('nch', 3, 'ds', wire_name='ptail')\\n nmp = ports['nmp']\\n if nmp[0].track_id.num == 1:\\n nmp = self.connect_wires(ports['nmp'])[0]\\n nmn = self.connect_wires(ports['nmn'])[0]\\n else:\\n nmp = self.connect_to_tracks(ports['nmp'], nm_tid)\\n nmn = self.connect_to_tracks(ports['nmn'], nm_tid)\\n ans['nmp'] = nmp\\n ans['nmn'] = nmn\\n if seg_casc > 0:\\n casc_tid = self.get_wire_id('nch', 3, 'g', wire_idx=idx_dict.get('casc', -1))\\n casc = self.connect_to_tracks(ports['casc'], casc_tid)\\n ans['casc'] = casc\\n else:\\n cascp_idx = self.get_wire_id('nch', 3, 'g', wire_idx=-1).base_index\\n cascn_idx = self.get_wire_id('nch', 3, 'g', wire_idx=-2).base_index\\n casc0, casc1 = self.connect_differential_tracks(ports['casc<0>'], ports['casc<1>'],\\n hm_layer, cascp_idx, cascn_idx)\\n ans['casc<0>'] = casc0\\n ans['casc<1>'] = casc1\\n\\n # connect tail switch if it exists\\n if seg_tsw > 0:\\n nclk0_tid = self.get_wire_id('nch', 1, 'g', wire_name='clk')\\n ans['nclkn'] = self.connect_to_tracks(ports['nclk0'], nclk0_tid)\\n self.connect_to_substrate('ntap', ports['nvdd'])\\n\\n return ans, amp_info\",\n \"def layout_well2index(self, layout_name):\\n return {k:tuple(v) for k,v in self['well2coord'][self['layout_format'][layout_name]].items()}\",\n \"def run(self, dag):\\n new_dag = DAGCircuit()\\n\\n if self.initial_layout is None:\\n if self.property_set[\\\"layout\\\"]:\\n self.initial_layout = self.property_set[\\\"layout\\\"]\\n else:\\n self.initial_layout = Layout.generate_trivial_layout(*dag.qregs.values())\\n\\n if len(dag.qubits()) != len(self.initial_layout):\\n raise TranspilerError('The layout does not match the amount of qubits in the DAG')\\n\\n if len(self.coupling_map.physical_qubits) != len(self.initial_layout):\\n raise TranspilerError(\\n \\\"Mappers require to have the layout to be the same size as the coupling map\\\")\\n\\n current_layout = self.initial_layout.copy()\\n\\n for layer in dag.serial_layers():\\n subdag = layer['graph']\\n\\n for gate in subdag.twoQ_gates():\\n physical_q0 = current_layout[gate.qargs[0]]\\n physical_q1 = current_layout[gate.qargs[1]]\\n if self.coupling_map.distance(physical_q0, physical_q1) != 1:\\n # Insert a new layer with the SWAP(s).\\n swap_layer = DAGCircuit()\\n\\n path = self.coupling_map.shortest_undirected_path(physical_q0, physical_q1)\\n for swap in range(len(path) - 2):\\n connected_wire_1 = path[swap]\\n connected_wire_2 = path[swap + 1]\\n\\n qubit_1 = current_layout[connected_wire_1]\\n qubit_2 = current_layout[connected_wire_2]\\n\\n # create qregs\\n for qreg in current_layout.get_registers():\\n if qreg not in swap_layer.qregs.values():\\n swap_layer.add_qreg(qreg)\\n\\n # create the swap operation\\n swap_layer.apply_operation_back(SwapGate(),\\n qargs=[qubit_1, qubit_2],\\n cargs=[])\\n\\n # layer insertion\\n edge_map = current_layout.combine_into_edge_map(self.initial_layout)\\n new_dag.compose_back(swap_layer, edge_map)\\n\\n # update current_layout\\n for swap in range(len(path) - 2):\\n current_layout.swap(path[swap], path[swap + 1])\\n\\n edge_map = current_layout.combine_into_edge_map(self.initial_layout)\\n new_dag.extend_back(subdag, edge_map)\\n\\n return new_dag\",\n \"def solve(self):\\n\\n # Assign variables to each quantity being solved.\\n r_lookup, lookup, num = {}, {}, 0\\n for element in self.elements:\\n if is_wire(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n elif not is_cs(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n\\n # Set up the linear algebraic equation Ax=b\\n A = np.zeros((num, num))\\n b = np.zeros(num)\\n for row, element in lookup.items():\\n if is_wire(element) and element is not self.ground:\\n for two_sided in element.attached:\\n if is_cs(two_sided):\\n if two_sided.pos is element:\\n b[row] += -1 * two_sided.current\\n else:\\n b[row] += two_sided.current\\n else:\\n if two_sided.pos is element:\\n flow = 1\\n else:\\n flow = -1\\n A[row, r_lookup[two_sided]] = flow\\n elif is_vs(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n b[row] = element.voltage\\n elif is_resistor(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n A[row, r_lookup[element]] = -1 * element.resistance\\n\\n b = b.reshape((num, 1))\\n try:\\n x = np.linalg.solve(A, b)\\n except np.linalg.LinAlgError:\\n raise CircuitError('Insufficient information to solve circuit')\\n\\n # Assign values to all circuit components\\n for i in range(num):\\n item = lookup[i]\\n if is_wire(item):\\n item.potential = x[i, 0]\\n elif isinstance(item, DualSided):\\n item.current = x[i, 0]\\n\\n # Mark circuit as solved\\n self.been_solved = True\",\n \"def q3(puzzle):\\n mysudoku = build_csp(puzzle)\\n mysudoku.ac3_algorithm()\\n solution = mysudoku.backtracking_search(\\\"MRV\\\")\\n return solution, mysudoku\",\n \"def numpy_IoU_minmax(bb1, bb2):\\n\\n # There should be at least one anchor, but maybe more. \\n # If the number of dimensions is only 1 (so it's just\\n # one anchor), reshape the array to allow the slicing\\n # to work properly:\\n \\n if bb1.ndim == 1:\\n bb1 = np.reshape(bb1, (1,) + bb1.shape)\\n if bb2.ndim == 1:\\n bb2 = np.reshape(bb2, (1,) + bb2.shape)\\n\\n # Now, n1 and n2 can represent the number of anchors:\\n n_1 = bb1.shape[0]\\n n_2 = bb2.shape[0]\\n\\n\\n # Want the IoU for every bb1 to every bb2, so tile them into\\n # long 1D arrays to allow slicing:\\n bb1_arr = np.reshape(np.tile(bb1, [1, n_2]), (n_1*n_2, 4))\\n bb2_arr = np.tile(bb2, [n_1, 1])\\n\\n\\n x1 = np.max((bb1_arr[:,0], \\n bb2_arr[:,0]),\\n axis=0)\\n y1 = np.max((bb1_arr[:,1], \\n bb2_arr[:,1]),\\n axis=0)\\n x2 = np.min((bb1_arr[:,2], \\n bb2_arr[:,2]),\\n axis=0)\\n y2 = np.min((bb1_arr[:,3], \\n bb2_arr[:,3]),\\n axis=0)\\n\\n\\n w = x2 - x1\\n h = y2 - y1\\n\\n\\n inter = w*h\\n\\n aarea = (bb1_arr[:,3] - bb1_arr[:,1])*(bb1_arr[:,2] - bb1_arr[:,0])\\n barea = (bb2_arr[:,3] - bb2_arr[:,1])*(bb2_arr[:,2] - bb2_arr[:,0])\\n\\n\\n denom = aarea + barea - inter\\n # mask = (denom == 0)\\n # denom[mask] = 0.1\\n\\n IoU = inter / (denom)\\n # return IoU\\n # IoU[mask] = 0\\n IoU[w <= 0] = 0\\n IoU[h <= 0] = 0\\n \\n return np.reshape(IoU, (n_1,n_2))\",\n \"def test_queue_region_with_invalid_parameter(self):\\n self.verify(self.nic in [\\\"fortville_eagle\\\", \\\"fortville_spirit\\\",\\n \\\"fortville_spirit_single\\\", \\\"fortpark_TLV\\\", \\\"fortville_25g\\\"], \\\"NIC Unsupported: \\\" + str(self.nic))\\n self.pmdout.start_testpmd(\\\"%s\\\" % self.cores, \\\"--rxq=16 --txq=16 --port-topology=chained\\\")\\n self.dut.send_expect(\\\"set fwd rxonly\\\", \\\"testpmd> \\\", 120)\\n self.dut.send_expect(\\\"set verbose 1\\\", \\\"testpmd> \\\", 120)\\n self.dut.send_expect(\\\"start\\\", \\\"testpmd> \\\", 120)\\n time.sleep(2)\\n\\n # Create a rss queue rule.\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern end actions rss queues 8 10 11 12 15 end / end\\\", \\\"created\\\")\\n # Set a queue region with invalid queue ID\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern vlan tci is 0x2000 / end actions rss queues 8 9 end / end\\\", \\\"error\\\")\\n # Set a queue region with discontinuous queue ID\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern vlan tci is 0x2000 / end actions rss queues 8 10 end / end\\\", \\\"error\\\")\\n # Set a queue region with invalid queue number\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern vlan tci is 0x4000 / end actions rss queues 10 11 12 end / end\\\", \\\"error\\\")\",\n \"def printInterfaces(self, idx = None, flag = None, anchor = \\\"\\\"):\\n\\n if idx is None:\\n idx = range(self.atoms.shape[0])\\n elif isinstance(idx, (int, np.integer)):\\n idx = [idx]\\n\\n header1 = \\\"%-2s%6s | %3s %-9s | %5s | %5s | %-5s | %-5s | %4s %-25s | %3s %-11s | %3s %-11s \\\"\\\\\\n % (\\\"\\\", \\\"Index\\\", \\\"\\\", \\\"Length\\\", \\\"Angle\\\", \\\"Angle\\\", \\\"Area\\\", \\\"Atoms\\\", \\\"\\\", \\\"Epsilon (*100)\\\",\\\\\\n \\\"\\\", \\\"Lattice 1\\\", \\\"\\\", \\\"Lattice 2\\\")\\n header2 = \\\"%-2s%6s | %6s, %5s | %5s | %5s | %6s | %5s | %7s,%7s,%7s,%6s | \\\"\\\\\\n \\\"%3s,%3s,%3s,%3s | %3s,%3s,%3s,%3s\\\"\\\\\\n % (\\\"\\\", \\\"i\\\", \\\"a1\\\", \\\"a2\\\", \\\"b1/b2\\\", \\\"a1/a2\\\", \\\"Ang^2\\\", \\\"Nr\\\", \\\"11\\\", \\\"22\\\", \\\"12\\\", \\\"mas\\\",\\\\\\n \\\"a1x\\\", \\\"a1y\\\", \\\"a2x\\\", \\\"a2y\\\", \\\"b1x\\\", \\\"b1y\\\", \\\"b2x\\\", \\\"b2y\\\")\\n\\n div = \\\"=\\\" * len(header1)\\n print(\\\"\\\\n\\\" + header1 + \\\"\\\\n\\\" + header2 + \\\"\\\\n\\\" + div)\\n\\n for i in idx:\\n\\n la = np.linalg.norm(self.cell_1[i, :, :], axis = 0)\\n lb = np.linalg.norm(self.cell_2[i, :, :], axis = 0)\\n\\n aa = np.dot(self.cell_1[i, :, 0], self.cell_1[i, :, 1]) / (la[0] * la[1])\\n aa = np.rad2deg(np.arccos(aa))\\n\\n ba = np.dot(self.cell_2[i, :, 0], self.cell_2[i, :, 1]) / (lb[0] * lb[1])\\n ba = np.rad2deg(np.arccos(ba))\\n\\n ar = np.abs(np.sin(np.deg2rad(aa))) * la[0] * la[1]\\n\\n s1 = self.eps_11[i] * 100\\n s2 = self.eps_22[i] * 100\\n s3 = self.eps_12[i] * 100\\n s4 = self.eps_mas[i] * 100\\n\\n ra = self.rep_1[i, :, :].flatten()\\n rb = self.rep_2[i, :, :].flatten()\\n\\n at = self.atoms[i]\\n\\n if np.isin(i, flag):\\n string = \\\"%-2s%6.0f * %6.1f,%6.1f * %5.1f * %5.1f * %6.1f * %5.0f * \\\"\\\\\\n \\\"%7.2f,%7.2f,%7.2f,%6.2f * %3i,%3i,%3i,%3i * %3i,%3i,%3i,%3i\\\"\\\\\\n % (anchor, i, la[0], la[1], ba, aa, ar, at, s1, s2, s3, s4,\\\\\\n ra[0], ra[2], ra[1], ra[3], rb[0], rb[2], rb[1], rb[3])\\n else:\\n string = \\\"%-2s%6.0f | %6.1f,%6.1f | %5.1f | %5.1f | %6.1f | %5.0f | \\\"\\\\\\n \\\"%7.2f,%7.2f,%7.2f,%6.2f | %3i,%3i,%3i,%3i | %3i,%3i,%3i,%3i\\\"\\\\\\n % (anchor, i, la[0], la[1], ba, aa, ar, at, s1, s2, s3, s4,\\\\\\n ra[0], ra[2], ra[1], ra[3], rb[0], rb[2], rb[1], rb[3])\\n\\n print(string)\\n\\n print(div + \\\"\\\\n\\\")\",\n \"def test_basic_usecases():\\n net = create_test_net()\\n eq_types = [\\\"rei\\\", \\\"ward\\\", \\\"xward\\\"]\\n for eq_type in eq_types:\\n net1, net2, net3 = run_basic_usecases(eq_type)\\n\\n if eq_type == \\\"rei\\\":\\n check_elements_amount(net1, {\\\"bus\\\": 5, \\\"load\\\": 3, \\\"sgen\\\": 2, \\\"shunt\\\": 3, \\\"ext_grid\\\": 1,\\n \\\"line\\\": 3, \\\"impedance\\\": 3}, check_all_pp_elements=True)\\n check_res_bus(net, net1)\\n assert np.allclose(net1.bus.min_vm_pu.values,\\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\\n check_elements_amount(net2, {\\\"bus\\\": 3, \\\"load\\\": 3, \\\"sgen\\\": 0, \\\"shunt\\\": 3, \\\"ext_grid\\\": 0,\\n \\\"line\\\": 0, \\\"impedance\\\": 3}, check_all_pp_elements=True)\\n check_res_bus(net, net2)\\n assert np.allclose(net2.bus.min_vm_pu.values,\\n net.bus.min_vm_pu.loc[[2, 4, 3]].values, equal_nan=True)\\n check_elements_amount(net3, {\\\"bus\\\": 5, \\\"load\\\": 3, \\\"sgen\\\": 2, \\\"shunt\\\": 3, \\\"ext_grid\\\": 1,\\n \\\"line\\\": 3, \\\"impedance\\\": 3}, check_all_pp_elements=True)\\n check_res_bus(net, net3)\\n assert np.allclose(net1.bus.min_vm_pu.values,\\n np.array([0.9, 0.91, np.nan, np.nan, 0.93]), equal_nan=True)\\n\\n elif \\\"ward\\\" in eq_type:\\n check_elements_amount(net1, {\\\"bus\\\": 4, \\\"load\\\": 2, \\\"sgen\\\": 2, \\\"ext_grid\\\": 1, \\\"line\\\": 3,\\n eq_type: 2, \\\"impedance\\\": 1}, check_all_pp_elements=True)\\n check_res_bus(net, net1)\\n check_elements_amount(net2, {\\\"bus\\\": 2, \\\"load\\\": 2, \\\"sgen\\\": 0, \\\"ext_grid\\\": 0, \\\"line\\\": 0,\\n eq_type: 2, \\\"impedance\\\": 1}, check_all_pp_elements=True)\\n check_res_bus(net, net2)\\n check_elements_amount(net3, {\\\"bus\\\": 4, \\\"load\\\": 2, \\\"sgen\\\": 2, \\\"ext_grid\\\": 1, \\\"line\\\": 3,\\n eq_type: 2, \\\"impedance\\\": 1}, check_all_pp_elements=True)\\n check_res_bus(net, net3)\",\n \"def test_collect_generic_layouts_dependencies(self, module_repo):\\n expected_result = {(\\\"pack_with_generic_field\\\", True)}\\n\\n test_input = [\\n {\\n \\\"Dummy Layout\\\": {\\n \\\"typeID\\\": \\\"dummy_layout\\\",\\n \\\"name\\\": \\\"Dummy Layout\\\",\\n \\\"pack\\\": \\\"dummy_pack\\\",\\n \\\"kind\\\": \\\"indicatorsDetails\\\",\\n \\\"path\\\": \\\"dummy_path\\\",\\n \\\"definitionId\\\": \\\"assets\\\",\\n \\\"incident_and_indicator_types\\\": [\\\"generic_type_id\\\"],\\n \\\"incident_and_indicator_fields\\\": [\\\"generic_field_id\\\"],\\n }\\n }\\n ]\\n\\n found_result = PackDependencies._collect_layouts_dependencies(\\n pack_layouts=test_input,\\n id_set=module_repo.id_set.read_json_as_dict(),\\n )\\n assert set(found_result) == set(expected_result)\",\n \"def test_check_map_bcs_and_added_demultiplex(self):\\r\\n\\r\\n # Combinations of bc plus added demultiplex field need to be unique\\r\\n # but can be duplicated if both options are being used.\\r\\n header, mapping_data = check_map(\\r\\n self.valid_mapping_data_bcs_and_added_demultiplex,\\r\\n barcode_type=4, added_demultiplex_field=\\\"Added_Demultiplex\\\")\\r\\n\\r\\n expected_header =\\\\\\r\\n ['SampleID', 'BarcodeSequence', 'LinkerPrimerSequence',\\r\\n 'Added_Demultiplex', 'Description']\\r\\n expected_mapping_data =\\\\\\r\\n [['s1', 'AAAA', 'ATTCGATART', '1', 's1_description'],\\r\\n ['s2', 'AAAA', 'ATTCGATART', '2', 's2_description'],\\r\\n ['s3', 'CCCC', 'YATGCTGCCTCCCGTAGGAGT', '1', 's3_description']]\\r\\n\\r\\n self.assertEquals(header, expected_header)\\r\\n self.assertEquals(mapping_data, expected_mapping_data)\",\n \"def WISE_match(t, RA_main, DEC_main,\\n width=0.0004, w_units=\\\"degrees\\\",\\n c_graph=True, DES_box=False,\\n plotfile_prefix=None, prefix=None,\\n verbose=False, debug=False):\\n\\n import numpy as np\\n import match_lists\\n import sqlutil\\n\\n function_name = inspect.stack()[0][3]\\n print()\\n print('__file__ ', __file__)\\n print('__name__ ', __name__)\\n print('Running:', function_name)\\n print('Depth of inspect stack:', len(inspect.stack()))\\n if len(inspect.stack()) > 1:\\n print('Caller:', inspect.stack()[1][3])\\n print(time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime()))\\n print()\\n\\n db, host, user, password, db_table = rd_config_wsdb(table='wise')\\n # db_table = 'allwise.main'\\n\\n print(mk_timestamp(), get_function_name(), get_linenumber() + ':',\\n 'Database table: ', db_table)\\n\\n if w_units == \\\"arcsecs\\\":\\n width = width / 3600.0\\n\\n cols = [\\\"RA_WISE\\\", \\\"DEC_WISE\\\", \\\"W1\\\", \\\"W1_ERR\\\",\\n \\\"W2\\\", \\\"W2_ERR\\\", \\\"W3\\\", \\\"W3_ERR\\\", \\\"W4\\\", \\\"W4_ERR\\\"]\\n\\n try:\\n for col in cols:\\n t.add_empty_column(col, dtype=np.float64)\\n\\n except AttributeError as e:\\n for col in cols:\\n t[col] = np.zeros(len(t))\\n\\n n = 0\\n\\n timestamp = mk_timestamp()\\n lineno = str(inspect.stack()[0][2])\\n print(mk_timestamp(), function_name, lineno + ':',\\n 'Number of source:', len(t))\\n\\n ra_min, ra_max, dec_min, dec_max = min_max_match(\\n t[RA_main], t[DEC_main], width, DES_box=DES_box)\\n area = ((float(ra_max) - float(ra_min)) *\\n (float(dec_max) - float(dec_min)))\\n nsources = len(t)\\n print('Area:', area, 'degrees')\\n print('Size of list:', nsources)\\n lineno = str(inspect.stack()[0][2])\\n print(mk_timestamp(), function_name, lineno + ':',\\n 'Source density:', nsources / area)\\n\\n if len(t) > 5000 and len(t) < 100000000:\\n\\n print(\\\"Retreiving data\\\")\\n query_wise = \\\"SELECT ra, dec, \\\\\\n w1mpro, w1sigmpro, w2mpro, w2sigmpro, \\\\\\n w3mpro, w3sigmpro, w4mpro, w4sigmpro \\\\\\n FROM allwise.main \\\\\\n WHERE ra > \\\" + ra_min + \\\" and ra < \\\" + ra_max \\\\\\n + \\\" and dec > \\\" + dec_min + \\\" and dec < \\\" + dec_max\\n\\n (RA_wise, DEC_wise, W1, W1err, W2, W2err, W3, W3err, W4, W4err) = \\\\\\n sqlutil.get(query_wise,\\n db=db, host=host, user=user, password=password)\\n\\n print(mk_timestamp(), function_name, lineno + ':')\\n print(\\\"Retrieved data:\\\", len(RA_wise), 'rows')\\n\\n info = [RA_wise, DEC_wise, W1, W1err, W2, W2err, W3, W3err, W4, W4err]\\n\\n if len(RA_wise) == 0:\\n for (i, col) in enumerate(cols):\\n t[col] = [np.float64(np.nan)] * len(t)\\n\\n else:\\n print(\\\"Retrieved data, matching lists\\\")\\n dists, inds = match_lists.match_lists(\\n t[RA_main], t[DEC_main], RA_wise, DEC_wise, width, 1)\\n print(\\\"Matched lists, updating table\\\")\\n match = np.where((inds != len(RA_wise)))[0]\\n no_match = np.where((inds == len(RA_wise)))[0]\\n\\n for (i, col) in enumerate(cols):\\n t[col][match] = info[i][inds[match]]\\n t[col][no_match] = np.float64(np.nan)\\n\\n print(\\\"Table updated\\\")\\n\\n elif len(t) <= 5000:\\n\\n print(mk_timestamp(), function_name, lineno + ':')\\n print(\\\"Looping through the source list:\\\", len(t), 'sources')\\n\\n time0 = time.time()\\n\\n while n < len(t):\\n RA = t[RA_main][n]\\n DEC = t[DEC_main][n]\\n query = \\\"select ra, dec, \\\\\\n w1mpro, w1sigmpro, w2mpro, w2sigmpro, \\\\\\n w3mpro, w3sigmpro, w4mpro, w4sigmpro \\\\\\n FROM allwise.main \\\\\\n WHERE q3c_radial_query(ra, dec, \\\" \\\\\\n + str(RA) + \\\", \\\" + str(DEC) + \\\", 0.1002)\\\"\\n\\n (RA_W, DEC_W, W1, W1err, W2, W2err, W3, W3err,\\n W4, W4err) = sqlutil.get(query, db=db, host=host,\\n user=user, password=password)\\n\\n if len(RA_W) > 0:\\n (dists, inds) = match_lists.match_lists(\\n [RA], [DEC], RA_W, DEC_W, width, 1)\\n j = inds[0]\\n\\n if j != len(RA_W):\\n info = [RA_W[j], DEC_W[j],\\n W1[j], W1err[j], W2[j], W2err[j],\\n W3[j], W3err[j], W4[j], W4err[j]]\\n\\n for (i, col) in enumerate(cols):\\n t[col][n] = info[i]\\n\\n else:\\n for (i, col) in enumerate(cols):\\n t[col][n] = np.float64(np.nan)\\n\\n else:\\n for (i, col) in enumerate(cols):\\n t[col][n] = np.float64(np.nan)\\n\\n if n + 1 == 1 or n + 1 == 10 or n + 1 == 100:\\n time1 = time.time()\\n rate = float(n + 1) / (time1 - time0)\\n lineno = str(inspect.stack()[0][2])\\n print(mk_timestamp(), function_name, lineno + ':',\\n 'Sources per second: ', rate, n + 1, time1 - time0)\\n\\n n += 1\\n\\n time1 = time.time()\\n rate = float(n + 1) / (time1 - time0)\\n lineno = str(inspect.stack()[0][2])\\n print(mk_timestamp(), function_name, lineno + ':',\\n 'Sources per second:', rate, n + 1, time1 - time0)\\n\\n elif len(t) > 1000000000:\\n\\n print(\\\"Splitting by tile\\\")\\n tiles_all = t[\\\"TILENAME\\\"]\\n tiles = set(tiles_all)\\n tiles = list(tiles)\\n print(len(tiles), \\\"distinct tiles\\\")\\n\\n t.sort(\\\"TILENAME\\\")\\n tiles.sort()\\n\\n n = 0\\n m = 0\\n rows = []\\n tile_rows = []\\n\\n while n < len(t):\\n tile = tiles[m]\\n if t[\\\"TILENAME\\\"][n] == tile:\\n rows.append(n)\\n n += 1\\n else:\\n tile_rows.append(rows)\\n rows = []\\n m += 1\\n\\n for rows in tile_rows:\\n t1 = t.rows(rows)\\n print(\\\"Matching\\\", t1[\\\"TILENAME\\\"][0], \\\"with length\\\", len(t1))\\n t1 = WISE_match(t1, RA_main, DEC_main, width, c_graph=False)\\n\\n if tile_rows.index(rows) == 0:\\n t_out = t1\\n else:\\n t_out.append(t1)\\n t = t_out\\n\\n if c_graph:\\n width = width * 3600.0\\n (RA_med, DEC_med) = check_graph(\\n t, RA_main, DEC_main, \\\"WISE\\\", width, gtype=\\\"square\\\",\\n plotfile_prefix=plotfile_prefix)\\n\\n return t\",\n \"def check_pattern(pattern, n_qubits):\\n\\n pattern_flat = []\\n for pat in pattern:\\n pattern_flat.extend(pat)\\n\\n if np.max(pattern_flat) >= n_qubits:\\n print(\\\"Invalid pattern. Qubit index in the pattern exceeds the number of qubits.\\\")\\n\\n _, uni_counts = np.unique(np.array(pattern_flat), return_counts=True)\\n if (uni_counts > 1).any():\\n raise ValueError(\\\"Invalid pattern. Duplicate qubit index.\\\")\",\n \"def getQOfPosition(self,a, b, c, d):\\n '''\\n the initial list of qOfPosition given by the paper \\\"The Secrets of Notakto\\\" Figure 6,\\\\\\n the first element is the board position and second is corresponding value\\n '''\\n qOfPosition_List = \\\\\\n [ #\\\"\\\"\\\"row 1\\\"\\\"\\\"\\n #row 1 column 1\\n [[False, False, False, False, False, False, False, False, False],c],\\\\\\n #row 1 column 2\\n [[True, False, False, False, False, False, False, False, False],1],\\\\\\n #row 1 column 3\\n [[False, True, False, False, False, False, False, False, False],1],\\\\\\n #row 1 column 4\\n [[False, False, False, False, True, False, False, False, False],c**2],\\\\\\n #row 1 column 5\\n [[True, True, False, False, False, False, False, False, False],a*d],\\\\\\n #row 1 column 6\\n [[True, False, True, False, False, False, False, False, False],b],\\\\\\n #row 1 column 7\\n [[True, False, False, False, True, False, False, False, False],b],\\\\\\n #row 1 column 8\\n [[True, False, False, False, False, True, False, False, False],b],\\\\\\n #row 1 column 9\\n [[True, False, False, False, False, False, False, False, True],a],\\\\\\n #\\\"\\\"\\\"row 2\\\"\\\"\\\"\\n #row 2 column 1\\n [[False, True, False, True, False, False, False, False, False],a],\\\\\\n #row 2 column 2\\n [[False, True, False, False, True, False, False, False, False],b],\\\\\\n #row 2 column 3\\n [[False, True, False, False, False, False, False, True, False],a],\\\\\\n #row 2 column 4 is a dead board, we will skip it \\n #row 2 column 5\\n [[True, True, False, True, False, False, False, False, False],b],\\\\\\n #row 2 column 6\\n [[True, True, False, False, True, False, False, False, False],a*b],\\\\\\n #row 2 column 7\\n [[True, True, False, False, False, True, False, False, False],d],\\\\\\n #row 2 column 8\\n [[True, True, False, False, False, False, True, False, False],a],\\\\\\n #row 2 column 9\\n [[True, True, False, False, False, False, False, True, False],d],\\\\\\n #\\\"\\\"\\\"row 3\\\"\\\"\\\"\\n #row 3 column 1\\n [[True, True, False, False, False, False, False, False, True],d],\\\\\\n #row 3 column 2\\n [[True, False, True, False, True, False, False, False, False],a],\\\\\\n #row 3 column 3\\n [[True, False, True, False, False, False, True, False, False],a*b],\\\\\\n #row 3 column 4\\n [[True, False, True, False, False, False, False, True, False],a],\\\\\\n #row 3 column 5\\n [[True, False, False, False, True, True, False, False, False],a],\\\\\\n #row 3 column 6 is a dead board, we will skip it \\n #row 3 column 7\\n [[True, False, False, False, False, True, False, True, False],1],\\\\\\n #row 3 column 8\\n [[False, True, False, True, True, False, False, False, False],a*b],\\\\\\n #row 3 column 9\\n [[False, True, False, True, False, True, False, False, False],b],\\\\\\n #\\\"\\\"\\\"row 4\\\"\\\"\\\"\\n #row 4 column 1, 2, 3, 4, 5 are all dead boards, we will skip them \\n #row 4 column 6 \\n [[True, True, False, True, True, False, False, False, False],a],\\\\\\n #row 4 column 7\\n [[True, True, False, True, False, True, False, False, False],a],\\\\\\n #row 4 column 8\\n [[True, True, False, True, False, False, False, False, True],a],\\\\\\n #row 4 column 9\\n [[True, True, False, False, True, True, False, False, False],b],\\\\\\n #\\\"\\\"\\\"row 5\\\"\\\"\\\"\\n #row 5 column 1\\n [[True, True, False, False, True, False, True, False, False],b],\\\\\\n #row 5 column 2,3 are dead boards\\n #row 5 column 4\\n [[True, True, False, False, False, True, True, False, False],b],\\\\\\n #row 5 column 5\\n [[True, True, False, False, False, True, False, True, False],a*b],\\\\\\n #row 5 column 6 \\n [[True, True, False, False, False, True, False, False, True],a*b],\\\\\\n #row 5 column 7\\n [[True, True, False, False, False, False, True, True, False],b],\\\\\\n #row 5 column 8\\n [[True, True, False, False, False, False, True, False, True],b],\\\\\\n #row 5 column 9\\n [[True, True, False, False, False, False, False, True, True],a],\\\\\\n #\\\"\\\"\\\"row 6\\\"\\\"\\\"\\n #row 6 column 1 is a dead board\\n #row 6 column 2\\n [[True, False, True, False, True, False, False, True, False],b],\\\\\\n #row 6 column 3\\n [[True, False, True, False, False, False, True, False, True],a],\\\\\\n #row 6 column 4\\n [[True, False, False, False, True, True, False, True, False],b],\\\\\\n #row 6 column 5 is a dead board \\n #row 6 column 6 \\n [[False, True, False, True, False, True, False, True, False],a],\\\\\\n #row 6 column 7,8,9 are dead boards\\n #\\\"\\\"\\\"row 7\\\"\\\"\\\" \\n #row 7 column 1-8 are dead boards\\n #row 7 column 9 \\n [[True, True, False, True, False, True, False, True, False],b],\\\\\\n #\\\"\\\"\\\"row 8\\\"\\\"\\\"\\n #row 8 column 1\\n [[True, True, False, True, False, True, False, False, True],b],\\\\\\n #row 8 column 2\\n [[True, True, False, False, True, True, True, False, False],a],\\\\\\n #row 8 column 3-7 are dead boards\\n #row 8 column 8\\n [[True, True, False, False, False, True, True, True, False],a],\\\\\\n #row 8 column 9\\n [[True, True, False, False, False, True, True, False, True],a],\\\\\\n #\\\"\\\"\\\"row 9 are all dead boards\\\"\\\"\\\"\\n #\\\"\\\"\\\"row 10\\\"\\\"\\\"\\n #row 10 column 1-6, 8, 9 are dead boards \\n #row 10 column 7\\n [[True, True, False, True, False, True, False, True, True],a]\\n #the rest are all dead boards\\n ]#boundary of qOfPosition_List\\n '''\\n the above list doesn't consider all the situations, we need to add\\\\\\n the rotated and reflected versions into them. we use a dictionary \\\\\\n to store the (board, value) pair\\n '''\\n qOfPosition_Dict = {}\\n for boardAndValue in qOfPosition_List:\\n board = boardAndValue[0]\\n boardValue = boardAndValue[1]\\n #get the reflected version, the second one is the same as the initial one\\n for i in range(2):\\n board = self.reflectBoard(board)\\n #get the rotated version, we need to call rotateBoard function four times\\n #the fourth one is the same as initial one\\n for j in range(4):\\n #update the board by rotating\\n board = self.rotateBoard(board)\\n #transfer the board to a string for making a key\\n boardKey = self.transferBoardToString(board)\\n #check if the key has already existed\\n if boardKey in qOfPosition_Dict:\\n pass\\n else:\\n #if not exist, store the (boardKey, boardValue into the qOfPosition_Dict)\\n qOfPosition_Dict.update({boardKey: boardValue})\\n #print(len(qOfPosition_Dict))\\n return qOfPosition_Dict\",\n \"def updatePlotLayoutGrid(self):\\n\\n print('updatePlotLayoutGrid()')\\n plotLayoutType = self.plotLayoutType # 1x, 1x2, 2x1, 2x2\\n if plotLayoutType == '1x':\\n numPlots = 1\\n elif plotLayoutType == '1x2':\\n numPlots = 2\\n elif plotLayoutType == '2x1':\\n numPlots = 2\\n elif plotLayoutType == '2x2':\\n numPlots = 4\\n\\n # remove all widgets from self.plotLayout\\n n = self.plotLayout.count()\\n for i in range(n):\\n item = self.plotLayout.itemAt(i)\\n if item is None:\\n print(' warning: updatePlotLayoutGrid() got None item at step', i)\\n continue\\n widget = item.widget()\\n print(' updatePlotLayoutGrid() removing i:', i, 'item:', type(item))\\n self.plotLayout.removeWidget(widget)\\n #self.plotLayout.removeItem(item)\\n\\n state = self.getState()\\n for i in range(numPlots):\\n if i==0:\\n row = 0\\n col = 0\\n elif i==1:\\n if plotLayoutType == '1x2':\\n row = 0\\n col = 1\\n elif plotLayoutType == '2x1':\\n row = 1\\n col = 0\\n elif plotLayoutType == '2x2':\\n row = 0\\n col = 1\\n elif i==2:\\n row = 1\\n col = 0\\n elif i==3:\\n row = 1\\n col = 1\\n #\\n oneCanvas = myMplCanvas(plotNumber=i)\\n oneCanvas.myUpdate(state) # initial plot\\n oneCanvas.signalSelectFromPlot.connect(self.slotSelectFromPlot)\\n self.signalCancelSelection.connect(oneCanvas.slotCancelSelection)\\n self.myPlotCanvasList[i] = oneCanvas\\n\\n #\\n self.plotLayout.addWidget(oneCanvas, row, col)\\n\\n # connect each canvas to all other canvas\\n for i in range(numPlots):\\n iCanvas = self.myPlotCanvasList[i]\\n iCanvas.signalSelectSquare.connect(self.slotSelectSquare)\\n # feb 2023, I was connecting this twice and was getting 2x calls for each click\\n #iCanvas.signalSelectFromPlot.connect(self.slotSelectFromPlot)\\n for j in range(numPlots):\\n #if i==j:\\n # continue\\n jCanvas = self.myPlotCanvasList[j]\\n iCanvas.signalSelectFromPlot.connect(jCanvas.slotSelectInd)\\n iCanvas.signalSelectSquare.connect(jCanvas.slotSelectSquare)\\n\\n #\\n # select the firsr plot\\n self.myPlotCanvasList[0].signalSelectSquare.emit(0, None) #slotSelectSquare(0)\",\n \"def test_get_qasms_noname(self):\\n q_program = QuantumProgram()\\n qr = q_program.create_quantum_register(size=3)\\n cr = q_program.create_classical_register(size=3)\\n qc1 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])\\n qc2 = q_program.create_circuit(qregisters=[qr], cregisters=[cr])\\n qc1.h(qr[0])\\n qc1.cx(qr[0], qr[1])\\n qc1.cx(qr[1], qr[2])\\n qc1.measure(qr[0], cr[0])\\n qc1.measure(qr[1], cr[1])\\n qc1.measure(qr[2], cr[2])\\n qc2.h(qr)\\n qc2.measure(qr[0], cr[0])\\n qc2.measure(qr[1], cr[1])\\n qc2.measure(qr[2], cr[2])\\n results = dict(zip(q_program.get_circuit_names(), q_program.get_qasms()))\\n qr_name_len = len(qr.name)\\n cr_name_len = len(cr.name)\\n self.assertEqual(len(results[qc1.name]), qr_name_len * 9 + cr_name_len * 4 + 147)\\n self.assertEqual(len(results[qc2.name]), qr_name_len * 7 + cr_name_len * 4 + 137)\",\n \"def test_opt_a1a2(self, nqubits):\\n dim = 2**nqubits\\n umat = scipy.stats.unitary_group.rvs(dim, random_state=1224)\\n circ = self.qsd(umat, opt_a1=True, opt_a2=True)\\n ccirc = transpile(circ, basis_gates=[\\\"u\\\", \\\"cx\\\"], optimization_level=0)\\n self.assertTrue(Operator(umat) == Operator(ccirc))\\n if nqubits > 2:\\n self.assertEqual(\\n ccirc.count_ops().get(\\\"cx\\\"),\\n (23 / 48) * 4**nqubits - (3 / 2) * 2**nqubits + 4 / 3,\\n )\\n elif nqubits == 1:\\n self.assertEqual(ccirc.count_ops().get(\\\"cx\\\", 0), 0)\\n elif nqubits == 2:\\n self.assertLessEqual(ccirc.count_ops().get(\\\"cx\\\", 0), 3)\",\n \"def _general_get_information(self, k=None):\\n ## Format k\\n ks = self.get_k(k)\\n idx_ks = self._get_k_indices(ks)\\n ## Get iss\\n iss = self.iss\\n ## Format idxs\\n assert(type(idx_ks) == list)\\n neighs = self.get_neighs(idx_ks)\\n sp_relative_pos = self.get_sp_rel_pos(idx_ks)\\n self.check_output_standards(neighs, sp_relative_pos, ks, iss)\\n# print '3'*50, neighs, sp_relative_pos, ks, iss\\n return neighs, sp_relative_pos, ks, iss\",\n \"def q1(puzzle):\\n mysudoku = build_csp(puzzle)\\n solution = mysudoku.backtracking_search()\\n return solution, mysudoku\",\n \"def test_queue_region_with_rss_rule_api(self):\\n self.verify(self.nic in [\\\"fortville_eagle\\\", \\\"fortville_spirit\\\",\\n \\\"fortville_spirit_single\\\", \\\"fortpark_TLV\\\", \\\"fortville_25g\\\"], \\\"NIC Unsupported: \\\" + str(self.nic))\\n self.pmdout.start_testpmd(\\\"%s\\\" % self.cores, \\\"--rxq=16 --txq=16 --port-topology=chained\\\")\\n self.dut.send_expect(\\\"set fwd rxonly\\\", \\\"testpmd> \\\", 120)\\n self.dut.send_expect(\\\"set verbose 1\\\", \\\"testpmd> \\\", 120)\\n self.dut.send_expect(\\\"start\\\", \\\"testpmd> \\\", 120)\\n time.sleep(2)\\n\\n # Create a rss queue rule.\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern end actions rss types tcp end queues 7 8 10 11 12 14 15 end / end\\\", \\\"created\\\")\\n # send the packets and verify the results\\n rss_queue = [\\\"7\\\", \\\"8\\\", \\\"10\\\", \\\"11\\\", \\\"12\\\", \\\"14\\\", \\\"15\\\"]\\n queue1 = self.send_and_check(self.prio_pkt1, rss_queue)\\n queue2 = self.send_and_check(self.prio_pkt2, rss_queue)\\n queue3 = self.send_and_check(self.prio_pkt3, rss_queue)\\n self.verify(queue1 == queue2 == queue3, \\\"the packet doesn't enter the expected RSS queue.\\\")\\n\\n # Create three queue regions.\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern vlan tci is 0x2000 / end actions rss queues 7 8 end / end\\\", \\\"created\\\")\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern vlan tci is 0x4000 / end actions rss queues 11 12 end / end\\\", \\\"created\\\")\\n self.dut.send_expect(\\n \\\"flow create 0 ingress pattern vlan tci is 0x6000 / end actions rss queues 15 end / end\\\", \\\"created\\\")\\n # send the packets and verify the results\\n rss_queue = [\\\"7\\\", \\\"8\\\"]\\n queue1 = self.send_and_check(self.prio_pkt1, rss_queue)\\n rss_queue = [\\\"11\\\", \\\"12\\\"]\\n queue2 = self.send_and_check(self.prio_pkt2, rss_queue)\\n rss_queue = [\\\"15\\\"]\\n queue3 = self.send_and_check(self.prio_pkt3, rss_queue)\\n\\n # Destroy one queue region rule, all the rules become invalid.\\n self.dut.send_expect(\\\"flow destroy 0 rule 2\\\", \\\"testpmd> \\\")\\n rss_queue = [\\\"0\\\"]\\n self.send_and_check(self.prio_pkt1, rss_queue)\\n self.send_and_check(self.prio_pkt2, rss_queue)\\n self.send_and_check(self.prio_pkt3, rss_queue)\",\n \"def produce(self, layout, layers, parameters, cell):\\n self._layers = layers\\n self.cell = cell\\n self._param_values = parameters\\n self.layout = layout\\n\\n\\n # cell: layout cell to place the layout\\n # LayerSiN: which layer to use\\n # r: radius\\n # w: waveguide width\\n # length units in dbu\\n\\n from math import pi, cos, sin\\n from SiEPIC.utils import arc, arc_to_waveguide, points_per_circle, arc_wg\\n\\n # fetch the parameters\\n dbu = self.layout.dbu\\n ly = self.layout\\n shapes = self.cell.shapes\\n \\n LayerSi = self.silayer\\n LayerSiN = self.silayer_layer\\n LayerPinRecN = ly.layer(self.pinrec)\\n LayerDevRecN = ly.layer(self.devrec)\\n \\n w = int(round(self.wg_width/dbu))\\n r = int(round(self.radius/dbu))\\n\\n # draw the quarter-circle\\n x = -r\\n y = r\\n # layout_arc_wg_dbu(self.cell, LayerSiN, x, y, r, w, 270, 360)\\n t = Trans(Trans.R0,x, y)\\n self.cell.shapes(LayerSiN).insert(arc_to_waveguide(arc(r, 270, 360), w).transformed(t))\\n \\n # Create the pins on the waveguides, as short paths:\\n from SiEPIC._globals import PIN_LENGTH as pin_length\\n \\n # Pin on the top side:\\n p2 = [Point(0, y-pin_length/2), Point(0, y+pin_length/2)]\\n p2c = Point(0, y)\\n self.set_p2 = p2c\\n self.p2 = p2c\\n pin = Path(p2, w)\\n shapes(LayerPinRecN).insert(pin)\\n t = Trans(Trans.R0, 0, y)\\n text = Text (\\\"pin2\\\", t)\\n shape = shapes(LayerPinRecN).insert(text)\\n shape.text_size = 0.4/dbu\\n\\n # Pin on the left side:\\n p1 = [Point(pin_length/2+x,0), Point(-pin_length/2+x,0)]\\n p1c = Point(x,0)\\n self.set_p1 = p1c\\n self.p1 = p1c\\n pin = Path(p1, w)\\n shapes(LayerPinRecN).insert(pin)\\n t = Trans(Trans.R0, x, 0)\\n text = Text (\\\"pin1\\\", t)\\n shape = shapes(LayerPinRecN).insert(text)\\n shape.text_size = 0.4/dbu\\n\\n # Create the device recognition layer -- make it 1 * wg_width away from the waveguides.\\n t = Trans(Trans.R0,x, y)\\n self.cell.shapes(LayerDevRecN).insert(arc_to_waveguide(arc(r, 270, 360), w*3).transformed(t))\\n #layout_arc_wg_dbu(self.cell, LayerDevRecN, x, y, r, w*3, 270, 360)\\n\\n # Compact model information\\n t = Trans(Trans.R0, x+r/10, 0)\\n text = Text (\\\"Lumerical_INTERCONNECT_library=Design kits/EBeam\\\", t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\\n t = Trans(Trans.R0, x+r/10, r/4)\\n text = Text ('Component=ebeam_bend_1550', t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\\n t = Trans(Trans.R0, x+r/10, r/2)\\n text = Text ('Spice_param:radius=%.3fu wg_width=%.3fu'% (self.radius,self.wg_width), t)\\n shape = shapes(LayerDevRecN).insert(text)\\n shape.text_size = r/100\",\n \"def occupied_first(r, c, layout):\\n occupy = 0\\n\\n NW = (-1, -1)\\n NE = (-1, 1)\\n N = (-1, 0)\\n W = (0, -1)\\n E = (0, 1)\\n SW = (1, -1)\\n SE = (1, 1)\\n S = (1, 0)\\n\\n for dirs in [NW, NE, N, W, E, SW, SE, S]:\\n dr, dc = r+dirs[0], c + dirs[1]\\n while (dr >= 0) and (dc >= 0) and (dr < len(layout)) and (dc < len(layout[0])):\\n if layout[dr][dc] == '#':\\n occupy += 1\\n break\\n elif layout[dr][dc] == 'L':\\n break\\n dr, dc = dr+dirs[0], dc + dirs[1]\\n\\n return occupy\",\n \"def _valid_placement(self, i_row, i_col):\\n if not self._empty_cell(i_row, i_col):\\n return (False, [])\\n adj_opp_cells = []\\n\\n if (i_row, i_col) == self._tl_cell:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_corners, \\\"tl\\\")\\n elif (i_row, i_col) == self._tr_cell:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_rs_corners, \\\"tr\\\")\\n elif (i_row, i_col) == self._bl_cell:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_corners, \\\"bl\\\")\\n elif (i_row, i_col) == self._br_cell:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_rs_corners, \\\"br\\\")\\n elif (i_row, i_col) in self._ls_cells:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_and_rs, \\\"ls\\\")\\n elif (i_row, i_col) in self._ts_cells:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ts_and_bs, \\\"ts\\\")\\n elif (i_row, i_col) in self._rs_cells:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ls_and_rs, \\\"rs\\\")\\n elif (i_row, i_col) in self._bs_cells:\\n self._handle_border(i_row, i_col, adj_opp_cells, self._check_ts_and_bs, \\\"bs\\\")\\n else:\\n self._check_inner_dirs(i_row, i_col, adj_opp_cells)\\n\\n #print(\\\"\\\\nFOR TESTING. adj_opp_cells: \\\", adj_opp_cells)\\n\\n if adj_opp_cells == []:\\n return (False, [])\\n else:\\n can_place, flip_lst = self._flip_dirs(adj_opp_cells)\\n return (can_place, flip_lst)\",\n \"def test_ex_3_1(self):\\n fact1, fact2, query, scope = parse(PROLOG_OPS, 'q(a, b)', 'r(b, c)', 'p(U, V)')\\n\\n compiler = Compiler()\\n fact1_instrs = compiler.compile_rule(fact1, [])\\n fact2_instrs = compiler.compile_rule(fact2, [])\\n reg_allocation = RegisterAllocation()\\n query_instrs = compiler.compile_query_m1(query, reg_allocation)\\n\\n wam = WAM()\\n wam.load(('p', 2), self.fig_3_1_instrs)\\n wam.load(('q', 2), fact1_instrs)\\n wam.load(('r', 2), fact2_instrs)\\n query_offset = wam.load(None, query_instrs)\\n wam.p = query_offset\\n\\n wam.run()\\n\\n aU = wam.deref_reg(reg_allocation[scope.var('U')])\\n self.assertEqual(wam.get_term_repr(aU), 'a')\\n aV = wam.deref_reg(reg_allocation[scope.var('V')])\\n self.assertEqual(wam.get_term_repr(aV), 'c')\",\n \"def test_comb(pad_size = (200, 200), wire_width = 1, wire_gap = 3,\\n comb_layer = 0, overlap_zigzag_layer = 1,\\n comb_pad_layer = 2, comb_gnd_layer = 3,\\n overlap_pad_layer = 4):\\n CI = Device(\\\"test_comb\\\")\\n\\n # if comb_pad_layer is None: comb_pad_layer = comb_layer\\n # if comb_gnd_layer is None: comb_gnd_layer = comb_layer\\n # if overlap_pad_layer is None: overlap_pad_layer = overlap_zigzag_layer\\n wire_spacing = wire_width + wire_gap*2\\n\\n # pad overlays\\n overlay_padb = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = overlap_pad_layer))\\n overlay_padl = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_pad_layer))\\n overlay_padt = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_pad_layer))\\n overlay_padr = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_gnd_layer))\\n overlay_padl.xmin = 0\\n overlay_padl.ymin = 0\\n overlay_padb.ymax = 0\\n overlay_padb.xmin = overlay_padl.xmax + pad_size[1]/5\\n overlay_padr.ymin = overlay_padl.ymin\\n overlay_padr.xmin = overlay_padb.xmax + pad_size[1]/5\\n overlay_padt.xmin = overlay_padl.xmax + pad_size[1]/5\\n overlay_padt.ymin = overlay_padl.ymax\\n\\n # pads\\n padl = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padt = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padr = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padb = CI.add_ref(rectangle(size = pad_size, layer = overlap_zigzag_layer))\\n padl_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\\n pad_size[1]/2),\\n layer = comb_layer))\\n padr_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\\n pad_size[1]/2),\\n layer = comb_layer))\\n padl.xmin = overlay_padl.xmin\\n padl.center = [padl.center[0], overlay_padl.center[1]]\\n padt.ymax = overlay_padt.ymax\\n padt.center = [overlay_padt.center[0], padt.center[1]]\\n padr.xmax = overlay_padr.xmax\\n padr.center = [padr.center[0], overlay_padr.center[1]]\\n padb.ymin = overlay_padb.ymin\\n padb.center = [overlay_padb.center[0], padb.center[1]]\\n padl_nub.xmin = padl.xmax\\n padl_nub.center = [padl_nub.center[0], padl.center[1]]\\n padr_nub.xmax = padr.xmin\\n padr_nub.center = [padr_nub.center[0], padr.center[1]]\\n\\n # connected zig\\n head = CI.add_ref(compass(size = (pad_size[0]/12, wire_width),\\n layer = comb_layer))\\n head.xmin = padl_nub.xmax\\n head.ymax = padl_nub.ymax\\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n connector.connect(port = 'W', destination = head.ports['E'])\\n old_port = connector.ports['S']\\n top = True\\n obj = connector\\n while(obj.xmax + pad_size[0]/12 < padr_nub.xmin):\\n # long zig zag rectangle\\n obj = CI.add_ref(compass(size = (pad_size[1]/2 - 2*wire_width,\\n wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n if(top):\\n # zig zag edge rectangle\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'N', destination = old_port)\\n top = False\\n else:\\n # zig zag edge rectangle\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'S', destination = old_port)\\n top = True\\n # comb rectange\\n comb = CI.add_ref(rectangle(\\n size = ((padt.ymin - head.ymax) + pad_size[1]/2 \\\\\\n - (wire_spacing + wire_width)/2, wire_width),\\n layer = comb_layer))\\n comb.rotate(90)\\n comb.ymax = padt.ymin\\n comb.xmax = obj.xmax - (wire_spacing + wire_width)/2\\n old_port = obj.ports['E']\\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n if(top): old_port = obj.ports['S']\\n else: old_port = obj.ports['N']\\n old_port = obj.ports['E']\\n if(padr_nub.xmin-obj.xmax > 0):\\n tail = CI.add_ref(compass(size = (padr_nub.xmin-obj.xmax, wire_width),\\n layer = comb_layer))\\n else:\\n tail = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n tail.connect(port = 'W', destination = old_port)\\n\\n # disconnected zig\\n dhead = CI.add_ref(compass(size = (padr_nub.ymin - padb.ymax - wire_width,\\n wire_width),\\n layer = overlap_zigzag_layer))\\n dhead.rotate(90)\\n dhead.ymin = padb.ymax\\n dhead.xmax = tail.xmin - (wire_spacing+wire_width)/2\\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n connector.connect(port = 'S', destination = dhead.ports['E'])\\n old_port = connector.ports['N']\\n right = True\\n obj = connector\\n while(obj.ymax + wire_spacing + wire_width < head.ymax):\\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n if(right):\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'W', destination = old_port)\\n right = False\\n else:\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'E', destination = old_port)\\n right = True\\n old_port = obj.ports['N']\\n obj = CI.add_ref(compass(\\n size = (dhead.xmin - (head.xmax+head.xmin+wire_width)/2,\\n wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'E', destination = old_port)\\n old_port = obj.ports['W']\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'S', destination = old_port)\\n if(right):\\n old_port = obj.ports['W']\\n else:\\n old_port = obj.ports['E']\\n\\n return CI\",\n \"def test_140707_general(self):\\n spc = parser(get_file('PTSDY1_complex.txt'))\\n # spc.draw_outlooks()\\n outlook = spc.get_outlook('CATEGORICAL', 'TSTM')\\n self.assertAlmostEqual(outlook.geometry.area, 606.33, 2)\",\n \"def verify_connections_layout(comm, log, name, outputs=None):\\n for conn in comm.values():\\n #loop thru all connections\\n if isinstance(conn, dict):\\n for (key, value) in conn.items():\\n #loop thru sub items of the connections\\n #if sub item is a dict we found a output channel\\n if isinstance(value, dict):\\n if isinstance(outputs, list):\\n if not key in outputs:\\n log.warning(\\\"%s has unknown outputs '%s' in Connections.\\\"\\n ' Valid outputs are: %s', name, key, outputs)\\n else:\\n #handle case where outputs is not specified\\n log.warning(\\\"%s has unexpected outputs '%s' in Connections.\\\"\\n ' No outputs are allowed', name, key)\",\n \"def adjacency_extraction_consistent(wfc_ns, pattern_cat):\\n # This is a brute force implementation. We should really use the adjacency list we've already calculated...\\n legal = []\\n #print(f\\\"pattern_cat\\\\n{pattern_cat}\\\")\\n for p1, pattern1 in enumerate(pattern_cat):\\n for d_index, d in enumerate(wfc_ns.adjacency_directions):\\n for p2, pattern2 in enumerate(pattern_cat):\\n if is_valid_overlap_xy(d, p1, p2, pattern_cat, wfc_ns.pattern_width, wfc_ns.adjacency_directions):\\n legal.append((d_index, p1, p2))\\n return legal\",\n \"def __sudoku(A):\\r\\n if not sudoku_isready(A):\\r\\n print(\\\"Invalid Grid\\\")\\r\\n return None\\r\\n else:\\r\\n n = len(A)\\r\\n x, seen = isqrt(n), [0 for i in range(n)]\\r\\n for i in range(n):\\r\\n line = sudoku_getline(A, i)\\r\\n for v in line:\\r\\n if v in seen:\\r\\n return \\\"Invalid\\\"\\r\\n else:\\r\\n seen[i] = v\\r\\n seen = [0 for i in range(n)]\\r\\n for i in range(n):\\r\\n line = sudoku_getcol(A, i)\\r\\n for v in line:\\r\\n if v in seen:\\r\\n return \\\"Invalid\\\"\\r\\n else:\\r\\n seen[i] = v\\r\\n seen = [0 for i in range(n)]\\r\\n for i in range(n):\\r\\n line = sudoku_region_to_line(sudoku_getregion(A, i))\\r\\n for v in line:\\r\\n if v in seen:\\r\\n return \\\"Invalid\\\"\\r\\n else:\\r\\n seen[i] = v\\r\\n seen = [0 for i in range(n)]\\r\\n return \\\"Valid\\\"\",\n \"def solution2(inp):\\n rules, mticket, nearby = inp.strip().split(\\\"\\\\n\\\\n\\\")\\n rules = rules.split(\\\"\\\\n\\\")\\n nearby = nearby.split(\\\"\\\\n\\\")[1:]\\n mticket = list(map(int, mticket.split(\\\"\\\\n\\\")[1].split(\\\",\\\")))\\n rrules = []\\n for rule in rules:\\n a, b = rule.split(\\\" or \\\")\\n name = a.strip().split(\\\":\\\")[0]\\n r1 = a.strip().split(\\\" \\\")[-1]\\n r2 = b.strip()\\n def to_range(r):\\n i, j = list(map(int, r.split(\\\"-\\\")))\\n return range(i, j + 1)\\n rrules.append((to_range(r1), to_range(r2), name))\\n\\n nearby = [list(map(int, ticket.split(\\\",\\\"))) for ticket in nearby]\\n s = 0\\n to_remove = []\\n for i, ticket in enumerate(nearby):\\n for v in ticket:\\n valid = False\\n for r in rrules:\\n valid |= v in r[0] or v in r[1]\\n if not valid:\\n to_remove.append(i)\\n nearby = list(map(lambda x: x[1], filter(lambda x: x[0] not in to_remove, enumerate(nearby))))\\n indices = list(range(len(rrules)))\\n keys = {}\\n for rule in rrules:\\n rule_idx = []\\n for i in indices:\\n if all(ticket[i] in rule[0] or ticket[i] in rule[1] for ticket in nearby):\\n rule_idx.append(i)\\n keys[rule[2]] = rule_idx\\n\\n stack = list(keys.items())\\n def resolve(j, avail):\\n f, cand = stack[j]\\n for i in avail.intersection(cand):\\n if len(avail) == 1:\\n return [i]\\n avail.remove(i)\\n res = resolve(j + 1, avail)\\n avail.add(i)\\n if res != False:\\n return [i] + res\\n return False\\n solver = resolve(0, set(range(len(rrules))))\\n names = list(map(lambda x: x[0], stack))\\n return reduce(lambda x, y: x * y, [mticket[v] for k, v in zip(names, solver) if k.startswith(\\\"departure\\\")], 1)\",\n \"def _check_input(self, **kwargs):\\n\\n combi_a = ['nxny', 'dxdy', 'ul_corner']\\n combi_b = ['nxny', 'dxdy', 'll_corner']\\n if all(kwargs[k] is not None for k in combi_a):\\n nx, ny = kwargs['nxny']\\n dx, dy = kwargs['dxdy']\\n x0, y0 = kwargs['ul_corner']\\n if (dx <= 0.) or (dy >= 0.):\\n raise ValueError('dxdy and input params not compatible')\\n origin = 'upper-left'\\n elif all(kwargs[k] is not None for k in combi_b):\\n nx, ny = kwargs['nxny']\\n dx, dy = kwargs['dxdy']\\n x0, y0 = kwargs['ll_corner']\\n if (dx <= 0.) or (dy <= 0.):\\n raise ValueError('dxdy and input params not compatible')\\n origin = 'lower-left'\\n else:\\n raise ValueError('Input params not compatible')\\n\\n self._nx = int(nx)\\n self._ny = int(ny)\\n if (self._nx <= 0) or (self._ny <= 0):\\n raise ValueError('nxny not valid')\\n self._dx = float(dx)\\n self._dy = float(dy)\\n self._x0 = float(x0)\\n self._y0 = float(y0)\\n self._origin = origin\\n\\n # Check for pixel ref\\n self._pixel_ref = kwargs['pixel_ref'].lower()\\n if self._pixel_ref not in ['corner', 'center']:\\n raise ValueError('pixel_ref not recognized')\",\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 test_1_1_2D_rec_init(self): # TODO: REMOVE FUNC AFTER SPLIT\\n check = [(-1.0, -2.0), (7.0, 6.0), (7.0, -2.0), (-1.0, 6.0), (3.0, 2.0)]\\n nn_checks = {(-1.0, -2.0): [(7, -2), (3.0, 2.0), (-1, 6)],\\n (7.0, 6.0): [(7, -2), (3.0, 2.0), (-1, 6)],\\n (7.0, -2.0): [(7, 6), (3.0, 2.0), (-1, -2)]}\\n init_triangulation(2, 0, check, nn_checks, bounds=[(-1, 7), (-2, 6)])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.49703202","0.48756662","0.48414853","0.46022666","0.45521045","0.45476255","0.44789764","0.43654552","0.43505117","0.4343972","0.43153837","0.43040147","0.43010375","0.4282951","0.42795786","0.4265875","0.42644864","0.42477572","0.42424133","0.42418486","0.42294312","0.4226323","0.42168733","0.4204269","0.4200753","0.4197036","0.4196937","0.419217","0.41891772","0.41847417","0.41659823","0.41539955","0.41363728","0.41362843","0.41285813","0.41264668","0.41231832","0.41046062","0.410391","0.41029778","0.41013393","0.4099718","0.4073379","0.40728256","0.4067702","0.40654504","0.40512758","0.40494227","0.40491876","0.40484756","0.40427002","0.40397817","0.40276524","0.40251762","0.40238252","0.40232223","0.40200764","0.40161815","0.4010218","0.39998555","0.39982057","0.39952302","0.398715","0.39761674","0.39704722","0.3969171","0.39641544","0.39584926","0.39551818","0.39485636","0.39477104","0.3947592","0.39461344","0.39391235","0.3935954","0.3934847","0.39309397","0.39238852","0.39204624","0.391921","0.39082798","0.3902935","0.39007017","0.39003783","0.38987553","0.38983643","0.38982823","0.38979527","0.3895481","0.3893","0.3891085","0.38895223","0.3887512","0.38836017","0.38822368","0.38798878","0.38788167","0.3877183","0.38711128","0.38703972"],"string":"[\n \"0.49703202\",\n \"0.48756662\",\n \"0.48414853\",\n \"0.46022666\",\n \"0.45521045\",\n \"0.45476255\",\n \"0.44789764\",\n \"0.43654552\",\n \"0.43505117\",\n \"0.4343972\",\n \"0.43153837\",\n \"0.43040147\",\n \"0.43010375\",\n \"0.4282951\",\n \"0.42795786\",\n \"0.4265875\",\n \"0.42644864\",\n \"0.42477572\",\n \"0.42424133\",\n \"0.42418486\",\n \"0.42294312\",\n \"0.4226323\",\n \"0.42168733\",\n \"0.4204269\",\n \"0.4200753\",\n \"0.4197036\",\n \"0.4196937\",\n \"0.419217\",\n \"0.41891772\",\n \"0.41847417\",\n \"0.41659823\",\n \"0.41539955\",\n \"0.41363728\",\n \"0.41362843\",\n \"0.41285813\",\n \"0.41264668\",\n \"0.41231832\",\n \"0.41046062\",\n \"0.410391\",\n \"0.41029778\",\n \"0.41013393\",\n \"0.4099718\",\n \"0.4073379\",\n \"0.40728256\",\n \"0.4067702\",\n \"0.40654504\",\n \"0.40512758\",\n \"0.40494227\",\n \"0.40491876\",\n \"0.40484756\",\n \"0.40427002\",\n \"0.40397817\",\n \"0.40276524\",\n \"0.40251762\",\n \"0.40238252\",\n \"0.40232223\",\n \"0.40200764\",\n \"0.40161815\",\n \"0.4010218\",\n \"0.39998555\",\n \"0.39982057\",\n \"0.39952302\",\n \"0.398715\",\n \"0.39761674\",\n \"0.39704722\",\n \"0.3969171\",\n \"0.39641544\",\n \"0.39584926\",\n \"0.39551818\",\n \"0.39485636\",\n \"0.39477104\",\n \"0.3947592\",\n \"0.39461344\",\n \"0.39391235\",\n \"0.3935954\",\n \"0.3934847\",\n \"0.39309397\",\n \"0.39238852\",\n \"0.39204624\",\n \"0.391921\",\n \"0.39082798\",\n \"0.3902935\",\n \"0.39007017\",\n \"0.39003783\",\n \"0.38987553\",\n \"0.38983643\",\n \"0.38982823\",\n \"0.38979527\",\n \"0.3895481\",\n \"0.3893\",\n \"0.3891085\",\n \"0.38895223\",\n \"0.3887512\",\n \"0.38836017\",\n \"0.38822368\",\n \"0.38798878\",\n \"0.38788167\",\n \"0.3877183\",\n \"0.38711128\",\n \"0.38703972\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.49284887"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":74296,"cells":{"query":{"kind":"string","value":"Produces a program implementing reversible adding on a quantum computer to compute a + b. This implementation is based on [CDKM96]_, which is easy to implement, if not the most efficient. Each register of qubit labels should be provided such that the first qubit in each register is expected to carry the least significant bit of the respective number. This method also requires two extra ancilla, one initialized to 0 that acts as a dummy initial carry bit and another (which also probably ought be initialized to 0) that stores the most significant bit of the addition (should there be a final carry). The most straightforward"},"document":{"kind":"string","value":"def adder(num_a: Sequence[int], num_b: Sequence[int], register_a: Sequence[int],\n register_b: Sequence[int], carry_ancilla: int, z_ancilla: int, in_x_basis: bool = False,\n use_param_program: bool = False) -> Program:\n if len(num_a) != len(num_b):\n raise ValueError(\"Numbers being added must be equal length bitstrings\")\n\n # First, generate a set preparation program in the desired basis.\n prog = Program(Pragma('PRESERVE_BLOCK'))\n if use_param_program:\n input_register = register_a + register_b\n prog += parameterized_bitstring_prep(input_register[::-1], REG_NAME, in_x_basis=in_x_basis)\n else:\n prog += bitstring_prep(register_a, num_a[::-1], in_x_basis=in_x_basis)\n prog += bitstring_prep(register_b, num_b[::-1], in_x_basis=in_x_basis)\n\n if in_x_basis:\n prog += [H(carry_ancilla), H(z_ancilla)]\n\n # preparation complete; end the preserve block\n prog += Pragma(\"END_PRESERVE_BLOCK\")\n\n prog_to_rev = Program()\n current_carry_label = carry_ancilla\n for (a, b) in zip(register_a, register_b):\n prog += majority_gate(a, b, current_carry_label, in_x_basis)\n prog_to_rev += unmajority_add_gate(a, b, current_carry_label, in_x_basis).dagger()\n current_carry_label = a\n\n undo_and_add_prog = prog_to_rev.dagger()\n if in_x_basis:\n prog += CNOT_X_basis(register_a[-1], z_ancilla)\n # need to switch back to computational (z) basis before measuring\n for qubit in register_b: # answer lays on the b qubit register\n undo_and_add_prog.inst(H(qubit))\n undo_and_add_prog.inst(H(z_ancilla))\n else:\n prog += CNOT(register_a[-1], z_ancilla)\n prog += undo_and_add_prog\n\n ro = prog.declare('ro', memory_type='BIT', memory_size=len(register_b) + 1)\n for idx, qubit in enumerate(register_b):\n prog += MEASURE(qubit, ro[len(register_b) - idx])\n prog += MEASURE(z_ancilla, ro[0])\n\n return prog"},"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 addition(a, b):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n bina.reverse()\n binb.reverse()\n n = len(bina)+len(binb)\n na = len(bina)\n q = QuantumRegister(n+1, 'q')\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binb)):\n if binb[i]:\n circ.x(q[na+i])\n add(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\n circ_m = measure(circ, q, [i for i in range(na, n)])\n return circ_m","def addition_o(a, b):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n bina.reverse()\n binb.reverse()\n n = len(bina)+len(binb)\n na = len(bina)\n q = QuantumRegister(n+1, 'q')\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binb)):\n if binb[i]:\n circ.x(q[na+i])\n add_o(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\n circ_m = measure(circ, q, [i for i in range(na, n)])\n return circ_m","def BitAdd(a, b, bits_to_compute=None):\r\n k = len(a)\r\n if not bits_to_compute:\r\n bits_to_compute = list(range(k))\r\n d = [None] * k\r\n for i in range(1,k):\r\n t = a[i]*b[i]\r\n d[i] = (a[i] + b[i] - 2*t, t)\r\n d[0] = (None, a[0]*b[0])\r\n pg = PreOpL(carry, d)\r\n c = [pair[1] for pair in pg]\r\n \r\n s = [None] * (k+1)\r\n if 0 in bits_to_compute:\r\n s[0] = a[0] + b[0] - 2*c[0]\r\n bits_to_compute.remove(0)\r\n for i in bits_to_compute:\r\n s[i] = a[i] + b[i] + c[i-1] - 2*c[i]\r\n s[k] = c[k-1]\r\n return s","def addition_mod(a, b, nbr):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n binn = [int(x) for x in bin(nbr)[2:]]\n #print(binn)\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n while len(binn) < len(bina):\n binn = [0]+binn\n while len(binn) > len(bina):\n bina = [0]+bina\n binb = [0]+binb\n binn.reverse()\n bina.reverse()\n binb.reverse()\n #print(bina, binb, binn)\n n = len(bina)+len(binb)+len(binn)\n na = len(bina)\n nab = len(bina)+len(binb)\n q = QuantumRegister(n+2, 'q')\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binb)):\n if binb[i]:\n circ.x(q[na+i])\n for i in range(len(binn)):\n if binn[i]:\n circ.x(q[nab+i])\n addmod(circ, q, # A, B, lost, last, N, lost2, binn):\n [q[i] for i in range(len(bina))],\n [q[i+na] for i in range(len(binb)-1)],\n q[n],\n q[na+len(binb)-1],\n [q[i+nab] for i in range(len(binn))],\n q[n+1],\n binn)\n circ_m = measure(circ, q, [i for i in range(na,nab)])\n return circ_m","def _add(a, b):\n\n # Todo: What if numbers have bigger length than 8\n a = _I2B(a, fixed_length=8)\n b = _I2B(b, fixed_length=8)\n return _B2I([i ^ j for i, j in zip(a, b)])","def expFromAdd(a,b):\n\tif (b == 0):\n\t\treturn 1\n\tresult = 1\n\tfor c1 in range(0, b):\n\t\ttemp = 0\n\t\tfor c2 in range(0, a):\n\t\t\ttemp += result\n\t\tresult = temp\n\treturn result","def ff_add(a, b):\n return a ^ b","def getSum(self, a, b):\n result = 0\n carry = 0\n carry_on = {(0,0,0), (0,0,1), (1,0,0), (0,1,0)}\n\n for i in range(32):\n a_lsb = a & 1\n b_lsb = b & 1\n cur = a_lsb ^ b_lsb ^ carry\n carry = 0 if (a_lsb, b_lsb, carry) in carry_on else 1\n\n result |= cur << i\n a = a >> 1\n b = b >> 1\n # result is negative number\n if result >> 31 & 1 == 1:\n new_result = 0\n for i in range(32):\n result_lsb = result & 1\n new_bit = ~result_lsb & 1\n new_result |= new_bit << i\n\n result = result >> 1\n result = -(new_result + 1)\n return result","def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\n int]] = None,\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,\n num_shots: int = 100, use_param_program: bool = False,\n use_active_reset: bool = True, show_progress_bar: bool = False) \\\n -> Sequence[Sequence[Sequence[int]]]:\n if registers is None:\n registers = get_qubit_registers_for_adder(qc, n_bits, qubits)\n\n reset_prog = Program()\n if use_active_reset:\n reset_prog += RESET()\n\n add_prog = Program()\n if use_param_program:\n dummy_num = [0 for _ in range(n_bits)]\n add_prog = adder(dummy_num, dummy_num, *registers, in_x_basis=in_x_basis,\n use_param_program=True)\n\n all_results = []\n # loop over all binary strings of length n_bits\n for bits in tqdm(all_bitstrings(2 * n_bits), disable=not show_progress_bar):\n # split the binary number into two numbers\n # which are the binary numbers the user wants to add.\n # They are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bits[:n_bits]\n num_b = bits[n_bits:]\n\n if not use_param_program:\n add_prog = adder(num_a, num_b, *registers, in_x_basis=in_x_basis,\n use_param_program=False)\n\n prog = reset_prog + add_prog\n prog.wrap_in_numshots_loop(num_shots)\n nat_quil = qc.compiler.quil_to_native_quil(prog)\n exe = qc.compiler.native_quil_to_executable(nat_quil)\n\n if use_param_program:\n exe.write_memory(region_name=REG_NAME, value=bits)\n\n # Run it on the QPU or QVM\n results = qc.run(exe).readout_data.get('ro')\n all_results.append(results)\n\n return all_results","def add(a,b):\n if a == 0: return b\n elif b == 0: return a\n else: return add(a-1, b+1)","def add_bitwise(b1,b2):\n \n \n \n \n \n if b1 == \"\":\n \n return b2\n \n elif b2 == \"\":\n \n return b1\n \n elif b1 == \"\" and b2 == \"\":\n \n return \"\"\n \n elif b1 == \"1\" and b2 == \"1\":\n \n return \"10\"\n \n else: \n \n rest = add_bitwise(b1[:-1],b2[:-1])\n \n if len(b1) == len(b2): \n \n if b1[-1] == \"0\" and b2[-1] == \"0\":\n \n return rest + \"0\"\n \n elif b1[-1] == \"1\" and b2[-1] == \"0\":\n \n return rest + \"1\"\n \n elif b1[-1] == \"0\" and b2[-1] == \"1\":\n \n return rest + \"1\"\n \n \n elif b1[-1] == \"1\" and b2[-1] == \"1\" and len(b1) != 1 and len(b2) != 1:\n \n rest = add_bitwise(b1[:-1],b2[:-1])\n \n if rest == \"10\":\n \n rest = \"11\" \n \n elif rest == \"\":\n \n rest = \"10\"\n \n elif rest == \"1\":\n \n rest = \"10\"\n \n else: \n \n return \"1\" + rest \n \n return rest + \"0\"\n \n \n elif len(b1) > len(b2):\n \n b2_with_zeroes = \"0\"*(len(b1) - len(b2)) + b2\n \n return add_bitwise(b1,b2_with_zeroes) \n \n \n elif len(b2) > len(b1):\n \n b1_with_zeroes = \"0\"*(len(b2) - len(b1)) + b1\n \n return add_bitwise(b1_with_zeroes,b2)","def e_add(pub, a, b):\n return a * b % pub.n_sq","def soustraction(a,b):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n bina.reverse()\n binb.reverse()\n n = len(bina)+len(binb)\n na = len(bina)\n q = QuantumRegister(n+1, 'q')\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binb)):\n if binb[i]:\n circ.x(q[na+i])\n sub(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\n circ_m = measure(circ, q, [i for i in range(na, n)])\n return circ_m","def add(x, y):\n carry = \"\"\n result = \"\"\n carry = \"0\"\n for i in range(len(x) - 1, -1, -1):\n a = carry[0]\n b = x[i]\n c = y[i]\n\n if a == b and b == c and c == '0':\n result = \"0\" + result\n carry = \"0\"\n elif a == b and b == c and c == '1':\n result = \"1\" + result\n carry = \"1\"\n else:\n if a == '1' and b == c and c == '0':\n result = \"1\" + result\n carry = \"0\"\n elif a == '0' and b == '1' and c == '0':\n result = \"1\" + result\n carry = \"0\"\n elif a == '0' and b == '0' and c == '1':\n result = \"1\" + result\n carry = \"0\"\n elif a == '0' and b == '1' and c == '1':\n result = \"0\" + result\n carry = \"1\"\n elif a == '1' and b == '0' and c == '1':\n result = \"0\" + result\n carry = \"1\"\n elif a == '1' and b == '1' and c == '0':\n result = \"0\" + result\n carry = '1'\n return result","def add(a: int, b: int) -> int:\n if a == 0:\n return b\n elif b == 0:\n return a\n else: return add(a-1, b+1)","def __add__(self, tc): \n tc = TwosComplement(tc)\n bits = self.len if self.len > tc.len else tc.len \n result = self.int + tc.int\n return TwosComplement(result, bits)","def add(num1,num2):\n if(num2==0):\n return num1\n return add((num1^num2),(num1&num2)<<1)","def getSum(self, a: int, b: int) -> int:\n i = 0\n carry = 0\n res = 0\n while i < 12:\n curr_a_bit = (a >> i) & 1\n curr_b_bit = (b >> i) & 1\n # print(curr_a_bit, curr_b_bit)\n curr_bit = curr_a_bit ^ curr_b_bit ^ carry\n res |= (curr_bit << i)\n if curr_a_bit & curr_b_bit == 1 or curr_a_bit & carry == 1 or curr_b_bit & carry == 1:\n carry = 1\n else:\n carry = 0\n i += 1\n # print(res, bin(res), bin(a), bin(b))\n # 不用把 第 13 位 i = 12 时 carry 加上 result, 因为 这一位 判断 正 负 不需要\n if res >= 2 ** 11:\n # 举例：最大和2000 ，res < 2 ^ 11, 最小和 -2000， res > 2 ^ 11\n # 如果 和 是 0，比如 1 和 -1， res = 0\n # 如果和 是 -1，比如 1 和 -2， res > 2 ^ 11\n res = (~res) ^ 0b111111111111\n return res","def __add__(self, B):\n return (Polynomial(self) + B).simplify()","def addmul(a,b):\n return a*b+a*b","def Add(a, b):\n\tc = a + b\n\tRequire(c >= a)\n\treturn c","def add(a, b):\n c = Calculator()\n result = c.add(a, b)\n click.echo('{} + {} = {}'.format(a, b, result))","def instruction_add(self, register, a, b):\n if Vm.is_register(a):\n a = self.get_register(a)\n\n if Vm.is_register(b):\n b = self.get_register(b)\n\n result = ((a + b) % MAX_INT)\n\n self.set_register(register, ((a + b) % MAX_INT))","def _raw_add(self, e_a, e_b):\n return e_a * e_b % self.public_key.nsquare","def getSum(self, a, b):\n #\n # 首先，sum 存放每次循环中 a 与 b 的异或值，也就是直接相加值；\n # b 存放每次的进位值，然后 a 存储 sum （也就是直接相加值）进入下一次循环（当进位值非空）；\n # 当且仅当进位值为空时，用户的上一次循环中的 sum 已经是可以直接相加的异或结果了，此时得到结果，返回。\n #\n # if a == 0:\n # return b\n # if b == 0:\n # return a\n # while b != 0:\n # carry = a & b\n # a = a ^ b\n # b = carry << 1\n # return a\n # 32 bits interger max\n MAX = 0x7FFFFFFF\n # 32 bits interger min\n MIN = 0x80000000\n # mask to get last 32 bits\n mask = 0xFFFFFFFF\n\n #print('doc:', )\n while b != 0:\n a, b = (a ^ b) & mask, ((a & b) << 1) & mask\n\n return a if a <= MAX else ~(a ^ mask)","def add_wo_carry(n1, n2):\n l1 = [int(x) for x in str(n1)]\n l2 = [int(x) for x in str(n2)] \n res1 = map(operator.add, l1, l2)\n res2 = [str(x)[-1] for x in res1]\n return \"\".join(res2)","def add(num1, num2, Cin):\n Cin=0\n l2=[]\n final=\"\"\n\n \"\"\"Using for loop for starting addition from the last indexed number\"\"\"\n for i in range(len(num1)-1,-1,-1):\n bit1=num1[i]#storing each indexed() value of num1 in bit1\n bit2=num2[i]#storing each indexed() value of num2 in bit2\n S1=g.XOR(bit1, bit2)#calling XOR() method of gates module and passing value in it.\n S2=g.NAND(S1, Cin)#calling NAND() method of gates module and passing value in it.\n S3=g.OR(S1, Cin)#calling OR() method of gates module and passing value in it.\n SUM=g.AND(S2, S3)#calling AND() method of gates module and passing value in it.\n C1=g.AND(bit1, bit2)#calling AND() method of gates module and passing value in it.\n C2=g.AND(S1, Cin)#calling AND() method of gates module and passing value in it.\n C3=g.NOR(C1, C2)#calling NOR() method of gates module and passing value in it.\n Cout=g.NOT(C3)#calling NOT() method of gates module and passing value in it.\n Cin=Cout#declaring cout as cin for next bit addition\n l2.append(SUM)#adding SUM to l2\n l3=l2[::-1]##reversing the value of l2\n final+=str(l2[-1])#converting the list value to string\n final1=final[::-1]#reversing string value\n return final1 #returning the binary addition as string","def add(self, a, b):\n return a + b","def add( a, b ):\n return a + b","def add(a, b):\n if len(a) < len(b):\n aa = itertools.chain(reversed(a), itertools.repeat(0))\n bb = reversed(b)\n elif len(b) < len(a):\n bb = itertools.chain(reversed(b), itertools.repeat(0))\n aa = reversed(a)\n else:\n aa = reversed(a)\n bb = reversed(b)\n cc = _add_stream(aa, bb)\n return list(reversed(cc))","def add_binary(a, b):\n return bin(a + b)[2:]","def addition(a, b):\n pass","def addition(self, a, b):\n if not check_arguments(a, b): # check if arguments are numbers\n self.last_result = a + b","def __radd__(self,that):\n return self.__opExpand2(that,np.add)","def add(a,b):\n\treturn a+b","def add(a: PipeNumeric, b: PipeNumeric):\n assert a.get_type() == b.get_type()\n num_type = a.get_type()\n assert isinstance(num_type, num.SignedFixedNumberType) or isinstance(num_type, num.UnsignedIntegerNumberType)\n\n if isinstance(a, PipeConstant) and isinstance(b, PipeConstant):\n return PipeConstant(num_type, int(\n num_type.create_from_constant(a.get_value()) + num_type.create_from_constant(b.get_value())\n ))\n elif isinstance(a, PipeConstant) or isinstance(b, PipeConstant):\n if isinstance(a, PipeConstant):\n static_value = a.get_value()\n dynamic_value = b\n else:\n static_value = b.get_value()\n dynamic_value = a\n\n if static_value == 0:\n return dynamic_value\n\n node = OneCycleNode()\n\n node.add_inputs(a=a, b=b)\n res = PipeSignal(num_type, Signal(num_type.create()))\n node.add_output(res)\n node.set_name('{}-add'.format('fixed' if isinstance(num_type, num.SignedFixedNumberType) else 'integer'))\n node.set_logic(add_seq)\n\n return node","def add(a,b):\r\n return a+b","def loop_solution(self, a: str, b: str) -> str:\n res, carry, n = deque(), 0, max(len(a), len(b))\n for i in range(n):\n j1 = len(a) - i - 1\n j2 = len(b) - i - 1\n\n b1, b2 = 0, 0\n if 0 <= j1 < len(a):\n b1 = int(a[j1])\n if 0 <= j2 < len(b):\n b2 = int(b[j2])\n\n b3 = b1 + b2 + carry\n res.appendleft(str(b3 % 2))\n if b3 > 1:\n carry = 1\n else:\n carry = 0\n\n if carry:\n res.appendleft('1')\n return ''.join(res)","def __radd__(self, other):\n if other == 0:\n return self\n else:\n return self.__add__(other)","def __radd__(self, other):\n if other == 0:\n return self\n else:\n return self.__add__(other)","def add(a, b):\n return a + b","def add(a, b):\n return a + b","def add(a, b):\n return a + b","def add(a, b):\n return a + b","def add(a, b):\n return a + b","def add(a, b):\n return a + b","def ff_multiply(a, b):\n result = 0\n\n for i in range(8):\n if a == 0 or b == 0:\n break\n\n # If the rightmost bit of a is set, we can add b to the result\n if a & 1:\n result = ff_add(result, b)\n\n # Continuously move down the bits of a while updating b\n b = xtime(b)\n a >>= 1\n\n return result","def a_plus_abs_b(a, b):\n if b < 0:\n op = sub(a,b)\n else:\n op = add(a,b)\n return op","def add(a, b):\n return a+b","def add(self, other, carry=None):\n if carry is None:\n carry = TRIT_ZERO\n if carry == TRIT_ZERO:\n if self.value == ZERO:\n return (other, TRIT_ZERO)\n elif other.value == ZERO:\n return (self, TRIT_ZERO)\n elif self != other:\n return (TRIT_ZERO, TRIT_ZERO)\n else:\n return (-self, self)\n elif other.value == ZERO:\n return self.add(carry)\n elif self.value == ZERO:\n return other.add(carry)\n elif self != other:\n return (carry, TRIT_ZERO)\n elif self != carry:\n return (other, TRIT_ZERO)\n else:\n return (TRIT_ZERO, self)","def addition(a, b):\r\n\r\n result = a + b\r\n return result","def add_binary(a,b):\n max_len = max(len(a),len(b))\n a = a + (max_len-len(a))*'0'\n b = b + (max_len-len(b))*'0'\n result = \"\" \n elde = 0 \n for i in range(max_len):\n a_i,b_i = int(a[i]),int(b[i])\n if (a_i + b_i+elde) == 2:\n elde = 1\n t = 0\n else:\n t = (a_i + b_i+elde)%2\n result += str(t)\n if (i == max_len-1) and elde:\n result+=\"1\"\n return result[::-1]","def add(a,b):\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],1.0]","def add(a,b):\r\n result=a+b\r\n return result","def __radd__(self, other):\n return self + other","def __radd__(self, other):\n return self + other","def add_numbers(a,b):\r\n return a+ b","def _add_2_bit_oracle_without_ancilla_1_0(qc: QuantumCircuit, register: QuantumRegister) -> None:\n if len(list(register)) != 2:\n raise ValueError(f\"Need QuantumRegister with exactly 2 qubits, but got {len(list(register))} instead.\")\n\n qc.x(register[0])\n qc.cz(register[1], register[0])\n qc.x(register[0])","def add_no_carry(*args):\r\n num_digits = []\r\n\r\n for arg in args:\r\n num_digits.append(len(str(arg)))\r\n\r\n max_digits = max(num_digits)\r\n # list comprehension way\r\n # max_digits = max([len(str(arg)) for arg in args])\r\n final_sum = 0\r\n\r\n for pwr in range(1, max_digits + 1): # iterate through ea decimal\r\n result_no_carry = 0\r\n for arg in args:\r\n if len(str(arg)) >= pwr:\r\n # modulus sets the current decimal as the most significant\r\n # decimal\r\n # floor div selects the most significant decimal\r\n result_no_carry += arg % 10**pwr // 10**(pwr - 1)\r\n\r\n # list comprehension way\r\n # result_no_carry = sum([arg % 10**pwr // 10**(pwr - 1) for arg in args if len(str(arg)) >= pwr])\r\n\r\n # final_sum = str(result_no_carry % 10) + final_sum\r\n final_sum += result_no_carry % 10\r\n\r\n return int(final_sum)","def add(a,b):\n return a + b","def ab_plus_c(a, b, c):\n \"*** YOUR CODE HERE ***\"\n if a <= 0:\n return c\n else:\n return ab_plus_c(a - 1, b, 0) + b + c","def addition(a, b):\n return a + b","def _builtin_plus(a, b, c, **kwdargs):\n mode = check_mode((a, b, c), ['iii', 'iiv', 'ivi', 'vii'], functor='plus', **kwdargs)\n if mode == 0:\n a_v = int(a)\n b_v = int(b)\n c_v = int(c)\n if a_v + b_v == c_v:\n return [(a, b, c)]\n elif mode == 1:\n a_v = int(a)\n b_v = int(b)\n return [(a, b, Constant(a_v + b_v))]\n elif mode == 2:\n a_v = int(a)\n c_v = int(c)\n return [(a, Constant(c_v - a_v), c)]\n else:\n b_v = int(b)\n c_v = int(c)\n return [(Constant(c_v - b_v), b, c)]\n return []","def add(a, b):\n result = a+b\n return result","def addition_nocarry(a,b):\n result = bytearray()\n carry = 0\n for byte1, byte2 in zip(a,b):\n byte_res = (byte1+byte2+carry)\n #print(byte_res)\n if byte_res > 255:\n carry = 1\n result.append(byte_res%256)\n else:\n carry = 0\n result.append(byte_res)\n return(result)","def BitAdd(m, n, length):\n\n lmax = max(len(m), len(n))\n c = 0\n ml = [0] * (lmax - len(m)) + [int(x) for x in list(m)]\n nl = [0] * (lmax - len(n)) + [int(x) for x in list(n)]\n rl = []\n for i in range(1, lmax+1):\n if ml[-i] + nl[-i] + c == 0:\n rl.insert(0, 0)\n c = 0\n elif ml[-i] + nl[-i] + c == 1:\n rl.insert(0, 1)\n c = 0\n elif ml[-i] + nl[-i] + c == 2:\n rl.insert(0, 0)\n c = 1\n elif ml[-i] + nl[-i] + c == 3:\n rl.insert(0, 1)\n c = 1\n if c == 1:\n rl.insert(0, 1)\n if length > len(rl):\n rl = [0] * (length - len(rl)) + rl\n else:\n rl = rl[-length:]\n rl = \"\".join([str(x) for x in rl])\n return rl","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def math_add():\n a = int(request.args.get(\"a\"))\n b = int(request.args.get(\"b\"))\n return str(add(a, b))","def increment(b): \n if b == 11111111:\n return 00000000\n else:\n b = bin_to_dec(b)\n b = b + 1\n res = dec_to_bin (b)\n if len(res) == 8:\n return res\n else:\n c = 8 - len(res)\n return c*'0' + res","def __add__(self, other: 'SInt') -> 'SInt':\r\n # Recoding the addition\r\n if type(other) != self.__class__ or len(self) != len(other):\r\n raise TypeError(\"Wrong type or length for other\")\r\n retenue = [0 for i in range(len(self) + 1)]\r\n new_bin = ''\r\n for i in range(len(self)):\r\n k = int(self.binaire[-(i + 1)]) + int(other.binaire[-(i + 1)]) + retenue[i]\r\n new_bin = ['0', '1', '0', '1'][k] + new_bin\r\n retenue[i + 1] = 1 if k > 1 else 0\r\n if self.signe == other.signe and retenue[-1] != retenue[-2]:\r\n raise OverflowError(\"The sum is over the bytes available\")\r\n H = self.__class__(self.nbBytes)\r\n H.binaire = new_bin\r\n return H","def Add(p, q):\n return p*q","def add64(a,b):\n return(np.add(a, b, dtype=np.uint64))","def add(a,b):\n s = a+b\n return s","def ADD (self, n1, n2):","def _add_2_bit_oracle_with_ancilla_1_0(qc: QuantumCircuit, register: QuantumRegister, ancilla: Qubit) -> None:\n if len(list(register)) != 2:\n raise ValueError(f\"Need QuantumRegister with exactly 2 qubits, but got {len(list(register))} instead.\")\n\n qc.x(register[0])\n qc.ccx(register[1], register[0], ancilla)\n qc.x(register[0])","def add(a,b):\n print('submul = {}'.format(diff.submul(a,b)) ) # first method\n # print('diff = {}'.format(sub(a,b)) ) # second method\n return a+b","def __iadd__(self, B):\n m, n = self.shape\n try:\n k, r = B.shape\n except AttributeError: # treat B as constant\n c = mpfr(B)\n for i in range(m):\n for j in range(n):\n self[i, j] += c\n return self\n assert (m == k\n and n == r), (\"Cannot add shapes ({}, {}) and ({}, {})\".format(\n m, n, k, r))\n for i in range(m):\n for j in range(n):\n self[i, j] += B[i, j]\n return self","def addBinary(self, a: str, b: str) -> str:\n return self.bit_manipulation(a, b)","def addition(a,b):\n return a+b","def andbits(num1,num2):\n thingstoadd=[]\n for i in range(31):\n bit1=setbit(num1,i)\n bit2=setbit(num2,i)\n bit1=shiftleft(bit1,30 - i)\n bit2=shiftleft(bit2,30 - i)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n bitsum=shiftright(bitsum,31 - i)\n thingstoadd.append(bitsum)\n bit1=setbit(num1,31)\n bit2=setbit(num2,31)\n bit1=shiftright(bit1,1)\n bit2=shiftright(bit2,1)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n thingstoadd.append(bitsum)\n return sum(thingstoadd)","def _add(self, i, k):\n while i < self._size:\n self._bit[i] += k\n i += lsb(i)","def __iadd__(self, other):\n\n return self + other","def add_quad(a, b):\n s = np.sqrt(np.square(a) + np.square(b))\n return s","def __add__(self, other)\n \n def __mul__(self, other):\n print(\"Standard multiplication with\", other.which)\n print(other.which)\n \n if isinstance(other, int):\n print(\"Other is int\")\n self.coefficients *= other\n \n return self\n \n else:\n print(\"Other operator is spin operator\")\n summandsNew = []\n coeffsNew = []\n for otherSummandIndex, otherSummand in enumerate(other.summands):\n for thisSummandIndex, thisSummand in enumerate(self.summands):\n summandsNew.append(flatten([thisSummand, otherSummand]))\n coeffsNew.append(self.coefficients[thisSummandIndex]*other.coefficients[otherSummandIndex])\n print(summandsNew) \n self.coeffs = coeffsNew\n self.summands = summandsNew\n \n return self","def __radd__(self, other):\n return self.runtime.add(self, other)","def mult_mod(a, b, nbr, control):\n bina = [int(x) for x in bin(a)[2:]]\n # binb = [int(x) for x in bin(b)[2:]]\n binn = [int(x) for x in bin(nbr)[2:]]\n while len(binn) < len(bina):\n binn = [0]+binn\n # print(bina, binn)\n binn.reverse()\n bina.reverse()\n n = len(bina)+len(binn)*3+1\n na = len(bina)\n nan = len(bina)+len(binn) # debut de Y\n nany = len(bina)+2*len(binn)+1 # debut de \"A\" (ici c'est b)\n q = QuantumRegister(n+2+1, 'q') # +lost+lost2+control\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binn)):\n if binn[i]:\n circ.x(q[na+i])\n if control:\n circ.x(q[n+2])\n cmultmod(circ, q, # control, X, a, A, Y, n, N, binn, lost, lost2\n q[n+2],\n [q[i] for i in range(len(bina))],\n b,\n [q[i+nany] for i in range(len(binn))],\n [q[i+nan] for i in range(len(binn)+1)],\n nbr,\n [q[i+na] for i in range(len(binn))],\n binn,\n q[n],\n q[n+1])\n circ_m = measure(circ, q, [i for i in range(nan,nany)])\n return circ_m","def __radd__(self, other):\n\n return self.__add__(other)","def suma(a, b):\n\n\ttotal = a + b\n\treturn total","def add_sub_dsp(a, b, *, t=None, quantization=Quantization.TRUNCATE, overflow=Overflow.WRAP_AROUND, latency=0,\n operation=Operation.ADD):\n\n if operation == Operation.ADD:\n sum_diff = a + b\n elif operation == Operation.SUB:\n sum_diff = a - b\n else:\n raise Exception(f\"Parameter operation has to be chosen from Operation.ADD|SUB\")\n\n latency_iter = latency\n\n if t is None:\n res = sum_diff\n elif typeof(t, Integer):\n\n if latency_iter:\n pipe_len = ceil_div(latency_iter, 3)\n sum_diff = sum_diff | pipeline(length=pipe_len)\n latency_iter -= pipe_len\n\n if typeof(sum_diff.dtype, Integer):\n quant_sum_diff = sum_diff\n elif typeof(sum_diff.dtype, Fixpnumber):\n if quantization == Quantization.TRUNCATE:\n quant_sum_diff = cast(sum_diff, t=t)\n elif quantization == Quantization.ROUND:\n quant_sum_diff = qround(sum_diff)\n else:\n raise Exception(f\"Parameter quantization has to be chosen from Quantization.TRUNCATE|ROUND\")\n else:\n raise Exception('t has to be either Integer or Fixpnumber')\n\n if latency_iter:\n pipe_len = ceil_div(latency_iter, 2)\n quant_sum_diff = quant_sum_diff | pipeline(length=pipe_len)\n latency_iter -= pipe_len\n\n if overflow == Overflow.WRAP_AROUND:\n res = trunc(quant_sum_diff, t=t)\n elif overflow == Overflow.SATURATE:\n res = saturate(quant_sum_diff, t=t)\n else:\n raise Exception(f\"Parameter overflow has to be chosen from Overflow.WRAP_AROUND|SATURATE\")\n elif type(t, Fixpnumber):\n\n if latency_iter:\n pipe_len = ceil_div(latency_iter, 3)\n sum_diff = sum_diff | pipeline(length=pipe_len)\n latency_iter -= pipe_len\n\n if quantization == Quantization.TRUNCATE:\n quant_sum_diff = trunc(sum_diff, t=t.base[sum_diff.dtype.integer, sum_diff.dtype.integer + t.fract])\n elif quantization == Quantization.ROUND:\n quant_sum_diff = qround(sum_diff, fract=t.fract)\n else:\n raise Exception(f\"Parameter quantization has to be chosen from Quantization.TRUNCATE|ROUND\")\n\n if latency_iter:\n pipe_len = ceil_div(latency_iter, 2)\n quant_sum_diff = quant_sum_diff | pipeline(length=pipe_len)\n latency_iter -= pipe_len\n\n if overflow == Overflow.WRAP_AROUND:\n res = trunc(quant_sum_diff, t=t)\n elif overflow == Overflow.SATURATE:\n res = saturate(quant_sum_diff, t=t)\n else:\n raise Exception(f\"Parameter overflow has to be chosen from Overflow.WRAP_AROUND|SATURATE\")\n else:\n raise Exception('t has to be either Integer or Fixpnumber')\n\n if latency_iter:\n return res | pipeline(length=latency_iter)\n else:\n return res","def funky_sum(a, b, mix):\n if mix <= 0:\n return a\n elif mix >= 1:\n return b\n else:\n return (1 - mix) * a + mix * b","def enc_add(pub, m1, m2):\n add_result = m1 * m2 % pub.n_sq\n return add_result","def a_plus_abs_b(a, b):\n if b < 0:\n f = sub(a,b)\n else:\n f = add(a,b)\n return f","def sum(self, a, b):\n return int(a) + int(b)","def add(a: int, b, c=5, d=7., e=None):\n if e is None:\n e = 0\n return a + b + c + d + e"],"string":"[\n \"def addition(a, b):\\n bina = [int(x) for x in bin(a)[2:]]\\n binb = [int(x) for x in bin(b)[2:]]\\n while len(bina) >= len(binb):\\n binb = [0]+binb\\n while len(bina) < len(binb)-1:\\n bina = [0]+bina\\n bina.reverse()\\n binb.reverse()\\n n = len(bina)+len(binb)\\n na = len(bina)\\n q = QuantumRegister(n+1, 'q')\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binb)):\\n if binb[i]:\\n circ.x(q[na+i])\\n add(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\\n circ_m = measure(circ, q, [i for i in range(na, n)])\\n return circ_m\",\n \"def addition_o(a, b):\\n bina = [int(x) for x in bin(a)[2:]]\\n binb = [int(x) for x in bin(b)[2:]]\\n while len(bina) >= len(binb):\\n binb = [0]+binb\\n while len(bina) < len(binb)-1:\\n bina = [0]+bina\\n bina.reverse()\\n binb.reverse()\\n n = len(bina)+len(binb)\\n na = len(bina)\\n q = QuantumRegister(n+1, 'q')\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binb)):\\n if binb[i]:\\n circ.x(q[na+i])\\n add_o(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\\n circ_m = measure(circ, q, [i for i in range(na, n)])\\n return circ_m\",\n \"def BitAdd(a, b, bits_to_compute=None):\\r\\n k = len(a)\\r\\n if not bits_to_compute:\\r\\n bits_to_compute = list(range(k))\\r\\n d = [None] * k\\r\\n for i in range(1,k):\\r\\n t = a[i]*b[i]\\r\\n d[i] = (a[i] + b[i] - 2*t, t)\\r\\n d[0] = (None, a[0]*b[0])\\r\\n pg = PreOpL(carry, d)\\r\\n c = [pair[1] for pair in pg]\\r\\n \\r\\n s = [None] * (k+1)\\r\\n if 0 in bits_to_compute:\\r\\n s[0] = a[0] + b[0] - 2*c[0]\\r\\n bits_to_compute.remove(0)\\r\\n for i in bits_to_compute:\\r\\n s[i] = a[i] + b[i] + c[i-1] - 2*c[i]\\r\\n s[k] = c[k-1]\\r\\n return s\",\n \"def addition_mod(a, b, nbr):\\n bina = [int(x) for x in bin(a)[2:]]\\n binb = [int(x) for x in bin(b)[2:]]\\n binn = [int(x) for x in bin(nbr)[2:]]\\n #print(binn)\\n while len(bina) >= len(binb):\\n binb = [0]+binb\\n while len(bina) < len(binb)-1:\\n bina = [0]+bina\\n while len(binn) < len(bina):\\n binn = [0]+binn\\n while len(binn) > len(bina):\\n bina = [0]+bina\\n binb = [0]+binb\\n binn.reverse()\\n bina.reverse()\\n binb.reverse()\\n #print(bina, binb, binn)\\n n = len(bina)+len(binb)+len(binn)\\n na = len(bina)\\n nab = len(bina)+len(binb)\\n q = QuantumRegister(n+2, 'q')\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binb)):\\n if binb[i]:\\n circ.x(q[na+i])\\n for i in range(len(binn)):\\n if binn[i]:\\n circ.x(q[nab+i])\\n addmod(circ, q, # A, B, lost, last, N, lost2, binn):\\n [q[i] for i in range(len(bina))],\\n [q[i+na] for i in range(len(binb)-1)],\\n q[n],\\n q[na+len(binb)-1],\\n [q[i+nab] for i in range(len(binn))],\\n q[n+1],\\n binn)\\n circ_m = measure(circ, q, [i for i in range(na,nab)])\\n return circ_m\",\n \"def _add(a, b):\\n\\n # Todo: What if numbers have bigger length than 8\\n a = _I2B(a, fixed_length=8)\\n b = _I2B(b, fixed_length=8)\\n return _B2I([i ^ j for i, j in zip(a, b)])\",\n \"def expFromAdd(a,b):\\n\\tif (b == 0):\\n\\t\\treturn 1\\n\\tresult = 1\\n\\tfor c1 in range(0, b):\\n\\t\\ttemp = 0\\n\\t\\tfor c2 in range(0, a):\\n\\t\\t\\ttemp += result\\n\\t\\tresult = temp\\n\\treturn result\",\n \"def ff_add(a, b):\\n return a ^ b\",\n \"def getSum(self, a, b):\\n result = 0\\n carry = 0\\n carry_on = {(0,0,0), (0,0,1), (1,0,0), (0,1,0)}\\n\\n for i in range(32):\\n a_lsb = a & 1\\n b_lsb = b & 1\\n cur = a_lsb ^ b_lsb ^ carry\\n carry = 0 if (a_lsb, b_lsb, carry) in carry_on else 1\\n\\n result |= cur << i\\n a = a >> 1\\n b = b >> 1\\n # result is negative number\\n if result >> 31 & 1 == 1:\\n new_result = 0\\n for i in range(32):\\n result_lsb = result & 1\\n new_bit = ~result_lsb & 1\\n new_result |= new_bit << i\\n\\n result = result >> 1\\n result = -(new_result + 1)\\n return result\",\n \"def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\\n int]] = None,\\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,\\n num_shots: int = 100, use_param_program: bool = False,\\n use_active_reset: bool = True, show_progress_bar: bool = False) \\\\\\n -> Sequence[Sequence[Sequence[int]]]:\\n if registers is None:\\n registers = get_qubit_registers_for_adder(qc, n_bits, qubits)\\n\\n reset_prog = Program()\\n if use_active_reset:\\n reset_prog += RESET()\\n\\n add_prog = Program()\\n if use_param_program:\\n dummy_num = [0 for _ in range(n_bits)]\\n add_prog = adder(dummy_num, dummy_num, *registers, in_x_basis=in_x_basis,\\n use_param_program=True)\\n\\n all_results = []\\n # loop over all binary strings of length n_bits\\n for bits in tqdm(all_bitstrings(2 * n_bits), disable=not show_progress_bar):\\n # split the binary number into two numbers\\n # which are the binary numbers the user wants to add.\\n # They are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\\n num_a = bits[:n_bits]\\n num_b = bits[n_bits:]\\n\\n if not use_param_program:\\n add_prog = adder(num_a, num_b, *registers, in_x_basis=in_x_basis,\\n use_param_program=False)\\n\\n prog = reset_prog + add_prog\\n prog.wrap_in_numshots_loop(num_shots)\\n nat_quil = qc.compiler.quil_to_native_quil(prog)\\n exe = qc.compiler.native_quil_to_executable(nat_quil)\\n\\n if use_param_program:\\n exe.write_memory(region_name=REG_NAME, value=bits)\\n\\n # Run it on the QPU or QVM\\n results = qc.run(exe).readout_data.get('ro')\\n all_results.append(results)\\n\\n return all_results\",\n \"def add(a,b):\\n if a == 0: return b\\n elif b == 0: return a\\n else: return add(a-1, b+1)\",\n \"def add_bitwise(b1,b2):\\n \\n \\n \\n \\n \\n if b1 == \\\"\\\":\\n \\n return b2\\n \\n elif b2 == \\\"\\\":\\n \\n return b1\\n \\n elif b1 == \\\"\\\" and b2 == \\\"\\\":\\n \\n return \\\"\\\"\\n \\n elif b1 == \\\"1\\\" and b2 == \\\"1\\\":\\n \\n return \\\"10\\\"\\n \\n else: \\n \\n rest = add_bitwise(b1[:-1],b2[:-1])\\n \\n if len(b1) == len(b2): \\n \\n if b1[-1] == \\\"0\\\" and b2[-1] == \\\"0\\\":\\n \\n return rest + \\\"0\\\"\\n \\n elif b1[-1] == \\\"1\\\" and b2[-1] == \\\"0\\\":\\n \\n return rest + \\\"1\\\"\\n \\n elif b1[-1] == \\\"0\\\" and b2[-1] == \\\"1\\\":\\n \\n return rest + \\\"1\\\"\\n \\n \\n elif b1[-1] == \\\"1\\\" and b2[-1] == \\\"1\\\" and len(b1) != 1 and len(b2) != 1:\\n \\n rest = add_bitwise(b1[:-1],b2[:-1])\\n \\n if rest == \\\"10\\\":\\n \\n rest = \\\"11\\\" \\n \\n elif rest == \\\"\\\":\\n \\n rest = \\\"10\\\"\\n \\n elif rest == \\\"1\\\":\\n \\n rest = \\\"10\\\"\\n \\n else: \\n \\n return \\\"1\\\" + rest \\n \\n return rest + \\\"0\\\"\\n \\n \\n elif len(b1) > len(b2):\\n \\n b2_with_zeroes = \\\"0\\\"*(len(b1) - len(b2)) + b2\\n \\n return add_bitwise(b1,b2_with_zeroes) \\n \\n \\n elif len(b2) > len(b1):\\n \\n b1_with_zeroes = \\\"0\\\"*(len(b2) - len(b1)) + b1\\n \\n return add_bitwise(b1_with_zeroes,b2)\",\n \"def e_add(pub, a, b):\\n return a * b % pub.n_sq\",\n \"def soustraction(a,b):\\n bina = [int(x) for x in bin(a)[2:]]\\n binb = [int(x) for x in bin(b)[2:]]\\n while len(bina) >= len(binb):\\n binb = [0]+binb\\n while len(bina) < len(binb)-1:\\n bina = [0]+bina\\n bina.reverse()\\n binb.reverse()\\n n = len(bina)+len(binb)\\n na = len(bina)\\n q = QuantumRegister(n+1, 'q')\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binb)):\\n if binb[i]:\\n circ.x(q[na+i])\\n sub(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\\n circ_m = measure(circ, q, [i for i in range(na, n)])\\n return circ_m\",\n \"def add(x, y):\\n carry = \\\"\\\"\\n result = \\\"\\\"\\n carry = \\\"0\\\"\\n for i in range(len(x) - 1, -1, -1):\\n a = carry[0]\\n b = x[i]\\n c = y[i]\\n\\n if a == b and b == c and c == '0':\\n result = \\\"0\\\" + result\\n carry = \\\"0\\\"\\n elif a == b and b == c and c == '1':\\n result = \\\"1\\\" + result\\n carry = \\\"1\\\"\\n else:\\n if a == '1' and b == c and c == '0':\\n result = \\\"1\\\" + result\\n carry = \\\"0\\\"\\n elif a == '0' and b == '1' and c == '0':\\n result = \\\"1\\\" + result\\n carry = \\\"0\\\"\\n elif a == '0' and b == '0' and c == '1':\\n result = \\\"1\\\" + result\\n carry = \\\"0\\\"\\n elif a == '0' and b == '1' and c == '1':\\n result = \\\"0\\\" + result\\n carry = \\\"1\\\"\\n elif a == '1' and b == '0' and c == '1':\\n result = \\\"0\\\" + result\\n carry = \\\"1\\\"\\n elif a == '1' and b == '1' and c == '0':\\n result = \\\"0\\\" + result\\n carry = '1'\\n return result\",\n \"def add(a: int, b: int) -> int:\\n if a == 0:\\n return b\\n elif b == 0:\\n return a\\n else: return add(a-1, b+1)\",\n \"def __add__(self, tc): \\n tc = TwosComplement(tc)\\n bits = self.len if self.len > tc.len else tc.len \\n result = self.int + tc.int\\n return TwosComplement(result, bits)\",\n \"def add(num1,num2):\\n if(num2==0):\\n return num1\\n return add((num1^num2),(num1&num2)<<1)\",\n \"def getSum(self, a: int, b: int) -> int:\\n i = 0\\n carry = 0\\n res = 0\\n while i < 12:\\n curr_a_bit = (a >> i) & 1\\n curr_b_bit = (b >> i) & 1\\n # print(curr_a_bit, curr_b_bit)\\n curr_bit = curr_a_bit ^ curr_b_bit ^ carry\\n res |= (curr_bit << i)\\n if curr_a_bit & curr_b_bit == 1 or curr_a_bit & carry == 1 or curr_b_bit & carry == 1:\\n carry = 1\\n else:\\n carry = 0\\n i += 1\\n # print(res, bin(res), bin(a), bin(b))\\n # 不用把 第 13 位 i = 12 时 carry 加上 result, 因为 这一位 判断 正 负 不需要\\n if res >= 2 ** 11:\\n # 举例：最大和2000 ，res < 2 ^ 11, 最小和 -2000， res > 2 ^ 11\\n # 如果 和 是 0，比如 1 和 -1， res = 0\\n # 如果和 是 -1，比如 1 和 -2， res > 2 ^ 11\\n res = (~res) ^ 0b111111111111\\n return res\",\n \"def __add__(self, B):\\n return (Polynomial(self) + B).simplify()\",\n \"def addmul(a,b):\\n return a*b+a*b\",\n \"def Add(a, b):\\n\\tc = a + b\\n\\tRequire(c >= a)\\n\\treturn c\",\n \"def add(a, b):\\n c = Calculator()\\n result = c.add(a, b)\\n click.echo('{} + {} = {}'.format(a, b, result))\",\n \"def instruction_add(self, register, a, b):\\n if Vm.is_register(a):\\n a = self.get_register(a)\\n\\n if Vm.is_register(b):\\n b = self.get_register(b)\\n\\n result = ((a + b) % MAX_INT)\\n\\n self.set_register(register, ((a + b) % MAX_INT))\",\n \"def _raw_add(self, e_a, e_b):\\n return e_a * e_b % self.public_key.nsquare\",\n \"def getSum(self, a, b):\\n #\\n # 首先，sum 存放每次循环中 a 与 b 的异或值，也就是直接相加值；\\n # b 存放每次的进位值，然后 a 存储 sum （也就是直接相加值）进入下一次循环（当进位值非空）；\\n # 当且仅当进位值为空时，用户的上一次循环中的 sum 已经是可以直接相加的异或结果了，此时得到结果，返回。\\n #\\n # if a == 0:\\n # return b\\n # if b == 0:\\n # return a\\n # while b != 0:\\n # carry = a & b\\n # a = a ^ b\\n # b = carry << 1\\n # return a\\n # 32 bits interger max\\n MAX = 0x7FFFFFFF\\n # 32 bits interger min\\n MIN = 0x80000000\\n # mask to get last 32 bits\\n mask = 0xFFFFFFFF\\n\\n #print('doc:', )\\n while b != 0:\\n a, b = (a ^ b) & mask, ((a & b) << 1) & mask\\n\\n return a if a <= MAX else ~(a ^ mask)\",\n \"def add_wo_carry(n1, n2):\\n l1 = [int(x) for x in str(n1)]\\n l2 = [int(x) for x in str(n2)] \\n res1 = map(operator.add, l1, l2)\\n res2 = [str(x)[-1] for x in res1]\\n return \\\"\\\".join(res2)\",\n \"def add(num1, num2, Cin):\\n Cin=0\\n l2=[]\\n final=\\\"\\\"\\n\\n \\\"\\\"\\\"Using for loop for starting addition from the last indexed number\\\"\\\"\\\"\\n for i in range(len(num1)-1,-1,-1):\\n bit1=num1[i]#storing each indexed() value of num1 in bit1\\n bit2=num2[i]#storing each indexed() value of num2 in bit2\\n S1=g.XOR(bit1, bit2)#calling XOR() method of gates module and passing value in it.\\n S2=g.NAND(S1, Cin)#calling NAND() method of gates module and passing value in it.\\n S3=g.OR(S1, Cin)#calling OR() method of gates module and passing value in it.\\n SUM=g.AND(S2, S3)#calling AND() method of gates module and passing value in it.\\n C1=g.AND(bit1, bit2)#calling AND() method of gates module and passing value in it.\\n C2=g.AND(S1, Cin)#calling AND() method of gates module and passing value in it.\\n C3=g.NOR(C1, C2)#calling NOR() method of gates module and passing value in it.\\n Cout=g.NOT(C3)#calling NOT() method of gates module and passing value in it.\\n Cin=Cout#declaring cout as cin for next bit addition\\n l2.append(SUM)#adding SUM to l2\\n l3=l2[::-1]##reversing the value of l2\\n final+=str(l2[-1])#converting the list value to string\\n final1=final[::-1]#reversing string value\\n return final1 #returning the binary addition as string\",\n \"def add(self, a, b):\\n return a + b\",\n \"def add( a, b ):\\n return a + b\",\n \"def add(a, b):\\n if len(a) < len(b):\\n aa = itertools.chain(reversed(a), itertools.repeat(0))\\n bb = reversed(b)\\n elif len(b) < len(a):\\n bb = itertools.chain(reversed(b), itertools.repeat(0))\\n aa = reversed(a)\\n else:\\n aa = reversed(a)\\n bb = reversed(b)\\n cc = _add_stream(aa, bb)\\n return list(reversed(cc))\",\n \"def add_binary(a, b):\\n return bin(a + b)[2:]\",\n \"def addition(a, b):\\n pass\",\n \"def addition(self, a, b):\\n if not check_arguments(a, b): # check if arguments are numbers\\n self.last_result = a + b\",\n \"def __radd__(self,that):\\n return self.__opExpand2(that,np.add)\",\n \"def add(a,b):\\n\\treturn a+b\",\n \"def add(a: PipeNumeric, b: PipeNumeric):\\n assert a.get_type() == b.get_type()\\n num_type = a.get_type()\\n assert isinstance(num_type, num.SignedFixedNumberType) or isinstance(num_type, num.UnsignedIntegerNumberType)\\n\\n if isinstance(a, PipeConstant) and isinstance(b, PipeConstant):\\n return PipeConstant(num_type, int(\\n num_type.create_from_constant(a.get_value()) + num_type.create_from_constant(b.get_value())\\n ))\\n elif isinstance(a, PipeConstant) or isinstance(b, PipeConstant):\\n if isinstance(a, PipeConstant):\\n static_value = a.get_value()\\n dynamic_value = b\\n else:\\n static_value = b.get_value()\\n dynamic_value = a\\n\\n if static_value == 0:\\n return dynamic_value\\n\\n node = OneCycleNode()\\n\\n node.add_inputs(a=a, b=b)\\n res = PipeSignal(num_type, Signal(num_type.create()))\\n node.add_output(res)\\n node.set_name('{}-add'.format('fixed' if isinstance(num_type, num.SignedFixedNumberType) else 'integer'))\\n node.set_logic(add_seq)\\n\\n return node\",\n \"def add(a,b):\\r\\n return a+b\",\n \"def loop_solution(self, a: str, b: str) -> str:\\n res, carry, n = deque(), 0, max(len(a), len(b))\\n for i in range(n):\\n j1 = len(a) - i - 1\\n j2 = len(b) - i - 1\\n\\n b1, b2 = 0, 0\\n if 0 <= j1 < len(a):\\n b1 = int(a[j1])\\n if 0 <= j2 < len(b):\\n b2 = int(b[j2])\\n\\n b3 = b1 + b2 + carry\\n res.appendleft(str(b3 % 2))\\n if b3 > 1:\\n carry = 1\\n else:\\n carry = 0\\n\\n if carry:\\n res.appendleft('1')\\n return ''.join(res)\",\n \"def __radd__(self, other):\\n if other == 0:\\n return self\\n else:\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n if other == 0:\\n return self\\n else:\\n return self.__add__(other)\",\n \"def add(a, b):\\n return a + b\",\n \"def add(a, b):\\n return a + b\",\n \"def add(a, b):\\n return a + b\",\n \"def add(a, b):\\n return a + b\",\n \"def add(a, b):\\n return a + b\",\n \"def add(a, b):\\n return a + b\",\n \"def ff_multiply(a, b):\\n result = 0\\n\\n for i in range(8):\\n if a == 0 or b == 0:\\n break\\n\\n # If the rightmost bit of a is set, we can add b to the result\\n if a & 1:\\n result = ff_add(result, b)\\n\\n # Continuously move down the bits of a while updating b\\n b = xtime(b)\\n a >>= 1\\n\\n return result\",\n \"def a_plus_abs_b(a, b):\\n if b < 0:\\n op = sub(a,b)\\n else:\\n op = add(a,b)\\n return op\",\n \"def add(a, b):\\n return a+b\",\n \"def add(self, other, carry=None):\\n if carry is None:\\n carry = TRIT_ZERO\\n if carry == TRIT_ZERO:\\n if self.value == ZERO:\\n return (other, TRIT_ZERO)\\n elif other.value == ZERO:\\n return (self, TRIT_ZERO)\\n elif self != other:\\n return (TRIT_ZERO, TRIT_ZERO)\\n else:\\n return (-self, self)\\n elif other.value == ZERO:\\n return self.add(carry)\\n elif self.value == ZERO:\\n return other.add(carry)\\n elif self != other:\\n return (carry, TRIT_ZERO)\\n elif self != carry:\\n return (other, TRIT_ZERO)\\n else:\\n return (TRIT_ZERO, self)\",\n \"def addition(a, b):\\r\\n\\r\\n result = a + b\\r\\n return result\",\n \"def add_binary(a,b):\\n max_len = max(len(a),len(b))\\n a = a + (max_len-len(a))*'0'\\n b = b + (max_len-len(b))*'0'\\n result = \\\"\\\" \\n elde = 0 \\n for i in range(max_len):\\n a_i,b_i = int(a[i]),int(b[i])\\n if (a_i + b_i+elde) == 2:\\n elde = 1\\n t = 0\\n else:\\n t = (a_i + b_i+elde)%2\\n result += str(t)\\n if (i == max_len-1) and elde:\\n result+=\\\"1\\\"\\n return result[::-1]\",\n \"def add(a,b):\\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],1.0]\",\n \"def add(a,b):\\r\\n result=a+b\\r\\n return result\",\n \"def __radd__(self, other):\\n return self + other\",\n \"def __radd__(self, other):\\n return self + other\",\n \"def add_numbers(a,b):\\r\\n return a+ b\",\n \"def _add_2_bit_oracle_without_ancilla_1_0(qc: QuantumCircuit, register: QuantumRegister) -> None:\\n if len(list(register)) != 2:\\n raise ValueError(f\\\"Need QuantumRegister with exactly 2 qubits, but got {len(list(register))} instead.\\\")\\n\\n qc.x(register[0])\\n qc.cz(register[1], register[0])\\n qc.x(register[0])\",\n \"def add_no_carry(*args):\\r\\n num_digits = []\\r\\n\\r\\n for arg in args:\\r\\n num_digits.append(len(str(arg)))\\r\\n\\r\\n max_digits = max(num_digits)\\r\\n # list comprehension way\\r\\n # max_digits = max([len(str(arg)) for arg in args])\\r\\n final_sum = 0\\r\\n\\r\\n for pwr in range(1, max_digits + 1): # iterate through ea decimal\\r\\n result_no_carry = 0\\r\\n for arg in args:\\r\\n if len(str(arg)) >= pwr:\\r\\n # modulus sets the current decimal as the most significant\\r\\n # decimal\\r\\n # floor div selects the most significant decimal\\r\\n result_no_carry += arg % 10**pwr // 10**(pwr - 1)\\r\\n\\r\\n # list comprehension way\\r\\n # result_no_carry = sum([arg % 10**pwr // 10**(pwr - 1) for arg in args if len(str(arg)) >= pwr])\\r\\n\\r\\n # final_sum = str(result_no_carry % 10) + final_sum\\r\\n final_sum += result_no_carry % 10\\r\\n\\r\\n return int(final_sum)\",\n \"def add(a,b):\\n return a + b\",\n \"def ab_plus_c(a, b, c):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if a <= 0:\\n return c\\n else:\\n return ab_plus_c(a - 1, b, 0) + b + c\",\n \"def addition(a, b):\\n return a + b\",\n \"def _builtin_plus(a, b, c, **kwdargs):\\n mode = check_mode((a, b, c), ['iii', 'iiv', 'ivi', 'vii'], functor='plus', **kwdargs)\\n if mode == 0:\\n a_v = int(a)\\n b_v = int(b)\\n c_v = int(c)\\n if a_v + b_v == c_v:\\n return [(a, b, c)]\\n elif mode == 1:\\n a_v = int(a)\\n b_v = int(b)\\n return [(a, b, Constant(a_v + b_v))]\\n elif mode == 2:\\n a_v = int(a)\\n c_v = int(c)\\n return [(a, Constant(c_v - a_v), c)]\\n else:\\n b_v = int(b)\\n c_v = int(c)\\n return [(Constant(c_v - b_v), b, c)]\\n return []\",\n \"def add(a, b):\\n result = a+b\\n return result\",\n \"def addition_nocarry(a,b):\\n result = bytearray()\\n carry = 0\\n for byte1, byte2 in zip(a,b):\\n byte_res = (byte1+byte2+carry)\\n #print(byte_res)\\n if byte_res > 255:\\n carry = 1\\n result.append(byte_res%256)\\n else:\\n carry = 0\\n result.append(byte_res)\\n return(result)\",\n \"def BitAdd(m, n, length):\\n\\n lmax = max(len(m), len(n))\\n c = 0\\n ml = [0] * (lmax - len(m)) + [int(x) for x in list(m)]\\n nl = [0] * (lmax - len(n)) + [int(x) for x in list(n)]\\n rl = []\\n for i in range(1, lmax+1):\\n if ml[-i] + nl[-i] + c == 0:\\n rl.insert(0, 0)\\n c = 0\\n elif ml[-i] + nl[-i] + c == 1:\\n rl.insert(0, 1)\\n c = 0\\n elif ml[-i] + nl[-i] + c == 2:\\n rl.insert(0, 0)\\n c = 1\\n elif ml[-i] + nl[-i] + c == 3:\\n rl.insert(0, 1)\\n c = 1\\n if c == 1:\\n rl.insert(0, 1)\\n if length > len(rl):\\n rl = [0] * (length - len(rl)) + rl\\n else:\\n rl = rl[-length:]\\n rl = \\\"\\\".join([str(x) for x in rl])\\n return rl\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def math_add():\\n a = int(request.args.get(\\\"a\\\"))\\n b = int(request.args.get(\\\"b\\\"))\\n return str(add(a, b))\",\n \"def increment(b): \\n if b == 11111111:\\n return 00000000\\n else:\\n b = bin_to_dec(b)\\n b = b + 1\\n res = dec_to_bin (b)\\n if len(res) == 8:\\n return res\\n else:\\n c = 8 - len(res)\\n return c*'0' + res\",\n \"def __add__(self, other: 'SInt') -> 'SInt':\\r\\n # Recoding the addition\\r\\n if type(other) != self.__class__ or len(self) != len(other):\\r\\n raise TypeError(\\\"Wrong type or length for other\\\")\\r\\n retenue = [0 for i in range(len(self) + 1)]\\r\\n new_bin = ''\\r\\n for i in range(len(self)):\\r\\n k = int(self.binaire[-(i + 1)]) + int(other.binaire[-(i + 1)]) + retenue[i]\\r\\n new_bin = ['0', '1', '0', '1'][k] + new_bin\\r\\n retenue[i + 1] = 1 if k > 1 else 0\\r\\n if self.signe == other.signe and retenue[-1] != retenue[-2]:\\r\\n raise OverflowError(\\\"The sum is over the bytes available\\\")\\r\\n H = self.__class__(self.nbBytes)\\r\\n H.binaire = new_bin\\r\\n return H\",\n \"def Add(p, q):\\n return p*q\",\n \"def add64(a,b):\\n return(np.add(a, b, dtype=np.uint64))\",\n \"def add(a,b):\\n s = a+b\\n return s\",\n \"def ADD (self, n1, n2):\",\n \"def _add_2_bit_oracle_with_ancilla_1_0(qc: QuantumCircuit, register: QuantumRegister, ancilla: Qubit) -> None:\\n if len(list(register)) != 2:\\n raise ValueError(f\\\"Need QuantumRegister with exactly 2 qubits, but got {len(list(register))} instead.\\\")\\n\\n qc.x(register[0])\\n qc.ccx(register[1], register[0], ancilla)\\n qc.x(register[0])\",\n \"def add(a,b):\\n print('submul = {}'.format(diff.submul(a,b)) ) # first method\\n # print('diff = {}'.format(sub(a,b)) ) # second method\\n return a+b\",\n \"def __iadd__(self, B):\\n m, n = self.shape\\n try:\\n k, r = B.shape\\n except AttributeError: # treat B as constant\\n c = mpfr(B)\\n for i in range(m):\\n for j in range(n):\\n self[i, j] += c\\n return self\\n assert (m == k\\n and n == r), (\\\"Cannot add shapes ({}, {}) and ({}, {})\\\".format(\\n m, n, k, r))\\n for i in range(m):\\n for j in range(n):\\n self[i, j] += B[i, j]\\n return self\",\n \"def addBinary(self, a: str, b: str) -> str:\\n return self.bit_manipulation(a, b)\",\n \"def addition(a,b):\\n return a+b\",\n \"def andbits(num1,num2):\\n thingstoadd=[]\\n for i in range(31):\\n bit1=setbit(num1,i)\\n bit2=setbit(num2,i)\\n bit1=shiftleft(bit1,30 - i)\\n bit2=shiftleft(bit2,30 - i)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n bitsum=shiftright(bitsum,31 - i)\\n thingstoadd.append(bitsum)\\n bit1=setbit(num1,31)\\n bit2=setbit(num2,31)\\n bit1=shiftright(bit1,1)\\n bit2=shiftright(bit2,1)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n thingstoadd.append(bitsum)\\n return sum(thingstoadd)\",\n \"def _add(self, i, k):\\n while i < self._size:\\n self._bit[i] += k\\n i += lsb(i)\",\n \"def __iadd__(self, other):\\n\\n return self + other\",\n \"def add_quad(a, b):\\n s = np.sqrt(np.square(a) + np.square(b))\\n return s\",\n \"def __add__(self, other)\\n \\n def __mul__(self, other):\\n print(\\\"Standard multiplication with\\\", other.which)\\n print(other.which)\\n \\n if isinstance(other, int):\\n print(\\\"Other is int\\\")\\n self.coefficients *= other\\n \\n return self\\n \\n else:\\n print(\\\"Other operator is spin operator\\\")\\n summandsNew = []\\n coeffsNew = []\\n for otherSummandIndex, otherSummand in enumerate(other.summands):\\n for thisSummandIndex, thisSummand in enumerate(self.summands):\\n summandsNew.append(flatten([thisSummand, otherSummand]))\\n coeffsNew.append(self.coefficients[thisSummandIndex]*other.coefficients[otherSummandIndex])\\n print(summandsNew) \\n self.coeffs = coeffsNew\\n self.summands = summandsNew\\n \\n return self\",\n \"def __radd__(self, other):\\n return self.runtime.add(self, other)\",\n \"def mult_mod(a, b, nbr, control):\\n bina = [int(x) for x in bin(a)[2:]]\\n # binb = [int(x) for x in bin(b)[2:]]\\n binn = [int(x) for x in bin(nbr)[2:]]\\n while len(binn) < len(bina):\\n binn = [0]+binn\\n # print(bina, binn)\\n binn.reverse()\\n bina.reverse()\\n n = len(bina)+len(binn)*3+1\\n na = len(bina)\\n nan = len(bina)+len(binn) # debut de Y\\n nany = len(bina)+2*len(binn)+1 # debut de \\\"A\\\" (ici c'est b)\\n q = QuantumRegister(n+2+1, 'q') # +lost+lost2+control\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binn)):\\n if binn[i]:\\n circ.x(q[na+i])\\n if control:\\n circ.x(q[n+2])\\n cmultmod(circ, q, # control, X, a, A, Y, n, N, binn, lost, lost2\\n q[n+2],\\n [q[i] for i in range(len(bina))],\\n b,\\n [q[i+nany] for i in range(len(binn))],\\n [q[i+nan] for i in range(len(binn)+1)],\\n nbr,\\n [q[i+na] for i in range(len(binn))],\\n binn,\\n q[n],\\n q[n+1])\\n circ_m = measure(circ, q, [i for i in range(nan,nany)])\\n return circ_m\",\n \"def __radd__(self, other):\\n\\n return self.__add__(other)\",\n \"def suma(a, b):\\n\\n\\ttotal = a + b\\n\\treturn total\",\n \"def add_sub_dsp(a, b, *, t=None, quantization=Quantization.TRUNCATE, overflow=Overflow.WRAP_AROUND, latency=0,\\n operation=Operation.ADD):\\n\\n if operation == Operation.ADD:\\n sum_diff = a + b\\n elif operation == Operation.SUB:\\n sum_diff = a - b\\n else:\\n raise Exception(f\\\"Parameter operation has to be chosen from Operation.ADD|SUB\\\")\\n\\n latency_iter = latency\\n\\n if t is None:\\n res = sum_diff\\n elif typeof(t, Integer):\\n\\n if latency_iter:\\n pipe_len = ceil_div(latency_iter, 3)\\n sum_diff = sum_diff | pipeline(length=pipe_len)\\n latency_iter -= pipe_len\\n\\n if typeof(sum_diff.dtype, Integer):\\n quant_sum_diff = sum_diff\\n elif typeof(sum_diff.dtype, Fixpnumber):\\n if quantization == Quantization.TRUNCATE:\\n quant_sum_diff = cast(sum_diff, t=t)\\n elif quantization == Quantization.ROUND:\\n quant_sum_diff = qround(sum_diff)\\n else:\\n raise Exception(f\\\"Parameter quantization has to be chosen from Quantization.TRUNCATE|ROUND\\\")\\n else:\\n raise Exception('t has to be either Integer or Fixpnumber')\\n\\n if latency_iter:\\n pipe_len = ceil_div(latency_iter, 2)\\n quant_sum_diff = quant_sum_diff | pipeline(length=pipe_len)\\n latency_iter -= pipe_len\\n\\n if overflow == Overflow.WRAP_AROUND:\\n res = trunc(quant_sum_diff, t=t)\\n elif overflow == Overflow.SATURATE:\\n res = saturate(quant_sum_diff, t=t)\\n else:\\n raise Exception(f\\\"Parameter overflow has to be chosen from Overflow.WRAP_AROUND|SATURATE\\\")\\n elif type(t, Fixpnumber):\\n\\n if latency_iter:\\n pipe_len = ceil_div(latency_iter, 3)\\n sum_diff = sum_diff | pipeline(length=pipe_len)\\n latency_iter -= pipe_len\\n\\n if quantization == Quantization.TRUNCATE:\\n quant_sum_diff = trunc(sum_diff, t=t.base[sum_diff.dtype.integer, sum_diff.dtype.integer + t.fract])\\n elif quantization == Quantization.ROUND:\\n quant_sum_diff = qround(sum_diff, fract=t.fract)\\n else:\\n raise Exception(f\\\"Parameter quantization has to be chosen from Quantization.TRUNCATE|ROUND\\\")\\n\\n if latency_iter:\\n pipe_len = ceil_div(latency_iter, 2)\\n quant_sum_diff = quant_sum_diff | pipeline(length=pipe_len)\\n latency_iter -= pipe_len\\n\\n if overflow == Overflow.WRAP_AROUND:\\n res = trunc(quant_sum_diff, t=t)\\n elif overflow == Overflow.SATURATE:\\n res = saturate(quant_sum_diff, t=t)\\n else:\\n raise Exception(f\\\"Parameter overflow has to be chosen from Overflow.WRAP_AROUND|SATURATE\\\")\\n else:\\n raise Exception('t has to be either Integer or Fixpnumber')\\n\\n if latency_iter:\\n return res | pipeline(length=latency_iter)\\n else:\\n return res\",\n \"def funky_sum(a, b, mix):\\n if mix <= 0:\\n return a\\n elif mix >= 1:\\n return b\\n else:\\n return (1 - mix) * a + mix * b\",\n \"def enc_add(pub, m1, m2):\\n add_result = m1 * m2 % pub.n_sq\\n return add_result\",\n \"def a_plus_abs_b(a, b):\\n if b < 0:\\n f = sub(a,b)\\n else:\\n f = add(a,b)\\n return f\",\n \"def sum(self, a, b):\\n return int(a) + int(b)\",\n \"def add(a: int, b, c=5, d=7., e=None):\\n if e is None:\\n e = 0\\n return a + b + c + d + e\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8332056","0.7943099","0.7541027","0.7422055","0.72869945","0.68409365","0.66323876","0.657023","0.6435118","0.6424183","0.6408739","0.63692945","0.63223016","0.63202614","0.63042223","0.6280893","0.6249376","0.62431586","0.6136598","0.610853","0.61025476","0.6084867","0.60637516","0.60605466","0.60505885","0.60477287","0.60107833","0.59930235","0.5986176","0.5974526","0.5972724","0.59721977","0.5953952","0.5941528","0.5940148","0.5910195","0.5903704","0.5890449","0.58850634","0.58850634","0.58832824","0.58832824","0.58832824","0.58832824","0.58832824","0.58832824","0.58765155","0.58671546","0.5863677","0.5855535","0.5853882","0.5828111","0.58280087","0.58185107","0.5808959","0.5808959","0.57876974","0.57845724","0.57408607","0.5738981","0.57265127","0.5723256","0.57101154","0.5701654","0.56989044","0.5696104","0.5685156","0.5685156","0.5685156","0.5685156","0.5685156","0.5685156","0.5685156","0.56726635","0.56578344","0.56295764","0.56087834","0.56081563","0.56039476","0.5601435","0.56011593","0.5592137","0.5576711","0.5575516","0.5565236","0.5562406","0.55559963","0.55529886","0.55528957","0.5552523","0.5551779","0.55463576","0.5543818","0.5539378","0.5533688","0.5531984","0.5514504","0.5507691","0.5499814","0.5498827"],"string":"[\n \"0.8332056\",\n \"0.7943099\",\n \"0.7541027\",\n \"0.7422055\",\n \"0.72869945\",\n \"0.68409365\",\n \"0.66323876\",\n \"0.657023\",\n \"0.6435118\",\n \"0.6424183\",\n \"0.6408739\",\n \"0.63692945\",\n \"0.63223016\",\n \"0.63202614\",\n \"0.63042223\",\n \"0.6280893\",\n \"0.6249376\",\n \"0.62431586\",\n \"0.6136598\",\n \"0.610853\",\n \"0.61025476\",\n \"0.6084867\",\n \"0.60637516\",\n \"0.60605466\",\n \"0.60505885\",\n \"0.60477287\",\n \"0.60107833\",\n \"0.59930235\",\n \"0.5986176\",\n \"0.5974526\",\n \"0.5972724\",\n \"0.59721977\",\n \"0.5953952\",\n \"0.5941528\",\n \"0.5940148\",\n \"0.5910195\",\n \"0.5903704\",\n \"0.5890449\",\n \"0.58850634\",\n \"0.58850634\",\n \"0.58832824\",\n \"0.58832824\",\n \"0.58832824\",\n \"0.58832824\",\n \"0.58832824\",\n \"0.58832824\",\n \"0.58765155\",\n \"0.58671546\",\n \"0.5863677\",\n \"0.5855535\",\n \"0.5853882\",\n \"0.5828111\",\n \"0.58280087\",\n \"0.58185107\",\n \"0.5808959\",\n \"0.5808959\",\n \"0.57876974\",\n \"0.57845724\",\n \"0.57408607\",\n \"0.5738981\",\n \"0.57265127\",\n \"0.5723256\",\n \"0.57101154\",\n \"0.5701654\",\n \"0.56989044\",\n \"0.5696104\",\n \"0.5685156\",\n \"0.5685156\",\n \"0.5685156\",\n \"0.5685156\",\n \"0.5685156\",\n \"0.5685156\",\n \"0.5685156\",\n \"0.56726635\",\n \"0.56578344\",\n \"0.56295764\",\n \"0.56087834\",\n \"0.56081563\",\n \"0.56039476\",\n \"0.5601435\",\n \"0.56011593\",\n \"0.5592137\",\n \"0.5576711\",\n \"0.5575516\",\n \"0.5565236\",\n \"0.5562406\",\n \"0.55559963\",\n \"0.55529886\",\n \"0.55528957\",\n \"0.5552523\",\n \"0.5551779\",\n \"0.55463576\",\n \"0.5543818\",\n \"0.5539378\",\n \"0.5533688\",\n \"0.5531984\",\n \"0.5514504\",\n \"0.5507691\",\n \"0.5499814\",\n \"0.5498827\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7033453"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":74297,"cells":{"query":{"kind":"string","value":"Convenient wrapper for collecting the results of addition for every possible pair of n_bits long summands."},"document":{"kind":"string","value":"def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\n int]] = None,\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,\n num_shots: int = 100, use_param_program: bool = False,\n use_active_reset: bool = True, show_progress_bar: bool = False) \\\n -> Sequence[Sequence[Sequence[int]]]:\n if registers is None:\n registers = get_qubit_registers_for_adder(qc, n_bits, qubits)\n\n reset_prog = Program()\n if use_active_reset:\n reset_prog += RESET()\n\n add_prog = Program()\n if use_param_program:\n dummy_num = [0 for _ in range(n_bits)]\n add_prog = adder(dummy_num, dummy_num, *registers, in_x_basis=in_x_basis,\n use_param_program=True)\n\n all_results = []\n # loop over all binary strings of length n_bits\n for bits in tqdm(all_bitstrings(2 * n_bits), disable=not show_progress_bar):\n # split the binary number into two numbers\n # which are the binary numbers the user wants to add.\n # They are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bits[:n_bits]\n num_b = bits[n_bits:]\n\n if not use_param_program:\n add_prog = adder(num_a, num_b, *registers, in_x_basis=in_x_basis,\n use_param_program=False)\n\n prog = reset_prog + add_prog\n prog.wrap_in_numshots_loop(num_shots)\n nat_quil = qc.compiler.quil_to_native_quil(prog)\n exe = qc.compiler.native_quil_to_executable(nat_quil)\n\n if use_param_program:\n exe.write_memory(region_name=REG_NAME, value=bits)\n\n # Run it on the QPU or QVM\n results = qc.run(exe).readout_data.get('ro')\n all_results.append(results)\n\n return all_results"},"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 BitAdd(m, n, length):\n\n lmax = max(len(m), len(n))\n c = 0\n ml = [0] * (lmax - len(m)) + [int(x) for x in list(m)]\n nl = [0] * (lmax - len(n)) + [int(x) for x in list(n)]\n rl = []\n for i in range(1, lmax+1):\n if ml[-i] + nl[-i] + c == 0:\n rl.insert(0, 0)\n c = 0\n elif ml[-i] + nl[-i] + c == 1:\n rl.insert(0, 1)\n c = 0\n elif ml[-i] + nl[-i] + c == 2:\n rl.insert(0, 0)\n c = 1\n elif ml[-i] + nl[-i] + c == 3:\n rl.insert(0, 1)\n c = 1\n if c == 1:\n rl.insert(0, 1)\n if length > len(rl):\n rl = [0] * (length - len(rl)) + rl\n else:\n rl = rl[-length:]\n rl = \"\".join([str(x) for x in rl])\n return rl","def andbits(num1,num2):\n thingstoadd=[]\n for i in range(31):\n bit1=setbit(num1,i)\n bit2=setbit(num2,i)\n bit1=shiftleft(bit1,30 - i)\n bit2=shiftleft(bit2,30 - i)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n bitsum=shiftright(bitsum,31 - i)\n thingstoadd.append(bitsum)\n bit1=setbit(num1,31)\n bit2=setbit(num2,31)\n bit1=shiftright(bit1,1)\n bit2=shiftright(bit2,1)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n thingstoadd.append(bitsum)\n return sum(thingstoadd)","def combine_many(*fudge):\n result = sum(fudge)\n print(result)","def possible_sums(numbers: Iterator[SnailfishNumber]) -> Iterator[SnailfishNumber]:\n yield from (a + b for a, b in permutations(numbers, 2))","def BitAdd(a, b, bits_to_compute=None):\r\n k = len(a)\r\n if not bits_to_compute:\r\n bits_to_compute = list(range(k))\r\n d = [None] * k\r\n for i in range(1,k):\r\n t = a[i]*b[i]\r\n d[i] = (a[i] + b[i] - 2*t, t)\r\n d[0] = (None, a[0]*b[0])\r\n pg = PreOpL(carry, d)\r\n c = [pair[1] for pair in pg]\r\n \r\n s = [None] * (k+1)\r\n if 0 in bits_to_compute:\r\n s[0] = a[0] + b[0] - 2*c[0]\r\n bits_to_compute.remove(0)\r\n for i in bits_to_compute:\r\n s[i] = a[i] + b[i] + c[i-1] - 2*c[i]\r\n s[k] = c[k-1]\r\n return s","def _add_stream(aa, bb):\n carry = 0\n cc = []\n for aaa, bbb in zip(aa, bb):\n carry, val = _add_digit(aaa,bbb, carry)\n cc.append(val)\n if carry:\n cc.append(carry)\n return cc","def power_list_sum(s):\n x = len(s)\n my_list = []\n for i in range(1 << x):\n my_list.append(sum(([s[j] for j in range(x) if (i & (1 << j))])))\n\n return sorted(my_list)","def getSum(self, a: int, b: int) -> int:\n i = 0\n carry = 0\n res = 0\n while i < 12:\n curr_a_bit = (a >> i) & 1\n curr_b_bit = (b >> i) & 1\n # print(curr_a_bit, curr_b_bit)\n curr_bit = curr_a_bit ^ curr_b_bit ^ carry\n res |= (curr_bit << i)\n if curr_a_bit & curr_b_bit == 1 or curr_a_bit & carry == 1 or curr_b_bit & carry == 1:\n carry = 1\n else:\n carry = 0\n i += 1\n # print(res, bin(res), bin(a), bin(b))\n # 不用把 第 13 位 i = 12 时 carry 加上 result, 因为 这一位 判断 正 负 不需要\n if res >= 2 ** 11:\n # 举例：最大和2000 ，res < 2 ^ 11, 最小和 -2000， res > 2 ^ 11\n # 如果 和 是 0，比如 1 和 -1， res = 0\n # 如果和 是 -1，比如 1 和 -2， res > 2 ^ 11\n res = (~res) ^ 0b111111111111\n return res","def getSum(self, a, b):\n result = 0\n carry = 0\n carry_on = {(0,0,0), (0,0,1), (1,0,0), (0,1,0)}\n\n for i in range(32):\n a_lsb = a & 1\n b_lsb = b & 1\n cur = a_lsb ^ b_lsb ^ carry\n carry = 0 if (a_lsb, b_lsb, carry) in carry_on else 1\n\n result |= cur << i\n a = a >> 1\n b = b >> 1\n # result is negative number\n if result >> 31 & 1 == 1:\n new_result = 0\n for i in range(32):\n result_lsb = result & 1\n new_bit = ~result_lsb & 1\n new_result |= new_bit << i\n\n result = result >> 1\n result = -(new_result + 1)\n return result","def addRes(res1, res2):\n return [(x + y) for x, y in zip(res1, res2)]","def add(iter_1, iter_2):\n return tuple(int(a + b) for a, b in zip(iter_1, iter_2))","def sum_product(numbers: List[int]) -> Tuple[int, int]:\n#[SOLUTION]\n sum_value = 0\n prod_value = 1\n\n for n in numbers:\n sum_value += n\n prod_value *= n\n return sum_value, prod_value","def _add(a, b):\n\n # Todo: What if numbers have bigger length than 8\n a = _I2B(a, fixed_length=8)\n b = _I2B(b, fixed_length=8)\n return _B2I([i ^ j for i, j in zip(a, b)])","def add_wo_carry(n1, n2):\n l1 = [int(x) for x in str(n1)]\n l2 = [int(x) for x in str(n2)] \n res1 = map(operator.add, l1, l2)\n res2 = [str(x)[-1] for x in res1]\n return \"\".join(res2)","def add_no_carry(*args):\r\n num_digits = []\r\n\r\n for arg in args:\r\n num_digits.append(len(str(arg)))\r\n\r\n max_digits = max(num_digits)\r\n # list comprehension way\r\n # max_digits = max([len(str(arg)) for arg in args])\r\n final_sum = 0\r\n\r\n for pwr in range(1, max_digits + 1): # iterate through ea decimal\r\n result_no_carry = 0\r\n for arg in args:\r\n if len(str(arg)) >= pwr:\r\n # modulus sets the current decimal as the most significant\r\n # decimal\r\n # floor div selects the most significant decimal\r\n result_no_carry += arg % 10**pwr // 10**(pwr - 1)\r\n\r\n # list comprehension way\r\n # result_no_carry = sum([arg % 10**pwr // 10**(pwr - 1) for arg in args if len(str(arg)) >= pwr])\r\n\r\n # final_sum = str(result_no_carry % 10) + final_sum\r\n final_sum += result_no_carry % 10\r\n\r\n return int(final_sum)","def multi_2(cur,p,n):\n\tr=p\n\twhile n>1:\n\t\tr=sum(cur,r,p)\n\t\tn-=1\n\treturn r","def test_get_n_bits_combinations():\n # Check n=1 - Pass\n assert layer_util.get_n_bits_combinations(1) == [[0], [1]]\n # Check n=2 - Pass\n assert layer_util.get_n_bits_combinations(2) == [[0, 0], [0, 1], [1, 0], [1, 1]]\n\n # Check n=3 - Pass\n assert layer_util.get_n_bits_combinations(3) == [\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 0],\n [0, 1, 1],\n [1, 0, 0],\n [1, 0, 1],\n [1, 1, 0],\n [1, 1, 1],\n ]","def test_bit_add_multiple_bytes(self):\n ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 8, 16, 65535, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([0] * 1 + [255] * 2 + [0] * 2)\n assert bins[self.test_bin_zeroes] == expected_result","def smart_add(*args):\n result = 0\n for item in args:\n result += item\n\n return result","def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\n result = ListNode(0)\n node = result\n carry = 0\n while True:\n if not l1 is None:\n x = l1.val\n l1 = l1.next\n l1_n = True\n else:\n x = 0\n l1_n = False\n if not l2 is None:\n y = l2.val\n l2 = l2.next\n l2_n = True\n else:\n y = 0\n l2_n = False\n res = x + y + carry\n if res == 0 and not l1_n and not l2_n:\n return result.next\n if res > 9:\n res = res % 10\n carry = 1\n else:\n carry = 0\n\n addNode(node, res)\n node = node.next","def summed(L):\r\n result = 0\r\n for e in L:\r\n result = result + e # or result += e\r\n return result","def sum(*args):\n result = 0\n for i in args:\n result += i\n return result","def EncryptMultipleInt64s(self, numberlist, r_value=None):\n plaintext = 0\n number_counter = 0\n if len(numberlist) > PACKING_LIMIT:\n raise ValueError('The number of entries in the input list cannot be'\n + ' more than %d' % (PACKING_LIMIT))\n for entry in numberlist:\n if not isinstance(entry, int) and not isinstance(entry, long):\n raise ValueError('Expected int or long but got: %s' % type(number))\n if entry < MIN_INT64 or entry > MAX_INT64:\n raise ValueError('Int64 values need to be between %d and %d but got %d'\n % (MIN_INT64, MAX_INT64, entry))\n entry = self._Extend64bitTo96bitTwosComplement(entry)\n if number_counter > 0:\n plaintext <<= PACKING_BIT_SIZE\n plaintext += entry\n number_counter += 1\n return self.Encrypt(plaintext, r_value=r_value)","def addition_mod(a, b, nbr):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n binn = [int(x) for x in bin(nbr)[2:]]\n #print(binn)\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n while len(binn) < len(bina):\n binn = [0]+binn\n while len(binn) > len(bina):\n bina = [0]+bina\n binb = [0]+binb\n binn.reverse()\n bina.reverse()\n binb.reverse()\n #print(bina, binb, binn)\n n = len(bina)+len(binb)+len(binn)\n na = len(bina)\n nab = len(bina)+len(binb)\n q = QuantumRegister(n+2, 'q')\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binb)):\n if binb[i]:\n circ.x(q[na+i])\n for i in range(len(binn)):\n if binn[i]:\n circ.x(q[nab+i])\n addmod(circ, q, # A, B, lost, last, N, lost2, binn):\n [q[i] for i in range(len(bina))],\n [q[i+na] for i in range(len(binb)-1)],\n q[n],\n q[na+len(binb)-1],\n [q[i+nab] for i in range(len(binn))],\n q[n+1],\n binn)\n circ_m = measure(circ, q, [i for i in range(na,nab)])\n return circ_m","def bits_apply(op, n):\n return verts_to_bits(op[v] for v in bits_to_verts(n))","def pack_bits( longbits ):\n byte = longbits & (0x0101010101010101)\n byte = (byte | (byte>>7)) & (0x0003000300030003)\n byte = (byte | (byte>>14)) & (0x0000000f0000000f)\n byte = (byte | (byte>>28)) & (0x00000000000000ff)\n return byte","def power_sum(power, *args):\n total = 0\n for i in args:\n total += pow(i, power)\n return total","def sumList(n1: Node, n2: Node):\n result = LinkedList()\n carry = 0\n while n1 is not None and n2 is not None:\n total = n1.data + n2.data + carry\n carry = total // 10\n result.appendToTail(total % 10)\n n1 = n1.next\n n2 = n2.next\n\n while n1 is not None:\n total = n1.data + carry\n carry = total // 10\n result.appendToTail(total % 10)\n n1 = n1.next\n\n while n2 is not None:\n total = n2.data + carry\n carry = total // 10\n result.appendToTail(total % 10)\n n2 = n2.next\n\n if carry:\n result.appendToTail(carry)\n\n return result","def add(a, b):\n return tuple(x+y for x,y in zip(a,b))","def xorbits(num1,num2):\n thingstoadd = []\n for i in range(31):\n bit1=setbit(num1,i)\n bit2=setbit(num2,i)\n bit1=shiftleft(bit1,31 - i)\n bit2=shiftleft(bit2,31 - i)\n bitsum=add(bit1,bit2)\n bitsum=shiftright(bitsum,31 - i)\n thingstoadd.append(bitsum)\n return sum(thingstoadd)","def multi_1(cur,p,n):\n\tr=p\n\tfor k in range(0,n-1):\n\t\tr=sum(cur,r,p)\n\treturn r","def binary_sums(start, limit):\n for n in range(start, limit):\n for i in range(1, n/2 + 1):\n yield i, n - i","def sum(*args):\n return reduce(lambda x, y: x + y, args)","def concatenate_bits(num, bit_mask):\n\tbit_positions = get_bit_positions(bit_mask)\n\tnum_bits_at_positions = [get_bit(num, pos) for pos in bit_positions]\n\tout = 0\n\tfor bit in num_bits_at_positions:\n\t\tout = (out << 1) | bit\n\treturn out","def addTwoNumbers(l1, l2):\r\n dummy = curr = ListNode(0)\r\n carry = 0\r\n while l1 and l2:\r\n curr.next = ListNode( ( l1.val + l2.val + carry ) % 10 ) \r\n carry = ( l1.val + l2.val + carry ) // 10\r\n l1 = l1.next\r\n l2 = l2.next\r\n curr = curr.next\r\n l = l1 or l2 \r\n while l:\r\n curr.next = ListNode( ( l.val + carry ) % 10 ) \r\n carry = ( l.val + carry ) // 10\r\n l = l.next\r\n curr = curr.next\r\n if carry > 0:\r\n curr.next = ListNode( carry )\r\n \r\n return dummy.next","def count_bits(dqxx, n):\n return sum([check_bit(x, n) for x in dqxx])","def sum_of_squares(n, k, zeros=False):\n yield from power_representation(n, 2, k, zeros)","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)","def mult_and_sum(*arg_list):\r\n result = numpy.empty(arg_list[0].shape, dtype=numpy.float32)\r\n result[:] = nodata\r\n array_stack = numpy.array(arg_list[0::2])\r\n scalar_list = numpy.array(arg_list[1::2])\r\n # make a valid mask as big as a single array\r\n valid_mask = numpy.logical_and.reduce(\r\n array_stack != pop_nodata, axis=0)\r\n\r\n # mask out all invalid elements but reshape so there's still the same\r\n # number of arrays\r\n valid_array_elements = (\r\n array_stack[numpy.broadcast_to(valid_mask, array_stack.shape)])\r\n array_stack = None\r\n\r\n # sometimes this array is empty, check first before reshaping\r\n if valid_array_elements.size != 0:\r\n valid_array_elements = valid_array_elements.reshape(\r\n -1, numpy.count_nonzero(valid_mask))\r\n # multiply each element of the scalar with each row of the valid\r\n # array stack, then sum along the 0 axis to get the result\r\n result[valid_mask] = numpy.sum(\r\n (valid_array_elements.T * scalar_list).T, axis=0)\r\n scalar_list = None\r\n valid_mask = None\r\n valid_array_elements = None\r\n return result","def expand_bits(cls, bits):\n if len(bits) != 32:\n raise ValueError('Can only expand 32 bit bitstrings')\n else:\n return cls.permute(bits, cls._expand_bits)","def _product(self, args):\n pools = map(tuple, args) #within original version args defined as *args\n result = [[]]\n for pool in pools:\n result = [x + [y] for x in result for y in pool]\n return result","def make_sum_in_2(a1, *rest):\n def helper(a, alist, acc):\n \"\"\"\n a: first argument\n alist: scheme list; rest of arguments\n acc: sum result so far\n \"\"\"\n if isNull(alist):\n if isNumber(a) and a == 0:\n return acc\n elif isNumber(acc) and acc == 0:\n return a\n elif isNumber(a) and isNumber(acc):\n return a + acc\n elif isList(acc):\n return append(acc, List(plus, a))\n else:\n return append(List(acc), List(plus, a))\n else:\n # more arguments in alist to process\n p = car(alist)\n q = cdr(alist)\n if isNumber(a) and a == 0:\n return helper(p, q, acc)\n elif isNumber(acc) and acc == 0:\n return helper(p, q, a)\n elif isNumber(a) and isNumber(acc):\n return helper(p, q, acc + a)\n else:\n if isList(acc):\n return helper(p, q, append(acc, List(plus, a)))\n else:\n return helper(p, q, append(List(acc), List(plus, a)))\n\n rests = List(*rest)\n return helper(a1, rests, 0)","def kkAdd(*args):\n if (None in args):\n return None\n total = 0\n for arg in args:\n total += arg\n return total","def bincoeff(n: int, k: int = None) -> Union[int, List[int]]:\n if k is not None:\n return comb(n, k)\n else:\n result = []\n for i in range(0, n + 1):\n result.append(comb(n, i))\n return result","def create_sum(length, n, take='take'):\n\n\tresult = []\n\t# Generate n sums.\n\tfor j in range(n):\n\t\tfirst = []\n\t\tsecond = []\n\t\t# Generate a random number of <length> digits.\n\t\tfor i in range(length):\n\t\t\tfirst.append(random.randint(0,9))\n\t\t# Generate a random number of <length> digits.\n\t\tfor dig in first:\n\t\t\t# If take / carry is allowed, second number is purely random.\n\t\t\tif take == 'take':\n\t\t\t\tsecond.append(random.randint(0,9))\n\t\t\t# If take / carry is not allowed, second number is restricted so that its addition does not cross 9.\n\t\t\telse:\n\t\t\t\tsecond.append(random.randint(0,9-dig))\n\t\t# Convert from list of numbers to strings.\n\t\tdig1 = num_to_str(first)\n\t\tdig2 = num_to_str(second)\n\t\t# Append to the result.\n\t\tresult.append((dig1, dig2))\n\t# Return the result.\n\treturn result","def join_bits(byteseq) -> int:\n return reduce(lambda acc, bit: (acc << 1) | int(bit), byteseq)","def sum_two_linked_lists(ll1, ll2):\n\n result = LL()\n carry = 0\n\n while ll1 or ll2:\n\n v1 = ll1.value if ll1 else 0\n v2 = ll2.value if ll2 else 0\n\n sum = v1 + v2 + carry\n if sum > 9:\n carry = 1\n sum = sum - 10\n else:\n carry = 0\n\n result.add(sum)\n\n if ll1:\n ll1 = ll1.next\n\n if ll2:\n ll2 = ll2.next\n\n if carry:\n result.add(carry)\n\n return result.head","def compute_combinations(items: List[Union[List[Any], Tuple]], n: int) -> List[List[Any]]:\n return [chunks[i:i + n] for chunks in items for i in range(len(chunks) - (n - 1))]","def combinln(n, k):\n return (special.gammaln(n + 1) - (special.gammaln(k + 1) +\n special.gammaln(n - k + 1)))","def add_bitwise(x, y):\n\n answer = 0\n carry_in = 0\n k = 1\n iterations_tracker = x | y\n\n while (iterations_tracker):\n x_k = x & k\n y_k = y & k\n\n answer |= x_k ^ y_k ^ carry_in\n carry_out = majority_bitwise(x_k, y_k, carry_in)\n\n carry_in = carry_out << 1\n\n k <<= 1\n iterations_tracker >>= 1\n\n if (carry_in):\n answer |= carry_in\n\n return answer","def ll_sum(x):\n xlist = []\n for i in x:\n for num in i:\n xlist.append(num)\n return sum(xlist)","def add64(a,b):\n return(np.add(a, b, dtype=np.uint64))","def add(num1,num2):\n if(num2==0):\n return num1\n return add((num1^num2),(num1&num2)<<1)","def combine(num_one, num_two=0):\n result = num_one + num_two\n return result","def totalSolutions(n:int):\n\n memo = [0]*6\n memo[5] = 1\n if n == 1:\n return 1\n\n for i in range(n):\n solutions = sum(memo)\n memo.pop(0)\n memo.append(solutions)\n\n return memo.pop()","def SUM(*args):\n return _group_function(lambda x, y: x + y, *args)","def mono_sum(l):\n r = next(l)\n for m in l: r = r + m\n return r","def __iadd__(self,l):\r\n\t\t\r\n\t\treturn self.add(l)","def accumulate(combiner, base, n, term):\n total, k = base, 1\n while k <= n:\n total, k = combiner(total, term(k)), k + 1\n return total","def sum_tuples(t1, t2):\n return tuple(sum(t) for t in zip(t1, t2))","def _generateResults_combosToBitmasks(self, all, want_combos):\n names = {}\n iter = enumerate(all)\n try:\n i, name = next(iter)\n while True:\n names[name] = (1 << i)\n i, name = next(iter)\n except StopIteration:\n pass\n print \"combosToBitmasks names:\", names\n results = []\n for combo in want_combos:\n mask = 0\n for name in combo:\n if name in names:\n mask |= names[name]\n results.append(mask)\n return results","def carry(nums):\n #See get_long_len(nums) doc string for info on this\n long_len = get_long_len(nums)\n #See format_nums(nums, sep) doc string for info on this\n str_nums = format_nums(nums, \"0\")\n #Used to keep track of the current carried number\n carry_num = 0\n #All the carried numbers used during the operation\n carry_list = []\n #Start from the ones digit of all numbers and move up each time, stopping\n #at the second to last digit\n for i in range(long_len-1, 0, -1):\n #The sum for the current digit starts at the previous\n #carried number\n digit_sum = carry_num\n #Reset the carried number for the beginning of the summation\n #for this digit\n carry_num = 0\n #Add all numbers in the current digit location\n digit_sum += sum([int(num[i]) for num in str_nums])\n #Find the number to be carried over by dividing by 10\n carry_num = digit_sum / 10\n #Append that number to the list of carried numbers\n carry_list.append(carry_num)\n\n #Return a copy of the list reversed\n return reversed(carry_list)","def convert_to_bits(n):\n result = []\n if n == 0:\n return [0]\n while n > 0:\n result = [int(n % 2)] + result\n n = n / 2\n return result","def sum_integer(n):\n return sum([int(elem) for elem in str(n)])","def getSum(self, a, b):\n #\n # 首先，sum 存放每次循环中 a 与 b 的异或值，也就是直接相加值；\n # b 存放每次的进位值，然后 a 存储 sum （也就是直接相加值）进入下一次循环（当进位值非空）；\n # 当且仅当进位值为空时，用户的上一次循环中的 sum 已经是可以直接相加的异或结果了，此时得到结果，返回。\n #\n # if a == 0:\n # return b\n # if b == 0:\n # return a\n # while b != 0:\n # carry = a & b\n # a = a ^ b\n # b = carry << 1\n # return a\n # 32 bits interger max\n MAX = 0x7FFFFFFF\n # 32 bits interger min\n MIN = 0x80000000\n # mask to get last 32 bits\n mask = 0xFFFFFFFF\n\n #print('doc:', )\n while b != 0:\n a, b = (a ^ b) & mask, ((a & b) << 1) & mask\n\n return a if a <= MAX else ~(a ^ mask)","def create_samples(f: Callable[..., int], n_args: int, n_bits: int,\n) -> Dict[Tuple[int, ...], Tuple[int, ...]]:\n samples = {}\n max_arg = 2 ** n_bits\n for inputs in itertools.product((0, 1), repeat=n_args * n_bits):\n ints = [int(\"\".join(str(bit) for bit in inputs[i:i + n_bits]), 2)\n for i in range(0, len(inputs), n_bits)]\n try:\n output = f(*ints)\n if 0 <= output < max_arg:\n bit_string = (\"{:0\" + str(n_bits) + \"b}\").format(output)\n samples[inputs] = tuple(int(bit) for bit in bit_string)\n except ZeroDivisionError:\n pass\n return samples","def test_merge_list_values(short_ll, long_ll):\n ml(short_ll, long_ll)\n assert long_ll.head.val == 8\n assert long_ll.head._next.val == 16","def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\n class ListIter():\n def __init__(self, l: ListNode):\n self.l = ListNode(next=l)\n def __iter__(self):\n return self\n def __next__(self):\n self.l = self.l.next\n if self.l:\n return self.l.val\n raise StopIteration\n \n l3 = ListNode()\n li, rem = l3, False\n for n1, n2 in zip_longest(ListIter(l1), ListIter(l2)):\n li.next = ListNode()\n li = li.next\n s = (n1 if n1 else 0) + (n2 if n2 else 0) + rem\n li.val, rem = (s - 10, True) if s >= 10 else (s, False)\n if rem:\n li.next = ListNode(1)\n return l3.next","def task_8_sum_of_ints(data: List[int]) -> int:\n return sum(data)","def ADD (self, n1, n2):","def sum_of_three_squares(n):\n special = {1:(1, 0, 0), 2:(1, 1, 0), 3:(1, 1, 1), 10: (1, 3, 0), 34: (3, 3, 4), 58:(3, 7, 0),\n 85:(6, 7, 0), 130:(3, 11, 0), 214:(3, 6, 13), 226:(8, 9, 9), 370:(8, 9, 15),\n 526:(6, 7, 21), 706:(15, 15, 16), 730:(1, 27, 0), 1414:(6, 17, 33), 1906:(13, 21, 36),\n 2986: (21, 32, 39), 9634: (56, 57, 57)}\n\n v = 0\n\n if n == 0:\n return (0, 0, 0)\n\n v = multiplicity(4, n)\n n //= 4**v\n\n if n % 8 == 7:\n return\n\n if n in special.keys():\n x, y, z = special[n]\n return _sorted_tuple(2**v*x, 2**v*y, 2**v*z)\n\n s, _exact = integer_nthroot(n, 2)\n\n if _exact:\n return (2**v*s, 0, 0)\n\n x = None\n\n if n % 8 == 3:\n s = s if _odd(s) else s - 1\n\n for x in range(s, -1, -2):\n N = (n - x**2) // 2\n if isprime(N):\n y, z = prime_as_sum_of_two_squares(N)\n return _sorted_tuple(2**v*x, 2**v*(y + z), 2**v*abs(y - z))\n return\n\n if n % 8 in (2, 6):\n s = s if _odd(s) else s - 1\n else:\n s = s - 1 if _odd(s) else s\n\n for x in range(s, -1, -2):\n N = n - x**2\n if isprime(N):\n y, z = prime_as_sum_of_two_squares(N)\n return _sorted_tuple(2**v*x, 2**v*y, 2**v*z)","def bits(a,m):\r\n if isinstance(a, int):\r\n res = [None]*m\r\n for i in range(m):\r\n res[i] = a & 1\r\n a >>= 1\r\n else:\r\n res = []\r\n from Compiler.types import regint, cint\r\n while m > 0:\r\n aa = regint()\r\n convmodp(aa, a, bitlength=0)\r\n res += [cint(x) for x in aa.bit_decompose(min(64, m))]\r\n m -= 64\r\n if m > 0:\r\n aa = cint()\r\n shrci(aa, a, 64)\r\n a = aa\r\n return res","def test_sum_of_yields(n):\n x = 0\n x += yield (0, x)\n x += yield (0, x)\n yield (1, x)","def get_chunk_combination(indiv_1, indiv_2, pair_1, pair_2):\t\r\n\tif check_fixed(indiv_1):\r\n\t\treturn [[indiv_1+indiv_2, indiv_1+indiv_2]] if check_fixed(indiv_2) else [[indiv_1+pair_2[0], indiv_1+pair_2[1]]]\r\n\telse:\r\n\t\treturn [[pair_1[0]+indiv_2, pair_1[1]+indiv_2]] if check_fixed(indiv_2) else [[pair_1[0]+pair_2[0], pair_1[0]+pair_2[1]], [pair_1[1]+pair_2[0], pair_1[1]+pair_2[1]]]\r\n\treturn res","def sum_unique(l):\n pass","def __add__(self, tc): \n tc = TwosComplement(tc)\n bits = self.len if self.len > tc.len else tc.len \n result = self.int + tc.int\n return TwosComplement(result, bits)","def sum_nums(n1=0, n2=0):\n return n1 + n2","def sum_series(n,v1=0,v2=1):\n\tL1=v2\n\tL2=v1\n\tif n<0:\n\t\tprint(\"please enter positive int value\")\n\n\telif n==0:\n\t\treturn v1\n\n\telif n==1:\n\t\treturn v2\n\n\telse:\n\t\tfor i in range(n-1):\n\t\t\tC=L1+L2\n\t\t\tL2=L1\n\t\t\tL1=C\n\t\treturn C","def add4(a,b):\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],a[3]+b[3]]","def add_digits(n):\n return sum([int(d) for d in str(n)])","def summation_i_squared(n):\n if (type(n) is not int) or (n is None) or (n < 1):\n return None\n else:\n numbers = range(1, n + 1)\n result = 0\n result = map(lambda i: i ** 2, numbers)\n return sum(result)","def bitlist(n):\n return [n >> i & 1 for i in range(7,-1,-1)]","def compute_n_codes(n_bits, half_bit=None):\n n_bits, half_bit = parse_bits(n_bits, half_bit)\n if half_bit:\n return 2**(n_bits + 1) - 1\n else:\n return 2**n_bits","def bits(n):\n\n # Create a list of the first 1,000 binary numbers\n binary_list = reverse_binary_list()\n\n # Start by calculating number of 1's for n\n n_ones = num_of_ones(n, binary_list)\n\n # Calculate number of 1's for next value\n next_ones = 0\n while n_ones != next_ones:\n n = n + 1\n next_ones = num_of_ones(n, binary_list)\n\n return(n)","def lsum (inlist):\r\n s = 0\r\n for item in inlist:\r\n s = s + item\r\n return s","def triplets():\n for a in xrange(1, 1000):\n for b in xrange(a, 1000):\n c = 1000 - (a + b)\n if a**2 + b**2 == c**2:\n return a, b, c","def add(num1, num2, Cin):\n Cin=0\n l2=[]\n final=\"\"\n\n \"\"\"Using for loop for starting addition from the last indexed number\"\"\"\n for i in range(len(num1)-1,-1,-1):\n bit1=num1[i]#storing each indexed() value of num1 in bit1\n bit2=num2[i]#storing each indexed() value of num2 in bit2\n S1=g.XOR(bit1, bit2)#calling XOR() method of gates module and passing value in it.\n S2=g.NAND(S1, Cin)#calling NAND() method of gates module and passing value in it.\n S3=g.OR(S1, Cin)#calling OR() method of gates module and passing value in it.\n SUM=g.AND(S2, S3)#calling AND() method of gates module and passing value in it.\n C1=g.AND(bit1, bit2)#calling AND() method of gates module and passing value in it.\n C2=g.AND(S1, Cin)#calling AND() method of gates module and passing value in it.\n C3=g.NOR(C1, C2)#calling NOR() method of gates module and passing value in it.\n Cout=g.NOT(C3)#calling NOT() method of gates module and passing value in it.\n Cin=Cout#declaring cout as cin for next bit addition\n l2.append(SUM)#adding SUM to l2\n l3=l2[::-1]##reversing the value of l2\n final+=str(l2[-1])#converting the list value to string\n final1=final[::-1]#reversing string value\n return final1 #returning the binary addition as string","def _add(self, i, k):\n while i < self._size:\n self._bit[i] += k\n i += lsb(i)","def tup_add(t1, t2):\n return tuple(map(operator.add, t1, t2))","def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\n\n def fetchValueFromListNode(node: ListNode) -> int:\n \"\"\"\n Traverse given linked list and generate 1 integer.\n If given list is something like this (2 -> 4 -> 3),\n this function returns 3 * 100 + 4 * 10 + 2.\n \"\"\"\n curNode = node\n result = curNode.val\n loopCount = 1\n while curNode.next is not None:\n curNode = curNode.next\n result += curNode.val * (10 ** loopCount)\n loopCount += 1\n\n return result\n\n # Get integers from given lists\n value1 = fetchValueFromListNode(l1)\n value2 = fetchValueFromListNode(l2)\n sumVal = value1 + value2\n\n # Generate an answer linked list\n # by traversing array from top\n sumValList = str(sumVal)\n curListNode = ListNode(sumValList[0])\n prevListNode = None\n for idx in range(1, len(sumValList)):\n prevListNode = curListNode\n curListNode = ListNode(sumValList[idx])\n curListNode.next = prevListNode\n\n return curListNode","def _cartesian_add(xs):\n return sum(prefer_static.reshape(x, shape=[-1] + [1]*(len(xs) - 1 - i))\n for i, x in enumerate(xs))","def GetAllBits(self):\n return (self.output, self.NumBits())","def triple_step_simplified(n):\n\ta = 0\n\tb = 0\n\tc = 1\n\tfor i in range(n):\n\t\ttemp = a + b + c\n\t\ta, b, c = b, c, temp\n\treturn temp","def _generate_bitmask(n: int = 2, n_bits: int = 8) -> int:\n all_ones = 2 ** n_bits - 1\n cancel_bits = 2 ** n - 1\n return all_ones - cancel_bits","def prod_LLL(*args):\n return reduce(lambda a, b: a*b, [2*L+1 for L in args])","def addition(a, b):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n bina.reverse()\n binb.reverse()\n n = len(bina)+len(binb)\n na = len(bina)\n q = QuantumRegister(n+1, 'q')\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binb)):\n if binb[i]:\n circ.x(q[na+i])\n add(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\n circ_m = measure(circ, q, [i for i in range(na, n)])\n return circ_m","def interleaved_sum(n, odd_term, even_term):\n def sum_helper(i, res):\n if i > n:\n return res\n if i % 2 == 0:\n return sum_helper(i+1, res + even_term(i))\n else:\n return sum_helper(i+1, res + odd_term(i))\n return sum_helper(0, 0)","def rle_conversion(bit_data):\n rle, pos = [], 0;\n for bit, group in itertools.groupby(bit_data):\n group_list = list(group);\n if bit: rle.extend([pos, sum(group_list)]);\n pos += len(group_list);\n return rle;"],"string":"[\n \"def BitAdd(m, n, length):\\n\\n lmax = max(len(m), len(n))\\n c = 0\\n ml = [0] * (lmax - len(m)) + [int(x) for x in list(m)]\\n nl = [0] * (lmax - len(n)) + [int(x) for x in list(n)]\\n rl = []\\n for i in range(1, lmax+1):\\n if ml[-i] + nl[-i] + c == 0:\\n rl.insert(0, 0)\\n c = 0\\n elif ml[-i] + nl[-i] + c == 1:\\n rl.insert(0, 1)\\n c = 0\\n elif ml[-i] + nl[-i] + c == 2:\\n rl.insert(0, 0)\\n c = 1\\n elif ml[-i] + nl[-i] + c == 3:\\n rl.insert(0, 1)\\n c = 1\\n if c == 1:\\n rl.insert(0, 1)\\n if length > len(rl):\\n rl = [0] * (length - len(rl)) + rl\\n else:\\n rl = rl[-length:]\\n rl = \\\"\\\".join([str(x) for x in rl])\\n return rl\",\n \"def andbits(num1,num2):\\n thingstoadd=[]\\n for i in range(31):\\n bit1=setbit(num1,i)\\n bit2=setbit(num2,i)\\n bit1=shiftleft(bit1,30 - i)\\n bit2=shiftleft(bit2,30 - i)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n bitsum=shiftright(bitsum,31 - i)\\n thingstoadd.append(bitsum)\\n bit1=setbit(num1,31)\\n bit2=setbit(num2,31)\\n bit1=shiftright(bit1,1)\\n bit2=shiftright(bit2,1)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n thingstoadd.append(bitsum)\\n return sum(thingstoadd)\",\n \"def combine_many(*fudge):\\n result = sum(fudge)\\n print(result)\",\n \"def possible_sums(numbers: Iterator[SnailfishNumber]) -> Iterator[SnailfishNumber]:\\n yield from (a + b for a, b in permutations(numbers, 2))\",\n \"def BitAdd(a, b, bits_to_compute=None):\\r\\n k = len(a)\\r\\n if not bits_to_compute:\\r\\n bits_to_compute = list(range(k))\\r\\n d = [None] * k\\r\\n for i in range(1,k):\\r\\n t = a[i]*b[i]\\r\\n d[i] = (a[i] + b[i] - 2*t, t)\\r\\n d[0] = (None, a[0]*b[0])\\r\\n pg = PreOpL(carry, d)\\r\\n c = [pair[1] for pair in pg]\\r\\n \\r\\n s = [None] * (k+1)\\r\\n if 0 in bits_to_compute:\\r\\n s[0] = a[0] + b[0] - 2*c[0]\\r\\n bits_to_compute.remove(0)\\r\\n for i in bits_to_compute:\\r\\n s[i] = a[i] + b[i] + c[i-1] - 2*c[i]\\r\\n s[k] = c[k-1]\\r\\n return s\",\n \"def _add_stream(aa, bb):\\n carry = 0\\n cc = []\\n for aaa, bbb in zip(aa, bb):\\n carry, val = _add_digit(aaa,bbb, carry)\\n cc.append(val)\\n if carry:\\n cc.append(carry)\\n return cc\",\n \"def power_list_sum(s):\\n x = len(s)\\n my_list = []\\n for i in range(1 << x):\\n my_list.append(sum(([s[j] for j in range(x) if (i & (1 << j))])))\\n\\n return sorted(my_list)\",\n \"def getSum(self, a: int, b: int) -> int:\\n i = 0\\n carry = 0\\n res = 0\\n while i < 12:\\n curr_a_bit = (a >> i) & 1\\n curr_b_bit = (b >> i) & 1\\n # print(curr_a_bit, curr_b_bit)\\n curr_bit = curr_a_bit ^ curr_b_bit ^ carry\\n res |= (curr_bit << i)\\n if curr_a_bit & curr_b_bit == 1 or curr_a_bit & carry == 1 or curr_b_bit & carry == 1:\\n carry = 1\\n else:\\n carry = 0\\n i += 1\\n # print(res, bin(res), bin(a), bin(b))\\n # 不用把 第 13 位 i = 12 时 carry 加上 result, 因为 这一位 判断 正 负 不需要\\n if res >= 2 ** 11:\\n # 举例：最大和2000 ，res < 2 ^ 11, 最小和 -2000， res > 2 ^ 11\\n # 如果 和 是 0，比如 1 和 -1， res = 0\\n # 如果和 是 -1，比如 1 和 -2， res > 2 ^ 11\\n res = (~res) ^ 0b111111111111\\n return res\",\n \"def getSum(self, a, b):\\n result = 0\\n carry = 0\\n carry_on = {(0,0,0), (0,0,1), (1,0,0), (0,1,0)}\\n\\n for i in range(32):\\n a_lsb = a & 1\\n b_lsb = b & 1\\n cur = a_lsb ^ b_lsb ^ carry\\n carry = 0 if (a_lsb, b_lsb, carry) in carry_on else 1\\n\\n result |= cur << i\\n a = a >> 1\\n b = b >> 1\\n # result is negative number\\n if result >> 31 & 1 == 1:\\n new_result = 0\\n for i in range(32):\\n result_lsb = result & 1\\n new_bit = ~result_lsb & 1\\n new_result |= new_bit << i\\n\\n result = result >> 1\\n result = -(new_result + 1)\\n return result\",\n \"def addRes(res1, res2):\\n return [(x + y) for x, y in zip(res1, res2)]\",\n \"def add(iter_1, iter_2):\\n return tuple(int(a + b) for a, b in zip(iter_1, iter_2))\",\n \"def sum_product(numbers: List[int]) -> Tuple[int, int]:\\n#[SOLUTION]\\n sum_value = 0\\n prod_value = 1\\n\\n for n in numbers:\\n sum_value += n\\n prod_value *= n\\n return sum_value, prod_value\",\n \"def _add(a, b):\\n\\n # Todo: What if numbers have bigger length than 8\\n a = _I2B(a, fixed_length=8)\\n b = _I2B(b, fixed_length=8)\\n return _B2I([i ^ j for i, j in zip(a, b)])\",\n \"def add_wo_carry(n1, n2):\\n l1 = [int(x) for x in str(n1)]\\n l2 = [int(x) for x in str(n2)] \\n res1 = map(operator.add, l1, l2)\\n res2 = [str(x)[-1] for x in res1]\\n return \\\"\\\".join(res2)\",\n \"def add_no_carry(*args):\\r\\n num_digits = []\\r\\n\\r\\n for arg in args:\\r\\n num_digits.append(len(str(arg)))\\r\\n\\r\\n max_digits = max(num_digits)\\r\\n # list comprehension way\\r\\n # max_digits = max([len(str(arg)) for arg in args])\\r\\n final_sum = 0\\r\\n\\r\\n for pwr in range(1, max_digits + 1): # iterate through ea decimal\\r\\n result_no_carry = 0\\r\\n for arg in args:\\r\\n if len(str(arg)) >= pwr:\\r\\n # modulus sets the current decimal as the most significant\\r\\n # decimal\\r\\n # floor div selects the most significant decimal\\r\\n result_no_carry += arg % 10**pwr // 10**(pwr - 1)\\r\\n\\r\\n # list comprehension way\\r\\n # result_no_carry = sum([arg % 10**pwr // 10**(pwr - 1) for arg in args if len(str(arg)) >= pwr])\\r\\n\\r\\n # final_sum = str(result_no_carry % 10) + final_sum\\r\\n final_sum += result_no_carry % 10\\r\\n\\r\\n return int(final_sum)\",\n \"def multi_2(cur,p,n):\\n\\tr=p\\n\\twhile n>1:\\n\\t\\tr=sum(cur,r,p)\\n\\t\\tn-=1\\n\\treturn r\",\n \"def test_get_n_bits_combinations():\\n # Check n=1 - Pass\\n assert layer_util.get_n_bits_combinations(1) == [[0], [1]]\\n # Check n=2 - Pass\\n assert layer_util.get_n_bits_combinations(2) == [[0, 0], [0, 1], [1, 0], [1, 1]]\\n\\n # Check n=3 - Pass\\n assert layer_util.get_n_bits_combinations(3) == [\\n [0, 0, 0],\\n [0, 0, 1],\\n [0, 1, 0],\\n [0, 1, 1],\\n [1, 0, 0],\\n [1, 0, 1],\\n [1, 1, 0],\\n [1, 1, 1],\\n ]\",\n \"def test_bit_add_multiple_bytes(self):\\n ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 8, 16, 65535, False, aerospike.BIT_OVERFLOW_FAIL, None)]\\n\\n self.as_connection.operate(self.test_key, ops)\\n\\n _, _, bins = self.as_connection.get(self.test_key)\\n expected_result = bytearray([0] * 1 + [255] * 2 + [0] * 2)\\n assert bins[self.test_bin_zeroes] == expected_result\",\n \"def smart_add(*args):\\n result = 0\\n for item in args:\\n result += item\\n\\n return result\",\n \"def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\\n result = ListNode(0)\\n node = result\\n carry = 0\\n while True:\\n if not l1 is None:\\n x = l1.val\\n l1 = l1.next\\n l1_n = True\\n else:\\n x = 0\\n l1_n = False\\n if not l2 is None:\\n y = l2.val\\n l2 = l2.next\\n l2_n = True\\n else:\\n y = 0\\n l2_n = False\\n res = x + y + carry\\n if res == 0 and not l1_n and not l2_n:\\n return result.next\\n if res > 9:\\n res = res % 10\\n carry = 1\\n else:\\n carry = 0\\n\\n addNode(node, res)\\n node = node.next\",\n \"def summed(L):\\r\\n result = 0\\r\\n for e in L:\\r\\n result = result + e # or result += e\\r\\n return result\",\n \"def sum(*args):\\n result = 0\\n for i in args:\\n result += i\\n return result\",\n \"def EncryptMultipleInt64s(self, numberlist, r_value=None):\\n plaintext = 0\\n number_counter = 0\\n if len(numberlist) > PACKING_LIMIT:\\n raise ValueError('The number of entries in the input list cannot be'\\n + ' more than %d' % (PACKING_LIMIT))\\n for entry in numberlist:\\n if not isinstance(entry, int) and not isinstance(entry, long):\\n raise ValueError('Expected int or long but got: %s' % type(number))\\n if entry < MIN_INT64 or entry > MAX_INT64:\\n raise ValueError('Int64 values need to be between %d and %d but got %d'\\n % (MIN_INT64, MAX_INT64, entry))\\n entry = self._Extend64bitTo96bitTwosComplement(entry)\\n if number_counter > 0:\\n plaintext <<= PACKING_BIT_SIZE\\n plaintext += entry\\n number_counter += 1\\n return self.Encrypt(plaintext, r_value=r_value)\",\n \"def addition_mod(a, b, nbr):\\n bina = [int(x) for x in bin(a)[2:]]\\n binb = [int(x) for x in bin(b)[2:]]\\n binn = [int(x) for x in bin(nbr)[2:]]\\n #print(binn)\\n while len(bina) >= len(binb):\\n binb = [0]+binb\\n while len(bina) < len(binb)-1:\\n bina = [0]+bina\\n while len(binn) < len(bina):\\n binn = [0]+binn\\n while len(binn) > len(bina):\\n bina = [0]+bina\\n binb = [0]+binb\\n binn.reverse()\\n bina.reverse()\\n binb.reverse()\\n #print(bina, binb, binn)\\n n = len(bina)+len(binb)+len(binn)\\n na = len(bina)\\n nab = len(bina)+len(binb)\\n q = QuantumRegister(n+2, 'q')\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binb)):\\n if binb[i]:\\n circ.x(q[na+i])\\n for i in range(len(binn)):\\n if binn[i]:\\n circ.x(q[nab+i])\\n addmod(circ, q, # A, B, lost, last, N, lost2, binn):\\n [q[i] for i in range(len(bina))],\\n [q[i+na] for i in range(len(binb)-1)],\\n q[n],\\n q[na+len(binb)-1],\\n [q[i+nab] for i in range(len(binn))],\\n q[n+1],\\n binn)\\n circ_m = measure(circ, q, [i for i in range(na,nab)])\\n return circ_m\",\n \"def bits_apply(op, n):\\n return verts_to_bits(op[v] for v in bits_to_verts(n))\",\n \"def pack_bits( longbits ):\\n byte = longbits & (0x0101010101010101)\\n byte = (byte | (byte>>7)) & (0x0003000300030003)\\n byte = (byte | (byte>>14)) & (0x0000000f0000000f)\\n byte = (byte | (byte>>28)) & (0x00000000000000ff)\\n return byte\",\n \"def power_sum(power, *args):\\n total = 0\\n for i in args:\\n total += pow(i, power)\\n return total\",\n \"def sumList(n1: Node, n2: Node):\\n result = LinkedList()\\n carry = 0\\n while n1 is not None and n2 is not None:\\n total = n1.data + n2.data + carry\\n carry = total // 10\\n result.appendToTail(total % 10)\\n n1 = n1.next\\n n2 = n2.next\\n\\n while n1 is not None:\\n total = n1.data + carry\\n carry = total // 10\\n result.appendToTail(total % 10)\\n n1 = n1.next\\n\\n while n2 is not None:\\n total = n2.data + carry\\n carry = total // 10\\n result.appendToTail(total % 10)\\n n2 = n2.next\\n\\n if carry:\\n result.appendToTail(carry)\\n\\n return result\",\n \"def add(a, b):\\n return tuple(x+y for x,y in zip(a,b))\",\n \"def xorbits(num1,num2):\\n thingstoadd = []\\n for i in range(31):\\n bit1=setbit(num1,i)\\n bit2=setbit(num2,i)\\n bit1=shiftleft(bit1,31 - i)\\n bit2=shiftleft(bit2,31 - i)\\n bitsum=add(bit1,bit2)\\n bitsum=shiftright(bitsum,31 - i)\\n thingstoadd.append(bitsum)\\n return sum(thingstoadd)\",\n \"def multi_1(cur,p,n):\\n\\tr=p\\n\\tfor k in range(0,n-1):\\n\\t\\tr=sum(cur,r,p)\\n\\treturn r\",\n \"def binary_sums(start, limit):\\n for n in range(start, limit):\\n for i in range(1, n/2 + 1):\\n yield i, n - i\",\n \"def sum(*args):\\n return reduce(lambda x, y: x + y, args)\",\n \"def concatenate_bits(num, bit_mask):\\n\\tbit_positions = get_bit_positions(bit_mask)\\n\\tnum_bits_at_positions = [get_bit(num, pos) for pos in bit_positions]\\n\\tout = 0\\n\\tfor bit in num_bits_at_positions:\\n\\t\\tout = (out << 1) | bit\\n\\treturn out\",\n \"def addTwoNumbers(l1, l2):\\r\\n dummy = curr = ListNode(0)\\r\\n carry = 0\\r\\n while l1 and l2:\\r\\n curr.next = ListNode( ( l1.val + l2.val + carry ) % 10 ) \\r\\n carry = ( l1.val + l2.val + carry ) // 10\\r\\n l1 = l1.next\\r\\n l2 = l2.next\\r\\n curr = curr.next\\r\\n l = l1 or l2 \\r\\n while l:\\r\\n curr.next = ListNode( ( l.val + carry ) % 10 ) \\r\\n carry = ( l.val + carry ) // 10\\r\\n l = l.next\\r\\n curr = curr.next\\r\\n if carry > 0:\\r\\n curr.next = ListNode( carry )\\r\\n \\r\\n return dummy.next\",\n \"def count_bits(dqxx, n):\\n return sum([check_bit(x, n) for x in dqxx])\",\n \"def sum_of_squares(n, k, zeros=False):\\n yield from power_representation(n, 2, k, zeros)\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def custom_sum(*args):\\n return functools.reduce(lambda x, y: x + y, args)\",\n \"def mult_and_sum(*arg_list):\\r\\n result = numpy.empty(arg_list[0].shape, dtype=numpy.float32)\\r\\n result[:] = nodata\\r\\n array_stack = numpy.array(arg_list[0::2])\\r\\n scalar_list = numpy.array(arg_list[1::2])\\r\\n # make a valid mask as big as a single array\\r\\n valid_mask = numpy.logical_and.reduce(\\r\\n array_stack != pop_nodata, axis=0)\\r\\n\\r\\n # mask out all invalid elements but reshape so there's still the same\\r\\n # number of arrays\\r\\n valid_array_elements = (\\r\\n array_stack[numpy.broadcast_to(valid_mask, array_stack.shape)])\\r\\n array_stack = None\\r\\n\\r\\n # sometimes this array is empty, check first before reshaping\\r\\n if valid_array_elements.size != 0:\\r\\n valid_array_elements = valid_array_elements.reshape(\\r\\n -1, numpy.count_nonzero(valid_mask))\\r\\n # multiply each element of the scalar with each row of the valid\\r\\n # array stack, then sum along the 0 axis to get the result\\r\\n result[valid_mask] = numpy.sum(\\r\\n (valid_array_elements.T * scalar_list).T, axis=0)\\r\\n scalar_list = None\\r\\n valid_mask = None\\r\\n valid_array_elements = None\\r\\n return result\",\n \"def expand_bits(cls, bits):\\n if len(bits) != 32:\\n raise ValueError('Can only expand 32 bit bitstrings')\\n else:\\n return cls.permute(bits, cls._expand_bits)\",\n \"def _product(self, args):\\n pools = map(tuple, args) #within original version args defined as *args\\n result = [[]]\\n for pool in pools:\\n result = [x + [y] for x in result for y in pool]\\n return result\",\n \"def make_sum_in_2(a1, *rest):\\n def helper(a, alist, acc):\\n \\\"\\\"\\\"\\n a: first argument\\n alist: scheme list; rest of arguments\\n acc: sum result so far\\n \\\"\\\"\\\"\\n if isNull(alist):\\n if isNumber(a) and a == 0:\\n return acc\\n elif isNumber(acc) and acc == 0:\\n return a\\n elif isNumber(a) and isNumber(acc):\\n return a + acc\\n elif isList(acc):\\n return append(acc, List(plus, a))\\n else:\\n return append(List(acc), List(plus, a))\\n else:\\n # more arguments in alist to process\\n p = car(alist)\\n q = cdr(alist)\\n if isNumber(a) and a == 0:\\n return helper(p, q, acc)\\n elif isNumber(acc) and acc == 0:\\n return helper(p, q, a)\\n elif isNumber(a) and isNumber(acc):\\n return helper(p, q, acc + a)\\n else:\\n if isList(acc):\\n return helper(p, q, append(acc, List(plus, a)))\\n else:\\n return helper(p, q, append(List(acc), List(plus, a)))\\n\\n rests = List(*rest)\\n return helper(a1, rests, 0)\",\n \"def kkAdd(*args):\\n if (None in args):\\n return None\\n total = 0\\n for arg in args:\\n total += arg\\n return total\",\n \"def bincoeff(n: int, k: int = None) -> Union[int, List[int]]:\\n if k is not None:\\n return comb(n, k)\\n else:\\n result = []\\n for i in range(0, n + 1):\\n result.append(comb(n, i))\\n return result\",\n \"def create_sum(length, n, take='take'):\\n\\n\\tresult = []\\n\\t# Generate n sums.\\n\\tfor j in range(n):\\n\\t\\tfirst = []\\n\\t\\tsecond = []\\n\\t\\t# Generate a random number of <length> digits.\\n\\t\\tfor i in range(length):\\n\\t\\t\\tfirst.append(random.randint(0,9))\\n\\t\\t# Generate a random number of <length> digits.\\n\\t\\tfor dig in first:\\n\\t\\t\\t# If take / carry is allowed, second number is purely random.\\n\\t\\t\\tif take == 'take':\\n\\t\\t\\t\\tsecond.append(random.randint(0,9))\\n\\t\\t\\t# If take / carry is not allowed, second number is restricted so that its addition does not cross 9.\\n\\t\\t\\telse:\\n\\t\\t\\t\\tsecond.append(random.randint(0,9-dig))\\n\\t\\t# Convert from list of numbers to strings.\\n\\t\\tdig1 = num_to_str(first)\\n\\t\\tdig2 = num_to_str(second)\\n\\t\\t# Append to the result.\\n\\t\\tresult.append((dig1, dig2))\\n\\t# Return the result.\\n\\treturn result\",\n \"def join_bits(byteseq) -> int:\\n return reduce(lambda acc, bit: (acc << 1) | int(bit), byteseq)\",\n \"def sum_two_linked_lists(ll1, ll2):\\n\\n result = LL()\\n carry = 0\\n\\n while ll1 or ll2:\\n\\n v1 = ll1.value if ll1 else 0\\n v2 = ll2.value if ll2 else 0\\n\\n sum = v1 + v2 + carry\\n if sum > 9:\\n carry = 1\\n sum = sum - 10\\n else:\\n carry = 0\\n\\n result.add(sum)\\n\\n if ll1:\\n ll1 = ll1.next\\n\\n if ll2:\\n ll2 = ll2.next\\n\\n if carry:\\n result.add(carry)\\n\\n return result.head\",\n \"def compute_combinations(items: List[Union[List[Any], Tuple]], n: int) -> List[List[Any]]:\\n return [chunks[i:i + n] for chunks in items for i in range(len(chunks) - (n - 1))]\",\n \"def combinln(n, k):\\n return (special.gammaln(n + 1) - (special.gammaln(k + 1) +\\n special.gammaln(n - k + 1)))\",\n \"def add_bitwise(x, y):\\n\\n answer = 0\\n carry_in = 0\\n k = 1\\n iterations_tracker = x | y\\n\\n while (iterations_tracker):\\n x_k = x & k\\n y_k = y & k\\n\\n answer |= x_k ^ y_k ^ carry_in\\n carry_out = majority_bitwise(x_k, y_k, carry_in)\\n\\n carry_in = carry_out << 1\\n\\n k <<= 1\\n iterations_tracker >>= 1\\n\\n if (carry_in):\\n answer |= carry_in\\n\\n return answer\",\n \"def ll_sum(x):\\n xlist = []\\n for i in x:\\n for num in i:\\n xlist.append(num)\\n return sum(xlist)\",\n \"def add64(a,b):\\n return(np.add(a, b, dtype=np.uint64))\",\n \"def add(num1,num2):\\n if(num2==0):\\n return num1\\n return add((num1^num2),(num1&num2)<<1)\",\n \"def combine(num_one, num_two=0):\\n result = num_one + num_two\\n return result\",\n \"def totalSolutions(n:int):\\n\\n memo = [0]*6\\n memo[5] = 1\\n if n == 1:\\n return 1\\n\\n for i in range(n):\\n solutions = sum(memo)\\n memo.pop(0)\\n memo.append(solutions)\\n\\n return memo.pop()\",\n \"def SUM(*args):\\n return _group_function(lambda x, y: x + y, *args)\",\n \"def mono_sum(l):\\n r = next(l)\\n for m in l: r = r + m\\n return r\",\n \"def __iadd__(self,l):\\r\\n\\t\\t\\r\\n\\t\\treturn self.add(l)\",\n \"def accumulate(combiner, base, n, term):\\n total, k = base, 1\\n while k <= n:\\n total, k = combiner(total, term(k)), k + 1\\n return total\",\n \"def sum_tuples(t1, t2):\\n return tuple(sum(t) for t in zip(t1, t2))\",\n \"def _generateResults_combosToBitmasks(self, all, want_combos):\\n names = {}\\n iter = enumerate(all)\\n try:\\n i, name = next(iter)\\n while True:\\n names[name] = (1 << i)\\n i, name = next(iter)\\n except StopIteration:\\n pass\\n print \\\"combosToBitmasks names:\\\", names\\n results = []\\n for combo in want_combos:\\n mask = 0\\n for name in combo:\\n if name in names:\\n mask |= names[name]\\n results.append(mask)\\n return results\",\n \"def carry(nums):\\n #See get_long_len(nums) doc string for info on this\\n long_len = get_long_len(nums)\\n #See format_nums(nums, sep) doc string for info on this\\n str_nums = format_nums(nums, \\\"0\\\")\\n #Used to keep track of the current carried number\\n carry_num = 0\\n #All the carried numbers used during the operation\\n carry_list = []\\n #Start from the ones digit of all numbers and move up each time, stopping\\n #at the second to last digit\\n for i in range(long_len-1, 0, -1):\\n #The sum for the current digit starts at the previous\\n #carried number\\n digit_sum = carry_num\\n #Reset the carried number for the beginning of the summation\\n #for this digit\\n carry_num = 0\\n #Add all numbers in the current digit location\\n digit_sum += sum([int(num[i]) for num in str_nums])\\n #Find the number to be carried over by dividing by 10\\n carry_num = digit_sum / 10\\n #Append that number to the list of carried numbers\\n carry_list.append(carry_num)\\n\\n #Return a copy of the list reversed\\n return reversed(carry_list)\",\n \"def convert_to_bits(n):\\n result = []\\n if n == 0:\\n return [0]\\n while n > 0:\\n result = [int(n % 2)] + result\\n n = n / 2\\n return result\",\n \"def sum_integer(n):\\n return sum([int(elem) for elem in str(n)])\",\n \"def getSum(self, a, b):\\n #\\n # 首先，sum 存放每次循环中 a 与 b 的异或值，也就是直接相加值；\\n # b 存放每次的进位值，然后 a 存储 sum （也就是直接相加值）进入下一次循环（当进位值非空）；\\n # 当且仅当进位值为空时，用户的上一次循环中的 sum 已经是可以直接相加的异或结果了，此时得到结果，返回。\\n #\\n # if a == 0:\\n # return b\\n # if b == 0:\\n # return a\\n # while b != 0:\\n # carry = a & b\\n # a = a ^ b\\n # b = carry << 1\\n # return a\\n # 32 bits interger max\\n MAX = 0x7FFFFFFF\\n # 32 bits interger min\\n MIN = 0x80000000\\n # mask to get last 32 bits\\n mask = 0xFFFFFFFF\\n\\n #print('doc:', )\\n while b != 0:\\n a, b = (a ^ b) & mask, ((a & b) << 1) & mask\\n\\n return a if a <= MAX else ~(a ^ mask)\",\n \"def create_samples(f: Callable[..., int], n_args: int, n_bits: int,\\n) -> Dict[Tuple[int, ...], Tuple[int, ...]]:\\n samples = {}\\n max_arg = 2 ** n_bits\\n for inputs in itertools.product((0, 1), repeat=n_args * n_bits):\\n ints = [int(\\\"\\\".join(str(bit) for bit in inputs[i:i + n_bits]), 2)\\n for i in range(0, len(inputs), n_bits)]\\n try:\\n output = f(*ints)\\n if 0 <= output < max_arg:\\n bit_string = (\\\"{:0\\\" + str(n_bits) + \\\"b}\\\").format(output)\\n samples[inputs] = tuple(int(bit) for bit in bit_string)\\n except ZeroDivisionError:\\n pass\\n return samples\",\n \"def test_merge_list_values(short_ll, long_ll):\\n ml(short_ll, long_ll)\\n assert long_ll.head.val == 8\\n assert long_ll.head._next.val == 16\",\n \"def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\\n class ListIter():\\n def __init__(self, l: ListNode):\\n self.l = ListNode(next=l)\\n def __iter__(self):\\n return self\\n def __next__(self):\\n self.l = self.l.next\\n if self.l:\\n return self.l.val\\n raise StopIteration\\n \\n l3 = ListNode()\\n li, rem = l3, False\\n for n1, n2 in zip_longest(ListIter(l1), ListIter(l2)):\\n li.next = ListNode()\\n li = li.next\\n s = (n1 if n1 else 0) + (n2 if n2 else 0) + rem\\n li.val, rem = (s - 10, True) if s >= 10 else (s, False)\\n if rem:\\n li.next = ListNode(1)\\n return l3.next\",\n \"def task_8_sum_of_ints(data: List[int]) -> int:\\n return sum(data)\",\n \"def ADD (self, n1, n2):\",\n \"def sum_of_three_squares(n):\\n special = {1:(1, 0, 0), 2:(1, 1, 0), 3:(1, 1, 1), 10: (1, 3, 0), 34: (3, 3, 4), 58:(3, 7, 0),\\n 85:(6, 7, 0), 130:(3, 11, 0), 214:(3, 6, 13), 226:(8, 9, 9), 370:(8, 9, 15),\\n 526:(6, 7, 21), 706:(15, 15, 16), 730:(1, 27, 0), 1414:(6, 17, 33), 1906:(13, 21, 36),\\n 2986: (21, 32, 39), 9634: (56, 57, 57)}\\n\\n v = 0\\n\\n if n == 0:\\n return (0, 0, 0)\\n\\n v = multiplicity(4, n)\\n n //= 4**v\\n\\n if n % 8 == 7:\\n return\\n\\n if n in special.keys():\\n x, y, z = special[n]\\n return _sorted_tuple(2**v*x, 2**v*y, 2**v*z)\\n\\n s, _exact = integer_nthroot(n, 2)\\n\\n if _exact:\\n return (2**v*s, 0, 0)\\n\\n x = None\\n\\n if n % 8 == 3:\\n s = s if _odd(s) else s - 1\\n\\n for x in range(s, -1, -2):\\n N = (n - x**2) // 2\\n if isprime(N):\\n y, z = prime_as_sum_of_two_squares(N)\\n return _sorted_tuple(2**v*x, 2**v*(y + z), 2**v*abs(y - z))\\n return\\n\\n if n % 8 in (2, 6):\\n s = s if _odd(s) else s - 1\\n else:\\n s = s - 1 if _odd(s) else s\\n\\n for x in range(s, -1, -2):\\n N = n - x**2\\n if isprime(N):\\n y, z = prime_as_sum_of_two_squares(N)\\n return _sorted_tuple(2**v*x, 2**v*y, 2**v*z)\",\n \"def bits(a,m):\\r\\n if isinstance(a, int):\\r\\n res = [None]*m\\r\\n for i in range(m):\\r\\n res[i] = a & 1\\r\\n a >>= 1\\r\\n else:\\r\\n res = []\\r\\n from Compiler.types import regint, cint\\r\\n while m > 0:\\r\\n aa = regint()\\r\\n convmodp(aa, a, bitlength=0)\\r\\n res += [cint(x) for x in aa.bit_decompose(min(64, m))]\\r\\n m -= 64\\r\\n if m > 0:\\r\\n aa = cint()\\r\\n shrci(aa, a, 64)\\r\\n a = aa\\r\\n return res\",\n \"def test_sum_of_yields(n):\\n x = 0\\n x += yield (0, x)\\n x += yield (0, x)\\n yield (1, x)\",\n \"def get_chunk_combination(indiv_1, indiv_2, pair_1, pair_2):\\t\\r\\n\\tif check_fixed(indiv_1):\\r\\n\\t\\treturn [[indiv_1+indiv_2, indiv_1+indiv_2]] if check_fixed(indiv_2) else [[indiv_1+pair_2[0], indiv_1+pair_2[1]]]\\r\\n\\telse:\\r\\n\\t\\treturn [[pair_1[0]+indiv_2, pair_1[1]+indiv_2]] if check_fixed(indiv_2) else [[pair_1[0]+pair_2[0], pair_1[0]+pair_2[1]], [pair_1[1]+pair_2[0], pair_1[1]+pair_2[1]]]\\r\\n\\treturn res\",\n \"def sum_unique(l):\\n pass\",\n \"def __add__(self, tc): \\n tc = TwosComplement(tc)\\n bits = self.len if self.len > tc.len else tc.len \\n result = self.int + tc.int\\n return TwosComplement(result, bits)\",\n \"def sum_nums(n1=0, n2=0):\\n return n1 + n2\",\n \"def sum_series(n,v1=0,v2=1):\\n\\tL1=v2\\n\\tL2=v1\\n\\tif n<0:\\n\\t\\tprint(\\\"please enter positive int value\\\")\\n\\n\\telif n==0:\\n\\t\\treturn v1\\n\\n\\telif n==1:\\n\\t\\treturn v2\\n\\n\\telse:\\n\\t\\tfor i in range(n-1):\\n\\t\\t\\tC=L1+L2\\n\\t\\t\\tL2=L1\\n\\t\\t\\tL1=C\\n\\t\\treturn C\",\n \"def add4(a,b):\\n return [a[0]+b[0],a[1]+b[1],a[2]+b[2],a[3]+b[3]]\",\n \"def add_digits(n):\\n return sum([int(d) for d in str(n)])\",\n \"def summation_i_squared(n):\\n if (type(n) is not int) or (n is None) or (n < 1):\\n return None\\n else:\\n numbers = range(1, n + 1)\\n result = 0\\n result = map(lambda i: i ** 2, numbers)\\n return sum(result)\",\n \"def bitlist(n):\\n return [n >> i & 1 for i in range(7,-1,-1)]\",\n \"def compute_n_codes(n_bits, half_bit=None):\\n n_bits, half_bit = parse_bits(n_bits, half_bit)\\n if half_bit:\\n return 2**(n_bits + 1) - 1\\n else:\\n return 2**n_bits\",\n \"def bits(n):\\n\\n # Create a list of the first 1,000 binary numbers\\n binary_list = reverse_binary_list()\\n\\n # Start by calculating number of 1's for n\\n n_ones = num_of_ones(n, binary_list)\\n\\n # Calculate number of 1's for next value\\n next_ones = 0\\n while n_ones != next_ones:\\n n = n + 1\\n next_ones = num_of_ones(n, binary_list)\\n\\n return(n)\",\n \"def lsum (inlist):\\r\\n s = 0\\r\\n for item in inlist:\\r\\n s = s + item\\r\\n return s\",\n \"def triplets():\\n for a in xrange(1, 1000):\\n for b in xrange(a, 1000):\\n c = 1000 - (a + b)\\n if a**2 + b**2 == c**2:\\n return a, b, c\",\n \"def add(num1, num2, Cin):\\n Cin=0\\n l2=[]\\n final=\\\"\\\"\\n\\n \\\"\\\"\\\"Using for loop for starting addition from the last indexed number\\\"\\\"\\\"\\n for i in range(len(num1)-1,-1,-1):\\n bit1=num1[i]#storing each indexed() value of num1 in bit1\\n bit2=num2[i]#storing each indexed() value of num2 in bit2\\n S1=g.XOR(bit1, bit2)#calling XOR() method of gates module and passing value in it.\\n S2=g.NAND(S1, Cin)#calling NAND() method of gates module and passing value in it.\\n S3=g.OR(S1, Cin)#calling OR() method of gates module and passing value in it.\\n SUM=g.AND(S2, S3)#calling AND() method of gates module and passing value in it.\\n C1=g.AND(bit1, bit2)#calling AND() method of gates module and passing value in it.\\n C2=g.AND(S1, Cin)#calling AND() method of gates module and passing value in it.\\n C3=g.NOR(C1, C2)#calling NOR() method of gates module and passing value in it.\\n Cout=g.NOT(C3)#calling NOT() method of gates module and passing value in it.\\n Cin=Cout#declaring cout as cin for next bit addition\\n l2.append(SUM)#adding SUM to l2\\n l3=l2[::-1]##reversing the value of l2\\n final+=str(l2[-1])#converting the list value to string\\n final1=final[::-1]#reversing string value\\n return final1 #returning the binary addition as string\",\n \"def _add(self, i, k):\\n while i < self._size:\\n self._bit[i] += k\\n i += lsb(i)\",\n \"def tup_add(t1, t2):\\n return tuple(map(operator.add, t1, t2))\",\n \"def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:\\n\\n def fetchValueFromListNode(node: ListNode) -> int:\\n \\\"\\\"\\\"\\n Traverse given linked list and generate 1 integer.\\n If given list is something like this (2 -> 4 -> 3),\\n this function returns 3 * 100 + 4 * 10 + 2.\\n \\\"\\\"\\\"\\n curNode = node\\n result = curNode.val\\n loopCount = 1\\n while curNode.next is not None:\\n curNode = curNode.next\\n result += curNode.val * (10 ** loopCount)\\n loopCount += 1\\n\\n return result\\n\\n # Get integers from given lists\\n value1 = fetchValueFromListNode(l1)\\n value2 = fetchValueFromListNode(l2)\\n sumVal = value1 + value2\\n\\n # Generate an answer linked list\\n # by traversing array from top\\n sumValList = str(sumVal)\\n curListNode = ListNode(sumValList[0])\\n prevListNode = None\\n for idx in range(1, len(sumValList)):\\n prevListNode = curListNode\\n curListNode = ListNode(sumValList[idx])\\n curListNode.next = prevListNode\\n\\n return curListNode\",\n \"def _cartesian_add(xs):\\n return sum(prefer_static.reshape(x, shape=[-1] + [1]*(len(xs) - 1 - i))\\n for i, x in enumerate(xs))\",\n \"def GetAllBits(self):\\n return (self.output, self.NumBits())\",\n \"def triple_step_simplified(n):\\n\\ta = 0\\n\\tb = 0\\n\\tc = 1\\n\\tfor i in range(n):\\n\\t\\ttemp = a + b + c\\n\\t\\ta, b, c = b, c, temp\\n\\treturn temp\",\n \"def _generate_bitmask(n: int = 2, n_bits: int = 8) -> int:\\n all_ones = 2 ** n_bits - 1\\n cancel_bits = 2 ** n - 1\\n return all_ones - cancel_bits\",\n \"def prod_LLL(*args):\\n return reduce(lambda a, b: a*b, [2*L+1 for L in args])\",\n \"def addition(a, b):\\n bina = [int(x) for x in bin(a)[2:]]\\n binb = [int(x) for x in bin(b)[2:]]\\n while len(bina) >= len(binb):\\n binb = [0]+binb\\n while len(bina) < len(binb)-1:\\n bina = [0]+bina\\n bina.reverse()\\n binb.reverse()\\n n = len(bina)+len(binb)\\n na = len(bina)\\n q = QuantumRegister(n+1, 'q')\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binb)):\\n if binb[i]:\\n circ.x(q[na+i])\\n add(circ, q, [q[i] for i in range(len(bina))], [q[i+na] for i in range(len(binb)-1)], q[n], q[na+len(binb)-1])\\n circ_m = measure(circ, q, [i for i in range(na, n)])\\n return circ_m\",\n \"def interleaved_sum(n, odd_term, even_term):\\n def sum_helper(i, res):\\n if i > n:\\n return res\\n if i % 2 == 0:\\n return sum_helper(i+1, res + even_term(i))\\n else:\\n return sum_helper(i+1, res + odd_term(i))\\n return sum_helper(0, 0)\",\n \"def rle_conversion(bit_data):\\n rle, pos = [], 0;\\n for bit, group in itertools.groupby(bit_data):\\n group_list = list(group);\\n if bit: rle.extend([pos, sum(group_list)]);\\n pos += len(group_list);\\n return rle;\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.639511","0.63929343","0.59793633","0.59044194","0.5766572","0.573465","0.56742185","0.5659172","0.5646547","0.56439763","0.56177783","0.5554337","0.555092","0.5537357","0.5496097","0.549155","0.5491507","0.54769105","0.54585946","0.54068106","0.54036504","0.5385841","0.536871","0.53622293","0.5354209","0.5346841","0.53454995","0.5311072","0.5301481","0.5297582","0.5280112","0.5280024","0.52655685","0.5234943","0.522878","0.521867","0.5217387","0.5201712","0.5201712","0.5188775","0.5178968","0.5177461","0.5176383","0.51747596","0.5163057","0.51510733","0.5147775","0.5133944","0.5131477","0.5122804","0.51093507","0.51006436","0.51005113","0.5093024","0.50876236","0.50843036","0.5082826","0.5074755","0.5071661","0.5069753","0.5069358","0.50668174","0.5052459","0.50424975","0.5029049","0.5027713","0.5025939","0.50214744","0.50193655","0.5015646","0.50153035","0.5011101","0.50058204","0.50020885","0.4987807","0.49837896","0.49784583","0.4973981","0.49694702","0.49652803","0.496422","0.496133","0.49604315","0.49503657","0.49434716","0.49381483","0.4937226","0.49334148","0.49233338","0.49193275","0.49159703","0.49141857","0.4913301","0.4906243","0.49043357","0.49013934","0.48944318","0.48910788","0.48873428","0.48827904"],"string":"[\n \"0.639511\",\n \"0.63929343\",\n \"0.59793633\",\n \"0.59044194\",\n \"0.5766572\",\n \"0.573465\",\n \"0.56742185\",\n \"0.5659172\",\n \"0.5646547\",\n \"0.56439763\",\n \"0.56177783\",\n \"0.5554337\",\n \"0.555092\",\n \"0.5537357\",\n \"0.5496097\",\n \"0.549155\",\n \"0.5491507\",\n \"0.54769105\",\n \"0.54585946\",\n \"0.54068106\",\n \"0.54036504\",\n \"0.5385841\",\n \"0.536871\",\n \"0.53622293\",\n \"0.5354209\",\n \"0.5346841\",\n \"0.53454995\",\n \"0.5311072\",\n \"0.5301481\",\n \"0.5297582\",\n \"0.5280112\",\n \"0.5280024\",\n \"0.52655685\",\n \"0.5234943\",\n \"0.522878\",\n \"0.521867\",\n \"0.5217387\",\n \"0.5201712\",\n \"0.5201712\",\n \"0.5188775\",\n \"0.5178968\",\n \"0.5177461\",\n \"0.5176383\",\n \"0.51747596\",\n \"0.5163057\",\n \"0.51510733\",\n \"0.5147775\",\n \"0.5133944\",\n \"0.5131477\",\n \"0.5122804\",\n \"0.51093507\",\n \"0.51006436\",\n \"0.51005113\",\n \"0.5093024\",\n \"0.50876236\",\n \"0.50843036\",\n \"0.5082826\",\n \"0.5074755\",\n \"0.5071661\",\n \"0.5069753\",\n \"0.5069358\",\n \"0.50668174\",\n \"0.5052459\",\n \"0.50424975\",\n \"0.5029049\",\n \"0.5027713\",\n \"0.5025939\",\n \"0.50214744\",\n \"0.50193655\",\n \"0.5015646\",\n \"0.50153035\",\n \"0.5011101\",\n \"0.50058204\",\n \"0.50020885\",\n \"0.4987807\",\n \"0.49837896\",\n \"0.49784583\",\n \"0.4973981\",\n \"0.49694702\",\n \"0.49652803\",\n \"0.496422\",\n \"0.496133\",\n \"0.49604315\",\n \"0.49503657\",\n \"0.49434716\",\n \"0.49381483\",\n \"0.4937226\",\n \"0.49334148\",\n \"0.49233338\",\n \"0.49193275\",\n \"0.49159703\",\n \"0.49141857\",\n \"0.4913301\",\n \"0.4906243\",\n \"0.49043357\",\n \"0.49013934\",\n \"0.48944318\",\n \"0.48910788\",\n \"0.48873428\",\n \"0.48827904\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6577094"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74298,"cells":{"query":{"kind":"string","value":"Get the probability of a successful addition for each possible pair of two n_bit summands from the results output by get_n_bit_adder_results"},"document":{"kind":"string","value":"def get_success_probabilities_from_results(results: Sequence[Sequence[Sequence[int]]]) \\\n -> Sequence[float]:\n num_shots = len(results[0])\n n_bits = len(results[0][0]) - 1\n\n probabilities = []\n # loop over all binary strings of length n_bits\n for result, bits in zip(results, all_bitstrings(2 * n_bits)):\n # Input nums are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bit_array_to_int(bits[:n_bits])\n num_b = bit_array_to_int(bits[n_bits:])\n\n # add the numbers\n ans = num_a + num_b\n ans_bits = int_to_bit_array(ans, n_bits + 1)\n\n # a success occurs if a shot matches the expected ans bit for bit\n probability = 0\n for shot in result:\n if np.array_equal(ans_bits, shot):\n probability += 1. / num_shots\n probabilities.append(probability)\n\n return probabilities"},"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_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\n int]] = None,\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,\n num_shots: int = 100, use_param_program: bool = False,\n use_active_reset: bool = True, show_progress_bar: bool = False) \\\n -> Sequence[Sequence[Sequence[int]]]:\n if registers is None:\n registers = get_qubit_registers_for_adder(qc, n_bits, qubits)\n\n reset_prog = Program()\n if use_active_reset:\n reset_prog += RESET()\n\n add_prog = Program()\n if use_param_program:\n dummy_num = [0 for _ in range(n_bits)]\n add_prog = adder(dummy_num, dummy_num, *registers, in_x_basis=in_x_basis,\n use_param_program=True)\n\n all_results = []\n # loop over all binary strings of length n_bits\n for bits in tqdm(all_bitstrings(2 * n_bits), disable=not show_progress_bar):\n # split the binary number into two numbers\n # which are the binary numbers the user wants to add.\n # They are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bits[:n_bits]\n num_b = bits[n_bits:]\n\n if not use_param_program:\n add_prog = adder(num_a, num_b, *registers, in_x_basis=in_x_basis,\n use_param_program=False)\n\n prog = reset_prog + add_prog\n prog.wrap_in_numshots_loop(num_shots)\n nat_quil = qc.compiler.quil_to_native_quil(prog)\n exe = qc.compiler.native_quil_to_executable(nat_quil)\n\n if use_param_program:\n exe.write_memory(region_name=REG_NAME, value=bits)\n\n # Run it on the QPU or QVM\n results = qc.run(exe).readout_data.get('ro')\n all_results.append(results)\n\n return all_results","def bin_dist(n, p, x):\n def factorial(x):\n if x >= 0:\n \n factorial = 1\n\n for i in range(1, x + 1):\n factorial = float(factorial * i)\n # print(f' The factorial of {x} is {factorial}') \n return factorial\n\n else:\n raise ValueError(\"Sorry x cannot be a negative number\")\n\n def combination(n, r):\n \"\"\"\n Given n total number of items,\n what is the number of possible ways\n to choose r items from it?\n\n :param n: total number of items (integer)\n :param r: number of items to arrange (int)\n :return: number of combinations\n :rtype: integer\n \"\"\"\n\n \n\n \n numerator = factorial(n)\n denominator = factorial(r)\n subtracted_answer = factorial(n-r)\n \n\n answer = numerator/(denominator * subtracted_answer)\n print(answer)\n return answer \n\n # from scipy.special import comb\n if x > n:\n raise ValueError(\"Error, x must be less than n\")\n else:\n\n\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\n\n print(prob_success)\n return prob_success","def probability_of_all_successes(p: float, r: int, n: int) -> float:\n\n if r == 1:\n return pow(p, n)\n elif n == 0:\n return 1\n else:\n result = 0\n for x in range(0, n+1):\n result += pow(p, x) * pow(1-p, n-x) * probability_of_all_successes(p, r-1, n-x)\n return result","def binomial(n, p):\n sum_ans = 0\n for k in range(n):\n sum_ans = sum_ans + bernoulli(p)\n return sum_ans","def chance(n, p):\n total = 0.0\n for k in range(n+1):\n total += comb(n, k, exact=False) * p**k * (1-p) ** (n-k)\n return total","def test_get_n_bits_combinations():\n # Check n=1 - Pass\n assert layer_util.get_n_bits_combinations(1) == [[0], [1]]\n # Check n=2 - Pass\n assert layer_util.get_n_bits_combinations(2) == [[0, 0], [0, 1], [1, 0], [1, 1]]\n\n # Check n=3 - Pass\n assert layer_util.get_n_bits_combinations(3) == [\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 0],\n [0, 1, 1],\n [1, 0, 0],\n [1, 0, 1],\n [1, 1, 0],\n [1, 1, 1],\n ]","def test_count_bits(n, result):\n from count_bits import count_bits\n assert count_bits(n) == result","def solution(n: int = 28123) -> int:\n\n nums = range(1, n+1)\n abundant = list(filter(is_abundant, nums))\n abundant_sums = set(all_sums(abundant, n))\n fit = set(nums) - abundant_sums\n return fit","def solution2(n):\n ones = 0\n while n > 0:\n if n & 1:\n ones += 1\n n = n >> 1\n\n return 0 if ones % 2 == 0 else 1","def calculate_probability(k: int, m: int, n: int) -> float:\n population = [\"AA\" for _ in range(k)] + [\"Aa\" for _ in range(m)] + [\"aa\" for _ in range(n)]\n pairings = it.combinations(population, 2)\n probabilities = [PROBABILITIES[pairing] for pairing in pairings]\n output = sum(probabilities) / len(probabilities)\n\n return output","def binomial(n: int, p: float) -> int:\n return sum(bernoulli_trial(p) for _ in range(n))","def _get_possible_outcomes(m, bits):\n\n # This is filled with loads of dirty binary tricks...You have been warned\n\n size = max(m.shape) # Max of shape to account for bra or ket\n nqubits = int(math.log(size, 2) + .1) # Number of qubits possible\n\n # Make the output states and put in output_matrices, nothing in them now.\n # Each state will represent a possible outcome of the measurement\n # Thus, output_matrices[0] is the matrix which we get when all measured\n # bits return 0. and output_matrices[1] is the matrix for only the 0th\n # bit being true\n output_matrices = []\n for i in range(1 << len(bits)):\n output_matrices.append(zeros(2**nqubits, 1))\n\n # Bitmasks will help sort how to determine possible outcomes.\n # When the bit mask is and-ed with a matrix-index,\n # it will determine which state that index belongs to\n bit_masks = []\n for bit in bits:\n bit_masks.append(1 << bit)\n\n # Make possible outcome states\n for i in range(2**nqubits):\n trueness = 0 # This tells us to which output_matrix this value belongs\n # Find trueness\n for j in range(len(bit_masks)):\n if i & bit_masks[j]:\n trueness += j + 1\n # Put the value in the correct output matrix\n output_matrices[trueness][i] = m[i]\n return output_matrices","def bin_cdf(n, p, x):\n\n # p C (bin_dist) ** 0 ) *(1-bin_dist)** p\n\n # n = (p)=20\n # x = x = 1 = r\n # nCr = n! / r!(n-r)\n\n \n\n\n\n\n\n\n\n\n def bin_dist(n, p, x):\n \"\"\"\n Given n number of trials, p the probability of success,\n what is the probability of having x successes?\n\n Your function should raise a ValueError if x is higher\n than n.\n\n If you need to compute combinations, you can import the\n function \"comb\" from the package \"scipy.special\"\n\n :param n: number of trials (int)\n :param p: probability of success\n :param x: number of successes (int)\n :return: probability of having x successes\n :rtype: float\n :raise ValueError: if x > n\n \"\"\"\n def factorial(x):\n if x >= 0:\n \n factorial = 1\n\n for i in range(1, x + 1):\n factorial = float(factorial * i)\n # print(f' The factorial of {x} is {factorial}') \n return factorial\n\n else:\n raise ValueError(\"Sorry x cannot be a negative number\")\n\n def combination(n, r):\n \"\"\"\n Given n total number of items,\n what is the number of possible ways\n to choose r items from it?\n\n :param n: total number of items (integer)\n :param r: number of items to arrange (int)\n :return: number of combinations\n :rtype: integer\n \"\"\"\n\n \n\n \n numerator = factorial(n)\n denominator = factorial(r)\n subtracted_answer = factorial(n-r)\n \n\n answer = numerator/(denominator * subtracted_answer)\n print(answer)\n return answer \n\n # from scipy.special import comb\n if x > n:\n raise ValueError(\"Error, x must be less than n\")\n else:\n\n\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\n\n print(prob_success)\n return prob_success \n \n # an= 1-bin_dist(n,p,x)\n # print(f'word{an}')\n # n= 12\n # p=0.25\n # # x=0??\n # ((n!)/ (x!*(n-x)!)) * (p**x) * (1-p)**(n-x)\n sum_prob = []\n for i in range(x+1):\n print(i)\n prob = bin_dist(n,p,x=i)\n sum_prob.append(prob)\n print(sum_prob)\n total =sum(sum_prob)\n print(total)","def perform_bernoulli_trials(n, p):\n # Initialize number of successes: n_success\n n_success = 0\n\n\n # Perform trials\n for i in range(n):\n # Choose random number between zero and one: random_number\n random_number = np.random.random()\n\n\n # If less than p, it's a success so add one to n_success\n if random_number < p:\n n_success += 1\n\n return n_success","def perform_bernoulli_trials(n, p):\n # Initialize number of successes: n_success\n n_success = 0\n\n\n # Perform trials\n for i in range(n):\n # Choose random number between zero and one: random_number\n random_number = np.random.random()\n\n # If less than p, it's a success so add one to n_success\n if random_number< p:\n n_success += 1\n\n return n_success","def addition_mod(a, b, nbr):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n binn = [int(x) for x in bin(nbr)[2:]]\n #print(binn)\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n while len(binn) < len(bina):\n binn = [0]+binn\n while len(binn) > len(bina):\n bina = [0]+bina\n binb = [0]+binb\n binn.reverse()\n bina.reverse()\n binb.reverse()\n #print(bina, binb, binn)\n n = len(bina)+len(binb)+len(binn)\n na = len(bina)\n nab = len(bina)+len(binb)\n q = QuantumRegister(n+2, 'q')\n circ = QuantumCircuit(q)\n for i in range(na):\n if bina[i]:\n circ.x(q[i])\n for i in range(len(binb)):\n if binb[i]:\n circ.x(q[na+i])\n for i in range(len(binn)):\n if binn[i]:\n circ.x(q[nab+i])\n addmod(circ, q, # A, B, lost, last, N, lost2, binn):\n [q[i] for i in range(len(bina))],\n [q[i+na] for i in range(len(binb)-1)],\n q[n],\n q[na+len(binb)-1],\n [q[i+nab] for i in range(len(binn))],\n q[n+1],\n binn)\n circ_m = measure(circ, q, [i for i in range(na,nab)])\n return circ_m","def solution(N):\n\tresult = 0\n\tcounter = 0\n\n\tbin_number = \"{0:b}\".format(N)\n\n\tfor num in bin_number:\n\t\tif num == \"1\":\n\t\t\tif counter > result:\n\t\t\t\tresult = counter\n\t\t\tcounter = 0\n\t\telse:\n\t\t\tcounter += 1\n\n\treturn result;","def perform_bernoulli_trials(n, p):\n # Initialize number of successes: n_success\n n_success = 0\n # Perform trials\n for i in range(n):\n # Choose random number between zero and one: random_number\n random_number = np.random.random()\n # If less than p, it's a success so add one to n_success\n if random_number < p:\n n_success += 1\n\n return n_success","def countbrute(m):\n nfound=0\n\n for i in range(1,m+1):\n for j in range(1,i+1):\n for k in range(1,j+1):\n d1=i*i+(j+k)*(j+k) \n if(checkpsq(d1)):\n nfound=nfound+1\n\n return nfound","def perform_bernoulli_trials(n, p):\n # Initialize number of successes: n_success\n n_success = 0\n\n # Perform trials\n for i in range(n):\n # Choose random number between zero and one: random_number\n random_number = np.random.random()\n\n # If less than p, it's a success so add one to n_success\n if random_number < p:\n n_success += 1\n\n return n_success","def test_conditional_2bit(self):\n shots = 100\n circuits = ref_conditionals.conditional_circuits_2bit(final_measure=True)\n targets = ref_conditionals.conditional_counts_2bit(shots)\n job = execute(circuits, QasmSimulator(), shots=shots)\n result = job.result()\n self.is_completed(result)\n self.compare_counts(result, circuits, targets, delta=0)","def andbits(num1,num2):\n thingstoadd=[]\n for i in range(31):\n bit1=setbit(num1,i)\n bit2=setbit(num2,i)\n bit1=shiftleft(bit1,30 - i)\n bit2=shiftleft(bit2,30 - i)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n bitsum=shiftright(bitsum,31 - i)\n thingstoadd.append(bitsum)\n bit1=setbit(num1,31)\n bit2=setbit(num2,31)\n bit1=shiftright(bit1,1)\n bit2=shiftright(bit2,1)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n thingstoadd.append(bitsum)\n return sum(thingstoadd)","def bits(n):\n\n # Create a list of the first 1,000 binary numbers\n binary_list = reverse_binary_list()\n\n # Start by calculating number of 1's for n\n n_ones = num_of_ones(n, binary_list)\n\n # Calculate number of 1's for next value\n next_ones = 0\n while n_ones != next_ones:\n n = n + 1\n next_ones = num_of_ones(n, binary_list)\n\n return(n)","def challenge_solver(number1, number2, threshold):\n return (sum_of_n_terms(number1, threshold)\n + sum_of_n_terms(number2, threshold)\n - sum_of_n_terms(number1 * number2, threshold))","def count_pairs(idx, bit_up_a, bit_up_b, bit_up_c, mem):\n\n global a\n global b\n global c\n\n if idx == -1:\n return 1\n\n if (idx, bit_up_a, bit_up_b, bit_up_c) in mem:\n return mem[(idx, bit_up_a, bit_up_b, bit_up_c)]\n\n count = 0\n mask = 1 << idx\n\n for i, j in [(0, 0), (0, 1), (1, 0), (1, 1)]:\n\n k = i ^ j\n\n if bit_up_a:\n if not (a & mask) and i == 1:\n continue\n elif (a & mask) and i == 0:\n next_a = 0\n else:\n next_a = 1\n else:\n next_a = 0\n\n if bit_up_b:\n if not (b & mask) and j == 1:\n continue\n elif (b & mask) and j == 0:\n next_b = 0\n else:\n next_b = 1\n else:\n next_b = 0\n\n if bit_up_c:\n if not (c & mask) and k == 1:\n continue\n elif (c & mask) and k == 0:\n next_c = 0\n else:\n next_c = 1\n else:\n next_c = 0\n\n count += count_pairs(idx - 1, next_a, next_b, next_c, mem)\n\n mem[(idx, bit_up_a, bit_up_b, bit_up_c)] = count\n return count","def combination(n, r):\n\n \n\n \n numerator = factorial(n)\n denominator = factorial(r)\n subtracted_answer = factorial(n-r)\n \n\n answer = numerator/(denominator * subtracted_answer)\n print(answer)\n return answer","def test_results():\n x = 0.5\n np.testing.assert_almost_equal(nbf.sum_x_n_calc(\n x, z_n, k_n_1), npf.sum_x_n_calc(x, z_n, k_n_1))","def get_most_probable_bit_with_thres(filtered_capture, prob_threshold):\n # Enumerate challenge/responses to build a list of\n # (probabilities, challenge, value)\n sorted_prob = []\n for challenge, response in filtered_capture.items():\n n0, n1 = response\n n = n0 + n1\n if n < MIN_COUNT_FOR_MEANING:\n # Ignore challenges with not enough measures\n continue\n # q0 = ncr(n, n0) * pow(1 - PROB, n0) * pow(PROB, n1)\n # q1 = ncr(n, n0) * pow(PROB, n0) * pow(1 - PROB, n1)\n # unnormalize_q0 = pow(1 - PROB, n0) * pow(PROB, n1)\n # unnormalize_q1 = pow(PROB, n0) * pow(1 - PROB, n1)\n # p_b0 = unnormalized_q0 / (unnormalized_q1 + unnormalized_q0)\n # p_b1 = unnormalized_q1 / (unnormalized_q1 + unnormalized_q0)\n if n >= 500:\n # Prevent \"OverflowError: (34, 'Numerical result out of range')\"\n p_b0 = n0 / (n0 + n1)\n p_b1 = n1 / (n1 + n0)\n else:\n p_b0 = 1. / (1 + pow(PROB / (1 - PROB), n0) * pow((1 - PROB) / PROB, n1))\n p_b1 = 1. / (1. + pow(PROB / (1 - PROB), n1) * pow((1 - PROB) / PROB, n0))\n # print(f\"[{n0:2}+{n1:2}={n:2}] pb0={p_b0:.3}, pb1={p_b1:.3}\")\n if p_b1 > prob_threshold and p_b1 > p_b0:\n sorted_prob.append((p_b1, challenge, 1))\n elif p_b0 > prob_threshold and p_b0 > p_b1:\n sorted_prob.append((p_b0, challenge, 0))\n\n sorted_prob.sort()\n # print(f\"Trying to find a bit out of {len(sorted_prob)} challenges with p>={prob_threshold}...\")\n while sorted_prob:\n best_prob, best_chall, best_val = sorted_prob.pop()\n best_count = count_ones(best_chall)\n if best_count == 1:\n print(f\"Found a bit: {best_chall:#x} = {best_val} (proba {best_prob})\")\n return (best_chall, best_val)\n\n # Combine the probabilities\n for prob, chall, val in sorted_prob.copy():\n if chall == best_chall:\n continue\n # Reduce the masking with XOR\n if chall & ~best_chall == 0:\n # Ensure that the masking is reasonable\n count_xor = count_ones(best_chall ^ chall)\n if count_xor <= 2 and count_xor < best_count:\n new_prob = prob * best_prob\n if new_prob > prob_threshold:\n sorted_prob.append((new_prob, chall ^ best_chall, val ^ best_val))\n sorted_prob.sort()\n\n print(f\"Unable to found a bit with threshold={prob_threshold}\")\n return None","def bit_contribution_test(hash_function):\n\n model = hash_function()\n hash_list = []\n zero_str = '0' * 2048\n for i in range(1, 2049):\n for j in range(0, i):\n flip_str = zero_str[:j] + '1' + zero_str[j+1:i]\n hash_list.append(list(map(int, list(msg_to_bits.pad_msg(flip_str, i)))))\n if i % 200 == 0:\n print(i)\n\n hashed_dict = dict()\n collisions = 0\n i = 0\n for to_hash in hash_list:\n i += 1\n hash_val = model.hash(to_hash, False).tostring()\n if hash_val in hashed_dict:\n collisions += 1\n hashed_dict[hash_val] = True\n if i % 10000 == 0:\n print(i)\n\n return collisions","def test_bin_addition():\n outcome1 = Outcome(\"red\", 1)\n outcome2 = Outcome(\"black\", 1)\n outcome3 = Outcome(\"low\", 5)\n outcome4 = Outcome(\"high\", 5)\n\n rng = NonRandom()\n wheel = Wheel(rng)\n\n wheel.addOutcome(1, outcome1)\n wheel.addOutcome(1, outcome3)\n wheel.addOutcome(31, outcome2)\n wheel.addOutcome(31, outcome4)\n\n # since we added only two outcomes for each of the two bins,\n # the number of outcomes for both bins should be 2 and 0 for all others\n wheel.rng.setSeed(1)\n returned_bin = wheel.next()\n outcomes = returned_bin.outcomes\n print outcomes\n assert len(outcomes) == 2\n assert outcome1 in returned_bin.outcomes\n assert outcome3 in returned_bin.outcomes\n\n wheel.rng.setSeed(31)\n returned_bin = wheel.next()\n assert outcome3, outcome2 in returned_bin.outcomes\n assert outcome3, outcome4 in returned_bin.outcomes\n\n for i in range(0, 38):\n if i not in [1, 31]:\n wheel.rng.setSeed(i)\n returned_bin = wheel.next()\n assert len(returned_bin.outcomes) == 0","def _expected_values(cont):\n n = float(sum(cont))\n results = []\n for i in range(4):\n results.append((cont[i] + cont[i ^ 1]) * (cont[i] + cont[i ^ 2]) / n)\n return results","def problem(args:int) -> int:\r\n\ta, b, c = 1, 2, 0\r\n\tresult = [a]\r\n\twhile c <= args:\r\n\t\tc = a + b\r\n\t\ta = b\r\n\t\tb = c\r\n\t\tresult.append(a)\r\n\tresult = np.array(result)\r\n\treturn sum(result[result % 2 == 0])","def main():\n\n import sys\n sys.setrecursionlimit(10**7)\n from itertools import accumulate, combinations, permutations, product # https://docs.python.org/ja/3/library/itertools.html\n # accumulate() returns iterator! to get list: list(accumulate())\n from math import factorial, ceil, floor\n def factorize(n):\n \"\"\"return the factors of the Arg and count of each factor\n \n Args:\n n (long): number to be resolved into factors\n \n Returns:\n list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]\n \"\"\"\n fct = [] # prime factor\n b, e = 2, 0 # base, exponent\n while b * b <= n:\n while n % b == 0:\n n = n // b\n e = e + 1\n if e > 0:\n fct.append((b, e))\n b, e = b + 1, 0\n if n > 1:\n fct.append((n, 1))\n return fct\n def combinations_count(n, r):\n \"\"\"Return the number of selecting r pieces of items from n kinds of items.\n \n Args:\n n (long): number\n r (long): number\n \n Raises:\n Exception: not defined when n or r is negative\n \n Returns:\n long: number\n \"\"\"\n # TODO: How should I do when n - r is negative?\n if n < 0 or r < 0:\n raise Exception('combinations_count(n, r) not defined when n or r is negative')\n if n - r < r: r = n - r\n if r < 0: return 0\n if r == 0: return 1\n if r == 1: return n\n numerator = [n - r + k + 1 for k in range(r)]\n denominator = [k + 1 for k in range(r)]\n for p in range(2,r+1):\n pivot = denominator[p - 1]\n if pivot > 1:\n offset = (n - r) % p\n for k in range(p-1,r,p):\n numerator[k - offset] /= pivot\n denominator[k] /= pivot\n result = 1\n for k in range(r):\n if numerator[k] > 1:\n result *= int(numerator[k])\n return result\n def combinations_with_replacement_count(n, r):\n \"\"\"Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.\n \n Args:\n n (long): number\n r (long): number\n \n Raises:\n Exception: not defined when n or r is negative\n \n Returns:\n long: number\n \"\"\"\n if n < 0 or r < 0:\n raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')\n elif n == 0:\n return 1\n else:\n return combinations_count(n + r - 1, r)\n from bisect import bisect_left, bisect_right\n from collections import deque, Counter, defaultdict # https://docs.python.org/ja/3/library/collections.html#collections.deque\n from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html\n from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html\n from operator import itemgetter\n # ex1: List.sort(key=itemgetter(1))\n # ex2: sorted(tuples, key=itemgetter(1,2))\n from functools import reduce\n def chmin(x, y):\n \"\"\"change minimum\n if x > y, x = y and return (x, True).\n convenient when solving problems of dp[i]\n \n Args:\n x (long): current minimum value\n y (long): potential minimum value\n \n Returns:\n (x, bool): (x, True) when updated, else (x, False)\n \"\"\"\n if x > y:\n x = y\n return (x, True)\n else:\n return (x, False)\n def chmax(x, y):\n \"\"\"change maximum\n if x < y, x = y and return (x, True).\n convenient when solving problems of dp[i]\n \n Args:\n x (long): current maximum value\n y (long): potential maximum value\n \n Returns:\n (x, bool): (x, True) when updated, else (x, False)\n \"\"\"\n if x < y:\n x = y\n return (x, True)\n else:\n return (x, False)\n\n from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.\n def gcds(numbers):\n return reduce(gcd, numbers)\n def lcm(x, y):\n return (x * y) // gcd(x, y)\n def lcms(numbers):\n return reduce(lcm, numbers, 1)\n\n # first create factorial_list\n # fac_list = mod_factorial_list(n)\n INF = 10 ** 18\n MOD = 10 ** 9 + 7\n modpow = lambda a, n, p = MOD: pow(a, n, p) # Recursive function in python is slow!\n def modinv(a, p = MOD):\n # evaluate reciprocal using Fermat's little theorem:\n # a**(p-1) is identical to 1 (mod p) when a and p is coprime\n return modpow(a, p-2, p)\n def modinv_list(n, p = MOD):\n if n <= 1:\n return [0,1][:n+1]\n else:\n inv_t = [0,1]\n for i in range(2, n+1):\n inv_t += [inv_t[p % i] * (p - int(p / i)) % p]\n return inv_t\n def modfactorial_list(n, p = MOD):\n if n == 0:\n return [1]\n else:\n l = [0] * (n+1)\n tmp = 1\n for i in range(1, n+1):\n tmp = tmp * i % p\n l[i] = tmp\n return l\n def modcomb(n, k, fac_list = [], p = MOD):\n # fac_list = modfactorial_list(100)\n # print(modcomb(100, 5, modfactorial_list(100)))\n from math import factorial\n if n < 0 or k < 0 or n < k: return 0\n if n == 0 or k == 0: return 1\n if len(fac_list) <= n:\n a = factorial(n) % p\n b = factorial(k) % p\n c = factorial(n-k) % p\n else:\n a = fac_list[n]\n b = fac_list[k]\n c = fac_list[n-k]\n return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p\n def modadd(a, b, p = MOD):\n return (a + b) % MOD\n def modsub(a, b, p = MOD):\n return (a - b) % p\n def modmul(a, b, p = MOD):\n return ((a % p) * (b % p)) % p\n def moddiv(a, b, p = MOD):\n return modmul(a, modpow(b, p-2, p))\n\n \"\"\" initialize variables and set inputs\n # initialize variables\n # to initialize list, use [0] * n\n # to initialize two dimentional array, use [[0] * N for _ in range(N)]\n # set inputs\n # open(0).read() is a convenient method:\n # ex) n, m, *x = map(int, open(0).read().split())\n # min(x[::2]) - max(x[1::2])\n # ex2) *x, = map(int, open(0).read().split())\n # don't forget to add comma after *x if only one variable is used\n # preprocessing\n # transpose = [x for x in zip(*data)]\n # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [(1, 4, 7), (2, 5, 8), (3, 6, 9)]\n # flat = [flatten for inner in data for flatten in inner]\n # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [1, 2, 3, 4, 5, 6, 7, 8, 9]\n # calculate and output\n # output pattern\n # ex1) print(*l) => when l = [2, 5, 6], printed 2 5 6\n \"\"\"\n\n # functions used\n r = lambda: sys.stdin.readline().strip()\n r_int = lambda: int(r())\n R = lambda: list(map(int, r().split()))\n Rfloat = lambda: list(map(float, r().split()))\n Rtuple = lambda: tuple(map(int, r().split()))\n Rmap = lambda: map(int, r().split())\n\n \"\"\" how to treat input\n # single int: int(r())\n # single string: r()\n # single float: float(r())\n # line int: R()\n # line string: r().split()\n # line (str, int, int): [j if i == 0 else int(j) for i, j in enumerate(r().split())]\n # lines int: [R() for _ in range(n)]\n \"\"\"\n\n # main\n N, Q = R()\n STX = [R() for _ in range(N)]\n STX.sort(key=itemgetter(2))\n\n D = [int(r()) for _ in range(Q)]\n Stopped = [-1] * Q\n ans = [-1] * Q\n\n for s, t, x in STX:\n l = bisect_left(D, s-x)\n r = bisect_left(D,t-x)\n a = l\n while a < r:\n if Stopped[a] == -1:\n ans[a] = x\n Stopped[a] = r\n a += 1\n else:\n a = Stopped[a]\n\n for i in ans:\n print(i)\n\n \"\"\"memo: how to use defaultdict of list\n # initialize\n Dic = defaultdict(list)\n # append / extend\n Dic[x].append(y)\n # for\n for k, v in Dic.items():\n \"\"\"","def taskOfPairing(freq):\n n_pairs = list(map(lambda x: x // 2, freq))\n remainders = list(map(lambda x: x % 2, freq))\n print(freq)\n print(n_pairs)\n print(remainders)\n\n total = sum(n_pairs)\n print(total)\n i = 1\n while i < len(freq):\n print('i', i, remainders[i], remainders[i - 1])\n if remainders[i] + remainders[i - 1] == 2:\n print('total', total, 'i', i)\n total = total + 1\n i = i + 2\n print('newtotal', total, 'i', i)\n else:\n i += 1\n print(total)\n return total","def calculate_bleu(candidate, reference):\n pn_sum = 0\n for n in range(1, 4):\n cand_grama, ref_grama = n_grama(candidate, n), n_grama(reference, n)\n p = calculate_p(cand_grama, ref_grama)\n if p != 0:\n # If there are no matches between n_grams,\n # don't add nothing\n pn_sum += (0.33 * math.log(p))\n bp = calculate_bp_penality(candidate, reference)\n return bp * math.exp(pn_sum)","def compute_n_codes(n_bits, half_bit=None):\n n_bits, half_bit = parse_bits(n_bits, half_bit)\n if half_bit:\n return 2**(n_bits + 1) - 1\n else:\n return 2**n_bits","def test_count_binary_decisions(self):\n abs_centered_quantized_data_0 = numpy.array([0.75, 0.05, 0.1, 0.2, 0.2, 0.15], dtype=numpy.float32)\n bin_width_test_0 = 0.05\n abs_centered_quantized_data_1 = numpy.array([210., 6., 9., 6.], dtype=numpy.float32)\n bin_width_test_1 = 3.\n truncated_unary_prefix = 7\n \n (cumulated_zeros_0, cumulated_ones_0) = \\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_0,\n bin_width_test_0,\n truncated_unary_prefix)\n (cumulated_zeros_1, cumulated_ones_1) = \\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_1,\n bin_width_test_1,\n truncated_unary_prefix)\n print('1st experiment:')\n print('Number of occurrences of 0 for each binary decision computed by the function:')\n print(cumulated_zeros_0)\n print('Number of occurrences of 0 for each binary decision computed by hand:')\n print(numpy.array([0, 1, 1, 1, 2, 0, 0]))\n print('Number of occurrences of 1 for each binary decision computed by the function:')\n print(cumulated_ones_0)\n print('Number of occurrences of 1 for each binary decision computed by hand:')\n print(numpy.array([6, 5, 4, 3, 1, 1, 1]))\n print('\\n2nd experiment:')\n print('Number of occurrences of 0 for each binary decision computed by the function:')\n print(cumulated_zeros_1)\n print('Number of occurrences of 0 for each binary decision computed by hand:')\n print(numpy.array([0, 0, 2, 1, 0, 0, 0]))\n print('Number of occurrences of 1 for each binary decision computed by the function:')\n print(cumulated_ones_1)\n print('Number of occurrences of 1 for each binary decision computed by hand:')\n print(numpy.array([4, 4, 2, 1, 1, 1, 1]))","def count_bits(dqxx, n):\n return sum([check_bit(x, n) for x in dqxx])","def wabbits(n, k):\n a, b = 1, 1\n for i in range(3, n+1):\n a, b = b, a*k + b\n return b","def sum_simulated_test():\n f = open(\"./results/simulated_sigmoid_sum.csv\", \"w\")\n #f1 = open(\"./results/avg_pres.txt\", \"w\")\n #f.write(\"num. of qubits; precision\\n\")\n\n\n computable_qubits = 27\n num_subtest = 1000\n\n acum_precision = 0\n coeffs = []\n temp = -10\n while temp < 11:\n coeffs.append(temp)\n temp += 0.25\n #for coeff in coeffs:\n # variables.c_summation = coeff\n # print(coeff)\n for i in range(2, computable_qubits):\n #print(\"qubit: \", i)\n precision = 0\n x = []\n for j in range(num_subtest):\n\n random_dict = get_random_dict(i)\n\n # compute real answer\n real_answer = 0\n for value in random_dict.values():\n real_answer += value\n # f1.write(str(real_answer)+\";\")\n x.append(real_answer)\n\n # assign spin value to real_answer\n if real_answer < 0:\n real_answer = -1\n elif real_answer > 0:\n real_answer = 1\n else:\n real_answer = 0\n bqm = get_bqm()\n quantum_sigmoid_sum(bqm, random_dict, \"target\")\n sampler = get_simulated_sampler()\n result = sampler.sample(bqm)\n if real_answer == 0:\n precision += 1\n # f1.write(\"1\\n\")\n elif real_answer == result.first.sample['target']:\n precision += 1\n # f1.write(\"1\\n\")\n# else:\n # f1.write(\"0\\n\")\n\n precision /= num_subtest\n # acum_precision+= precision\n\n f.write(str(i) + \";\" + str(precision) + \"\\n\")\n f.close()\n #f1.write(str(coeff)+\";\"+ str(round(acum_precision/(computable_qubits-1), 4)) + \"\\n\")\n # acum_precision = 0\n #f1.close()","def get_error_hamming_distributions_from_results(results: Sequence[Sequence[Sequence[int]]]) \\\n -> Sequence[Sequence[float]]:\n num_shots = len(results[0])\n n_bits = len(results[0][0]) - 1\n\n hamming_wt_distrs = []\n # loop over all binary strings of length n_bits\n for result, bits in zip(results, all_bitstrings(2 * n_bits)):\n # Input nums are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bit_array_to_int(bits[:n_bits])\n num_b = bit_array_to_int(bits[n_bits:])\n\n # add the numbers\n ans = num_a + num_b\n ans_bits = int_to_bit_array(ans, n_bits + 1)\n\n # record the fraction of shots that resulted in an error of the given weight\n hamming_wt_distr = [0. for _ in range(len(ans_bits) + 1)]\n for shot in result:\n # multiply relative hamming distance by the length of the output for the weight\n wt = len(ans_bits) * hamming(ans_bits, shot)\n hamming_wt_distr[int(wt)] += 1. / num_shots\n\n hamming_wt_distrs.append(hamming_wt_distr)\n\n return hamming_wt_distrs","def combinations(n) -> float:\r\n c = math.factorial(n) / (math.factorial(2) * math.factorial(n - 2))\r\n return c","def r_combinations(n,r):\n return r_permutations(n,r) / math.factorial(r)","def sol(n):\n p = 1\n res = 0\n \n while n:\n p*=5\n if n&1:\n res+=p\n n=n>>1\n return res%1000000007","def fn(mask, k):\n if not mask: return 0 \n ans = inf \n for i in range(n): \n if mask & (1<<i): \n ans = min(ans, (nums1[i]^nums2[k]) + fn(mask^(1<<i), k+1))\n return ans","def bits_to_probabilities(\n all_qubits: Sequence[Tuple[int, int]],\n subsys_qubits: Sequence[Tuple[int, int]],\n bits: np.ndarray,\n) -> np.ndarray:\n num_qubits = len(subsys_qubits)\n indices = [all_qubits.index(q) for q in subsys_qubits]\n bits_red = np.asarray(bits[:, indices], dtype=int)\n for i in range(num_qubits):\n bits_red[:, i] *= 2 ** (num_qubits - i - 1)\n bits = list(np.sum(bits_red, axis=1))\n p_reduced = np.bincount(bits, minlength=2 ** num_qubits)\n num_trials, _ = bits_red.shape\n return p_reduced / num_trials","def pairwise_bit_scores(blastf, ss, outf, verbose=False):\n\n if verbose:\n sys.stderr.write(f\"{bcolors.GREEN}Creating scores{bcolors.ENDC}\\n\")\n\n pb = {}\n out = open(outf + \".tsv\", 'w')\n out.write(\"Query\\tSubject\\tQLen\\tSLen\\tBits\\tnBits\\n\")\n for b in stream_blast_results(blastf, verbose):\n if b.query not in pb:\n pb[b.query] = {}\n if b.db not in pb:\n pb[b.db] = {}\n\n # we normalize by the bitscore of the two proteins if we can!\n if b.query in ss and b.db in ss:\n nb = b.bitscore / ((ss[b.query] + ss[b.db])/2)\n else:\n # if we can't do that, we cheat and normalize \n # the bit score by twice\n # the average length of the proteins\n # i.e. the sum of the lengths\n nb = b.bitscore / (b.query_length + b.subject_length + 3.3)\n\n if b.query in pb[b.db] and pb[b.db][b.query] > nb:\n continue\n pb[b.db][b.query] = pb[b.db][b.query] = nb\n out.write(f\"{b.query}\\t{b.db}\\t{b.query_length}\\t{b.subject_length}\\t{b.bitscore}\\t{nb}\\n\")\n return pb","def test_11(self):\n for _ in range(1000):\n num_types = np.random.randint(1, 10)\n edu_start = np.random.randint(10, 100)\n type_shares = np.random.normal(0, 1, size=num_types * 2)\n\n args = [type_shares, np.array([edu_start])]\n\n py = get_conditional_probabilities(*args)\n fort = fort_debug.wrapper_get_conditional_probabilities(*args + [num_types])\n\n assert_almost_equal(np.sum(py), 1.0)\n assert_almost_equal(py, fort)","def fn(i, s0, s1, c0, c1):\n if s0 > n or s1 > n: return 0 # impossible \n if i == len(balls): return int(c0 == c1)\n ans = 0 \n for x in range(balls[i]+1): \n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\n return ans","def _bin_numbers(col1, col2, bin_n):\n col1 = col1[~col1.map(lambda x: is_null_flag(x))].reset_index(drop=True)\n col2 = col2[~col2.map(lambda x: is_null_flag(x))].reset_index(drop=True)\n comb = pd.Series(pd.np.concatenate([col1, col2])).sort_values(inplace=False).reset_index(drop=True)\n bin_size = int(len(comb) / bin_n)\n bin_dict1, bin_dict2 = {}, {}\n for i in range(bin_n - 1): # last bin only needs bin_min\n bin_low = comb[i*bin_size]\n bin_high = comb[(i+1)*bin_size]\n bin_dict1[i] = sum((col1 >= bin_low) & (col1 < bin_high))\n bin_dict2[i] = sum((col2 >= bin_low) & (col2 < bin_high))\n # print bin_low, bin_high\n # Highest bin\n bin_dict1[i+1] = sum(col1 >= bin_high)\n bin_dict2[i+1] = sum(col2 >= bin_high)\n return bin_dict1, bin_dict2","def create_samples(f: Callable[..., int], n_args: int, n_bits: int,\n) -> Dict[Tuple[int, ...], Tuple[int, ...]]:\n samples = {}\n max_arg = 2 ** n_bits\n for inputs in itertools.product((0, 1), repeat=n_args * n_bits):\n ints = [int(\"\".join(str(bit) for bit in inputs[i:i + n_bits]), 2)\n for i in range(0, len(inputs), n_bits)]\n try:\n output = f(*ints)\n if 0 <= output < max_arg:\n bit_string = (\"{:0\" + str(n_bits) + \"b}\").format(output)\n samples[inputs] = tuple(int(bit) for bit in bit_string)\n except ZeroDivisionError:\n pass\n return samples","def count_bits(n):\n return sum(1 for x in bin(n) if x == \"1\")","def probability(n, k, p):\n prob = 0\n power = expotentation_by_squaring((1-p), n)\n count_mult = math.log(n, 2)\n p_fraction = p/(1-p)\n count_mult += 1\n for i in range(0, k+1):\n element = newton(n, i)*power\n prob += element\n power *= p_fraction\n count_mult += 2\n return prob, count_mult","def permutation_test_mat(matrix,\n n_1, n_2, n_permutations,\n a00=1, a11=1, a01=0):\n n = n_1 + n_2\n pi = np.zeros(n, dtype=np.int8)\n pi[n_1:] = 1\n\n larger = 0.\n count = 0\n \n for sample_n in range(1 + n_permutations):\n count = 0.\n for i in range(n):\n for j in range(i, n):\n mij = matrix[i, j] + matrix[j, i]\n if pi[i] == pi[j] == 0:\n count += a00 * mij\n elif pi[i] == pi[j] == 1:\n count += a11 * mij\n else:\n count += a01 * mij\n if sample_n == 0:\n statistic = count\n elif statistic <= count:\n larger += 1\n\n np.random.shuffle(pi)\n\n return larger / n_permutations","def getSum(self, a: int, b: int) -> int:\n i = 0\n carry = 0\n res = 0\n while i < 12:\n curr_a_bit = (a >> i) & 1\n curr_b_bit = (b >> i) & 1\n # print(curr_a_bit, curr_b_bit)\n curr_bit = curr_a_bit ^ curr_b_bit ^ carry\n res |= (curr_bit << i)\n if curr_a_bit & curr_b_bit == 1 or curr_a_bit & carry == 1 or curr_b_bit & carry == 1:\n carry = 1\n else:\n carry = 0\n i += 1\n # print(res, bin(res), bin(a), bin(b))\n # 不用把 第 13 位 i = 12 时 carry 加上 result, 因为 这一位 判断 正 负 不需要\n if res >= 2 ** 11:\n # 举例：最大和2000 ，res < 2 ^ 11, 最小和 -2000， res > 2 ^ 11\n # 如果 和 是 0，比如 1 和 -1， res = 0\n # 如果和 是 -1，比如 1 和 -2， res > 2 ^ 11\n res = (~res) ^ 0b111111111111\n return res","def successes(predictions,truth):\n\ttotal = len(predictions)\n\tcorrect = 0.0\n\tfor p in predictions:\n\t\tif p == truth:\n\t\t\tcorrect += 1\n\t\telse:\n\t\t\tprint truth,\"\\t\",p\n\treturn correct","def compute(n):\n if n == 1:\n return 1\n else:\n i = find_i(n)\n return 2 * compute(n - i) + 2 ** i - 1","def binomialTest(k, n, p = 0.5, exact = False):\n\tassert(k <= n)\n\tassert(k >= 0 and n > 0)\n\tn = int(n)\n\tk = int(k)\n\tp_value = 1.0\n\n\t# Trivial cases where p = 0 or p = 1\n\tif p == 0.0: # Must then have k = 0\n\t\tif k > 0:\n\t\t\treturn 0.0\n\t\telse:\n\t\t\treturn 1.0\n\tif p == 1.0: # Must then have k = n\n\t\tif k <= n:\n\t\t\treturn 1.0\n\n\tif k == 0:\n\t\t# Probability of at least zero successes is 1\n\t\tp_value = 1.0\n\telif k == n:\n\t\t# Probability of all successes\n\t\tp_value = p**n\n\telse:\n\t\tif not exact and n*p > 30 and n*(1-p) > 30:\n\t\t\t# Use normal approximation\n\t\t\tmu = n*p\n\t\t\tsd = math.sqrt(n*p*(1-p))\n\t\t\tz = (k-mu)/sd\n\t\t\tif z < 0.0:\n\t\t\t\tp_value = 1-Prob_Z(z)\n\t\t\telse:\n\t\t\t\tp_value = Prob_Z(z)\n\t\telse:\n\t\t\tp_value = p**n # The last term in the sum\n\t\t\tfor j in range(k,n):\n\t\t\t\t# Compute logarithm of (n choose j) p^j (1-p)^ (n-j), the\n\t\t\t\t# binomial probability. Use logarithm to avoid overflow\n\t\t\t\t# problems with potentially enormous factorials.\n\t\t\t\tlog_p = logChoose(n,j) + j*math.log(p) + (n-j)*math.log(1-p)\n\t\t\t\tp_value += math.exp(log_p)\n\t\t\tif p_value > 1.0:\n\t\t\t\tp_value = 1.0\n\treturn p_value","def judge(n1: List[int], n2: List[int]) -> int:\n\tmin_length = min(len(n1),len(n2))\n\tpass_count = 0\n\tfor i in range(min_length):\n\t\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\n\n\treturn pass_count","def add_bitwise(x, y):\n\n answer = 0\n carry_in = 0\n k = 1\n iterations_tracker = x | y\n\n while (iterations_tracker):\n x_k = x & k\n y_k = y & k\n\n answer |= x_k ^ y_k ^ carry_in\n carry_out = majority_bitwise(x_k, y_k, carry_in)\n\n carry_in = carry_out << 1\n\n k <<= 1\n iterations_tracker >>= 1\n\n if (carry_in):\n answer |= carry_in\n\n return answer","def solution(n):\n i = 1\n j = 2\n sum = 0\n while j <= n:\n if j % 2 == 0:\n sum += j\n i, j = j, i + j\n\n return sum","def measure_gcd_success():\n for size in range(2,16):\n print(\"--------- samplesize = %d\" % size)\n d = dict()\n for _ in range(1000):\n q = findpoly(size)\n d.setdefault(q,0)\n d[q] += 1\n for k,v in sorted(d.items(), key=lambda x: x[1]):\n print(\"%5d: %8s\" % (v, k))","def bits(self):\n if not self.group_list:\n return 0.0\n # TODO: Is it worth to cache the overall result?\n return self.bits_except_last + self.group_list[-1].bits","def brute_force_solution():\n def is_pythagorean_triplet(a, b, c):\n return c**2 == a**2 + b**2\n\n return next(\n a * b * (TRIPLET_SUM - a - b)\n for a in range(1, TRIPLET_SUM)\n for b in range(a + 1, TRIPLET_SUM - a)\n if is_pythagorean_triplet(a, b, TRIPLET_SUM - a - b)\n )","def getWays(n, c):\n # === Preprocess c ===\n # Filter out values exceeding n\n c = list(filter(lambda x: x <= n, c))\n\n # Sort in ascending order\n c.sort()\n\n # === Obtain relations ===\n # Dictionary of relations\n # The key is the target coin to be decomposed, and the value is a list of possible decompositions\n # Interpreted for a key k and a list value of v of length l, where each element is a tuple of length 2, k = v[0][0] + v[0][1], v[1][0] + v[1][1], ... , v[l][0] + v[l][1]\n relations = {}\n\n # Obtain relations between all coins\n # Loop through each coin\n for i in reversed(c):\n\n # For each coin, we attempt to find an additive relation. To do so, we need to loop through each coin smaller than i twice, with the first loop identifying the first value and the second loop identifying the second value. If these two values sum up to give i, we add it to our list of relations. \n for j in reversed(c): \n\n if j >= i: \n continue \n\n for k in reversed(c):\n\n # We want k to be less than or equal to j to preserve the ordering. E.g. in the case of 5 = 3 + 2, we do not want a repeat case of 5 = 2 + 3 recorded.\n if k > j: \n continue \n\n if j + k == i:\n\n # We store the results in a dictionary\n if i in relations.keys():\n relations[i].append((j, k))\n\n else:\n relations[i] = [(j, k)]\n\n # === Relational scores ===\n # We generate scores for each coin based on their relations, i.e. how many cases this coin can be broken up into\n scores = {}\n\n # For those that cannot be broken down into others, we set their score as 0\n for i in c:\n if i not in relations.keys():\n scores[i] = 0\n\n # Generate the remainder of the scores\n for i in c: \n\n # We only generate if they have relations\n if i not in relations.keys(): \n continue \n\n # If there is more than one relation, we can have more than one score per coin. Thus, we keep a running list of the coin's scores in a list.\n current_coin_scores = []\n\n # For all other coins, we access the list of relations\n for rel in relations[i]:\n\n # If a relation exists, there is already an additional case. \n current_score = 1\n\n # Obtain the number of unique components\n unique_components = set(rel)\n\n # For each unique component, obtain its 'additional case' score from scores\n add_cases = []\n\n for comp in unique_components:\n add_cases.append(scores[comp])\n\n # Calculate the score from this relation, based off the relational equation in the README\n current_score += sum(add_cases)\n\n # Add score to total_scores\n current_coin_scores.append(current_score)\n\n # Total up all the scores and add it to scores\n scores[i] = sum(current_coin_scores)\n\n # === Obtain top level answers === \n solutions = []\n\n # We loop through every coin in c\n # The point of this is to obtain a solution set that, at the very least, has at least one of this coin\n for k in reversed(c):\n\n # Instantiate s\n s = {}\n\n # We want to obtain values for which we have the maximum value of k for the given solution set\n for i in reversed(range(1, math.floor(n / k) + 1)):\n\n # We instantiate the solution set\n s = {i: 0 for i in list(filter(lambda x: x <= k, reversed(c)))}\n\n # Obtain solution\n s = populate(s, n, (k, i))\n \n # Check if s is None\n # If s is None, we need to continue with the loop\n # Else, we can append s to solutions and break out of the loop\n if s is not None: \n solutions.append(s)\n\n break\n\n # === Finalise total cases ===\n final_score = len(solutions)\n\n # For each solution, we obtain the additional scores based on the MAX-REST equation in README\n for s in solutions: \n\n # Biggest coin\n biggest_coin = max(s.keys())\n\n # Obtain max-rest score\n # Calculate the max score, which should have a minimum of 0\n max_score = max(0, (s[biggest_coin] - 1) * scores[biggest_coin])\n\n # Calculate the rest score\n rest_score = 0\n\n # We calculate the rest score using all other coins in the dictionary\n for i in s.keys():\n if i == biggest_coin:\n continue \n\n else: \n rest_score += s[i] * scores[i]\n\n max_rest_score = max_score + rest_score\n\n # Increment total score\n final_score += max_rest_score\n\n # DEBUG(f\"solution: {s}, max-rest score: {max_rest_score}\")\n\n\n # DEBUG(solutions)\n\n # DEBUG(f\"coin: {i}, uniques: {unique_components}, additionals: {add_cases}, current score: {current_score}\")\n \n\n # DEBUG(f\"coin: {i}, relation: {relations[i]}, scores: {scores}\")\n\n\n\n # We loop through all relations\n # \n # \n # \n # except for the first coin, which we set to have a score of +0. \n\n \n # DEBUG(f\"n: {n}, c: {c}, relations: {relations}, scores: {scores}, solutions: {solutions}, final_score: {final_score}\")\n\n return final_score","def fn(x, mask):\n ans = size = 0 \n for xx in range(1, 10): \n if not mask & (1 << xx): \n if (x, xx) not in mp or mask & 1 << mp[x, xx]: \n ans += fn(xx, mask^(1<<xx))\n size += 1\n size = 9 - size\n if m <= size <= n: ans += 1\n return ans","def test_compute_binary_probabilities(self):\n nb_images = 100\n height_map = 32\n width_map = 48\n bin_widths_test_0 = numpy.array([2., 2., 2.], dtype=numpy.float32)\n bin_widths_test_1 = numpy.array([0.5, 0.5, 0.5], dtype=numpy.float32)\n truncated_unary_length = 4\n \n y_float32_0 = numpy.random.uniform(low=-10.,\n high=10.,\n size=(nb_images, height_map, width_map, 1)).astype(numpy.float32)\n y_float32_1 = numpy.random.laplace(loc=0.5,\n scale=2.5,\n size=(nb_images, height_map, width_map, 1)).astype(numpy.float32)\n y_float32_2 = numpy.random.standard_cauchy(size=(nb_images, height_map, width_map, 1)).astype(numpy.float32)\n y_float32 = numpy.concatenate((y_float32_0, y_float32_1, y_float32_2),\n axis=3)\n map_mean = numpy.array([0., 0.5, 0.], dtype=numpy.float32)\n binary_probabilities_0 = lossless.stats.compute_binary_probabilities(y_float32,\n bin_widths_test_0,\n map_mean,\n truncated_unary_length)\n print('1st set of test quantization bin widths:')\n print(bin_widths_test_0)\n print('1st absolute centered-quantized latent variable feature map.')\n print('Binary probabilities computed by the function:')\n print(binary_probabilities_0[0, :])\n \n # Let x be a continuous random variable following the\n # uniform distribution of support [-10.0, 10.0]. The\n # probability the 1st binary decision is 0 is written\n # p(|x| <= 1.0) = 1.0/10. The probability the 2nd\n # binary decision is 0 is written\n # p(1.0 <= |x| <= 3.0)/p(|x| >= 1.0) = (2.0/10)/(9.0/10) = 2.0/9.\n # The probability the 3rd binary decision is 0 is written\n # p(3.0 <= |x| <= 5.0)/p(|x| >= 3.0) = (2.0/10)/(7.0/10) = 2.0/7.\n # The above calculations use the cumulative distribution\n # function of the uniform distribution of support [-10.0, 10.0].\n print('Binary probabilities computed by hand:')\n print([1./10, 2./9, 2./7, 2./5])\n print('2nd absolute centered-quantized latent variable feature map.')\n print('Binary probabilities computed by the function:')\n print(binary_probabilities_0[1, :])\n \n # Let x be a continuous random variable following the\n # Laplace distribution of mean 0.0 and scale 2.5. It is\n # said `mean 0.0` as the 2nd latent variable feature map\n # is centered before being quantized. The probability\n # the 1st binary decision is 0 is written\n # p(|x| <= 1.0) = 0.3297. The probability the 2nd binary\n # decision is 0 is written\n # p(1.0 <= |x| <= 3.0)/p(|x| >= 1.0) = 0.3691/0.6703 = 0.5507.\n # The probability the 3rd binary decision is 0 is written\n # p(3.0 <= |x| <= 5.0)/p(|x| >= 3.0) = 0.1659/0.3012 = 0.5507.\n # The above calculations use the cumulative distribution\n # function of the Laplace distribution of mean 0 and scale 2.5.\n print('Binary probabilities computed by hand:')\n print([0.3297, 0.5507, 0.5507, 0.5507])\n print('3rd absolute centered-quantized latent variable feature map.')\n print('Binary probabilities computed by the function:')\n print(binary_probabilities_0[2, :])\n \n # Let x be a continuous random variable following the\n # standard Cauchy distribution. The probability the 1st\n # binary decision is 0 is written p(|x| <= 1.0) = 0.5.\n # The probability the 2nd binary decision is 0 is written\n # p(1.0 <= |x| <= 3.0)/p(|x| >= 1.0) = 0.2952/0.5 = 0.5903.\n # The probability the 3rd binary decision is 0 is written\n # p(3.0 <= |x| <= 5.0)/p(|x| >= 3.0) = 0.079/0.2048 = 0.3865.\n # The above calculations use the cumulative distribution\n # function of the standard Cauchy distribution.\n print('Binary probabilities computed by hand:')\n print([0.5, 0.5903, 0.3865, 0.2811])\n \n binary_probabilities_1 = lossless.stats.compute_binary_probabilities(y_float32,\n bin_widths_test_1,\n map_mean,\n truncated_unary_length)\n print('\\n2nd set of test quantization bin widths:')\n print(bin_widths_test_1)\n print('1st absolute centered-quantized latent variable feature map.')\n print('Binary probabilities computed by the function:')\n print(binary_probabilities_1[0, :])\n \n # Let x be a continuous random variable following the\n # uniform distribution of support [-10.0, 10.0]. The\n # probability the 1st binary decision is 0 is written\n # p(|x| <= 0.25) = 1.0/40. The probability the 2nd\n # binary decision is 0 is written\n # p(0.25 <= |x| <= 0.75)/p(|x| >= 0.25) = (2.0/40)/(39.0/40) = 2.0/39.\n # The probability the 3rd binary decision is 0 is written\n # p(0.75 <= |x| <= 1.25)/p(|x| >= 0.75) = (2.0/40)/(37.0/40) = 2.0/37.\n print('Binary probabilities computed by hand:')\n print([1./40, 2./39, 2./37, 2./35])\n print('2nd absolute centered-quantized latent variable feature map.')\n print('Binary probabilities computed by the function:')\n print(binary_probabilities_1[1, :])\n \n # Let x be a continuous random variable following the\n # Laplace distribution of mean 0.0 and scale 2.5. The\n # probability the 1st binary decision is 0 is written\n # p(|x| <= 0.25) = 0.0952. The probability the 2nd binary\n # decision is 0 is written\n # p(0.25 <= |x| <= 0.75)/p(|x| >= 0.25) = 0.1640/0.9048 = 0.1813.\n # The probability the 3rd binary decision is 0 is written\n # p(0.75 <= |x| <= 1.25)/p(|x| >= 0.75) = 0.1343/0.7408 = 0.1813.\n print('Binary probabilities computed by hand:')\n print([0.0952, 0.1813, 0.1813, 0.1813])\n print('3rd absolute centered-quantized latent variable feature map.')\n print('Binary probabilities computed by the function:')\n print(binary_probabilities_1[2, :])\n \n # Let x be a continuous random variable following the\n # standard Cauchy distribution. The probability the 1st\n # binary decision is 0 is written p(|x| <= 0.25) = 0.1560.\n # The probability the 2nd binary decision is 0 is written\n # p(0.25 <= |x| <= 0.75)/p(|x| >= 0.25) = 0.2537/0.8440 = 0.3006.\n # The probability the 3rd binary decision is 0 is written\n # p(0.75 <= |x| <= 1.25)/p(|x| >= 0.75) = 0.1608/0.5903 = 0.2724.\n print('Binary probabilities computed by hand:')\n print([0.1560, 0.3006, 0.2724, 0.2306])","def faster_brute_force_solution():\n def calc_b(a, sum):\n return ((sum**2/2) - (sum * a)) / (sum - a)\n\n a, b = next(\n (a, calc_b(a, TRIPLET_SUM))\n for a in range(1, TRIPLET_SUM)\n if calc_b(a, TRIPLET_SUM).is_integer()\n )\n\n return a * b * (TRIPLET_SUM - a - b)","def testCounting(self):\n \n clk = Signal(0)\n clock_gen = ClkDriver(clk, period=4)\n \n for i in range(1, 6):\n #print \"Testing\", i, \"bits\"\n out = Signal(intbv(0)[i:])\n prev_out = Signal(intbv(2**i - 1)[i:])\n counter = Counter(out, clk, Signal(1))\n \n # make sure it increments and wraps at modulo 2^n\n @always(clk.posedge)\n def test():\n #print out, prev_out\n self.assertEqual(int(out), int((prev_out + 1) % 2**(len(prev_out))))\n prev_out.next = out\n \n sim = Simulation(counter, clock_gen, test)\n sim.run(12 * 2**i, quiet=1)","def tabulate_score(self):\n # Generate the bit formatting string\n n_bits = int(np.ceil(np.log2(self.max_ans)))\n fmt_str = \"{0:0\"+str(n_bits)+\"b}\"\n \n # Convert answers to int\n self.answers = self.answers.astype(np.int64)\n\n # Convert each element in answers to a bit string\n bits = [fmt_str.format(ans) for ans in self.answers]\n bit_string = \"\".join(bits)\n \n # Convert the combined bit string back to an integer\n seed = int(bit_string, 2)\n\n return seed","def compare():\n eb = 1\n p = 0.5\n R = 0.5\n N = 150 # set the error count to reach\n\n domain = np.linspace(0, 10, 11)\n hard_domain = np.linspace(0, 8, 9)\n soft_domain = np.linspace(0, 6, 7)\n hard_decibels = 10 ** (hard_domain / 10)\n soft_decibels = 10 ** (soft_domain / 10)\n\n # get results for hard decoding\n nos = eb / hard_decibels\n hard_results = []\n for no in nos:\n print(np.where(nos == no)[0][0])\n experiment = ViterbiHard(eb, no / R)\n bit_count = 0\n error_count = 0\n for output in experiment.run():\n bit_count += 1\n if output[0] != output[1]:\n error_count += 1\n if error_count == N:\n hard_results.append(error_count / bit_count)\n break\n\n # get results for soft decoding\n nos = eb / soft_decibels\n soft_results = []\n for no in nos:\n print(np.where(nos == no)[0][0])\n experiment = ViterbiSoft(eb, no / R)\n bit_count = 0\n error_count = 0\n for output in experiment.run():\n bit_count += 1\n if output[0] != output[1]:\n error_count += 1\n if error_count == N:\n soft_results.append(error_count / bit_count)\n break\n\n decibels = 10 ** (domain / 10)\n nos = eb / decibels\n taus = nos / 4 / np.sqrt(eb) * np.log((1 - p) / p)\n plt.semilogy(hard_domain, np.array(hard_results), label='Hard-decision')\n plt.semilogy(soft_domain, np.array(soft_results), label='Soft-decision')\n plt.semilogy(domain, norm.sf((taus + np.sqrt(eb)) / np.sqrt(nos / 2)) * (1 - p) +\n norm.sf((np.sqrt(eb) - taus) / np.sqrt(nos / 2)) * p, label='Expectation ($p=0.5$)')\n plt.xlabel('$E_b/N_0$ (dB)')\n plt.ylabel('Probability of bit error')\n plt.legend(loc='lower left')\n plt.show()","def aranksums(x,y):\r\n n1 = len(x)\r\n n2 = len(y)\r\n alldata = N.concatenate((x,y))\r\n ranked = arankdata(alldata)\r\n x = ranked[:n1]\r\n y = ranked[n1:]\r\n s = sum(x)\r\n expected = n1*(n1+n2+1) / 2.0\r\n z = (s - expected) / math.sqrt(n1*n2*(n1+n2+1)/12.0)\r\n prob = 2*(1.0 - azprob(abs(z)))\r\n return z, prob","def helper(nums_dict, S):\n if not nums_dict:\n return 1 if S == 0 else 0\n \n num = max(nums_dict.keys())\n num_count = nums_dict.pop(num)\n remaining_sum = sum([k*v for k, v in nums_dict.items()])\n #print(nums_dict, remaining_sum, S)\n \n ans = 0\n num_sum = -num*num_count\n for i in range(num_count+1):\n if -remaining_sum <= S - num_sum <= remaining_sum:\n ans += helper(nums_dict.copy(), S-num_sum) * comb(num_count, i)\n num_sum += 2*num\n return ans","def combination(num_m: int, num_n: int) -> int:\n if num_m < num_n:\n return 0\n\n tmp_m = 1\n tmp_n = 1\n tmp_cnt = 0\n for i in range(num_n, 0, -1):\n tmp_n *= i\n tmp_m *= num_m - tmp_cnt\n tmp_cnt += 1\n\n return tmp_m / tmp_n","def fn(i, j, mask):\n if j == n: return 1 \n if i == m: return fn(0, j+1, mask)\n ans = 0 \n for x in 1<<2*i, 1<<2*i+1, 0b11<<2*i: \n mask0 = mask ^ x\n if mask0 & 0b11<<2*i and (i == 0 or (mask0 >> 2*i) & 0b11 != (mask0 >> 2*i-2) & 0b11): \n ans += fn(i+1, j, mask0)\n return ans % 1_000_000_007","def bitvector(self, res1, res2):\n bitvector = [\n interaction(res1, res2) for interaction in self.interactions.values()\n ]\n if self.count:\n return np.array([sum(bits) for bits in bitvector], dtype=np.uint8)\n return np.array(bitvector, dtype=bool)","def find_num_appearing_once(ls):\n \n sum_bin = 0\n ans = [] # can also define a list with a length of 32 for 32 bit machine\n result = 0 # decimal\n for e in ls:\n # print(int(format(e, 'b')))\n sum_bin += int(format(e, 'b'))\n print(sum_bin)\n \n # record which bit cannot mod 3\n while sum_bin != 0:\n bit = sum_bin % 10\n if bit % 3 != 0:\n ans.append(1)\n else:\n ans.append(0)\n sum_bin //= 10\n print(ans)\n \n # convert ans into decimal\n pow = len(ans) - 1\n while len(ans) != 0:\n result += ans.pop() * 2**pow\n pow -= 1\n print(result)","def test_bp_example():\n signal = np.array([4, 7, 9, 10, 6, 11, 3])\n\n pe = permutation_entropy(signal, 2)\n\n assert 0.91 < pe < 0.92 # Should be approx 0.918.\n\n pe = permutation_entropy(signal, 3)\n\n assert 1.52 < pe < 1.53 # Should be approx 1.522.","def doubles(counts):\n return (counts==2).sum()","def ransac_iters(w=0.5, d=min_num_pairs(), z=0.99):\n\n return int(np.ceil(np.log(1 - z) / np.log(1 - np.power(w,d))))","def getCombination(mu1, mu2, sig1, sig2, confidence1, confidence2):\n\tglobal alpha, beta, gamma\n\n\t#Standard Bayesian\n\t# sigNew = math.sqrt(math.pow(sig1, 2) + math.pow(sig2, 2))\n\t# muNew = u1 + u2\n\t# return muNew, sigNew \n\n\t##In accordance with the nature papers:\n\tsigNew = (math.pow(sig1,2) * math.pow(sig2, 2)) \\\n\t/ float((math.pow(sig1,2) + math.pow(sig2, 2)))\n\tinv1 = 1 / float((math.pow(sig1, 2)))\n\tinv2 = 1 / float((math.pow(sig2, 2)))\n\tsumInverses = inv1 + inv2\n\n\t##inverse standard deviations squared\n\t# w1 = inv1 / float(sumInverses)\n\t# w2 = inv2 / float(sumInverses)\n\n\t## equal weighting\n\t# w1 = .5\n\t# w2 = .5\n\n\t## weightings based off of confidence\n\t# summation = confidence1 + confidence2\n\t# w1 = confidence1 / float(summation)\n\t# w2 = confidence2 / float(summation)\n\n\t##weightings with exponentials\n\t# w1 = w1**.001\n\t# w2 = w2**.001\n\t# newSummation = w1 + w2\n\t# w1 = w1 / float(newSummation)\n\t# w2 = w2 / float(newSummation)\n\n\t##weightings with polynomial factors\n\tw1 = (beta * confidence1 + alpha)**gamma \n\tw2 = (beta * confidence2 + alpha)**gamma \n\tnewSummation = w1 + w2\n\tw1 = w1 / float(newSummation)\n\tw2 = w2 / float(newSummation)\n\n\tmuNew = w1 * mu1 + w2 * mu2\n\treturn muNew, sigNew","def triplets():\n for a in xrange(1, 1000):\n for b in xrange(a, 1000):\n c = 1000 - (a + b)\n if a**2 + b**2 == c**2:\n return a, b, c","def countPairs(arr):\n pairs = 0\n for i in range(len(arr) - 1):\n for j in range(i + 1, len(arr)):\n if arr[i] & arr[j] == 0: # log 0 = Infinity...avoid this problem\n pass\n elif int(math.log2(arr[i] & arr[j])) == math.log2(arr[i] & arr[j]):\n print('(', arr[i], '&', arr[j], ')', '=', arr[i] & arr[j],\n '=2^', int(math.log2(arr[i] & arr[j])))\n pairs += 1\n # print('Pairs:', pairs, '\\n')\n print(pairs)\n return pairs","def problem():\n for a in range(1, 380):\n for b in range(a):\n if a + b + (a**2 + b**2)**0.5 == 1000:\n return int(a * b * (a**2 + b**2)**0.5)","def linear_combination(n):\n weighs = (1, 3, 9, 27)\n\n for factors in factors_set():\n sum = 0\n for i in range(len(factors)):\n sum += factors[i] * weighs[i]\n if sum == n:\n return factors","def getResults(solver, minBit, maxBit, saveFile, noResults):\n\n for k in range(minBit, maxBit + 1, 2):\n for i in range(noResults):\n\n keys = generate_RSA.KeyGen(k) # initialise keys\n keys.generateKeys() # generate keys\n\n solver.setN(keys.n) # setup solver\n solver.setE(keys.e)\n\n solver.solve() # solve problem\n\n if solver.d == keys.d: # if we got it right\n resTime = resTime_C # update correct dictionaries\n resCount = resCount_C\n resSpace = resSpace_C\n else:\n resTime = resTime_W # else update wrong dictionaries\n resCount = resCount_W\n resSpace = resSpace_W\n\n if k not in resTime: # if we've not yet had a result for k\n resTime[k] = [solver.time, 1] # then set\n resSpace[k] = [solver.space, 1] # then set\n resCount[k] = [solver.count, 1]\n else:\n oldT, oldC = resTime[k] # keeps a running average\n newC = oldC + 1 # increment count\n newT = ((oldT * oldC) + solver.time) / newC # get new averagae\n resTime[k] = [newT, newC] # without storing all variables\n\n oldS, oldC = resSpace[k] # keeps a running average\n newS = ((oldS * oldC) + solver.space) / newC\n resSpace[k] = [newS, newC] # without storing all variables\n\n oldCount, oldC = resCount[k] # keeps a running average\n newCount = ((oldCount * oldC) + solver.count) / newC\n resCount[k] = [newCount, newC] # without storing all variables\n\n if i % 10 == 0:\n saveResults(saveFile) # every ten results save again","def bitwise_stats(traces, N, delta):\n \n X = np.zeros((N,),dtype=int)\n padded_traces = pad_traces(traces, N)\n num_traces = padded_traces.shape[0]\n \n p = np.zeros(N)\n for j in range(N):\n p[j] = np.sum(padded_traces[:,j])/num_traces\n \n c = np.concatenate((np.ones(N,), np.zeros(N,)), axis=None)\n bounds = (0,1)\n \n for i in range(N):\n A_ub = np.zeros((2*N,2*N))\n for j in range(N):\n for k in range(N):\n if j == k:\n A_ub[j,k] = -1\n A_ub[j+N,k] = -1\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\n elif k > j:\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\n \n b_ub = np.concatenate((p,-1*p), axis=None)\n \n A_eq0 = np.zeros((i+1,2*N))\n b_eq0 = np.zeros(i+1)\n for j in range(i+1):\n A_eq0[j,j+N] = 1\n if j==i:\n b_eq0[j] = 0\n else:\n b_eq0[j] = X[j]\n \n A_eq1 = np.zeros((i+1,2*N))\n b_eq1 = np.zeros(i+1)\n for j in range(i+1):\n A_eq1[j,j+N] = 1\n if j==i:\n b_eq1[j] = 1\n else:\n b_eq1[j] = X[j]\n \n res0 = linprog(c,A_ub,b_ub,A_eq0,b_eq0,bounds,method='interior-point')\n res1 = linprog(c,A_ub,b_ub,A_eq1,b_eq1,bounds,method='interior-point')\n if res0.fun < res1.fun:\n X[i] = 0\n else:\n X[i] = 1\n \n return X","def countTriplets1(arr, r):\n from collections import Counter\n arr_dict = Counter()\n ratio_range = []\n triplets = 0\n\n # Build the counter\n for x in arr:\n arr_dict[x] += 1\n\n # Build a list for easier iteration\n for key, value in arr_dict.items():\n ratio_range.append(tuple([key,value]))\n ratio_range.sort()\n \n for y in range(len(ratio_range)-2):\n firstvalue = ratio_range[y][1]\n secondvalue = ratio_range[y+1][1]\n thirdvalue = ratio_range[y+2][1]\n print(ratio_range, firstvalue, secondvalue,thirdvalue)\n\n summedvalue = (firstvalue + secondvalue + thirdvalue) - 3\n triplet_count = 2**summedvalue\n print(summedvalue, triplet_count)\n triplets += triplet_count\n\n return triplets, arr_dict, ratio_range","def non_abundant_sums():\n # the sum of divisors of every number\n divisor_sum = [0] * LIMIT\n for i in range(1, LIMIT):\n for j in range(i * 2, LIMIT, i):\n divisor_sum[j] += i\n # abundant numbers\n abundant_nums = [i for (i, x) in enumerate(divisor_sum) if x > i]\n\n expressible = [False] * LIMIT\n for i in abundant_nums:\n for j in abundant_nums:\n if i + j < LIMIT:\n expressible[i + j] = True\n else:\n break\n ans = sum(i for (i, x) in enumerate(expressible) if not x)\n return str(ans)","def measure_all_1(n, state):\n state = state.copy()\n\n outs = ''\n for i in range(n):\n out = measure_single(n, state,\n i) # After measuring bit0, bit0 collapses. It affects the subsequent bit1 measurement, but does not affect the 1000 independent measurements of the upper layer\n outs = str(out) + outs # from low bit to high bit\n return outs","def part1b_0():\n xs = exampleInput\n _, forward = submission.computeForward(simpleCRF, xs)\n for i in xrange(len(xs)):\n grader.requireIsEqual( 1.0, sum( forward[i].values() ) )","def problem9_naive(n):\n for a in range(4, n, 4):\n for b in range(3, n - a):\n c = n - a - b\n if a ** 2 + b ** 2 == c ** 2:\n return a * b * c\n return None","def generateStats(self):\n\t\tn = float(self.n)\n\t\tm = float(self.m)\n\t\tk = float(self.k)\n\t\tp_fp = math.pow(1.0 - math.exp(-(k*n)/m), k)\n\t\tprint \"Probability of false positives: \", p_fp\n\t\tprint \"Predicted false positive rate: \", p_fp * 100.0\n\t\tprint \"Number of elements entered in filter: \", n\n\t\tprint \"Number of bits in filter: \", m\n\t\tprint \"Number of hashes in filter: \", k","def test_bit_add_multiple_bytes(self):\n ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 8, 16, 65535, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([0] * 1 + [255] * 2 + [0] * 2)\n assert bins[self.test_bin_zeroes] == expected_result","def part1b_1():\n xs = exampleInput\n backward = submission.computeBackward(simpleCRF, xs)\n for i in xrange(len(xs)):\n grader.requireIsEqual( 1.0, sum( backward[i].values() ) )","def part_two(rucksacks: list) -> int:\n summ = 0\n for i in range(0, len(rucksacks), 3):\n first_group = set(rucksacks[i])\n second_group = set(rucksacks[i + 1])\n third_group = set(rucksacks[i + 2])\n badge = first_group.intersection(second_group).intersection(third_group)\n badge = list(badge)[0] # extract item id from set\n summ += PRIORITY.get(badge, 0)\n return summ","def countTriplets3(arr, r):\n from collections import Counter\n from math import factorial\n arr_dict = Counter()\n n0 = arr[0]\n\n # If the ratio 'r' is 1 then this is a special case of combinations\n if r == 1:\n for x in arr:\n if x == n0: arr_dict[x] += 1\n n = arr_dict[n0]\n r2 = 3\n return factorial(n)//(factorial(r2)*factorial(n-r2)), arr_dict\n\n # Main variables for the rest of the function\n max_arr = max(arr)\n ratio_range = [n0]\n triplets = 0\n\n # Build all possible values\n index = n0 \n counter = 0\n while index < max_arr:\n index *= r\n ratio_range.append(index)\n counter += 1\n if ratio_range[-1] > max_arr: ratio_range.pop(-1)\n \n # Build the counter\n for x in arr:\n if x in ratio_range: arr_dict[x] += 1\n\n # With the 1 special case removed, there now cannot be triplets if there are not 3 items in the dict\n if len(arr_dict) < 3: return triplets, arr_dict, ratio_range\n\n for y in range(len(ratio_range)-2):\n firstkey = ratio_range[y]\n secondkey = ratio_range[y+1]\n thirdkey = ratio_range[y+2]\n \n # If there are no triplets then the loop will exit without incrementing triplets \n if firstkey not in arr_dict or secondkey not in arr_dict or thirdkey not in arr_dict: \n continue\n else:\n firstvalue = arr_dict[firstkey]\n secondvalue = arr_dict[secondkey]\n thirdvalue = arr_dict[thirdkey]\n \n triplet_count = (firstvalue) * (secondvalue) * (thirdvalue)\n triplets += triplet_count\n\n return triplets, arr_dict","def countTriplets2(arr, r):\n from collections import Counter\n from math import factorial\n\n # If the ratio 'r' is 1 then this is a special case of combinations\n if r == 1:\n n = len(arr)\n r = 3\n return factorial(n)//(factorial(r)*factorial(n-r))\n\n arr_dict = Counter()\n ratio_range = []\n index = 0\n counter = 0\n triplets = 0\n \n # Build the counter\n for x in arr:\n arr_dict[x] += 1\n max_arr_dict = max(arr_dict)\n\n # With the 1 special case removed, there now cannot be triplets if there are not 3 items in the dict\n if len(arr_dict) < 3: return triplets\n \n # There is now the potential for triplets so build all possible values\n while index < max_arr_dict:\n index = r**counter\n ratio_range.append(index)\n counter += 1\n if ratio_range[-1] > max_arr_dict: ratio_range.pop(-1)\n\n for y in range(len(ratio_range)-2):\n firstkey = ratio_range[y]\n secondkey = ratio_range[y+1]\n thirdkey = ratio_range[y+2]\n \n # If there are no triplets then the loop will exit without incrementing triplets \n if firstkey not in arr_dict or secondkey not in arr_dict or thirdkey not in arr_dict: \n continue\n else:\n firstvalue = arr_dict[firstkey]\n secondvalue = arr_dict[secondkey]\n thirdvalue = arr_dict[thirdkey]\n \n summedvalue = (firstvalue + secondvalue + thirdvalue) - 3\n triplet_count = 2**summedvalue\n triplets += triplet_count\n\n return triplets","def combine_many(*fudge):\n result = sum(fudge)\n print(result)","def potential_witnesses(n):\n if n < 1373653: return [2, 3] # n < 1,373,653\n if n < 9080191: return [31, 73] # n < 9,080,191\n if n < 4759123141: return [2, 7, 61] # n < 4,759,123,141\n if n < 2152302898747: return [2, 3, 5, 7, 11] # n < 2,152,302,898,747\n if n < 3474749660383: return [2, 3, 5, 7, 11, 13] # n < 3,474,749,660,383\n if n < 341550071728321: return [2, 3, 5, 7, 11, 13, 17] # n < 341,550,071,728,321\n return [random.randint(1,n-1) for _ in xrange(0,20)] # 99.999999999909051% (1 - .25**20) accuracy for n >= 341,550,071,728,321"],"string":"[\n \"def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\\n int]] = None,\\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,\\n num_shots: int = 100, use_param_program: bool = False,\\n use_active_reset: bool = True, show_progress_bar: bool = False) \\\\\\n -> Sequence[Sequence[Sequence[int]]]:\\n if registers is None:\\n registers = get_qubit_registers_for_adder(qc, n_bits, qubits)\\n\\n reset_prog = Program()\\n if use_active_reset:\\n reset_prog += RESET()\\n\\n add_prog = Program()\\n if use_param_program:\\n dummy_num = [0 for _ in range(n_bits)]\\n add_prog = adder(dummy_num, dummy_num, *registers, in_x_basis=in_x_basis,\\n use_param_program=True)\\n\\n all_results = []\\n # loop over all binary strings of length n_bits\\n for bits in tqdm(all_bitstrings(2 * n_bits), disable=not show_progress_bar):\\n # split the binary number into two numbers\\n # which are the binary numbers the user wants to add.\\n # They are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\\n num_a = bits[:n_bits]\\n num_b = bits[n_bits:]\\n\\n if not use_param_program:\\n add_prog = adder(num_a, num_b, *registers, in_x_basis=in_x_basis,\\n use_param_program=False)\\n\\n prog = reset_prog + add_prog\\n prog.wrap_in_numshots_loop(num_shots)\\n nat_quil = qc.compiler.quil_to_native_quil(prog)\\n exe = qc.compiler.native_quil_to_executable(nat_quil)\\n\\n if use_param_program:\\n exe.write_memory(region_name=REG_NAME, value=bits)\\n\\n # Run it on the QPU or QVM\\n results = qc.run(exe).readout_data.get('ro')\\n all_results.append(results)\\n\\n return all_results\",\n \"def bin_dist(n, p, x):\\n def factorial(x):\\n if x >= 0:\\n \\n factorial = 1\\n\\n for i in range(1, x + 1):\\n factorial = float(factorial * i)\\n # print(f' The factorial of {x} is {factorial}') \\n return factorial\\n\\n else:\\n raise ValueError(\\\"Sorry x cannot be a negative number\\\")\\n\\n def combination(n, r):\\n \\\"\\\"\\\"\\n Given n total number of items,\\n what is the number of possible ways\\n to choose r items from it?\\n\\n :param n: total number of items (integer)\\n :param r: number of items to arrange (int)\\n :return: number of combinations\\n :rtype: integer\\n \\\"\\\"\\\"\\n\\n \\n\\n \\n numerator = factorial(n)\\n denominator = factorial(r)\\n subtracted_answer = factorial(n-r)\\n \\n\\n answer = numerator/(denominator * subtracted_answer)\\n print(answer)\\n return answer \\n\\n # from scipy.special import comb\\n if x > n:\\n raise ValueError(\\\"Error, x must be less than n\\\")\\n else:\\n\\n\\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\\n\\n print(prob_success)\\n return prob_success\",\n \"def probability_of_all_successes(p: float, r: int, n: int) -> float:\\n\\n if r == 1:\\n return pow(p, n)\\n elif n == 0:\\n return 1\\n else:\\n result = 0\\n for x in range(0, n+1):\\n result += pow(p, x) * pow(1-p, n-x) * probability_of_all_successes(p, r-1, n-x)\\n return result\",\n \"def binomial(n, p):\\n sum_ans = 0\\n for k in range(n):\\n sum_ans = sum_ans + bernoulli(p)\\n return sum_ans\",\n \"def chance(n, p):\\n total = 0.0\\n for k in range(n+1):\\n total += comb(n, k, exact=False) * p**k * (1-p) ** (n-k)\\n return total\",\n \"def test_get_n_bits_combinations():\\n # Check n=1 - Pass\\n assert layer_util.get_n_bits_combinations(1) == [[0], [1]]\\n # Check n=2 - Pass\\n assert layer_util.get_n_bits_combinations(2) == [[0, 0], [0, 1], [1, 0], [1, 1]]\\n\\n # Check n=3 - Pass\\n assert layer_util.get_n_bits_combinations(3) == [\\n [0, 0, 0],\\n [0, 0, 1],\\n [0, 1, 0],\\n [0, 1, 1],\\n [1, 0, 0],\\n [1, 0, 1],\\n [1, 1, 0],\\n [1, 1, 1],\\n ]\",\n \"def test_count_bits(n, result):\\n from count_bits import count_bits\\n assert count_bits(n) == result\",\n \"def solution(n: int = 28123) -> int:\\n\\n nums = range(1, n+1)\\n abundant = list(filter(is_abundant, nums))\\n abundant_sums = set(all_sums(abundant, n))\\n fit = set(nums) - abundant_sums\\n return fit\",\n \"def solution2(n):\\n ones = 0\\n while n > 0:\\n if n & 1:\\n ones += 1\\n n = n >> 1\\n\\n return 0 if ones % 2 == 0 else 1\",\n \"def calculate_probability(k: int, m: int, n: int) -> float:\\n population = [\\\"AA\\\" for _ in range(k)] + [\\\"Aa\\\" for _ in range(m)] + [\\\"aa\\\" for _ in range(n)]\\n pairings = it.combinations(population, 2)\\n probabilities = [PROBABILITIES[pairing] for pairing in pairings]\\n output = sum(probabilities) / len(probabilities)\\n\\n return output\",\n \"def binomial(n: int, p: float) -> int:\\n return sum(bernoulli_trial(p) for _ in range(n))\",\n \"def _get_possible_outcomes(m, bits):\\n\\n # This is filled with loads of dirty binary tricks...You have been warned\\n\\n size = max(m.shape) # Max of shape to account for bra or ket\\n nqubits = int(math.log(size, 2) + .1) # Number of qubits possible\\n\\n # Make the output states and put in output_matrices, nothing in them now.\\n # Each state will represent a possible outcome of the measurement\\n # Thus, output_matrices[0] is the matrix which we get when all measured\\n # bits return 0. and output_matrices[1] is the matrix for only the 0th\\n # bit being true\\n output_matrices = []\\n for i in range(1 << len(bits)):\\n output_matrices.append(zeros(2**nqubits, 1))\\n\\n # Bitmasks will help sort how to determine possible outcomes.\\n # When the bit mask is and-ed with a matrix-index,\\n # it will determine which state that index belongs to\\n bit_masks = []\\n for bit in bits:\\n bit_masks.append(1 << bit)\\n\\n # Make possible outcome states\\n for i in range(2**nqubits):\\n trueness = 0 # This tells us to which output_matrix this value belongs\\n # Find trueness\\n for j in range(len(bit_masks)):\\n if i & bit_masks[j]:\\n trueness += j + 1\\n # Put the value in the correct output matrix\\n output_matrices[trueness][i] = m[i]\\n return output_matrices\",\n \"def bin_cdf(n, p, x):\\n\\n # p C (bin_dist) ** 0 ) *(1-bin_dist)** p\\n\\n # n = (p)=20\\n # x = x = 1 = r\\n # nCr = n! / r!(n-r)\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n def bin_dist(n, p, x):\\n \\\"\\\"\\\"\\n Given n number of trials, p the probability of success,\\n what is the probability of having x successes?\\n\\n Your function should raise a ValueError if x is higher\\n than n.\\n\\n If you need to compute combinations, you can import the\\n function \\\"comb\\\" from the package \\\"scipy.special\\\"\\n\\n :param n: number of trials (int)\\n :param p: probability of success\\n :param x: number of successes (int)\\n :return: probability of having x successes\\n :rtype: float\\n :raise ValueError: if x > n\\n \\\"\\\"\\\"\\n def factorial(x):\\n if x >= 0:\\n \\n factorial = 1\\n\\n for i in range(1, x + 1):\\n factorial = float(factorial * i)\\n # print(f' The factorial of {x} is {factorial}') \\n return factorial\\n\\n else:\\n raise ValueError(\\\"Sorry x cannot be a negative number\\\")\\n\\n def combination(n, r):\\n \\\"\\\"\\\"\\n Given n total number of items,\\n what is the number of possible ways\\n to choose r items from it?\\n\\n :param n: total number of items (integer)\\n :param r: number of items to arrange (int)\\n :return: number of combinations\\n :rtype: integer\\n \\\"\\\"\\\"\\n\\n \\n\\n \\n numerator = factorial(n)\\n denominator = factorial(r)\\n subtracted_answer = factorial(n-r)\\n \\n\\n answer = numerator/(denominator * subtracted_answer)\\n print(answer)\\n return answer \\n\\n # from scipy.special import comb\\n if x > n:\\n raise ValueError(\\\"Error, x must be less than n\\\")\\n else:\\n\\n\\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\\n\\n print(prob_success)\\n return prob_success \\n \\n # an= 1-bin_dist(n,p,x)\\n # print(f'word{an}')\\n # n= 12\\n # p=0.25\\n # # x=0??\\n # ((n!)/ (x!*(n-x)!)) * (p**x) * (1-p)**(n-x)\\n sum_prob = []\\n for i in range(x+1):\\n print(i)\\n prob = bin_dist(n,p,x=i)\\n sum_prob.append(prob)\\n print(sum_prob)\\n total =sum(sum_prob)\\n print(total)\",\n \"def perform_bernoulli_trials(n, p):\\n # Initialize number of successes: n_success\\n n_success = 0\\n\\n\\n # Perform trials\\n for i in range(n):\\n # Choose random number between zero and one: random_number\\n random_number = np.random.random()\\n\\n\\n # If less than p, it's a success so add one to n_success\\n if random_number < p:\\n n_success += 1\\n\\n return n_success\",\n \"def perform_bernoulli_trials(n, p):\\n # Initialize number of successes: n_success\\n n_success = 0\\n\\n\\n # Perform trials\\n for i in range(n):\\n # Choose random number between zero and one: random_number\\n random_number = np.random.random()\\n\\n # If less than p, it's a success so add one to n_success\\n if random_number< p:\\n n_success += 1\\n\\n return n_success\",\n \"def addition_mod(a, b, nbr):\\n bina = [int(x) for x in bin(a)[2:]]\\n binb = [int(x) for x in bin(b)[2:]]\\n binn = [int(x) for x in bin(nbr)[2:]]\\n #print(binn)\\n while len(bina) >= len(binb):\\n binb = [0]+binb\\n while len(bina) < len(binb)-1:\\n bina = [0]+bina\\n while len(binn) < len(bina):\\n binn = [0]+binn\\n while len(binn) > len(bina):\\n bina = [0]+bina\\n binb = [0]+binb\\n binn.reverse()\\n bina.reverse()\\n binb.reverse()\\n #print(bina, binb, binn)\\n n = len(bina)+len(binb)+len(binn)\\n na = len(bina)\\n nab = len(bina)+len(binb)\\n q = QuantumRegister(n+2, 'q')\\n circ = QuantumCircuit(q)\\n for i in range(na):\\n if bina[i]:\\n circ.x(q[i])\\n for i in range(len(binb)):\\n if binb[i]:\\n circ.x(q[na+i])\\n for i in range(len(binn)):\\n if binn[i]:\\n circ.x(q[nab+i])\\n addmod(circ, q, # A, B, lost, last, N, lost2, binn):\\n [q[i] for i in range(len(bina))],\\n [q[i+na] for i in range(len(binb)-1)],\\n q[n],\\n q[na+len(binb)-1],\\n [q[i+nab] for i in range(len(binn))],\\n q[n+1],\\n binn)\\n circ_m = measure(circ, q, [i for i in range(na,nab)])\\n return circ_m\",\n \"def solution(N):\\n\\tresult = 0\\n\\tcounter = 0\\n\\n\\tbin_number = \\\"{0:b}\\\".format(N)\\n\\n\\tfor num in bin_number:\\n\\t\\tif num == \\\"1\\\":\\n\\t\\t\\tif counter > result:\\n\\t\\t\\t\\tresult = counter\\n\\t\\t\\tcounter = 0\\n\\t\\telse:\\n\\t\\t\\tcounter += 1\\n\\n\\treturn result;\",\n \"def perform_bernoulli_trials(n, p):\\n # Initialize number of successes: n_success\\n n_success = 0\\n # Perform trials\\n for i in range(n):\\n # Choose random number between zero and one: random_number\\n random_number = np.random.random()\\n # If less than p, it's a success so add one to n_success\\n if random_number < p:\\n n_success += 1\\n\\n return n_success\",\n \"def countbrute(m):\\n nfound=0\\n\\n for i in range(1,m+1):\\n for j in range(1,i+1):\\n for k in range(1,j+1):\\n d1=i*i+(j+k)*(j+k) \\n if(checkpsq(d1)):\\n nfound=nfound+1\\n\\n return nfound\",\n \"def perform_bernoulli_trials(n, p):\\n # Initialize number of successes: n_success\\n n_success = 0\\n\\n # Perform trials\\n for i in range(n):\\n # Choose random number between zero and one: random_number\\n random_number = np.random.random()\\n\\n # If less than p, it's a success so add one to n_success\\n if random_number < p:\\n n_success += 1\\n\\n return n_success\",\n \"def test_conditional_2bit(self):\\n shots = 100\\n circuits = ref_conditionals.conditional_circuits_2bit(final_measure=True)\\n targets = ref_conditionals.conditional_counts_2bit(shots)\\n job = execute(circuits, QasmSimulator(), shots=shots)\\n result = job.result()\\n self.is_completed(result)\\n self.compare_counts(result, circuits, targets, delta=0)\",\n \"def andbits(num1,num2):\\n thingstoadd=[]\\n for i in range(31):\\n bit1=setbit(num1,i)\\n bit2=setbit(num2,i)\\n bit1=shiftleft(bit1,30 - i)\\n bit2=shiftleft(bit2,30 - i)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n bitsum=shiftright(bitsum,31 - i)\\n thingstoadd.append(bitsum)\\n bit1=setbit(num1,31)\\n bit2=setbit(num2,31)\\n bit1=shiftright(bit1,1)\\n bit2=shiftright(bit2,1)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n thingstoadd.append(bitsum)\\n return sum(thingstoadd)\",\n \"def bits(n):\\n\\n # Create a list of the first 1,000 binary numbers\\n binary_list = reverse_binary_list()\\n\\n # Start by calculating number of 1's for n\\n n_ones = num_of_ones(n, binary_list)\\n\\n # Calculate number of 1's for next value\\n next_ones = 0\\n while n_ones != next_ones:\\n n = n + 1\\n next_ones = num_of_ones(n, binary_list)\\n\\n return(n)\",\n \"def challenge_solver(number1, number2, threshold):\\n return (sum_of_n_terms(number1, threshold)\\n + sum_of_n_terms(number2, threshold)\\n - sum_of_n_terms(number1 * number2, threshold))\",\n \"def count_pairs(idx, bit_up_a, bit_up_b, bit_up_c, mem):\\n\\n global a\\n global b\\n global c\\n\\n if idx == -1:\\n return 1\\n\\n if (idx, bit_up_a, bit_up_b, bit_up_c) in mem:\\n return mem[(idx, bit_up_a, bit_up_b, bit_up_c)]\\n\\n count = 0\\n mask = 1 << idx\\n\\n for i, j in [(0, 0), (0, 1), (1, 0), (1, 1)]:\\n\\n k = i ^ j\\n\\n if bit_up_a:\\n if not (a & mask) and i == 1:\\n continue\\n elif (a & mask) and i == 0:\\n next_a = 0\\n else:\\n next_a = 1\\n else:\\n next_a = 0\\n\\n if bit_up_b:\\n if not (b & mask) and j == 1:\\n continue\\n elif (b & mask) and j == 0:\\n next_b = 0\\n else:\\n next_b = 1\\n else:\\n next_b = 0\\n\\n if bit_up_c:\\n if not (c & mask) and k == 1:\\n continue\\n elif (c & mask) and k == 0:\\n next_c = 0\\n else:\\n next_c = 1\\n else:\\n next_c = 0\\n\\n count += count_pairs(idx - 1, next_a, next_b, next_c, mem)\\n\\n mem[(idx, bit_up_a, bit_up_b, bit_up_c)] = count\\n return count\",\n \"def combination(n, r):\\n\\n \\n\\n \\n numerator = factorial(n)\\n denominator = factorial(r)\\n subtracted_answer = factorial(n-r)\\n \\n\\n answer = numerator/(denominator * subtracted_answer)\\n print(answer)\\n return answer\",\n \"def test_results():\\n x = 0.5\\n np.testing.assert_almost_equal(nbf.sum_x_n_calc(\\n x, z_n, k_n_1), npf.sum_x_n_calc(x, z_n, k_n_1))\",\n \"def get_most_probable_bit_with_thres(filtered_capture, prob_threshold):\\n # Enumerate challenge/responses to build a list of\\n # (probabilities, challenge, value)\\n sorted_prob = []\\n for challenge, response in filtered_capture.items():\\n n0, n1 = response\\n n = n0 + n1\\n if n < MIN_COUNT_FOR_MEANING:\\n # Ignore challenges with not enough measures\\n continue\\n # q0 = ncr(n, n0) * pow(1 - PROB, n0) * pow(PROB, n1)\\n # q1 = ncr(n, n0) * pow(PROB, n0) * pow(1 - PROB, n1)\\n # unnormalize_q0 = pow(1 - PROB, n0) * pow(PROB, n1)\\n # unnormalize_q1 = pow(PROB, n0) * pow(1 - PROB, n1)\\n # p_b0 = unnormalized_q0 / (unnormalized_q1 + unnormalized_q0)\\n # p_b1 = unnormalized_q1 / (unnormalized_q1 + unnormalized_q0)\\n if n >= 500:\\n # Prevent \\\"OverflowError: (34, 'Numerical result out of range')\\\"\\n p_b0 = n0 / (n0 + n1)\\n p_b1 = n1 / (n1 + n0)\\n else:\\n p_b0 = 1. / (1 + pow(PROB / (1 - PROB), n0) * pow((1 - PROB) / PROB, n1))\\n p_b1 = 1. / (1. + pow(PROB / (1 - PROB), n1) * pow((1 - PROB) / PROB, n0))\\n # print(f\\\"[{n0:2}+{n1:2}={n:2}] pb0={p_b0:.3}, pb1={p_b1:.3}\\\")\\n if p_b1 > prob_threshold and p_b1 > p_b0:\\n sorted_prob.append((p_b1, challenge, 1))\\n elif p_b0 > prob_threshold and p_b0 > p_b1:\\n sorted_prob.append((p_b0, challenge, 0))\\n\\n sorted_prob.sort()\\n # print(f\\\"Trying to find a bit out of {len(sorted_prob)} challenges with p>={prob_threshold}...\\\")\\n while sorted_prob:\\n best_prob, best_chall, best_val = sorted_prob.pop()\\n best_count = count_ones(best_chall)\\n if best_count == 1:\\n print(f\\\"Found a bit: {best_chall:#x} = {best_val} (proba {best_prob})\\\")\\n return (best_chall, best_val)\\n\\n # Combine the probabilities\\n for prob, chall, val in sorted_prob.copy():\\n if chall == best_chall:\\n continue\\n # Reduce the masking with XOR\\n if chall & ~best_chall == 0:\\n # Ensure that the masking is reasonable\\n count_xor = count_ones(best_chall ^ chall)\\n if count_xor <= 2 and count_xor < best_count:\\n new_prob = prob * best_prob\\n if new_prob > prob_threshold:\\n sorted_prob.append((new_prob, chall ^ best_chall, val ^ best_val))\\n sorted_prob.sort()\\n\\n print(f\\\"Unable to found a bit with threshold={prob_threshold}\\\")\\n return None\",\n \"def bit_contribution_test(hash_function):\\n\\n model = hash_function()\\n hash_list = []\\n zero_str = '0' * 2048\\n for i in range(1, 2049):\\n for j in range(0, i):\\n flip_str = zero_str[:j] + '1' + zero_str[j+1:i]\\n hash_list.append(list(map(int, list(msg_to_bits.pad_msg(flip_str, i)))))\\n if i % 200 == 0:\\n print(i)\\n\\n hashed_dict = dict()\\n collisions = 0\\n i = 0\\n for to_hash in hash_list:\\n i += 1\\n hash_val = model.hash(to_hash, False).tostring()\\n if hash_val in hashed_dict:\\n collisions += 1\\n hashed_dict[hash_val] = True\\n if i % 10000 == 0:\\n print(i)\\n\\n return collisions\",\n \"def test_bin_addition():\\n outcome1 = Outcome(\\\"red\\\", 1)\\n outcome2 = Outcome(\\\"black\\\", 1)\\n outcome3 = Outcome(\\\"low\\\", 5)\\n outcome4 = Outcome(\\\"high\\\", 5)\\n\\n rng = NonRandom()\\n wheel = Wheel(rng)\\n\\n wheel.addOutcome(1, outcome1)\\n wheel.addOutcome(1, outcome3)\\n wheel.addOutcome(31, outcome2)\\n wheel.addOutcome(31, outcome4)\\n\\n # since we added only two outcomes for each of the two bins,\\n # the number of outcomes for both bins should be 2 and 0 for all others\\n wheel.rng.setSeed(1)\\n returned_bin = wheel.next()\\n outcomes = returned_bin.outcomes\\n print outcomes\\n assert len(outcomes) == 2\\n assert outcome1 in returned_bin.outcomes\\n assert outcome3 in returned_bin.outcomes\\n\\n wheel.rng.setSeed(31)\\n returned_bin = wheel.next()\\n assert outcome3, outcome2 in returned_bin.outcomes\\n assert outcome3, outcome4 in returned_bin.outcomes\\n\\n for i in range(0, 38):\\n if i not in [1, 31]:\\n wheel.rng.setSeed(i)\\n returned_bin = wheel.next()\\n assert len(returned_bin.outcomes) == 0\",\n \"def _expected_values(cont):\\n n = float(sum(cont))\\n results = []\\n for i in range(4):\\n results.append((cont[i] + cont[i ^ 1]) * (cont[i] + cont[i ^ 2]) / n)\\n return results\",\n \"def problem(args:int) -> int:\\r\\n\\ta, b, c = 1, 2, 0\\r\\n\\tresult = [a]\\r\\n\\twhile c <= args:\\r\\n\\t\\tc = a + b\\r\\n\\t\\ta = b\\r\\n\\t\\tb = c\\r\\n\\t\\tresult.append(a)\\r\\n\\tresult = np.array(result)\\r\\n\\treturn sum(result[result % 2 == 0])\",\n \"def main():\\n\\n import sys\\n sys.setrecursionlimit(10**7)\\n from itertools import accumulate, combinations, permutations, product # https://docs.python.org/ja/3/library/itertools.html\\n # accumulate() returns iterator! to get list: list(accumulate())\\n from math import factorial, ceil, floor\\n def factorize(n):\\n \\\"\\\"\\\"return the factors of the Arg and count of each factor\\n \\n Args:\\n n (long): number to be resolved into factors\\n \\n Returns:\\n list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]\\n \\\"\\\"\\\"\\n fct = [] # prime factor\\n b, e = 2, 0 # base, exponent\\n while b * b <= n:\\n while n % b == 0:\\n n = n // b\\n e = e + 1\\n if e > 0:\\n fct.append((b, e))\\n b, e = b + 1, 0\\n if n > 1:\\n fct.append((n, 1))\\n return fct\\n def combinations_count(n, r):\\n \\\"\\\"\\\"Return the number of selecting r pieces of items from n kinds of items.\\n \\n Args:\\n n (long): number\\n r (long): number\\n \\n Raises:\\n Exception: not defined when n or r is negative\\n \\n Returns:\\n long: number\\n \\\"\\\"\\\"\\n # TODO: How should I do when n - r is negative?\\n if n < 0 or r < 0:\\n raise Exception('combinations_count(n, r) not defined when n or r is negative')\\n if n - r < r: r = n - r\\n if r < 0: return 0\\n if r == 0: return 1\\n if r == 1: return n\\n numerator = [n - r + k + 1 for k in range(r)]\\n denominator = [k + 1 for k in range(r)]\\n for p in range(2,r+1):\\n pivot = denominator[p - 1]\\n if pivot > 1:\\n offset = (n - r) % p\\n for k in range(p-1,r,p):\\n numerator[k - offset] /= pivot\\n denominator[k] /= pivot\\n result = 1\\n for k in range(r):\\n if numerator[k] > 1:\\n result *= int(numerator[k])\\n return result\\n def combinations_with_replacement_count(n, r):\\n \\\"\\\"\\\"Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.\\n \\n Args:\\n n (long): number\\n r (long): number\\n \\n Raises:\\n Exception: not defined when n or r is negative\\n \\n Returns:\\n long: number\\n \\\"\\\"\\\"\\n if n < 0 or r < 0:\\n raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')\\n elif n == 0:\\n return 1\\n else:\\n return combinations_count(n + r - 1, r)\\n from bisect import bisect_left, bisect_right\\n from collections import deque, Counter, defaultdict # https://docs.python.org/ja/3/library/collections.html#collections.deque\\n from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html\\n from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html\\n from operator import itemgetter\\n # ex1: List.sort(key=itemgetter(1))\\n # ex2: sorted(tuples, key=itemgetter(1,2))\\n from functools import reduce\\n def chmin(x, y):\\n \\\"\\\"\\\"change minimum\\n if x > y, x = y and return (x, True).\\n convenient when solving problems of dp[i]\\n \\n Args:\\n x (long): current minimum value\\n y (long): potential minimum value\\n \\n Returns:\\n (x, bool): (x, True) when updated, else (x, False)\\n \\\"\\\"\\\"\\n if x > y:\\n x = y\\n return (x, True)\\n else:\\n return (x, False)\\n def chmax(x, y):\\n \\\"\\\"\\\"change maximum\\n if x < y, x = y and return (x, True).\\n convenient when solving problems of dp[i]\\n \\n Args:\\n x (long): current maximum value\\n y (long): potential maximum value\\n \\n Returns:\\n (x, bool): (x, True) when updated, else (x, False)\\n \\\"\\\"\\\"\\n if x < y:\\n x = y\\n return (x, True)\\n else:\\n return (x, False)\\n\\n from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.\\n def gcds(numbers):\\n return reduce(gcd, numbers)\\n def lcm(x, y):\\n return (x * y) // gcd(x, y)\\n def lcms(numbers):\\n return reduce(lcm, numbers, 1)\\n\\n # first create factorial_list\\n # fac_list = mod_factorial_list(n)\\n INF = 10 ** 18\\n MOD = 10 ** 9 + 7\\n modpow = lambda a, n, p = MOD: pow(a, n, p) # Recursive function in python is slow!\\n def modinv(a, p = MOD):\\n # evaluate reciprocal using Fermat's little theorem:\\n # a**(p-1) is identical to 1 (mod p) when a and p is coprime\\n return modpow(a, p-2, p)\\n def modinv_list(n, p = MOD):\\n if n <= 1:\\n return [0,1][:n+1]\\n else:\\n inv_t = [0,1]\\n for i in range(2, n+1):\\n inv_t += [inv_t[p % i] * (p - int(p / i)) % p]\\n return inv_t\\n def modfactorial_list(n, p = MOD):\\n if n == 0:\\n return [1]\\n else:\\n l = [0] * (n+1)\\n tmp = 1\\n for i in range(1, n+1):\\n tmp = tmp * i % p\\n l[i] = tmp\\n return l\\n def modcomb(n, k, fac_list = [], p = MOD):\\n # fac_list = modfactorial_list(100)\\n # print(modcomb(100, 5, modfactorial_list(100)))\\n from math import factorial\\n if n < 0 or k < 0 or n < k: return 0\\n if n == 0 or k == 0: return 1\\n if len(fac_list) <= n:\\n a = factorial(n) % p\\n b = factorial(k) % p\\n c = factorial(n-k) % p\\n else:\\n a = fac_list[n]\\n b = fac_list[k]\\n c = fac_list[n-k]\\n return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p\\n def modadd(a, b, p = MOD):\\n return (a + b) % MOD\\n def modsub(a, b, p = MOD):\\n return (a - b) % p\\n def modmul(a, b, p = MOD):\\n return ((a % p) * (b % p)) % p\\n def moddiv(a, b, p = MOD):\\n return modmul(a, modpow(b, p-2, p))\\n\\n \\\"\\\"\\\" initialize variables and set inputs\\n # initialize variables\\n # to initialize list, use [0] * n\\n # to initialize two dimentional array, use [[0] * N for _ in range(N)]\\n # set inputs\\n # open(0).read() is a convenient method:\\n # ex) n, m, *x = map(int, open(0).read().split())\\n # min(x[::2]) - max(x[1::2])\\n # ex2) *x, = map(int, open(0).read().split())\\n # don't forget to add comma after *x if only one variable is used\\n # preprocessing\\n # transpose = [x for x in zip(*data)]\\n # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [(1, 4, 7), (2, 5, 8), (3, 6, 9)]\\n # flat = [flatten for inner in data for flatten in inner]\\n # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [1, 2, 3, 4, 5, 6, 7, 8, 9]\\n # calculate and output\\n # output pattern\\n # ex1) print(*l) => when l = [2, 5, 6], printed 2 5 6\\n \\\"\\\"\\\"\\n\\n # functions used\\n r = lambda: sys.stdin.readline().strip()\\n r_int = lambda: int(r())\\n R = lambda: list(map(int, r().split()))\\n Rfloat = lambda: list(map(float, r().split()))\\n Rtuple = lambda: tuple(map(int, r().split()))\\n Rmap = lambda: map(int, r().split())\\n\\n \\\"\\\"\\\" how to treat input\\n # single int: int(r())\\n # single string: r()\\n # single float: float(r())\\n # line int: R()\\n # line string: r().split()\\n # line (str, int, int): [j if i == 0 else int(j) for i, j in enumerate(r().split())]\\n # lines int: [R() for _ in range(n)]\\n \\\"\\\"\\\"\\n\\n # main\\n N, Q = R()\\n STX = [R() for _ in range(N)]\\n STX.sort(key=itemgetter(2))\\n\\n D = [int(r()) for _ in range(Q)]\\n Stopped = [-1] * Q\\n ans = [-1] * Q\\n\\n for s, t, x in STX:\\n l = bisect_left(D, s-x)\\n r = bisect_left(D,t-x)\\n a = l\\n while a < r:\\n if Stopped[a] == -1:\\n ans[a] = x\\n Stopped[a] = r\\n a += 1\\n else:\\n a = Stopped[a]\\n\\n for i in ans:\\n print(i)\\n\\n \\\"\\\"\\\"memo: how to use defaultdict of list\\n # initialize\\n Dic = defaultdict(list)\\n # append / extend\\n Dic[x].append(y)\\n # for\\n for k, v in Dic.items():\\n \\\"\\\"\\\"\",\n \"def taskOfPairing(freq):\\n n_pairs = list(map(lambda x: x // 2, freq))\\n remainders = list(map(lambda x: x % 2, freq))\\n print(freq)\\n print(n_pairs)\\n print(remainders)\\n\\n total = sum(n_pairs)\\n print(total)\\n i = 1\\n while i < len(freq):\\n print('i', i, remainders[i], remainders[i - 1])\\n if remainders[i] + remainders[i - 1] == 2:\\n print('total', total, 'i', i)\\n total = total + 1\\n i = i + 2\\n print('newtotal', total, 'i', i)\\n else:\\n i += 1\\n print(total)\\n return total\",\n \"def calculate_bleu(candidate, reference):\\n pn_sum = 0\\n for n in range(1, 4):\\n cand_grama, ref_grama = n_grama(candidate, n), n_grama(reference, n)\\n p = calculate_p(cand_grama, ref_grama)\\n if p != 0:\\n # If there are no matches between n_grams,\\n # don't add nothing\\n pn_sum += (0.33 * math.log(p))\\n bp = calculate_bp_penality(candidate, reference)\\n return bp * math.exp(pn_sum)\",\n \"def compute_n_codes(n_bits, half_bit=None):\\n n_bits, half_bit = parse_bits(n_bits, half_bit)\\n if half_bit:\\n return 2**(n_bits + 1) - 1\\n else:\\n return 2**n_bits\",\n \"def test_count_binary_decisions(self):\\n abs_centered_quantized_data_0 = numpy.array([0.75, 0.05, 0.1, 0.2, 0.2, 0.15], dtype=numpy.float32)\\n bin_width_test_0 = 0.05\\n abs_centered_quantized_data_1 = numpy.array([210., 6., 9., 6.], dtype=numpy.float32)\\n bin_width_test_1 = 3.\\n truncated_unary_prefix = 7\\n \\n (cumulated_zeros_0, cumulated_ones_0) = \\\\\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_0,\\n bin_width_test_0,\\n truncated_unary_prefix)\\n (cumulated_zeros_1, cumulated_ones_1) = \\\\\\n lossless.stats.count_binary_decisions(abs_centered_quantized_data_1,\\n bin_width_test_1,\\n truncated_unary_prefix)\\n print('1st experiment:')\\n print('Number of occurrences of 0 for each binary decision computed by the function:')\\n print(cumulated_zeros_0)\\n print('Number of occurrences of 0 for each binary decision computed by hand:')\\n print(numpy.array([0, 1, 1, 1, 2, 0, 0]))\\n print('Number of occurrences of 1 for each binary decision computed by the function:')\\n print(cumulated_ones_0)\\n print('Number of occurrences of 1 for each binary decision computed by hand:')\\n print(numpy.array([6, 5, 4, 3, 1, 1, 1]))\\n print('\\\\n2nd experiment:')\\n print('Number of occurrences of 0 for each binary decision computed by the function:')\\n print(cumulated_zeros_1)\\n print('Number of occurrences of 0 for each binary decision computed by hand:')\\n print(numpy.array([0, 0, 2, 1, 0, 0, 0]))\\n print('Number of occurrences of 1 for each binary decision computed by the function:')\\n print(cumulated_ones_1)\\n print('Number of occurrences of 1 for each binary decision computed by hand:')\\n print(numpy.array([4, 4, 2, 1, 1, 1, 1]))\",\n \"def count_bits(dqxx, n):\\n return sum([check_bit(x, n) for x in dqxx])\",\n \"def wabbits(n, k):\\n a, b = 1, 1\\n for i in range(3, n+1):\\n a, b = b, a*k + b\\n return b\",\n \"def sum_simulated_test():\\n f = open(\\\"./results/simulated_sigmoid_sum.csv\\\", \\\"w\\\")\\n #f1 = open(\\\"./results/avg_pres.txt\\\", \\\"w\\\")\\n #f.write(\\\"num. of qubits; precision\\\\n\\\")\\n\\n\\n computable_qubits = 27\\n num_subtest = 1000\\n\\n acum_precision = 0\\n coeffs = []\\n temp = -10\\n while temp < 11:\\n coeffs.append(temp)\\n temp += 0.25\\n #for coeff in coeffs:\\n # variables.c_summation = coeff\\n # print(coeff)\\n for i in range(2, computable_qubits):\\n #print(\\\"qubit: \\\", i)\\n precision = 0\\n x = []\\n for j in range(num_subtest):\\n\\n random_dict = get_random_dict(i)\\n\\n # compute real answer\\n real_answer = 0\\n for value in random_dict.values():\\n real_answer += value\\n # f1.write(str(real_answer)+\\\";\\\")\\n x.append(real_answer)\\n\\n # assign spin value to real_answer\\n if real_answer < 0:\\n real_answer = -1\\n elif real_answer > 0:\\n real_answer = 1\\n else:\\n real_answer = 0\\n bqm = get_bqm()\\n quantum_sigmoid_sum(bqm, random_dict, \\\"target\\\")\\n sampler = get_simulated_sampler()\\n result = sampler.sample(bqm)\\n if real_answer == 0:\\n precision += 1\\n # f1.write(\\\"1\\\\n\\\")\\n elif real_answer == result.first.sample['target']:\\n precision += 1\\n # f1.write(\\\"1\\\\n\\\")\\n# else:\\n # f1.write(\\\"0\\\\n\\\")\\n\\n precision /= num_subtest\\n # acum_precision+= precision\\n\\n f.write(str(i) + \\\";\\\" + str(precision) + \\\"\\\\n\\\")\\n f.close()\\n #f1.write(str(coeff)+\\\";\\\"+ str(round(acum_precision/(computable_qubits-1), 4)) + \\\"\\\\n\\\")\\n # acum_precision = 0\\n #f1.close()\",\n \"def get_error_hamming_distributions_from_results(results: Sequence[Sequence[Sequence[int]]]) \\\\\\n -> Sequence[Sequence[float]]:\\n num_shots = len(results[0])\\n n_bits = len(results[0][0]) - 1\\n\\n hamming_wt_distrs = []\\n # loop over all binary strings of length n_bits\\n for result, bits in zip(results, all_bitstrings(2 * n_bits)):\\n # Input nums are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\\n num_a = bit_array_to_int(bits[:n_bits])\\n num_b = bit_array_to_int(bits[n_bits:])\\n\\n # add the numbers\\n ans = num_a + num_b\\n ans_bits = int_to_bit_array(ans, n_bits + 1)\\n\\n # record the fraction of shots that resulted in an error of the given weight\\n hamming_wt_distr = [0. for _ in range(len(ans_bits) + 1)]\\n for shot in result:\\n # multiply relative hamming distance by the length of the output for the weight\\n wt = len(ans_bits) * hamming(ans_bits, shot)\\n hamming_wt_distr[int(wt)] += 1. / num_shots\\n\\n hamming_wt_distrs.append(hamming_wt_distr)\\n\\n return hamming_wt_distrs\",\n \"def combinations(n) -> float:\\r\\n c = math.factorial(n) / (math.factorial(2) * math.factorial(n - 2))\\r\\n return c\",\n \"def r_combinations(n,r):\\n return r_permutations(n,r) / math.factorial(r)\",\n \"def sol(n):\\n p = 1\\n res = 0\\n \\n while n:\\n p*=5\\n if n&1:\\n res+=p\\n n=n>>1\\n return res%1000000007\",\n \"def fn(mask, k):\\n if not mask: return 0 \\n ans = inf \\n for i in range(n): \\n if mask & (1<<i): \\n ans = min(ans, (nums1[i]^nums2[k]) + fn(mask^(1<<i), k+1))\\n return ans\",\n \"def bits_to_probabilities(\\n all_qubits: Sequence[Tuple[int, int]],\\n subsys_qubits: Sequence[Tuple[int, int]],\\n bits: np.ndarray,\\n) -> np.ndarray:\\n num_qubits = len(subsys_qubits)\\n indices = [all_qubits.index(q) for q in subsys_qubits]\\n bits_red = np.asarray(bits[:, indices], dtype=int)\\n for i in range(num_qubits):\\n bits_red[:, i] *= 2 ** (num_qubits - i - 1)\\n bits = list(np.sum(bits_red, axis=1))\\n p_reduced = np.bincount(bits, minlength=2 ** num_qubits)\\n num_trials, _ = bits_red.shape\\n return p_reduced / num_trials\",\n \"def pairwise_bit_scores(blastf, ss, outf, verbose=False):\\n\\n if verbose:\\n sys.stderr.write(f\\\"{bcolors.GREEN}Creating scores{bcolors.ENDC}\\\\n\\\")\\n\\n pb = {}\\n out = open(outf + \\\".tsv\\\", 'w')\\n out.write(\\\"Query\\\\tSubject\\\\tQLen\\\\tSLen\\\\tBits\\\\tnBits\\\\n\\\")\\n for b in stream_blast_results(blastf, verbose):\\n if b.query not in pb:\\n pb[b.query] = {}\\n if b.db not in pb:\\n pb[b.db] = {}\\n\\n # we normalize by the bitscore of the two proteins if we can!\\n if b.query in ss and b.db in ss:\\n nb = b.bitscore / ((ss[b.query] + ss[b.db])/2)\\n else:\\n # if we can't do that, we cheat and normalize \\n # the bit score by twice\\n # the average length of the proteins\\n # i.e. the sum of the lengths\\n nb = b.bitscore / (b.query_length + b.subject_length + 3.3)\\n\\n if b.query in pb[b.db] and pb[b.db][b.query] > nb:\\n continue\\n pb[b.db][b.query] = pb[b.db][b.query] = nb\\n out.write(f\\\"{b.query}\\\\t{b.db}\\\\t{b.query_length}\\\\t{b.subject_length}\\\\t{b.bitscore}\\\\t{nb}\\\\n\\\")\\n return pb\",\n \"def test_11(self):\\n for _ in range(1000):\\n num_types = np.random.randint(1, 10)\\n edu_start = np.random.randint(10, 100)\\n type_shares = np.random.normal(0, 1, size=num_types * 2)\\n\\n args = [type_shares, np.array([edu_start])]\\n\\n py = get_conditional_probabilities(*args)\\n fort = fort_debug.wrapper_get_conditional_probabilities(*args + [num_types])\\n\\n assert_almost_equal(np.sum(py), 1.0)\\n assert_almost_equal(py, fort)\",\n \"def fn(i, s0, s1, c0, c1):\\n if s0 > n or s1 > n: return 0 # impossible \\n if i == len(balls): return int(c0 == c1)\\n ans = 0 \\n for x in range(balls[i]+1): \\n ans += fn(i+1, s0+x, s1+balls[i]-x, c0+(x > 0), c1+(x < balls[i])) * comb(balls[i], x)\\n return ans\",\n \"def _bin_numbers(col1, col2, bin_n):\\n col1 = col1[~col1.map(lambda x: is_null_flag(x))].reset_index(drop=True)\\n col2 = col2[~col2.map(lambda x: is_null_flag(x))].reset_index(drop=True)\\n comb = pd.Series(pd.np.concatenate([col1, col2])).sort_values(inplace=False).reset_index(drop=True)\\n bin_size = int(len(comb) / bin_n)\\n bin_dict1, bin_dict2 = {}, {}\\n for i in range(bin_n - 1): # last bin only needs bin_min\\n bin_low = comb[i*bin_size]\\n bin_high = comb[(i+1)*bin_size]\\n bin_dict1[i] = sum((col1 >= bin_low) & (col1 < bin_high))\\n bin_dict2[i] = sum((col2 >= bin_low) & (col2 < bin_high))\\n # print bin_low, bin_high\\n # Highest bin\\n bin_dict1[i+1] = sum(col1 >= bin_high)\\n bin_dict2[i+1] = sum(col2 >= bin_high)\\n return bin_dict1, bin_dict2\",\n \"def create_samples(f: Callable[..., int], n_args: int, n_bits: int,\\n) -> Dict[Tuple[int, ...], Tuple[int, ...]]:\\n samples = {}\\n max_arg = 2 ** n_bits\\n for inputs in itertools.product((0, 1), repeat=n_args * n_bits):\\n ints = [int(\\\"\\\".join(str(bit) for bit in inputs[i:i + n_bits]), 2)\\n for i in range(0, len(inputs), n_bits)]\\n try:\\n output = f(*ints)\\n if 0 <= output < max_arg:\\n bit_string = (\\\"{:0\\\" + str(n_bits) + \\\"b}\\\").format(output)\\n samples[inputs] = tuple(int(bit) for bit in bit_string)\\n except ZeroDivisionError:\\n pass\\n return samples\",\n \"def count_bits(n):\\n return sum(1 for x in bin(n) if x == \\\"1\\\")\",\n \"def probability(n, k, p):\\n prob = 0\\n power = expotentation_by_squaring((1-p), n)\\n count_mult = math.log(n, 2)\\n p_fraction = p/(1-p)\\n count_mult += 1\\n for i in range(0, k+1):\\n element = newton(n, i)*power\\n prob += element\\n power *= p_fraction\\n count_mult += 2\\n return prob, count_mult\",\n \"def permutation_test_mat(matrix,\\n n_1, n_2, n_permutations,\\n a00=1, a11=1, a01=0):\\n n = n_1 + n_2\\n pi = np.zeros(n, dtype=np.int8)\\n pi[n_1:] = 1\\n\\n larger = 0.\\n count = 0\\n \\n for sample_n in range(1 + n_permutations):\\n count = 0.\\n for i in range(n):\\n for j in range(i, n):\\n mij = matrix[i, j] + matrix[j, i]\\n if pi[i] == pi[j] == 0:\\n count += a00 * mij\\n elif pi[i] == pi[j] == 1:\\n count += a11 * mij\\n else:\\n count += a01 * mij\\n if sample_n == 0:\\n statistic = count\\n elif statistic <= count:\\n larger += 1\\n\\n np.random.shuffle(pi)\\n\\n return larger / n_permutations\",\n \"def getSum(self, a: int, b: int) -> int:\\n i = 0\\n carry = 0\\n res = 0\\n while i < 12:\\n curr_a_bit = (a >> i) & 1\\n curr_b_bit = (b >> i) & 1\\n # print(curr_a_bit, curr_b_bit)\\n curr_bit = curr_a_bit ^ curr_b_bit ^ carry\\n res |= (curr_bit << i)\\n if curr_a_bit & curr_b_bit == 1 or curr_a_bit & carry == 1 or curr_b_bit & carry == 1:\\n carry = 1\\n else:\\n carry = 0\\n i += 1\\n # print(res, bin(res), bin(a), bin(b))\\n # 不用把 第 13 位 i = 12 时 carry 加上 result, 因为 这一位 判断 正 负 不需要\\n if res >= 2 ** 11:\\n # 举例：最大和2000 ，res < 2 ^ 11, 最小和 -2000， res > 2 ^ 11\\n # 如果 和 是 0，比如 1 和 -1， res = 0\\n # 如果和 是 -1，比如 1 和 -2， res > 2 ^ 11\\n res = (~res) ^ 0b111111111111\\n return res\",\n \"def successes(predictions,truth):\\n\\ttotal = len(predictions)\\n\\tcorrect = 0.0\\n\\tfor p in predictions:\\n\\t\\tif p == truth:\\n\\t\\t\\tcorrect += 1\\n\\t\\telse:\\n\\t\\t\\tprint truth,\\\"\\\\t\\\",p\\n\\treturn correct\",\n \"def compute(n):\\n if n == 1:\\n return 1\\n else:\\n i = find_i(n)\\n return 2 * compute(n - i) + 2 ** i - 1\",\n \"def binomialTest(k, n, p = 0.5, exact = False):\\n\\tassert(k <= n)\\n\\tassert(k >= 0 and n > 0)\\n\\tn = int(n)\\n\\tk = int(k)\\n\\tp_value = 1.0\\n\\n\\t# Trivial cases where p = 0 or p = 1\\n\\tif p == 0.0: # Must then have k = 0\\n\\t\\tif k > 0:\\n\\t\\t\\treturn 0.0\\n\\t\\telse:\\n\\t\\t\\treturn 1.0\\n\\tif p == 1.0: # Must then have k = n\\n\\t\\tif k <= n:\\n\\t\\t\\treturn 1.0\\n\\n\\tif k == 0:\\n\\t\\t# Probability of at least zero successes is 1\\n\\t\\tp_value = 1.0\\n\\telif k == n:\\n\\t\\t# Probability of all successes\\n\\t\\tp_value = p**n\\n\\telse:\\n\\t\\tif not exact and n*p > 30 and n*(1-p) > 30:\\n\\t\\t\\t# Use normal approximation\\n\\t\\t\\tmu = n*p\\n\\t\\t\\tsd = math.sqrt(n*p*(1-p))\\n\\t\\t\\tz = (k-mu)/sd\\n\\t\\t\\tif z < 0.0:\\n\\t\\t\\t\\tp_value = 1-Prob_Z(z)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tp_value = Prob_Z(z)\\n\\t\\telse:\\n\\t\\t\\tp_value = p**n # The last term in the sum\\n\\t\\t\\tfor j in range(k,n):\\n\\t\\t\\t\\t# Compute logarithm of (n choose j) p^j (1-p)^ (n-j), the\\n\\t\\t\\t\\t# binomial probability. Use logarithm to avoid overflow\\n\\t\\t\\t\\t# problems with potentially enormous factorials.\\n\\t\\t\\t\\tlog_p = logChoose(n,j) + j*math.log(p) + (n-j)*math.log(1-p)\\n\\t\\t\\t\\tp_value += math.exp(log_p)\\n\\t\\t\\tif p_value > 1.0:\\n\\t\\t\\t\\tp_value = 1.0\\n\\treturn p_value\",\n \"def judge(n1: List[int], n2: List[int]) -> int:\\n\\tmin_length = min(len(n1),len(n2))\\n\\tpass_count = 0\\n\\tfor i in range(min_length):\\n\\t\\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\\n\\n\\treturn pass_count\",\n \"def add_bitwise(x, y):\\n\\n answer = 0\\n carry_in = 0\\n k = 1\\n iterations_tracker = x | y\\n\\n while (iterations_tracker):\\n x_k = x & k\\n y_k = y & k\\n\\n answer |= x_k ^ y_k ^ carry_in\\n carry_out = majority_bitwise(x_k, y_k, carry_in)\\n\\n carry_in = carry_out << 1\\n\\n k <<= 1\\n iterations_tracker >>= 1\\n\\n if (carry_in):\\n answer |= carry_in\\n\\n return answer\",\n \"def solution(n):\\n i = 1\\n j = 2\\n sum = 0\\n while j <= n:\\n if j % 2 == 0:\\n sum += j\\n i, j = j, i + j\\n\\n return sum\",\n \"def measure_gcd_success():\\n for size in range(2,16):\\n print(\\\"--------- samplesize = %d\\\" % size)\\n d = dict()\\n for _ in range(1000):\\n q = findpoly(size)\\n d.setdefault(q,0)\\n d[q] += 1\\n for k,v in sorted(d.items(), key=lambda x: x[1]):\\n print(\\\"%5d: %8s\\\" % (v, k))\",\n \"def bits(self):\\n if not self.group_list:\\n return 0.0\\n # TODO: Is it worth to cache the overall result?\\n return self.bits_except_last + self.group_list[-1].bits\",\n \"def brute_force_solution():\\n def is_pythagorean_triplet(a, b, c):\\n return c**2 == a**2 + b**2\\n\\n return next(\\n a * b * (TRIPLET_SUM - a - b)\\n for a in range(1, TRIPLET_SUM)\\n for b in range(a + 1, TRIPLET_SUM - a)\\n if is_pythagorean_triplet(a, b, TRIPLET_SUM - a - b)\\n )\",\n \"def getWays(n, c):\\n # === Preprocess c ===\\n # Filter out values exceeding n\\n c = list(filter(lambda x: x <= n, c))\\n\\n # Sort in ascending order\\n c.sort()\\n\\n # === Obtain relations ===\\n # Dictionary of relations\\n # The key is the target coin to be decomposed, and the value is a list of possible decompositions\\n # Interpreted for a key k and a list value of v of length l, where each element is a tuple of length 2, k = v[0][0] + v[0][1], v[1][0] + v[1][1], ... , v[l][0] + v[l][1]\\n relations = {}\\n\\n # Obtain relations between all coins\\n # Loop through each coin\\n for i in reversed(c):\\n\\n # For each coin, we attempt to find an additive relation. To do so, we need to loop through each coin smaller than i twice, with the first loop identifying the first value and the second loop identifying the second value. If these two values sum up to give i, we add it to our list of relations. \\n for j in reversed(c): \\n\\n if j >= i: \\n continue \\n\\n for k in reversed(c):\\n\\n # We want k to be less than or equal to j to preserve the ordering. E.g. in the case of 5 = 3 + 2, we do not want a repeat case of 5 = 2 + 3 recorded.\\n if k > j: \\n continue \\n\\n if j + k == i:\\n\\n # We store the results in a dictionary\\n if i in relations.keys():\\n relations[i].append((j, k))\\n\\n else:\\n relations[i] = [(j, k)]\\n\\n # === Relational scores ===\\n # We generate scores for each coin based on their relations, i.e. how many cases this coin can be broken up into\\n scores = {}\\n\\n # For those that cannot be broken down into others, we set their score as 0\\n for i in c:\\n if i not in relations.keys():\\n scores[i] = 0\\n\\n # Generate the remainder of the scores\\n for i in c: \\n\\n # We only generate if they have relations\\n if i not in relations.keys(): \\n continue \\n\\n # If there is more than one relation, we can have more than one score per coin. Thus, we keep a running list of the coin's scores in a list.\\n current_coin_scores = []\\n\\n # For all other coins, we access the list of relations\\n for rel in relations[i]:\\n\\n # If a relation exists, there is already an additional case. \\n current_score = 1\\n\\n # Obtain the number of unique components\\n unique_components = set(rel)\\n\\n # For each unique component, obtain its 'additional case' score from scores\\n add_cases = []\\n\\n for comp in unique_components:\\n add_cases.append(scores[comp])\\n\\n # Calculate the score from this relation, based off the relational equation in the README\\n current_score += sum(add_cases)\\n\\n # Add score to total_scores\\n current_coin_scores.append(current_score)\\n\\n # Total up all the scores and add it to scores\\n scores[i] = sum(current_coin_scores)\\n\\n # === Obtain top level answers === \\n solutions = []\\n\\n # We loop through every coin in c\\n # The point of this is to obtain a solution set that, at the very least, has at least one of this coin\\n for k in reversed(c):\\n\\n # Instantiate s\\n s = {}\\n\\n # We want to obtain values for which we have the maximum value of k for the given solution set\\n for i in reversed(range(1, math.floor(n / k) + 1)):\\n\\n # We instantiate the solution set\\n s = {i: 0 for i in list(filter(lambda x: x <= k, reversed(c)))}\\n\\n # Obtain solution\\n s = populate(s, n, (k, i))\\n \\n # Check if s is None\\n # If s is None, we need to continue with the loop\\n # Else, we can append s to solutions and break out of the loop\\n if s is not None: \\n solutions.append(s)\\n\\n break\\n\\n # === Finalise total cases ===\\n final_score = len(solutions)\\n\\n # For each solution, we obtain the additional scores based on the MAX-REST equation in README\\n for s in solutions: \\n\\n # Biggest coin\\n biggest_coin = max(s.keys())\\n\\n # Obtain max-rest score\\n # Calculate the max score, which should have a minimum of 0\\n max_score = max(0, (s[biggest_coin] - 1) * scores[biggest_coin])\\n\\n # Calculate the rest score\\n rest_score = 0\\n\\n # We calculate the rest score using all other coins in the dictionary\\n for i in s.keys():\\n if i == biggest_coin:\\n continue \\n\\n else: \\n rest_score += s[i] * scores[i]\\n\\n max_rest_score = max_score + rest_score\\n\\n # Increment total score\\n final_score += max_rest_score\\n\\n # DEBUG(f\\\"solution: {s}, max-rest score: {max_rest_score}\\\")\\n\\n\\n # DEBUG(solutions)\\n\\n # DEBUG(f\\\"coin: {i}, uniques: {unique_components}, additionals: {add_cases}, current score: {current_score}\\\")\\n \\n\\n # DEBUG(f\\\"coin: {i}, relation: {relations[i]}, scores: {scores}\\\")\\n\\n\\n\\n # We loop through all relations\\n # \\n # \\n # \\n # except for the first coin, which we set to have a score of +0. \\n\\n \\n # DEBUG(f\\\"n: {n}, c: {c}, relations: {relations}, scores: {scores}, solutions: {solutions}, final_score: {final_score}\\\")\\n\\n return final_score\",\n \"def fn(x, mask):\\n ans = size = 0 \\n for xx in range(1, 10): \\n if not mask & (1 << xx): \\n if (x, xx) not in mp or mask & 1 << mp[x, xx]: \\n ans += fn(xx, mask^(1<<xx))\\n size += 1\\n size = 9 - size\\n if m <= size <= n: ans += 1\\n return ans\",\n \"def test_compute_binary_probabilities(self):\\n nb_images = 100\\n height_map = 32\\n width_map = 48\\n bin_widths_test_0 = numpy.array([2., 2., 2.], dtype=numpy.float32)\\n bin_widths_test_1 = numpy.array([0.5, 0.5, 0.5], dtype=numpy.float32)\\n truncated_unary_length = 4\\n \\n y_float32_0 = numpy.random.uniform(low=-10.,\\n high=10.,\\n size=(nb_images, height_map, width_map, 1)).astype(numpy.float32)\\n y_float32_1 = numpy.random.laplace(loc=0.5,\\n scale=2.5,\\n size=(nb_images, height_map, width_map, 1)).astype(numpy.float32)\\n y_float32_2 = numpy.random.standard_cauchy(size=(nb_images, height_map, width_map, 1)).astype(numpy.float32)\\n y_float32 = numpy.concatenate((y_float32_0, y_float32_1, y_float32_2),\\n axis=3)\\n map_mean = numpy.array([0., 0.5, 0.], dtype=numpy.float32)\\n binary_probabilities_0 = lossless.stats.compute_binary_probabilities(y_float32,\\n bin_widths_test_0,\\n map_mean,\\n truncated_unary_length)\\n print('1st set of test quantization bin widths:')\\n print(bin_widths_test_0)\\n print('1st absolute centered-quantized latent variable feature map.')\\n print('Binary probabilities computed by the function:')\\n print(binary_probabilities_0[0, :])\\n \\n # Let x be a continuous random variable following the\\n # uniform distribution of support [-10.0, 10.0]. The\\n # probability the 1st binary decision is 0 is written\\n # p(|x| <= 1.0) = 1.0/10. The probability the 2nd\\n # binary decision is 0 is written\\n # p(1.0 <= |x| <= 3.0)/p(|x| >= 1.0) = (2.0/10)/(9.0/10) = 2.0/9.\\n # The probability the 3rd binary decision is 0 is written\\n # p(3.0 <= |x| <= 5.0)/p(|x| >= 3.0) = (2.0/10)/(7.0/10) = 2.0/7.\\n # The above calculations use the cumulative distribution\\n # function of the uniform distribution of support [-10.0, 10.0].\\n print('Binary probabilities computed by hand:')\\n print([1./10, 2./9, 2./7, 2./5])\\n print('2nd absolute centered-quantized latent variable feature map.')\\n print('Binary probabilities computed by the function:')\\n print(binary_probabilities_0[1, :])\\n \\n # Let x be a continuous random variable following the\\n # Laplace distribution of mean 0.0 and scale 2.5. It is\\n # said `mean 0.0` as the 2nd latent variable feature map\\n # is centered before being quantized. The probability\\n # the 1st binary decision is 0 is written\\n # p(|x| <= 1.0) = 0.3297. The probability the 2nd binary\\n # decision is 0 is written\\n # p(1.0 <= |x| <= 3.0)/p(|x| >= 1.0) = 0.3691/0.6703 = 0.5507.\\n # The probability the 3rd binary decision is 0 is written\\n # p(3.0 <= |x| <= 5.0)/p(|x| >= 3.0) = 0.1659/0.3012 = 0.5507.\\n # The above calculations use the cumulative distribution\\n # function of the Laplace distribution of mean 0 and scale 2.5.\\n print('Binary probabilities computed by hand:')\\n print([0.3297, 0.5507, 0.5507, 0.5507])\\n print('3rd absolute centered-quantized latent variable feature map.')\\n print('Binary probabilities computed by the function:')\\n print(binary_probabilities_0[2, :])\\n \\n # Let x be a continuous random variable following the\\n # standard Cauchy distribution. The probability the 1st\\n # binary decision is 0 is written p(|x| <= 1.0) = 0.5.\\n # The probability the 2nd binary decision is 0 is written\\n # p(1.0 <= |x| <= 3.0)/p(|x| >= 1.0) = 0.2952/0.5 = 0.5903.\\n # The probability the 3rd binary decision is 0 is written\\n # p(3.0 <= |x| <= 5.0)/p(|x| >= 3.0) = 0.079/0.2048 = 0.3865.\\n # The above calculations use the cumulative distribution\\n # function of the standard Cauchy distribution.\\n print('Binary probabilities computed by hand:')\\n print([0.5, 0.5903, 0.3865, 0.2811])\\n \\n binary_probabilities_1 = lossless.stats.compute_binary_probabilities(y_float32,\\n bin_widths_test_1,\\n map_mean,\\n truncated_unary_length)\\n print('\\\\n2nd set of test quantization bin widths:')\\n print(bin_widths_test_1)\\n print('1st absolute centered-quantized latent variable feature map.')\\n print('Binary probabilities computed by the function:')\\n print(binary_probabilities_1[0, :])\\n \\n # Let x be a continuous random variable following the\\n # uniform distribution of support [-10.0, 10.0]. The\\n # probability the 1st binary decision is 0 is written\\n # p(|x| <= 0.25) = 1.0/40. The probability the 2nd\\n # binary decision is 0 is written\\n # p(0.25 <= |x| <= 0.75)/p(|x| >= 0.25) = (2.0/40)/(39.0/40) = 2.0/39.\\n # The probability the 3rd binary decision is 0 is written\\n # p(0.75 <= |x| <= 1.25)/p(|x| >= 0.75) = (2.0/40)/(37.0/40) = 2.0/37.\\n print('Binary probabilities computed by hand:')\\n print([1./40, 2./39, 2./37, 2./35])\\n print('2nd absolute centered-quantized latent variable feature map.')\\n print('Binary probabilities computed by the function:')\\n print(binary_probabilities_1[1, :])\\n \\n # Let x be a continuous random variable following the\\n # Laplace distribution of mean 0.0 and scale 2.5. The\\n # probability the 1st binary decision is 0 is written\\n # p(|x| <= 0.25) = 0.0952. The probability the 2nd binary\\n # decision is 0 is written\\n # p(0.25 <= |x| <= 0.75)/p(|x| >= 0.25) = 0.1640/0.9048 = 0.1813.\\n # The probability the 3rd binary decision is 0 is written\\n # p(0.75 <= |x| <= 1.25)/p(|x| >= 0.75) = 0.1343/0.7408 = 0.1813.\\n print('Binary probabilities computed by hand:')\\n print([0.0952, 0.1813, 0.1813, 0.1813])\\n print('3rd absolute centered-quantized latent variable feature map.')\\n print('Binary probabilities computed by the function:')\\n print(binary_probabilities_1[2, :])\\n \\n # Let x be a continuous random variable following the\\n # standard Cauchy distribution. The probability the 1st\\n # binary decision is 0 is written p(|x| <= 0.25) = 0.1560.\\n # The probability the 2nd binary decision is 0 is written\\n # p(0.25 <= |x| <= 0.75)/p(|x| >= 0.25) = 0.2537/0.8440 = 0.3006.\\n # The probability the 3rd binary decision is 0 is written\\n # p(0.75 <= |x| <= 1.25)/p(|x| >= 0.75) = 0.1608/0.5903 = 0.2724.\\n print('Binary probabilities computed by hand:')\\n print([0.1560, 0.3006, 0.2724, 0.2306])\",\n \"def faster_brute_force_solution():\\n def calc_b(a, sum):\\n return ((sum**2/2) - (sum * a)) / (sum - a)\\n\\n a, b = next(\\n (a, calc_b(a, TRIPLET_SUM))\\n for a in range(1, TRIPLET_SUM)\\n if calc_b(a, TRIPLET_SUM).is_integer()\\n )\\n\\n return a * b * (TRIPLET_SUM - a - b)\",\n \"def testCounting(self):\\n \\n clk = Signal(0)\\n clock_gen = ClkDriver(clk, period=4)\\n \\n for i in range(1, 6):\\n #print \\\"Testing\\\", i, \\\"bits\\\"\\n out = Signal(intbv(0)[i:])\\n prev_out = Signal(intbv(2**i - 1)[i:])\\n counter = Counter(out, clk, Signal(1))\\n \\n # make sure it increments and wraps at modulo 2^n\\n @always(clk.posedge)\\n def test():\\n #print out, prev_out\\n self.assertEqual(int(out), int((prev_out + 1) % 2**(len(prev_out))))\\n prev_out.next = out\\n \\n sim = Simulation(counter, clock_gen, test)\\n sim.run(12 * 2**i, quiet=1)\",\n \"def tabulate_score(self):\\n # Generate the bit formatting string\\n n_bits = int(np.ceil(np.log2(self.max_ans)))\\n fmt_str = \\\"{0:0\\\"+str(n_bits)+\\\"b}\\\"\\n \\n # Convert answers to int\\n self.answers = self.answers.astype(np.int64)\\n\\n # Convert each element in answers to a bit string\\n bits = [fmt_str.format(ans) for ans in self.answers]\\n bit_string = \\\"\\\".join(bits)\\n \\n # Convert the combined bit string back to an integer\\n seed = int(bit_string, 2)\\n\\n return seed\",\n \"def compare():\\n eb = 1\\n p = 0.5\\n R = 0.5\\n N = 150 # set the error count to reach\\n\\n domain = np.linspace(0, 10, 11)\\n hard_domain = np.linspace(0, 8, 9)\\n soft_domain = np.linspace(0, 6, 7)\\n hard_decibels = 10 ** (hard_domain / 10)\\n soft_decibels = 10 ** (soft_domain / 10)\\n\\n # get results for hard decoding\\n nos = eb / hard_decibels\\n hard_results = []\\n for no in nos:\\n print(np.where(nos == no)[0][0])\\n experiment = ViterbiHard(eb, no / R)\\n bit_count = 0\\n error_count = 0\\n for output in experiment.run():\\n bit_count += 1\\n if output[0] != output[1]:\\n error_count += 1\\n if error_count == N:\\n hard_results.append(error_count / bit_count)\\n break\\n\\n # get results for soft decoding\\n nos = eb / soft_decibels\\n soft_results = []\\n for no in nos:\\n print(np.where(nos == no)[0][0])\\n experiment = ViterbiSoft(eb, no / R)\\n bit_count = 0\\n error_count = 0\\n for output in experiment.run():\\n bit_count += 1\\n if output[0] != output[1]:\\n error_count += 1\\n if error_count == N:\\n soft_results.append(error_count / bit_count)\\n break\\n\\n decibels = 10 ** (domain / 10)\\n nos = eb / decibels\\n taus = nos / 4 / np.sqrt(eb) * np.log((1 - p) / p)\\n plt.semilogy(hard_domain, np.array(hard_results), label='Hard-decision')\\n plt.semilogy(soft_domain, np.array(soft_results), label='Soft-decision')\\n plt.semilogy(domain, norm.sf((taus + np.sqrt(eb)) / np.sqrt(nos / 2)) * (1 - p) +\\n norm.sf((np.sqrt(eb) - taus) / np.sqrt(nos / 2)) * p, label='Expectation ($p=0.5$)')\\n plt.xlabel('$E_b/N_0$ (dB)')\\n plt.ylabel('Probability of bit error')\\n plt.legend(loc='lower left')\\n plt.show()\",\n \"def aranksums(x,y):\\r\\n n1 = len(x)\\r\\n n2 = len(y)\\r\\n alldata = N.concatenate((x,y))\\r\\n ranked = arankdata(alldata)\\r\\n x = ranked[:n1]\\r\\n y = ranked[n1:]\\r\\n s = sum(x)\\r\\n expected = n1*(n1+n2+1) / 2.0\\r\\n z = (s - expected) / math.sqrt(n1*n2*(n1+n2+1)/12.0)\\r\\n prob = 2*(1.0 - azprob(abs(z)))\\r\\n return z, prob\",\n \"def helper(nums_dict, S):\\n if not nums_dict:\\n return 1 if S == 0 else 0\\n \\n num = max(nums_dict.keys())\\n num_count = nums_dict.pop(num)\\n remaining_sum = sum([k*v for k, v in nums_dict.items()])\\n #print(nums_dict, remaining_sum, S)\\n \\n ans = 0\\n num_sum = -num*num_count\\n for i in range(num_count+1):\\n if -remaining_sum <= S - num_sum <= remaining_sum:\\n ans += helper(nums_dict.copy(), S-num_sum) * comb(num_count, i)\\n num_sum += 2*num\\n return ans\",\n \"def combination(num_m: int, num_n: int) -> int:\\n if num_m < num_n:\\n return 0\\n\\n tmp_m = 1\\n tmp_n = 1\\n tmp_cnt = 0\\n for i in range(num_n, 0, -1):\\n tmp_n *= i\\n tmp_m *= num_m - tmp_cnt\\n tmp_cnt += 1\\n\\n return tmp_m / tmp_n\",\n \"def fn(i, j, mask):\\n if j == n: return 1 \\n if i == m: return fn(0, j+1, mask)\\n ans = 0 \\n for x in 1<<2*i, 1<<2*i+1, 0b11<<2*i: \\n mask0 = mask ^ x\\n if mask0 & 0b11<<2*i and (i == 0 or (mask0 >> 2*i) & 0b11 != (mask0 >> 2*i-2) & 0b11): \\n ans += fn(i+1, j, mask0)\\n return ans % 1_000_000_007\",\n \"def bitvector(self, res1, res2):\\n bitvector = [\\n interaction(res1, res2) for interaction in self.interactions.values()\\n ]\\n if self.count:\\n return np.array([sum(bits) for bits in bitvector], dtype=np.uint8)\\n return np.array(bitvector, dtype=bool)\",\n \"def find_num_appearing_once(ls):\\n \\n sum_bin = 0\\n ans = [] # can also define a list with a length of 32 for 32 bit machine\\n result = 0 # decimal\\n for e in ls:\\n # print(int(format(e, 'b')))\\n sum_bin += int(format(e, 'b'))\\n print(sum_bin)\\n \\n # record which bit cannot mod 3\\n while sum_bin != 0:\\n bit = sum_bin % 10\\n if bit % 3 != 0:\\n ans.append(1)\\n else:\\n ans.append(0)\\n sum_bin //= 10\\n print(ans)\\n \\n # convert ans into decimal\\n pow = len(ans) - 1\\n while len(ans) != 0:\\n result += ans.pop() * 2**pow\\n pow -= 1\\n print(result)\",\n \"def test_bp_example():\\n signal = np.array([4, 7, 9, 10, 6, 11, 3])\\n\\n pe = permutation_entropy(signal, 2)\\n\\n assert 0.91 < pe < 0.92 # Should be approx 0.918.\\n\\n pe = permutation_entropy(signal, 3)\\n\\n assert 1.52 < pe < 1.53 # Should be approx 1.522.\",\n \"def doubles(counts):\\n return (counts==2).sum()\",\n \"def ransac_iters(w=0.5, d=min_num_pairs(), z=0.99):\\n\\n return int(np.ceil(np.log(1 - z) / np.log(1 - np.power(w,d))))\",\n \"def getCombination(mu1, mu2, sig1, sig2, confidence1, confidence2):\\n\\tglobal alpha, beta, gamma\\n\\n\\t#Standard Bayesian\\n\\t# sigNew = math.sqrt(math.pow(sig1, 2) + math.pow(sig2, 2))\\n\\t# muNew = u1 + u2\\n\\t# return muNew, sigNew \\n\\n\\t##In accordance with the nature papers:\\n\\tsigNew = (math.pow(sig1,2) * math.pow(sig2, 2)) \\\\\\n\\t/ float((math.pow(sig1,2) + math.pow(sig2, 2)))\\n\\tinv1 = 1 / float((math.pow(sig1, 2)))\\n\\tinv2 = 1 / float((math.pow(sig2, 2)))\\n\\tsumInverses = inv1 + inv2\\n\\n\\t##inverse standard deviations squared\\n\\t# w1 = inv1 / float(sumInverses)\\n\\t# w2 = inv2 / float(sumInverses)\\n\\n\\t## equal weighting\\n\\t# w1 = .5\\n\\t# w2 = .5\\n\\n\\t## weightings based off of confidence\\n\\t# summation = confidence1 + confidence2\\n\\t# w1 = confidence1 / float(summation)\\n\\t# w2 = confidence2 / float(summation)\\n\\n\\t##weightings with exponentials\\n\\t# w1 = w1**.001\\n\\t# w2 = w2**.001\\n\\t# newSummation = w1 + w2\\n\\t# w1 = w1 / float(newSummation)\\n\\t# w2 = w2 / float(newSummation)\\n\\n\\t##weightings with polynomial factors\\n\\tw1 = (beta * confidence1 + alpha)**gamma \\n\\tw2 = (beta * confidence2 + alpha)**gamma \\n\\tnewSummation = w1 + w2\\n\\tw1 = w1 / float(newSummation)\\n\\tw2 = w2 / float(newSummation)\\n\\n\\tmuNew = w1 * mu1 + w2 * mu2\\n\\treturn muNew, sigNew\",\n \"def triplets():\\n for a in xrange(1, 1000):\\n for b in xrange(a, 1000):\\n c = 1000 - (a + b)\\n if a**2 + b**2 == c**2:\\n return a, b, c\",\n \"def countPairs(arr):\\n pairs = 0\\n for i in range(len(arr) - 1):\\n for j in range(i + 1, len(arr)):\\n if arr[i] & arr[j] == 0: # log 0 = Infinity...avoid this problem\\n pass\\n elif int(math.log2(arr[i] & arr[j])) == math.log2(arr[i] & arr[j]):\\n print('(', arr[i], '&', arr[j], ')', '=', arr[i] & arr[j],\\n '=2^', int(math.log2(arr[i] & arr[j])))\\n pairs += 1\\n # print('Pairs:', pairs, '\\\\n')\\n print(pairs)\\n return pairs\",\n \"def problem():\\n for a in range(1, 380):\\n for b in range(a):\\n if a + b + (a**2 + b**2)**0.5 == 1000:\\n return int(a * b * (a**2 + b**2)**0.5)\",\n \"def linear_combination(n):\\n weighs = (1, 3, 9, 27)\\n\\n for factors in factors_set():\\n sum = 0\\n for i in range(len(factors)):\\n sum += factors[i] * weighs[i]\\n if sum == n:\\n return factors\",\n \"def getResults(solver, minBit, maxBit, saveFile, noResults):\\n\\n for k in range(minBit, maxBit + 1, 2):\\n for i in range(noResults):\\n\\n keys = generate_RSA.KeyGen(k) # initialise keys\\n keys.generateKeys() # generate keys\\n\\n solver.setN(keys.n) # setup solver\\n solver.setE(keys.e)\\n\\n solver.solve() # solve problem\\n\\n if solver.d == keys.d: # if we got it right\\n resTime = resTime_C # update correct dictionaries\\n resCount = resCount_C\\n resSpace = resSpace_C\\n else:\\n resTime = resTime_W # else update wrong dictionaries\\n resCount = resCount_W\\n resSpace = resSpace_W\\n\\n if k not in resTime: # if we've not yet had a result for k\\n resTime[k] = [solver.time, 1] # then set\\n resSpace[k] = [solver.space, 1] # then set\\n resCount[k] = [solver.count, 1]\\n else:\\n oldT, oldC = resTime[k] # keeps a running average\\n newC = oldC + 1 # increment count\\n newT = ((oldT * oldC) + solver.time) / newC # get new averagae\\n resTime[k] = [newT, newC] # without storing all variables\\n\\n oldS, oldC = resSpace[k] # keeps a running average\\n newS = ((oldS * oldC) + solver.space) / newC\\n resSpace[k] = [newS, newC] # without storing all variables\\n\\n oldCount, oldC = resCount[k] # keeps a running average\\n newCount = ((oldCount * oldC) + solver.count) / newC\\n resCount[k] = [newCount, newC] # without storing all variables\\n\\n if i % 10 == 0:\\n saveResults(saveFile) # every ten results save again\",\n \"def bitwise_stats(traces, N, delta):\\n \\n X = np.zeros((N,),dtype=int)\\n padded_traces = pad_traces(traces, N)\\n num_traces = padded_traces.shape[0]\\n \\n p = np.zeros(N)\\n for j in range(N):\\n p[j] = np.sum(padded_traces[:,j])/num_traces\\n \\n c = np.concatenate((np.ones(N,), np.zeros(N,)), axis=None)\\n bounds = (0,1)\\n \\n for i in range(N):\\n A_ub = np.zeros((2*N,2*N))\\n for j in range(N):\\n for k in range(N):\\n if j == k:\\n A_ub[j,k] = -1\\n A_ub[j+N,k] = -1\\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\\n elif k > j:\\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\\n \\n b_ub = np.concatenate((p,-1*p), axis=None)\\n \\n A_eq0 = np.zeros((i+1,2*N))\\n b_eq0 = np.zeros(i+1)\\n for j in range(i+1):\\n A_eq0[j,j+N] = 1\\n if j==i:\\n b_eq0[j] = 0\\n else:\\n b_eq0[j] = X[j]\\n \\n A_eq1 = np.zeros((i+1,2*N))\\n b_eq1 = np.zeros(i+1)\\n for j in range(i+1):\\n A_eq1[j,j+N] = 1\\n if j==i:\\n b_eq1[j] = 1\\n else:\\n b_eq1[j] = X[j]\\n \\n res0 = linprog(c,A_ub,b_ub,A_eq0,b_eq0,bounds,method='interior-point')\\n res1 = linprog(c,A_ub,b_ub,A_eq1,b_eq1,bounds,method='interior-point')\\n if res0.fun < res1.fun:\\n X[i] = 0\\n else:\\n X[i] = 1\\n \\n return X\",\n \"def countTriplets1(arr, r):\\n from collections import Counter\\n arr_dict = Counter()\\n ratio_range = []\\n triplets = 0\\n\\n # Build the counter\\n for x in arr:\\n arr_dict[x] += 1\\n\\n # Build a list for easier iteration\\n for key, value in arr_dict.items():\\n ratio_range.append(tuple([key,value]))\\n ratio_range.sort()\\n \\n for y in range(len(ratio_range)-2):\\n firstvalue = ratio_range[y][1]\\n secondvalue = ratio_range[y+1][1]\\n thirdvalue = ratio_range[y+2][1]\\n print(ratio_range, firstvalue, secondvalue,thirdvalue)\\n\\n summedvalue = (firstvalue + secondvalue + thirdvalue) - 3\\n triplet_count = 2**summedvalue\\n print(summedvalue, triplet_count)\\n triplets += triplet_count\\n\\n return triplets, arr_dict, ratio_range\",\n \"def non_abundant_sums():\\n # the sum of divisors of every number\\n divisor_sum = [0] * LIMIT\\n for i in range(1, LIMIT):\\n for j in range(i * 2, LIMIT, i):\\n divisor_sum[j] += i\\n # abundant numbers\\n abundant_nums = [i for (i, x) in enumerate(divisor_sum) if x > i]\\n\\n expressible = [False] * LIMIT\\n for i in abundant_nums:\\n for j in abundant_nums:\\n if i + j < LIMIT:\\n expressible[i + j] = True\\n else:\\n break\\n ans = sum(i for (i, x) in enumerate(expressible) if not x)\\n return str(ans)\",\n \"def measure_all_1(n, state):\\n state = state.copy()\\n\\n outs = ''\\n for i in range(n):\\n out = measure_single(n, state,\\n i) # After measuring bit0, bit0 collapses. It affects the subsequent bit1 measurement, but does not affect the 1000 independent measurements of the upper layer\\n outs = str(out) + outs # from low bit to high bit\\n return outs\",\n \"def part1b_0():\\n xs = exampleInput\\n _, forward = submission.computeForward(simpleCRF, xs)\\n for i in xrange(len(xs)):\\n grader.requireIsEqual( 1.0, sum( forward[i].values() ) )\",\n \"def problem9_naive(n):\\n for a in range(4, n, 4):\\n for b in range(3, n - a):\\n c = n - a - b\\n if a ** 2 + b ** 2 == c ** 2:\\n return a * b * c\\n return None\",\n \"def generateStats(self):\\n\\t\\tn = float(self.n)\\n\\t\\tm = float(self.m)\\n\\t\\tk = float(self.k)\\n\\t\\tp_fp = math.pow(1.0 - math.exp(-(k*n)/m), k)\\n\\t\\tprint \\\"Probability of false positives: \\\", p_fp\\n\\t\\tprint \\\"Predicted false positive rate: \\\", p_fp * 100.0\\n\\t\\tprint \\\"Number of elements entered in filter: \\\", n\\n\\t\\tprint \\\"Number of bits in filter: \\\", m\\n\\t\\tprint \\\"Number of hashes in filter: \\\", k\",\n \"def test_bit_add_multiple_bytes(self):\\n ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 8, 16, 65535, False, aerospike.BIT_OVERFLOW_FAIL, None)]\\n\\n self.as_connection.operate(self.test_key, ops)\\n\\n _, _, bins = self.as_connection.get(self.test_key)\\n expected_result = bytearray([0] * 1 + [255] * 2 + [0] * 2)\\n assert bins[self.test_bin_zeroes] == expected_result\",\n \"def part1b_1():\\n xs = exampleInput\\n backward = submission.computeBackward(simpleCRF, xs)\\n for i in xrange(len(xs)):\\n grader.requireIsEqual( 1.0, sum( backward[i].values() ) )\",\n \"def part_two(rucksacks: list) -> int:\\n summ = 0\\n for i in range(0, len(rucksacks), 3):\\n first_group = set(rucksacks[i])\\n second_group = set(rucksacks[i + 1])\\n third_group = set(rucksacks[i + 2])\\n badge = first_group.intersection(second_group).intersection(third_group)\\n badge = list(badge)[0] # extract item id from set\\n summ += PRIORITY.get(badge, 0)\\n return summ\",\n \"def countTriplets3(arr, r):\\n from collections import Counter\\n from math import factorial\\n arr_dict = Counter()\\n n0 = arr[0]\\n\\n # If the ratio 'r' is 1 then this is a special case of combinations\\n if r == 1:\\n for x in arr:\\n if x == n0: arr_dict[x] += 1\\n n = arr_dict[n0]\\n r2 = 3\\n return factorial(n)//(factorial(r2)*factorial(n-r2)), arr_dict\\n\\n # Main variables for the rest of the function\\n max_arr = max(arr)\\n ratio_range = [n0]\\n triplets = 0\\n\\n # Build all possible values\\n index = n0 \\n counter = 0\\n while index < max_arr:\\n index *= r\\n ratio_range.append(index)\\n counter += 1\\n if ratio_range[-1] > max_arr: ratio_range.pop(-1)\\n \\n # Build the counter\\n for x in arr:\\n if x in ratio_range: arr_dict[x] += 1\\n\\n # With the 1 special case removed, there now cannot be triplets if there are not 3 items in the dict\\n if len(arr_dict) < 3: return triplets, arr_dict, ratio_range\\n\\n for y in range(len(ratio_range)-2):\\n firstkey = ratio_range[y]\\n secondkey = ratio_range[y+1]\\n thirdkey = ratio_range[y+2]\\n \\n # If there are no triplets then the loop will exit without incrementing triplets \\n if firstkey not in arr_dict or secondkey not in arr_dict or thirdkey not in arr_dict: \\n continue\\n else:\\n firstvalue = arr_dict[firstkey]\\n secondvalue = arr_dict[secondkey]\\n thirdvalue = arr_dict[thirdkey]\\n \\n triplet_count = (firstvalue) * (secondvalue) * (thirdvalue)\\n triplets += triplet_count\\n\\n return triplets, arr_dict\",\n \"def countTriplets2(arr, r):\\n from collections import Counter\\n from math import factorial\\n\\n # If the ratio 'r' is 1 then this is a special case of combinations\\n if r == 1:\\n n = len(arr)\\n r = 3\\n return factorial(n)//(factorial(r)*factorial(n-r))\\n\\n arr_dict = Counter()\\n ratio_range = []\\n index = 0\\n counter = 0\\n triplets = 0\\n \\n # Build the counter\\n for x in arr:\\n arr_dict[x] += 1\\n max_arr_dict = max(arr_dict)\\n\\n # With the 1 special case removed, there now cannot be triplets if there are not 3 items in the dict\\n if len(arr_dict) < 3: return triplets\\n \\n # There is now the potential for triplets so build all possible values\\n while index < max_arr_dict:\\n index = r**counter\\n ratio_range.append(index)\\n counter += 1\\n if ratio_range[-1] > max_arr_dict: ratio_range.pop(-1)\\n\\n for y in range(len(ratio_range)-2):\\n firstkey = ratio_range[y]\\n secondkey = ratio_range[y+1]\\n thirdkey = ratio_range[y+2]\\n \\n # If there are no triplets then the loop will exit without incrementing triplets \\n if firstkey not in arr_dict or secondkey not in arr_dict or thirdkey not in arr_dict: \\n continue\\n else:\\n firstvalue = arr_dict[firstkey]\\n secondvalue = arr_dict[secondkey]\\n thirdvalue = arr_dict[thirdkey]\\n \\n summedvalue = (firstvalue + secondvalue + thirdvalue) - 3\\n triplet_count = 2**summedvalue\\n triplets += triplet_count\\n\\n return triplets\",\n \"def combine_many(*fudge):\\n result = sum(fudge)\\n print(result)\",\n \"def potential_witnesses(n):\\n if n < 1373653: return [2, 3] # n < 1,373,653\\n if n < 9080191: return [31, 73] # n < 9,080,191\\n if n < 4759123141: return [2, 7, 61] # n < 4,759,123,141\\n if n < 2152302898747: return [2, 3, 5, 7, 11] # n < 2,152,302,898,747\\n if n < 3474749660383: return [2, 3, 5, 7, 11, 13] # n < 3,474,749,660,383\\n if n < 341550071728321: return [2, 3, 5, 7, 11, 13, 17] # n < 341,550,071,728,321\\n return [random.randint(1,n-1) for _ in xrange(0,20)] # 99.999999999909051% (1 - .25**20) accuracy for n >= 341,550,071,728,321\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67043245","0.6088592","0.6078585","0.60144264","0.5993007","0.59269917","0.59174794","0.5848427","0.58017844","0.5783029","0.57710576","0.57601815","0.5722196","0.57119036","0.5695961","0.5689013","0.5688207","0.56689256","0.5668077","0.5657879","0.56535506","0.5639762","0.5635178","0.5629599","0.5629558","0.562365","0.5620416","0.5617605","0.56173944","0.5604947","0.5592672","0.5586142","0.5575726","0.557274","0.5567741","0.5566534","0.5560307","0.55463105","0.552897","0.5527155","0.55267805","0.55215025","0.5516945","0.5515543","0.5490845","0.5476702","0.547457","0.54646343","0.5458854","0.54516083","0.5442245","0.54376894","0.54347444","0.54321724","0.54174024","0.5414753","0.53837824","0.5383377","0.5351607","0.5351332","0.5346999","0.5346052","0.5336103","0.5327579","0.5324194","0.53216493","0.53174955","0.53111726","0.5310535","0.53071594","0.53049636","0.53024006","0.5298849","0.52957386","0.5287341","0.5280848","0.52727264","0.52718186","0.52601206","0.5258473","0.5256633","0.5252897","0.5246382","0.5243324","0.52427155","0.52426565","0.523835","0.52373475","0.52342314","0.52332324","0.52271795","0.52254736","0.52176744","0.5214277","0.52135855","0.5208011","0.52012795","0.5198814","0.5193167","0.5184907"],"string":"[\n \"0.67043245\",\n \"0.6088592\",\n \"0.6078585\",\n \"0.60144264\",\n \"0.5993007\",\n \"0.59269917\",\n \"0.59174794\",\n \"0.5848427\",\n \"0.58017844\",\n \"0.5783029\",\n \"0.57710576\",\n \"0.57601815\",\n \"0.5722196\",\n \"0.57119036\",\n \"0.5695961\",\n \"0.5689013\",\n \"0.5688207\",\n \"0.56689256\",\n \"0.5668077\",\n \"0.5657879\",\n \"0.56535506\",\n \"0.5639762\",\n \"0.5635178\",\n \"0.5629599\",\n \"0.5629558\",\n \"0.562365\",\n \"0.5620416\",\n \"0.5617605\",\n \"0.56173944\",\n \"0.5604947\",\n \"0.5592672\",\n \"0.5586142\",\n \"0.5575726\",\n \"0.557274\",\n \"0.5567741\",\n \"0.5566534\",\n \"0.5560307\",\n \"0.55463105\",\n \"0.552897\",\n \"0.5527155\",\n \"0.55267805\",\n \"0.55215025\",\n \"0.5516945\",\n \"0.5515543\",\n \"0.5490845\",\n \"0.5476702\",\n \"0.547457\",\n \"0.54646343\",\n \"0.5458854\",\n \"0.54516083\",\n \"0.5442245\",\n \"0.54376894\",\n \"0.54347444\",\n \"0.54321724\",\n \"0.54174024\",\n \"0.5414753\",\n \"0.53837824\",\n \"0.5383377\",\n \"0.5351607\",\n \"0.5351332\",\n \"0.5346999\",\n \"0.5346052\",\n \"0.5336103\",\n \"0.5327579\",\n \"0.5324194\",\n \"0.53216493\",\n \"0.53174955\",\n \"0.53111726\",\n \"0.5310535\",\n \"0.53071594\",\n \"0.53049636\",\n \"0.53024006\",\n \"0.5298849\",\n \"0.52957386\",\n \"0.5287341\",\n \"0.5280848\",\n \"0.52727264\",\n \"0.52718186\",\n \"0.52601206\",\n \"0.5258473\",\n \"0.5256633\",\n \"0.5252897\",\n \"0.5246382\",\n \"0.5243324\",\n \"0.52427155\",\n \"0.52426565\",\n \"0.523835\",\n \"0.52373475\",\n \"0.52342314\",\n \"0.52332324\",\n \"0.52271795\",\n \"0.52254736\",\n \"0.52176744\",\n \"0.5214277\",\n \"0.52135855\",\n \"0.5208011\",\n \"0.52012795\",\n \"0.5198814\",\n \"0.5193167\",\n \"0.5184907\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6910166"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":74299,"cells":{"query":{"kind":"string","value":"Get the distribution of the hamming weight of the error vector (number of bits flipped between output and expected answer) for each possible pair of two n_bit summands using results output by get_n_bit_adder_results"},"document":{"kind":"string","value":"def get_error_hamming_distributions_from_results(results: Sequence[Sequence[Sequence[int]]]) \\\n -> Sequence[Sequence[float]]:\n num_shots = len(results[0])\n n_bits = len(results[0][0]) - 1\n\n hamming_wt_distrs = []\n # loop over all binary strings of length n_bits\n for result, bits in zip(results, all_bitstrings(2 * n_bits)):\n # Input nums are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bit_array_to_int(bits[:n_bits])\n num_b = bit_array_to_int(bits[n_bits:])\n\n # add the numbers\n ans = num_a + num_b\n ans_bits = int_to_bit_array(ans, n_bits + 1)\n\n # record the fraction of shots that resulted in an error of the given weight\n hamming_wt_distr = [0. for _ in range(len(ans_bits) + 1)]\n for shot in result:\n # multiply relative hamming distance by the length of the output for the weight\n wt = len(ans_bits) * hamming(ans_bits, shot)\n hamming_wt_distr[int(wt)] += 1. / num_shots\n\n hamming_wt_distrs.append(hamming_wt_distr)\n\n return hamming_wt_distrs"},"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_possible_outcomes(m, bits):\n\n # This is filled with loads of dirty binary tricks...You have been warned\n\n size = max(m.shape) # Max of shape to account for bra or ket\n nqubits = int(math.log(size, 2) + .1) # Number of qubits possible\n\n # Make the output states and put in output_matrices, nothing in them now.\n # Each state will represent a possible outcome of the measurement\n # Thus, output_matrices[0] is the matrix which we get when all measured\n # bits return 0. and output_matrices[1] is the matrix for only the 0th\n # bit being true\n output_matrices = []\n for i in range(1 << len(bits)):\n output_matrices.append(zeros(2**nqubits, 1))\n\n # Bitmasks will help sort how to determine possible outcomes.\n # When the bit mask is and-ed with a matrix-index,\n # it will determine which state that index belongs to\n bit_masks = []\n for bit in bits:\n bit_masks.append(1 << bit)\n\n # Make possible outcome states\n for i in range(2**nqubits):\n trueness = 0 # This tells us to which output_matrix this value belongs\n # Find trueness\n for j in range(len(bit_masks)):\n if i & bit_masks[j]:\n trueness += j + 1\n # Put the value in the correct output matrix\n output_matrices[trueness][i] = m[i]\n return output_matrices","def wabbits(n, k):\n a, b = 1, 1\n for i in range(3, n+1):\n a, b = b, a*k + b\n return b","def test_get_n_bits_combinations():\n # Check n=1 - Pass\n assert layer_util.get_n_bits_combinations(1) == [[0], [1]]\n # Check n=2 - Pass\n assert layer_util.get_n_bits_combinations(2) == [[0, 0], [0, 1], [1, 0], [1, 1]]\n\n # Check n=3 - Pass\n assert layer_util.get_n_bits_combinations(3) == [\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 0],\n [0, 1, 1],\n [1, 0, 0],\n [1, 0, 1],\n [1, 1, 0],\n [1, 1, 1],\n ]","def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\n int]] = None,\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,\n num_shots: int = 100, use_param_program: bool = False,\n use_active_reset: bool = True, show_progress_bar: bool = False) \\\n -> Sequence[Sequence[Sequence[int]]]:\n if registers is None:\n registers = get_qubit_registers_for_adder(qc, n_bits, qubits)\n\n reset_prog = Program()\n if use_active_reset:\n reset_prog += RESET()\n\n add_prog = Program()\n if use_param_program:\n dummy_num = [0 for _ in range(n_bits)]\n add_prog = adder(dummy_num, dummy_num, *registers, in_x_basis=in_x_basis,\n use_param_program=True)\n\n all_results = []\n # loop over all binary strings of length n_bits\n for bits in tqdm(all_bitstrings(2 * n_bits), disable=not show_progress_bar):\n # split the binary number into two numbers\n # which are the binary numbers the user wants to add.\n # They are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bits[:n_bits]\n num_b = bits[n_bits:]\n\n if not use_param_program:\n add_prog = adder(num_a, num_b, *registers, in_x_basis=in_x_basis,\n use_param_program=False)\n\n prog = reset_prog + add_prog\n prog.wrap_in_numshots_loop(num_shots)\n nat_quil = qc.compiler.quil_to_native_quil(prog)\n exe = qc.compiler.native_quil_to_executable(nat_quil)\n\n if use_param_program:\n exe.write_memory(region_name=REG_NAME, value=bits)\n\n # Run it on the QPU or QVM\n results = qc.run(exe).readout_data.get('ro')\n all_results.append(results)\n\n return all_results","def bin_dist(n, p, x):\n def factorial(x):\n if x >= 0:\n \n factorial = 1\n\n for i in range(1, x + 1):\n factorial = float(factorial * i)\n # print(f' The factorial of {x} is {factorial}') \n return factorial\n\n else:\n raise ValueError(\"Sorry x cannot be a negative number\")\n\n def combination(n, r):\n \"\"\"\n Given n total number of items,\n what is the number of possible ways\n to choose r items from it?\n\n :param n: total number of items (integer)\n :param r: number of items to arrange (int)\n :return: number of combinations\n :rtype: integer\n \"\"\"\n\n \n\n \n numerator = factorial(n)\n denominator = factorial(r)\n subtracted_answer = factorial(n-r)\n \n\n answer = numerator/(denominator * subtracted_answer)\n print(answer)\n return answer \n\n # from scipy.special import comb\n if x > n:\n raise ValueError(\"Error, x must be less than n\")\n else:\n\n\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\n\n print(prob_success)\n return prob_success","def compute_thres(n_bits, fsr_min, fsr_max, half_bit=None):\n n_bits, half_bit = parse_bits(n_bits, half_bit)\n lsb = compute_lsb(n_bits, fsr_min, fsr_max, half_bit)\n n_codes = compute_n_codes(n_bits, half_bit)\n\n range_2 = (lsb * (n_codes - 2))/2\n avg = (fsr_max + fsr_min) / 2\n\n if n_codes > 2:\n return np.linspace(-range_2, range_2, n_codes-1) + avg\n else:\n return np.reshape(avg, (1,))","def compare():\n eb = 1\n p = 0.5\n R = 0.5\n N = 150 # set the error count to reach\n\n domain = np.linspace(0, 10, 11)\n hard_domain = np.linspace(0, 8, 9)\n soft_domain = np.linspace(0, 6, 7)\n hard_decibels = 10 ** (hard_domain / 10)\n soft_decibels = 10 ** (soft_domain / 10)\n\n # get results for hard decoding\n nos = eb / hard_decibels\n hard_results = []\n for no in nos:\n print(np.where(nos == no)[0][0])\n experiment = ViterbiHard(eb, no / R)\n bit_count = 0\n error_count = 0\n for output in experiment.run():\n bit_count += 1\n if output[0] != output[1]:\n error_count += 1\n if error_count == N:\n hard_results.append(error_count / bit_count)\n break\n\n # get results for soft decoding\n nos = eb / soft_decibels\n soft_results = []\n for no in nos:\n print(np.where(nos == no)[0][0])\n experiment = ViterbiSoft(eb, no / R)\n bit_count = 0\n error_count = 0\n for output in experiment.run():\n bit_count += 1\n if output[0] != output[1]:\n error_count += 1\n if error_count == N:\n soft_results.append(error_count / bit_count)\n break\n\n decibels = 10 ** (domain / 10)\n nos = eb / decibels\n taus = nos / 4 / np.sqrt(eb) * np.log((1 - p) / p)\n plt.semilogy(hard_domain, np.array(hard_results), label='Hard-decision')\n plt.semilogy(soft_domain, np.array(soft_results), label='Soft-decision')\n plt.semilogy(domain, norm.sf((taus + np.sqrt(eb)) / np.sqrt(nos / 2)) * (1 - p) +\n norm.sf((np.sqrt(eb) - taus) / np.sqrt(nos / 2)) * p, label='Expectation ($p=0.5$)')\n plt.xlabel('$E_b/N_0$ (dB)')\n plt.ylabel('Probability of bit error')\n plt.legend(loc='lower left')\n plt.show()","def hamming_weight(num):\n\n return bin(num).count(\"1\");","def orderByIncreasingBitCount(n):\n res = [0] # freebie\n biggest = 2**n - 1\n for i in range(1, n):\n for j in range(1, biggest):\n if hamming_weight(j) == i:\n res.append(j)\n res.append(biggest) # another freebie\n return res","def get_success_probabilities_from_results(results: Sequence[Sequence[Sequence[int]]]) \\\n -> Sequence[float]:\n num_shots = len(results[0])\n n_bits = len(results[0][0]) - 1\n\n probabilities = []\n # loop over all binary strings of length n_bits\n for result, bits in zip(results, all_bitstrings(2 * n_bits)):\n # Input nums are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\n num_a = bit_array_to_int(bits[:n_bits])\n num_b = bit_array_to_int(bits[n_bits:])\n\n # add the numbers\n ans = num_a + num_b\n ans_bits = int_to_bit_array(ans, n_bits + 1)\n\n # a success occurs if a shot matches the expected ans bit for bit\n probability = 0\n for shot in result:\n if np.array_equal(ans_bits, shot):\n probability += 1. / num_shots\n probabilities.append(probability)\n\n return probabilities","def hamming_dist(a_b, b_b):\n return sum(bin(a_b[n] ^ b_b[n]).count('1') for n in range(len(a_b)))","def test_count_bits(n, result):\n from count_bits import count_bits\n assert count_bits(n) == result","def calHash(n, m):\n return int(m*BloomFilter.ln2/n)","def batina_recover_weight(secret_number, guess_range, mantissa_nbits=10, max_number_of_best_candidates=10, noise=None):\n if noise is not None:\n add_noise_function, signal_to_noise, frequency = noise\n # step 1: build signal for mantissa\n mantissa_known_inputs = build_input_values(mantissa_nbits=mantissa_nbits, component='mantissa')\n mantissa_weight_hw = np.vectorize(hamming_weight)(mantissa_known_inputs * secret_number)\n if noise is not None:\n mantissa_weight_hw = add_noise_function(mantissa_weight_hw, signal_to_noise, frequency)\n\n # step 2: build signal for exponent 8 bits\n exponent_known_inputs = build_input_values(component='exponent')\n exponent_weight_hw = np.vectorize(hamming_weight)(exponent_known_inputs * secret_number)\n if noise is not None:\n exponent_weight_hw = add_noise_function(exponent_weight_hw, signal_to_noise, frequency)\n # step 3: build signal for sign 1 bit\n sign_known_inputs = build_input_values(component='sign')\n sign_weight_hw = np.vectorize(hamming_weight)(sign_known_inputs * secret_number)\n if noise is not None:\n sign_weight_hw = add_noise_function(sign_weight_hw, signal_to_noise, frequency)\n\n return recover_weight(secret_hamming_weight_set=(mantissa_weight_hw, exponent_weight_hw, sign_weight_hw),\n input_value_set=(mantissa_known_inputs, exponent_known_inputs, sign_known_inputs),\n guess_range=guess_range,\n mantissa_nbits=mantissa_nbits,\n max_number_of_best_candidates=max_number_of_best_candidates)","def n_parameters_per_matrix(weight, n_bits):\n return 2**weight * (2**weight - 1)","def n_matrices_per_weight(weight, n_bits):\n return int(_sp.special.binom(n_bits, weight))","def pairwise_bit_scores(blastf, ss, outf, verbose=False):\n\n if verbose:\n sys.stderr.write(f\"{bcolors.GREEN}Creating scores{bcolors.ENDC}\\n\")\n\n pb = {}\n out = open(outf + \".tsv\", 'w')\n out.write(\"Query\\tSubject\\tQLen\\tSLen\\tBits\\tnBits\\n\")\n for b in stream_blast_results(blastf, verbose):\n if b.query not in pb:\n pb[b.query] = {}\n if b.db not in pb:\n pb[b.db] = {}\n\n # we normalize by the bitscore of the two proteins if we can!\n if b.query in ss and b.db in ss:\n nb = b.bitscore / ((ss[b.query] + ss[b.db])/2)\n else:\n # if we can't do that, we cheat and normalize \n # the bit score by twice\n # the average length of the proteins\n # i.e. the sum of the lengths\n nb = b.bitscore / (b.query_length + b.subject_length + 3.3)\n\n if b.query in pb[b.db] and pb[b.db][b.query] > nb:\n continue\n pb[b.db][b.query] = pb[b.db][b.query] = nb\n out.write(f\"{b.query}\\t{b.db}\\t{b.query_length}\\t{b.subject_length}\\t{b.bitscore}\\t{nb}\\n\")\n return pb","def test_bit_driver_output(self):\n\n H = qaoa.bit_driver(range(3), 1)\n hamiltonian = qml.Hamiltonian([1, 1, 1], [qml.PauliZ(0), qml.PauliZ(1), qml.PauliZ(2)])\n\n assert decompose_hamiltonian(H) == decompose_hamiltonian(hamiltonian)","def solution(n: int = 28123) -> int:\n\n nums = range(1, n+1)\n abundant = list(filter(is_abundant, nums))\n abundant_sums = set(all_sums(abundant, n))\n fit = set(nums) - abundant_sums\n return fit","def sugg(n):\n print (\"%s\\t\"*3)%(\"p\", \"m(bytes)\", \"ok\")\n for p in (0.1, 0.01, 0.001, 0.0001, 0.00001):\n m=BloomFilter.calBitLen(n,p)\n ok=BloomFilter.calHash(n,m)\n print (\"%.5f\\t\"+\"%d\\t\"*2)%(p, m/8, ok)\n for k in BloomFilter.KRange:\n rp=BloomFilter.calPFP(n,m,k)\n print (\"\\t\"*2+\"%d\\t%f\")%(k, rp)","def bit_contribution_test(hash_function):\n\n model = hash_function()\n hash_list = []\n zero_str = '0' * 2048\n for i in range(1, 2049):\n for j in range(0, i):\n flip_str = zero_str[:j] + '1' + zero_str[j+1:i]\n hash_list.append(list(map(int, list(msg_to_bits.pad_msg(flip_str, i)))))\n if i % 200 == 0:\n print(i)\n\n hashed_dict = dict()\n collisions = 0\n i = 0\n for to_hash in hash_list:\n i += 1\n hash_val = model.hash(to_hash, False).tostring()\n if hash_val in hashed_dict:\n collisions += 1\n hashed_dict[hash_val] = True\n if i % 10000 == 0:\n print(i)\n\n return collisions","def n_parameters(weight, n_bits):\n n_w = n_parameters_per_matrix(weight, n_bits)\n\n # Number of ways to pick weight bits out of n_bits\n n_a = n_matrices_per_weight(weight, n_bits)\n\n return n_w * n_a","def lfriedmanchisquare(*args):\r\n k = len(args)\r\n if k < 3:\r\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\r\n n = len(args[0])\r\n data = apply(pstats.abut,tuple(args))\r\n for i in range(len(data)):\r\n data[i] = rankdata(data[i])\r\n ssbn = 0\r\n for i in range(k):\r\n ssbn = ssbn + sum(args[i])**2\r\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\r\n return chisq, chisqprob(chisq,k-1)","def compute_probability_weights(indexing, \n counts, \n image, \n binary_set_mappings): \n S_w_cardinalities = np.zeros_like(indexing)\n\n countsgeq2 = sum(c>=2 for c in counts) # compute amount of indices that have count>=2\n countseq1 = [v for v in range(indexing.shape[0]) if counts[indexing[v]]==1]\n K_cardinalities = np.zeros_like(indexing)\n for card,w in enumerate(countseq1[::-1]):\n K_cardinalities[w] = card\n\n for w,index in enumerate(indexing):\n if counts[index] >= 3:\n S_w_cardinalities[w] = len(image)\n elif counts[index] == 2:\n offset = 1 if w==binary_set_mappings[index] else 0\n S_w_cardinalities[w] = len(image) - 1 + offset\n elif counts[index] == 1:\n S_w_cardinalities[w] = countsgeq2 + K_cardinalities[w]\n\n return S_w_cardinalities/np.sum(S_w_cardinalities)","def calculate_manhattan_dist(state):","def calc_H(J, N):\n\n H = np.array([[0.0] * 2 ** N for i in range(2 ** N)]) # np.zeros([ 2**N, 2**N]) macht das gleiche\n max_bin_len = len(bin(2 ** N - 1)[2:]) # need this for 2 -> 010 instead of 10\n\n #hier machst du dir viel mühe um die Binären zustände richtig darzustellen....\n for n in create_n(N):\n # ... Aber hier sagst du dem interpreter dass er das ganze wieder zu einer zahl machen soll. du kannst den\n # gleichen Effekt also mit einem einfachen `for n_dec in range(N+1)` erreichen\n n_dec = int(n, 2) # converts binary to integer\n\n for link in ['x', 'y', 'z']:\n for i in range(N): # loop over the combinations 12, 23 and 31 (repr. as 01, 12, 20)\n j = i + 1\n if j == N:\n j = 0\n\n # calculating l\n new_i = (max_bin_len - 1) - i # need to preprocess i, j and k because the most left site in |01 ... 1>\n new_j = (max_bin_len - 1) - j # is the most right digit in its binary representation\n l = n_dec + (1 - 2*int(n[new_i])) * 2 ** i + (1 - 2 * int(n[new_j])) * 2 ** j # no -1 in power because indexing is zero based\n\n # bin mir nicht 100% sicher hier, aber ich glaube du brauchst hier gar keine Fallunterscheidung für\n # x, y und z. weil du ja immer l gleich berechnest kannst du direkt alle Fälle damit füllen, falls die\n # jeweiligen (vielleicht dann abgeänderten) bedingungen erfüllt sind\n\n # inserting matrix elements\n if link == 'x':\n H[l, n_dec] += -J[0, i, j] / 4\n elif link == 'y':\n if n[i] == n[j]: # check for correct sign in y link\n H[l, n_dec] += J[1, i, j] / 4\n else:\n H[l, n_dec] += -J[1, i, j] / 4\n else: # z link\n if n[i] == n[j]: # check for sign\n H[n_dec, n_dec] += -J[2, i, j] * h / 4\n else:\n H[n_dec, n_dec] += J[2, i, j] * h / 4\n # bei der berechnung oder wertzuweisung von x23 und y23 macht der glaub ich komische sachen, konnte das nicht genau\n # erkennen. Der rest scheint auf den ersten blick zu funktionieren. bin mir wie gesagt nicht sicher.\n return H","def solution2(n):\n ones = 0\n while n > 0:\n if n & 1:\n ones += 1\n n = n >> 1\n\n return 0 if ones % 2 == 0 else 1","def check_correctness_c01b(f):\n\n rng = np.random.RandomState([2013, 5, 6])\n batch_size = 5\n rows = 32\n cols = 30\n channels = 3\n pool_rows = 2\n pool_cols = 3\n\n # Do the python ground truth in b01c format\n zv = rng.randn(batch_size, rows, cols,\n channels).astype(config.floatX) * 1. - 1.5\n top_down_v = rng.randn(batch_size, rows / pool_rows, cols / pool_cols,\n channels).astype(config.floatX)\n\n p_np, h_np = max_pool_python(zv, (pool_rows, pool_cols), top_down_v)\n\n # Dimshuffle the inputs into c01b for the theano implementation\n z_th = T.TensorType(broadcastable=(False, False, False, False),\n dtype = config.floatX)()\n z_th.tag.test_value = zv\n z_th.name = 'z_th'\n zr = z_th.dimshuffle(3, 1, 2, 0)\n\n top_down_th = T.TensorType(broadcastable=(False, False, False, False),\n dtype = config.floatX)()\n top_down_th.name = 'top_down_th'\n top_down_th.tag.test_value = top_down_v\n top_down_r = top_down_th.dimshuffle(3, 1, 2, 0)\n\n p_th, h_th = f(zr, (pool_rows, pool_cols), top_down_r)\n\n func = function([z_th, top_down_th], [p_th.dimshuffle(3, 1, 2, 0),\n h_th.dimshuffle(3, 1, 2, 0)])\n\n pv, hv = func(zv, top_down_v)\n\n if not p_np.shape == pv.shape:\n raise AssertionError(str((p_np.shape, pv.shape)))\n assert h_np.shape == hv.shape\n if not np.allclose(h_np, hv):\n print((h_np.min(), h_np.max()))\n print((hv.min(), hv.max()))\n assert False\n if not np.allclose(p_np, pv):\n diff = abs(p_np - pv)\n print('max diff ', diff.max())\n print('min diff ', diff.min())\n print('ave diff ', diff.mean())\n assert False\n warnings.warn(\"TODO: make sampling tests run on c01b format of pooling.\")","def ransac_iters(w=0.5, d=min_num_pairs(), z=0.99):\n\n return int(np.ceil(np.log(1 - z) / np.log(1 - np.power(w,d))))","def get_most_probable_bit_with_thres(filtered_capture, prob_threshold):\n # Enumerate challenge/responses to build a list of\n # (probabilities, challenge, value)\n sorted_prob = []\n for challenge, response in filtered_capture.items():\n n0, n1 = response\n n = n0 + n1\n if n < MIN_COUNT_FOR_MEANING:\n # Ignore challenges with not enough measures\n continue\n # q0 = ncr(n, n0) * pow(1 - PROB, n0) * pow(PROB, n1)\n # q1 = ncr(n, n0) * pow(PROB, n0) * pow(1 - PROB, n1)\n # unnormalize_q0 = pow(1 - PROB, n0) * pow(PROB, n1)\n # unnormalize_q1 = pow(PROB, n0) * pow(1 - PROB, n1)\n # p_b0 = unnormalized_q0 / (unnormalized_q1 + unnormalized_q0)\n # p_b1 = unnormalized_q1 / (unnormalized_q1 + unnormalized_q0)\n if n >= 500:\n # Prevent \"OverflowError: (34, 'Numerical result out of range')\"\n p_b0 = n0 / (n0 + n1)\n p_b1 = n1 / (n1 + n0)\n else:\n p_b0 = 1. / (1 + pow(PROB / (1 - PROB), n0) * pow((1 - PROB) / PROB, n1))\n p_b1 = 1. / (1. + pow(PROB / (1 - PROB), n1) * pow((1 - PROB) / PROB, n0))\n # print(f\"[{n0:2}+{n1:2}={n:2}] pb0={p_b0:.3}, pb1={p_b1:.3}\")\n if p_b1 > prob_threshold and p_b1 > p_b0:\n sorted_prob.append((p_b1, challenge, 1))\n elif p_b0 > prob_threshold and p_b0 > p_b1:\n sorted_prob.append((p_b0, challenge, 0))\n\n sorted_prob.sort()\n # print(f\"Trying to find a bit out of {len(sorted_prob)} challenges with p>={prob_threshold}...\")\n while sorted_prob:\n best_prob, best_chall, best_val = sorted_prob.pop()\n best_count = count_ones(best_chall)\n if best_count == 1:\n print(f\"Found a bit: {best_chall:#x} = {best_val} (proba {best_prob})\")\n return (best_chall, best_val)\n\n # Combine the probabilities\n for prob, chall, val in sorted_prob.copy():\n if chall == best_chall:\n continue\n # Reduce the masking with XOR\n if chall & ~best_chall == 0:\n # Ensure that the masking is reasonable\n count_xor = count_ones(best_chall ^ chall)\n if count_xor <= 2 and count_xor < best_count:\n new_prob = prob * best_prob\n if new_prob > prob_threshold:\n sorted_prob.append((new_prob, chall ^ best_chall, val ^ best_val))\n sorted_prob.sort()\n\n print(f\"Unable to found a bit with threshold={prob_threshold}\")\n return None","def calculate_weighted_results():\n pass","def bitwise_stats(traces, N, delta):\n \n X = np.zeros((N,),dtype=int)\n padded_traces = pad_traces(traces, N)\n num_traces = padded_traces.shape[0]\n \n p = np.zeros(N)\n for j in range(N):\n p[j] = np.sum(padded_traces[:,j])/num_traces\n \n c = np.concatenate((np.ones(N,), np.zeros(N,)), axis=None)\n bounds = (0,1)\n \n for i in range(N):\n A_ub = np.zeros((2*N,2*N))\n for j in range(N):\n for k in range(N):\n if j == k:\n A_ub[j,k] = -1\n A_ub[j+N,k] = -1\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\n elif k > j:\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\n \n b_ub = np.concatenate((p,-1*p), axis=None)\n \n A_eq0 = np.zeros((i+1,2*N))\n b_eq0 = np.zeros(i+1)\n for j in range(i+1):\n A_eq0[j,j+N] = 1\n if j==i:\n b_eq0[j] = 0\n else:\n b_eq0[j] = X[j]\n \n A_eq1 = np.zeros((i+1,2*N))\n b_eq1 = np.zeros(i+1)\n for j in range(i+1):\n A_eq1[j,j+N] = 1\n if j==i:\n b_eq1[j] = 1\n else:\n b_eq1[j] = X[j]\n \n res0 = linprog(c,A_ub,b_ub,A_eq0,b_eq0,bounds,method='interior-point')\n res1 = linprog(c,A_ub,b_ub,A_eq1,b_eq1,bounds,method='interior-point')\n if res0.fun < res1.fun:\n X[i] = 0\n else:\n X[i] = 1\n \n return X","def compute_n_codes(n_bits, half_bit=None):\n n_bits, half_bit = parse_bits(n_bits, half_bit)\n if half_bit:\n return 2**(n_bits + 1) - 1\n else:\n return 2**n_bits","def afriedmanchisquare(*args):\r\n k = len(args)\r\n if k < 3:\r\n raise ValueError, '\\nLess than 3 levels. Friedman test not appropriate.\\n'\r\n n = len(args[0])\r\n data = apply(pstats.aabut,args)\r\n data = data.astype(N.float_)\r\n for i in range(len(data)):\r\n data[i] = arankdata(data[i])\r\n ssbn = asum(asum(args,1)**2)\r\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\r\n return chisq, achisqprob(chisq,k-1)","def create_samples(f: Callable[..., int], n_args: int, n_bits: int,\n) -> Dict[Tuple[int, ...], Tuple[int, ...]]:\n samples = {}\n max_arg = 2 ** n_bits\n for inputs in itertools.product((0, 1), repeat=n_args * n_bits):\n ints = [int(\"\".join(str(bit) for bit in inputs[i:i + n_bits]), 2)\n for i in range(0, len(inputs), n_bits)]\n try:\n output = f(*ints)\n if 0 <= output < max_arg:\n bit_string = (\"{:0\" + str(n_bits) + \"b}\").format(output)\n samples[inputs] = tuple(int(bit) for bit in bit_string)\n except ZeroDivisionError:\n pass\n return samples","def fama2(self, n, weight, nums):\n ws = {0}\n for i in range(0, n):\n ts = set()\n for j in range(0, nums[i]):\n for w in ws:\n ts.add(weight[i] * (j + 1) + w)\n ws = ws.union(ts)\n for j in range(0, nums[i]):\n ws.add(weight[i] * (j + 1))\n return len(ws)","def nac_w_optimal_r(fan_in, fan_out):\n fan = max(fan_in + fan_out, 5)\n r = scipy.optimize.bisect(lambda r: fan * nac_w_variance(r) - 2, 0, 10)\n return r","def count_bits(dqxx, n):\n return sum([check_bit(x, n) for x in dqxx])","def SE(H, W):\n\n no_real, N, N, K, M = H.shape\n all_powers = np.swapaxes(np.swapaxes(H, 0, 1) @ hermitian(W), 0, 1)\n all_powers = np.abs(all_powers) ** 2\n\n\n\n # (no_real, N, N, K, K)\n # (no_real, n_t, n, k, k_neighbor)\n # the power coming from BS n_t to User k in BS n, using the\n # precoding of BS n_t to user k_neighbor in BS n1\n\n\n p_sig = np.zeros((no_real, N, K))\n p_int = np.zeros((no_real, N, K, N))\n sinr = np.zeros_like(p_sig)\n\n\n for r in range(no_real):\n for n in range(N):\n for k in range(K):\n p_sig[r, n, k] = all_powers[r, n, n, k, k]\n for n_t in range(N):\n p_int[r, n, k, n_t] = all_powers[r, n_t, n, k].sum()\n if n_t == n:\n p_int[r, n, k, n_t] -= p_sig[r,n,k]\n sinr = p_sig / ((p_int).sum(axis=-1) + 1)\n return np.log2(1 + sinr), p_sig, p_int","def check_sample_correctishness_channelwise(f):\n\n batch_size = 27\n pool_size = 4\n n = pool_size * 21\n\n rng = np.random.RandomState([2012, 9, 26])\n zv = rng.randn(batch_size, n).astype(config.floatX) * 3.5 - 5.\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\n\n z_th = T.matrix()\n z_th.tag.test_value = zv\n z_th.name = 'z_th'\n\n top_down_th = T.matrix()\n top_down_th.tag.test_value = top_down_v\n top_down_th.name = 'top_down_th'\n\n theano_rng = MRG_RandomStreams(rng.randint(2147462579))\n p_th, h_th, p_sth, h_sth = f(z_th, pool_size, top_down_th, theano_rng)\n\n prob_func = function([z_th, top_down_th], [p_th, h_th])\n pv, hv = prob_func(zv, top_down_v)\n\n sample_func = function([z_th, top_down_th], [p_sth, h_sth])\n\n acc_p = 0. * pv\n acc_h = 0. * hv\n\n # make sure the test gets good coverage, ie, that it includes\n # many different activation probs for both detector and pooling layer\n buckets = 10\n bucket_width = 1. / float(buckets)\n print(pv.min(), pv.max())\n print(hv.min(), hv.max())\n for i in xrange(buckets):\n lower_lim = i * bucket_width\n upper_lim = (i+1) * bucket_width\n print(lower_lim, upper_lim)\n\n assert np.any((pv >= lower_lim) * (pv < upper_lim))\n assert np.any((hv >= lower_lim) * (hv < upper_lim))\n\n assert upper_lim == 1.\n\n for i in xrange(10000):\n ps, hs = sample_func(zv, top_down_v)\n\n assert ps.shape == pv.shape\n assert hs.shape == hv.shape\n\n acc_p += ps\n acc_h += hs\n\n est_p = acc_p / float(i+1)\n est_h = acc_h / float(i+1)\n\n pd = np.abs(est_p-pv)\n hd = np.abs(est_h-hv)\n\n \"\"\"\n # plot maps of the estimation error, this is to see if it has some\n # spatial pattern this is useful for detecting bugs like not handling\n # the border correctly, etc.\n # from pylearn2.gui.patch_viewer import PatchViewer\n\n pv = PatchViewer((pd.shape[0],pd.shape[3]),(pd.shape[1],pd.shape[2]),\n is_color = False)\n for i in xrange(pd.shape[0]):\n for j in xrange(pd.shape[3]):\n pv.add_patch( (pd[i,:,:,j] / pd.max() )* 2.0 - 1.0, rescale = False)\n pv.show()\n\n pv = PatchViewer((hd.shape[0],hd.shape[3]),(hd.shape[1],hd.shape[2]),\n is_color = False)\n for i in xrange(hd.shape[0]):\n for j in xrange(hd.shape[3]):\n pv.add_patch( (hd[i,:,:,j] / hd.max() )* 2.0 - 1.0, rescale = False)\n pv.show()\n \"\"\"\n\n \"\"\"\n plot expectation to estimate versus error in estimation\n expect bigger errors for values closer to 0.5\n\n from matplotlib import pyplot as plt\n\n #nelem = reduce( lambda x, y : x*y, pd.shape)\n #plt.scatter( pv.reshape(nelem), pd.reshape(nelem))\n #plt.show()\n\n nelem = reduce( lambda x, y : x*y, hd.shape)\n plt.scatter( hv.reshape(nelem), hd.reshape(nelem))\n plt.show()\n \"\"\"\n\n # don't really know how tight this should be\n # but you can try to pose an equivalent problem\n # and implement it in another way\n # using a numpy implementation in softmax_acc.py\n # I got a max error of .17\n assert max(pd.max(), hd.max()) < .17\n\n # Do exhaustive checks on just the last sample\n assert np.all((ps == 0) + (ps == 1))\n assert np.all((hs == 0) + (hs == 1))\n\n for k in xrange(batch_size):\n for i in xrange(ps.shape[1]):\n p = ps[k, i]\n h = hs[k, i*pool_size:(i+1)*pool_size]\n assert h.shape == (pool_size,)\n assert p == h.max()\n assert h.sum() <= 1\n\n \"\"\" If you made it to here, it's correctish\n (cant tell if samples are perfectly \"correct\") \"\"\"","def check_correctness_sigmoid_channelwise(f):\n\n rng = np.random.RandomState([2012, 7, 19])\n batch_size = 5\n pool_size = 1\n n = 3 * pool_size\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\n\n z_th = T.matrix()\n z_th.name = 'z_th'\n\n top_down_th = T.matrix()\n top_down_th.name = 'top_down_th'\n\n p_th, h_th = f(z_th, pool_size, top_down_th)\n h_s = T.nnet.sigmoid(z_th + top_down_th)\n\n func = function([z_th, top_down_th], [p_th, h_th, h_s])\n\n pv, hv, h_s = func(zv, top_down_v)\n p_s = h_s\n\n assert p_s.shape == pv.shape\n assert h_s.shape == hv.shape\n if not np.allclose(h_s, hv):\n print((h_s.min(), h_s.max()))\n print((hv.min(), hv.max()))\n assert False\n if not np.allclose(p_s, pv):\n diff = abs(p_s - pv)\n print('max diff ', diff.max())\n print('min diff ', diff.min())\n print('ave diff ', diff.mean())\n assert False","def whack(code, decoder, p, N, C0, error_rate, mC, verbose, argv):\n\n errors = []\n succeeds = [] # put error ops here when we decode them\n fails = [] # if the decoder is wrong\n\n for i in range(N):\n err_op = ra.binomial(1, p, (code.n,))\n err_op = err_op.astype(numpy.int32)\n errors.append(err_op)\n\n target_succeed = (1. - error_rate) * N\n\n i = 0\n C = C0\n\n while len(succeeds) < target_succeed and len(succeeds)+len(errors) >= target_succeed:\n\n err_op = errors[i]\n\n # We use Hz to look at X type errors (bitflip errors)\n\n write(str(err_op.sum()))\n\n s = dot2(code.Hz, err_op)\n write(\":s%d:\"%s.sum())\n\n op = decoder.decode(p, err_op, C=C, verbose=verbose, argv=argv)\n\n c = 'F'\n success = False\n if op is None:\n print(i, \"TRY AGAIN\")\n i = i+1\n\n else:\n op = (op+err_op)%2\n # Should be a codeword of Hz (kernel of Hz)\n assert dot2(code.Hz, op).sum() == 0\n write(\"%d:\"%op.sum())\n\n success = code.is_stab(op)\n c = '.' if success else 'x'\n\n errors.pop(i)\n\n if success:\n print(i, \"GOOD\")\n succeeds.append(err_op)\n else:\n print(i, \"BAD\")\n fails.append(err_op)\n\n if i==len(errors):\n i = 0\n C = int(ceil(C*mC))\n print((\"C = \", C))\n\n write(c+' ')\n\n print(\"errors = \", len(errors), \"succeeds =\", len(succeeds), \"fails =\", len(fails))\n\n if len(succeeds) >= target_succeed:\n print(\"SUCCESS\")\n\n else:\n assert len(succeeds)+len(errors) < target_succeed\n print(\"FAIL\")\n\n print()\n print(datestr)\n print(argv)\n print(\"error rate = %.8f\" % (1.*(len(errors) + len(fails))/N))\n print(\"fail rate = %.8f\" % (1.*len(fails) / N))","def analyze_bit(key: List[Key],\n side_length: int,\n random_bits: str,\n message_bits: str):\n # Concatenate the input to get cube input.\n cube_input = message_bits + random_bits\n # Initialize the cube.\n cube = Cube(cube_input=cube_input, cube_side_length=side_length)\n\n # Xor, Shift, and apply move onto the cube.\n for each_key in key:\n cube.xor()\n cube.shift_cubie_content()\n cube.shift(key=each_key)\n\n # Count number of zeros and number of ones.\n return {\n \"0\": cube.content.count(\"0\"),\n \"1\": cube.content.count(\"1\")\n }","def get_hamming_distance(self, calc_bits):\n\n # Iterate through calculated bits and compare to received bits.\n # Store number of different bits in total_distance.\n total_distance = 0\n for idx, bit in enumerate(calc_bits):\n diff = abs(bit - self.received_bits[idx])\n total_distance += diff\n\n return total_distance","def getrandbits(k: int) -> int:\n ...","def fwht(X):\n n = X.shape[0]\n # number of stages\n s = (n-1).bit_length()\n\n def init1():\n Y = jnp.empty(X.shape, dtype=X.dtype)\n A = X[0::2]\n B = X[1::2]\n Y = Y.at[0::2].set(A + B)\n Y = Y.at[1::2].set(A - B)\n return (Y, 1, 2, 4)\n\n def body1(state):\n # gap between x entries\n # number of x entries\n X, count, gap, step = state\n Y = jnp.empty(X.shape, dtype=X.dtype)\n J = 0\n k = 0\n def body2(state):\n Y, J, k = state\n def body3(state):\n Y, j, k = state\n # compute the four parts\n a = X[j]\n b = X[j+gap]\n c = X[j+1]\n d = X[j+1+gap]\n Y = Y.at[k].set(a+b)\n Y = Y.at[k+1].set(a-b)\n Y = Y.at[k+2].set(c-d)\n Y = Y.at[k+3].set(c+d)\n return (Y, j+2, k+4)\n def cond3(state):\n j = state[1]\n return j < J+gap-1\n # the loop\n init3 = (Y, J, k)\n Y, j, k = lax.while_loop(cond3, body3, init3)\n return (Y, J + step, k)\n\n def cond2(state):\n k = state[2]\n return k < n - 1\n\n init2 = Y, J, 0\n Y, J, k = lax.while_loop(cond2, body2, init2)\n\n return (Y, count+1, 2*gap, 2*step)\n\n def cond1(state):\n count = state[1]\n return count < s\n\n state = lax.while_loop(cond1, body1, init1())\n return state[0]","def pertube_distribution_weight(self, random_state, n_samples, multipler):\n curr_sample_weight = np.ones((n_samples,), dtype=np.float64)\n indices = _generate_sample_indices(random_state, n_samples)\n sample_counts = bincount(indices, minlength=n_samples)\n curr_sample_weight *= np.power(sample_counts, multipler)\n return curr_sample_weight","def measure_all_1(n, state):\n state = state.copy()\n\n outs = ''\n for i in range(n):\n out = measure_single(n, state,\n i) # After measuring bit0, bit0 collapses. It affects the subsequent bit1 measurement, but does not affect the 1000 independent measurements of the upper layer\n outs = str(out) + outs # from low bit to high bit\n return outs","def binary_dec(A,n_iter = 1000):\n\n\t### Initialization ###\n\n\tp, q = np.shape(A)\n\t### B : to be changed\n\tB = np.eye(p)\n \t###\n\tC = bin_random_mat(p,q)\n\tlist_dist = []\n\tB_argmin = B\n\tC_argmin = C\n\n\n\n\n\t## temperature ##\n\tT_n = np.log(np.arange(2,n_iter+2,1))\n\t#T_n = np.arange(2,n_iter+2,1)\n\tfor i in range(n_iter):\n\t## update ##\n\t\tC_0 = np.matrix(C)\n\t\tlist_dist =np.append( list_dist, V_potential(np.dot(B,C_0),A) )\n\t\tif V_potential(np.dot(B_argmin,C_argmin),A) == 0:\n\t\t\tbreak\n\t########## transition #############\n\t# Here we take 2 steps independent(for B and for C respectively)\n\t# We could also use metropolis hasting kernel.\n\n\t\tC_iter = np.matrix(Metropolis_transition_C(C))\n\t\n\n\t\tB_iter = B[np.random.permutation(np.arange(p))]\n\t\t\n\t\tif np.random.uniform(0,1,1) < \\\n\t\t\t\tnp.exp(-1./T_n[i]*( V_potential(np.dot(B_iter,C_iter), A)\\\n\t\t\t\t - V_potential(np.dot(B,C_0),A) ) ):\n\t\t\tC = C_iter\n\t\t\tB = B_iter\n\t######### end of transition ##############\n\n\t\t\tif V_potential(np.dot(B,C),A) < np.min(list_dist):\n\t\t\t\t\n\t\t\t\tB_argmin = B\n\t\t\t\tC_argmin = np.matrix(C)\n\t\t\t# print i+1\n\t\t\t# print V_potential(np.dot(B_argmin,C_argmin),A)\n\t\t\t# print C_argmin\n\t\t\t# print '\\n'\n\n\treturn list_dist,B_argmin, C_argmin","def chk_hamming(data):\n pass","def tabulate_score(self):\n # Generate the bit formatting string\n n_bits = int(np.ceil(np.log2(self.max_ans)))\n fmt_str = \"{0:0\"+str(n_bits)+\"b}\"\n \n # Convert answers to int\n self.answers = self.answers.astype(np.int64)\n\n # Convert each element in answers to a bit string\n bits = [fmt_str.format(ans) for ans in self.answers]\n bit_string = \"\".join(bits)\n \n # Convert the combined bit string back to an integer\n seed = int(bit_string, 2)\n\n return seed","def fn(x, mask):\n ans = size = 0 \n for xx in range(1, 10): \n if not mask & (1 << xx): \n if (x, xx) not in mp or mask & 1 << mp[x, xx]: \n ans += fn(xx, mask^(1<<xx))\n size += 1\n size = 9 - size\n if m <= size <= n: ans += 1\n return ans","def fn(mask, k):\n if not mask: return 0 \n ans = inf \n for i in range(n): \n if mask & (1<<i): \n ans = min(ans, (nums1[i]^nums2[k]) + fn(mask^(1<<i), k+1))\n return ans","def getCombination(mu1, mu2, sig1, sig2, confidence1, confidence2):\n\tglobal alpha, beta, gamma\n\n\t#Standard Bayesian\n\t# sigNew = math.sqrt(math.pow(sig1, 2) + math.pow(sig2, 2))\n\t# muNew = u1 + u2\n\t# return muNew, sigNew \n\n\t##In accordance with the nature papers:\n\tsigNew = (math.pow(sig1,2) * math.pow(sig2, 2)) \\\n\t/ float((math.pow(sig1,2) + math.pow(sig2, 2)))\n\tinv1 = 1 / float((math.pow(sig1, 2)))\n\tinv2 = 1 / float((math.pow(sig2, 2)))\n\tsumInverses = inv1 + inv2\n\n\t##inverse standard deviations squared\n\t# w1 = inv1 / float(sumInverses)\n\t# w2 = inv2 / float(sumInverses)\n\n\t## equal weighting\n\t# w1 = .5\n\t# w2 = .5\n\n\t## weightings based off of confidence\n\t# summation = confidence1 + confidence2\n\t# w1 = confidence1 / float(summation)\n\t# w2 = confidence2 / float(summation)\n\n\t##weightings with exponentials\n\t# w1 = w1**.001\n\t# w2 = w2**.001\n\t# newSummation = w1 + w2\n\t# w1 = w1 / float(newSummation)\n\t# w2 = w2 / float(newSummation)\n\n\t##weightings with polynomial factors\n\tw1 = (beta * confidence1 + alpha)**gamma \n\tw2 = (beta * confidence2 + alpha)**gamma \n\tnewSummation = w1 + w2\n\tw1 = w1 / float(newSummation)\n\tw2 = w2 / float(newSummation)\n\n\tmuNew = w1 * mu1 + w2 * mu2\n\treturn muNew, sigNew","def weights(err):\n w = np.power(err, -2)\n w/= np.sum(w)\n return w","def get_response_with_weights(Response,zenith,azimuth,deg=True,binsize=5,cut=60.0,lookup=True):\n\n if lookup == True:\n # look up, no weighting\n rsp_mean = get_response_from_pixelhit_vector(Response,zenith,azimuth,binsize=binsize,cut=cut)\n\n else:\n \n # calculate the weighting for neighbouring pixels using their angular distance\n # also returns the indices of which pixels to be used for response averaging\n widx = get_response_weights_vector(zenith,azimuth,binsize,cut=cut)\n # This is a vectorised function so that each entry gets its own weighting\n # at the correct positions of the input angles ([:, None] is the same as \n # column-vector multiplcation of a lot of ones)\n\n # check for negative weights and indices and remove\n widx[1][widx[0][:,0,:] < 0] = 0.\n widx[1][widx[0][:,1,:] < 0] = 0.\n for i in range(4):\n widx[0][i,0,widx[0][i,0,:] < 0] = 0.\n widx[0][i,1,widx[0][i,1,:] < 0] = 0.\n \n # one energy bin\n #print(Response.shape,len(Response.shape))\n if len(Response.shape) < 4:\n rsp0 = Response[widx[0][0,1,:],widx[0][0,0,:],:]*widx[1][0,:][:, None]\n rsp1 = Response[widx[0][1,1,:],widx[0][1,0,:],:]*widx[1][1,:][:, None]\n rsp2 = Response[widx[0][2,1,:],widx[0][2,0,:],:]*widx[1][2,:][:, None]\n rsp3 = Response[widx[0][3,1,:],widx[0][3,0,:],:]*widx[1][3,:][:, None]\n # with energy matrix included\n elif len(Response.shape) >= 4:\n rsp0 = Response[widx[0][0,1,:],widx[0][0,0,:],:,:,:]*widx[1][0,:][:, None, None, None]\n rsp1 = Response[widx[0][1,1,:],widx[0][1,0,:],:,:,:]*widx[1][1,:][:, None, None, None]\n rsp2 = Response[widx[0][2,1,:],widx[0][2,0,:],:,:,:]*widx[1][2,:][:, None, None, None]\n rsp3 = Response[widx[0][3,1,:],widx[0][3,0,:],:,:,:]*widx[1][3,:][:, None, None, None]\n else:\n print('How this should really not happen ...')\n \n rsp_mean = rsp0 + rsp1 + rsp2 + rsp3\n\n # return response\n return rsp_mean","def compute_disturbances(n_bits, data_ref, data_test, num_bootstrap_samples=20,\n max_weight=4, solver=\"SCS\", verbosity=1, add_one_to_data=True):\n dist_ml, dist = compute_disturbances_bootstrap_rawdata(\n n_bits, data_ref, data_test, num_bootstrap_samples,\n max_weight, solver, verbosity, add_one_to_data=add_one_to_data)\n return compute_disturbances_from_bootstrap_rawdata(dist_ml, dist)","def check_correctness_channelwise(f):\n\n rng = np.random.RandomState([2012, 7, 19])\n batch_size = 5\n pool_size = 4\n n = 3 * pool_size\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\n\n p_np, h_np = max_pool_channels_python(zv, pool_size, top_down_v)\n\n z_th = T.matrix()\n z_th.name = 'z_th'\n\n top_down_th = T.matrix()\n top_down_th.name = 'top_down_th'\n\n p_th, h_th = f(z_th, pool_size, top_down_th)\n\n func = function([z_th, top_down_th], [p_th, h_th])\n\n pv, hv = func(zv, top_down_v)\n\n assert p_np.shape == pv.shape\n assert h_np.shape == hv.shape\n if not np.allclose(h_np, hv):\n print((h_np.min(), h_np.max()))\n print((hv.min(), hv.max()))\n assert False\n if not np.allclose(p_np, pv):\n diff = abs(p_np - pv)\n print('max diff ', diff.max())\n print('min diff ', diff.min())\n print('ave diff ', diff.mean())\n assert False","def solution(N):\n\tresult = 0\n\tcounter = 0\n\n\tbin_number = \"{0:b}\".format(N)\n\n\tfor num in bin_number:\n\t\tif num == \"1\":\n\t\t\tif counter > result:\n\t\t\t\tresult = counter\n\t\t\tcounter = 0\n\t\telse:\n\t\t\tcounter += 1\n\n\treturn result;","def bits(self):\n if not self.group_list:\n return 0.0\n # TODO: Is it worth to cache the overall result?\n return self.bits_except_last + self.group_list[-1].bits","def test_an_bn_1(self):\n n = 0\n w = 2.1\n kz = 3.e-5\n tp = 2.e3 \n tz = 100.\n vthz = 6.1e4\n omega = 0.34\n vz = 3.4e3\n \n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\n an, bn = an/w, bn/w\n npt.assert_allclose(an, -1.9218850625427564 + 5.595463531399411j,\n rtol=1e-7)\n npt.assert_allclose(bn, -102817.6686637071 + 391682.4471979587j,\n rtol=1e-7)\n\n w = 0.03\n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\n an, bn = an/w, bn/w\n npt.assert_allclose(an, 631.2715006824648 - 46.41868239430783j,\n rtol=1e-7)\n npt.assert_allclose(bn, 551271.5006824646 - 46418.68239430781j,\n rtol=1e-7)\n \n n, w = 5, 0.03\n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\n an, bn = an/w, bn/w\n npt.assert_allclose(bn, 1.6137363813074678e6 + 2.3743306625716157e7j,\n rtol=1e-7)\n npt.assert_allclose(an, -30.426402059415523 - 426.52646633023045j,\n rtol=1e-7)\n\n n, w, kz, vthz = 20, 3.7, 0.11, 0.35\n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\n an, bn = an/w, bn/w\n npt.assert_allclose(an, -0.26539669257210097 -0.0j, \\\n rtol=1e-7)\n npt.assert_allclose(bn, -902.3486484918872 + 0.0j,\\\n rtol=1e-7)","def _kuhn_munkres_algorithm(true_lab, pred_lab):\n nclass = len(set(true_lab))\n nobs = len(true_lab)\n wmat = np.zeros((nclass, nclass))\n for lab in range(nclass):\n for plab in range(lab, nclass):\n n_intersec = len(set(np.transpose(np.argwhere(true_lab == lab))[0]).intersection(\n set(np.transpose(np.argwhere(pred_lab == plab))[0])))\n w = (nobs - n_intersec) / nobs\n if lab == plab:\n wmat[lab, plab] = w\n else:\n wmat[lab, plab] = w\n n_intersec = len(set(np.transpose(np.argwhere(true_lab == plab))[0]).intersection(\n set(np.transpose(np.argwhere(pred_lab == lab))[0])))\n w = (nobs - n_intersec) / nobs\n wmat[plab, lab] = w\n new_pred_lab = list(linear_sum_assignment(wmat)[1])\n # print(f'Recode: {new_pred_lab}')\n # print(f'From matrix: {wmat}')\n pred_perm = np.array([new_pred_lab.index(i) for i in pred_lab])\n\n return pred_perm","def bits(n):\n\n # Create a list of the first 1,000 binary numbers\n binary_list = reverse_binary_list()\n\n # Start by calculating number of 1's for n\n n_ones = num_of_ones(n, binary_list)\n\n # Calculate number of 1's for next value\n next_ones = 0\n while n_ones != next_ones:\n n = n + 1\n next_ones = num_of_ones(n, binary_list)\n\n return(n)","def check_correctness_bc01(f):\n\n rng = np.random.RandomState([2012, 7, 19])\n batch_size = 5\n rows = 32\n cols = 30\n channels = 3\n pool_rows = 2\n pool_cols = 3\n zv = rng.randn(batch_size, rows, cols,\n channels).astype(config.floatX) * 1. - 1.5\n top_down_v = rng.randn(batch_size, rows / pool_rows, cols / pool_cols,\n channels).astype(config.floatX)\n\n p_np, h_np = max_pool_python(zv, (pool_rows, pool_cols), top_down_v)\n\n z_th = T.TensorType(broadcastable=(False, False, False, False),\n dtype = config.floatX)()\n z_th.name = 'z_th'\n zr = z_th.dimshuffle(0, 3, 1, 2)\n\n top_down_th = T.TensorType(broadcastable=(False, False, False, False),\n dtype = config.floatX)()\n top_down_th.name = 'top_down_th'\n top_down_r = top_down_th.dimshuffle(0, 3, 1, 2)\n\n p_th, h_th = f(zr, (pool_rows, pool_cols), top_down_r)\n\n func = function([z_th, top_down_th], [p_th.dimshuffle(0, 2, 3, 1),\n h_th.dimshuffle(0, 2, 3, 1)])\n\n pv, hv = func(zv, top_down_v)\n\n assert p_np.shape == pv.shape\n assert h_np.shape == hv.shape\n if not np.allclose(h_np, hv):\n print((h_np.min(), h_np.max()))\n print((hv.min(), hv.max()))\n assert False\n if not np.allclose(p_np, pv):\n diff = abs(p_np - pv)\n print('max diff ', diff.max())\n print('min diff ', diff.min())\n print('ave diff ', diff.mean())\n assert False","def bits_loss(msg, output, message_length):\n return reconstruction_loss(msg, output) * message_length","def compute_disturbances_bootstrap_rawdata(n_bits, data_ref, data_test, num_bootstrap_samples=20,\n max_weight=4, solver=\"SCS\", verbosity=1, seed=0,\n return_resampled_data=False, add_one_to_data=True):\n #p_ml = _np.array(data_ref) / _np.sum(data_ref)\n #q_ml = _np.array(data_test) / _np.sum(data_test)\n\n if verbosity > 0:\n print(\"Computing base disturbances\")\n dist_by_weight_ml = compute_disturbances_with_confidence(\n n_bits, data_ref, data_test, None, max_weight, solver=solver, verbosity=verbosity - 1)\n\n dist_by_weight = _np.zeros((max_weight, num_bootstrap_samples), 'd')\n resampled_data = []\n\n bootstrap_data_ref = data_ref + _np.ones(len(data_ref), dtype='int')\n bootstrap_data_test = data_test + _np.ones(len(data_test), dtype='int')\n\n for i in range(num_bootstrap_samples):\n if verbosity > 0:\n print(\"Analyzing bootstrap sample %d of %d...\" % (i + 1, num_bootstrap_samples), end='')\n _sys.stdout.flush(); tStart = _time.time()\n redata_ref = resample_data(bootstrap_data_ref, seed=seed + i)\n redata_test = resample_data(bootstrap_data_test, seed=seed + num_bootstrap_samples + i)\n if return_resampled_data:\n resampled_data.append((redata_ref, redata_test))\n\n try:\n disturbances = compute_disturbances_with_confidence(\n n_bits, redata_ref, redata_test, None, max_weight, solver=solver, verbosity=verbosity - 2)\n except Exception:\n try:\n if verbosity > 0: print(\"\\nFalling back on ECOS\")\n disturbances = compute_disturbances_with_confidence(\n n_bits, redata_ref, redata_test, None, max_weight, solver=\"ECOS\", verbosity=verbosity - 2)\n except Exception:\n if verbosity > 0: print(\"\\nFailed using %s and ECOS - reporting nans\" % solver)\n for w in range(max_weight):\n dist_by_weight[w, i] = _np.nan\n\n for w in range(max_weight):\n dist_by_weight[w, i] = disturbances[w][0]\n\n if verbosity > 0:\n print(\" (%.1fs)\" % (_time.time() - tStart))\n\n dist_ml = _np.array([dist_by_weight_ml[w][0] for w in range(max_weight)], 'd')\n\n if return_resampled_data:\n return dist_ml, dist_by_weight, resampled_data\n else:\n return dist_ml, dist_by_weight","def hpint_perm(n):\n c_new = []\n D_new = []\n H_new = []\n for i in range(2 ** n - 1):\n c_new_i = np.zeros((n, 1))\n binStr = bin(i + 1)[2:]\n for j in range(len(binStr)):\n c_new_i[n - 1 - j][0] = int(binStr[len(binStr) - 1 - j])\n c_new.append(c_new_i)\n D_new_i = np.diag(np.transpose(c_new_i)[0])\n D_new.append(D_new_i)\n H_new_i = np.diag(np.transpose(c_new_i * (-2) + 1)[0])\n H_new.append(H_new_i)\n\n return c_new, D_new, H_new","def andbits(num1,num2):\n thingstoadd=[]\n for i in range(31):\n bit1=setbit(num1,i)\n bit2=setbit(num2,i)\n bit1=shiftleft(bit1,30 - i)\n bit2=shiftleft(bit2,30 - i)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n bitsum=shiftright(bitsum,31 - i)\n thingstoadd.append(bitsum)\n bit1=setbit(num1,31)\n bit2=setbit(num2,31)\n bit1=shiftright(bit1,1)\n bit2=shiftright(bit2,1)\n bitsum=add(bit1,bit2)\n bitsum=setbit(bitsum,31)\n thingstoadd.append(bitsum)\n return sum(thingstoadd)","def potential_witnesses(n):\n if n < 1373653: return [2, 3] # n < 1,373,653\n if n < 9080191: return [31, 73] # n < 9,080,191\n if n < 4759123141: return [2, 7, 61] # n < 4,759,123,141\n if n < 2152302898747: return [2, 3, 5, 7, 11] # n < 2,152,302,898,747\n if n < 3474749660383: return [2, 3, 5, 7, 11, 13] # n < 3,474,749,660,383\n if n < 341550071728321: return [2, 3, 5, 7, 11, 13, 17] # n < 341,550,071,728,321\n return [random.randint(1,n-1) for _ in xrange(0,20)] # 99.999999999909051% (1 - .25**20) accuracy for n >= 341,550,071,728,321","def hamming_byte(bin1, bin2):\n\n diffs = 0\n xored = xor(bin1, bin2)\n for byte in xored:\n diffs += bin(byte).count(\"1\")\n return diffs","def test_RULE_110():\n\tk, outputs = 3, [0,1,1,1,0,1,1,0]\n\n\ttrue_pi0s = set(['200','111'])\n\ttrue_pi1s = set(['021','201','012','210'])\n\n\ttdt0, tdt1 = make_transition_density_tables(k=k, outputs=outputs)\n\tpi0s, pi1s = find_implicants_qm(tdt0) , find_implicants_qm(tdt1)\n\n\tassert (pi0s == true_pi0s) , ('Prime Implicants for 0 does not match. %s != %s' % (pi0s,true_pi0s))\n\tassert (pi1s == true_pi1s) , ('Prime Implicants for 1 does not match. %s != %s' % (pi1s,true_pi1s))\n\t# Two Symbols\n\ttrue_ts0s = [('200',[],[[1,2]]),('111',[],[[0,1,2]])]\n\ttrue_ts1s = [('201',[[0,1]],[]),('012',[[1,2]],[]),('201',[[1,2]],[]),('012',[[0,2]],[])]\n\n\tts0s,ts1s = find_two_symbols_v2(k=k, prime_implicants=pi0s) , find_two_symbols_v2(k=k, prime_implicants=pi1s)\n\n\tassert (ts0s == true_ts0s) , ('Two Symbol for 0 does not match. %s != %s' % (ts0s,true_ts0s))\n\tassert (ts1s == true_ts1s) , ('Two Symbol for 1 does not match. %s != %s' % (ts1s,true_ts1s))","def bin_contribution_(bin_weights, card_dataset, sample_contributions):\n bin_weight = np.sum([w for _, w in bin_weights])\n return bin_weight / card_dataset * np.abs(np.sum(sample_contributions))","def b_n(n):\n if n <= 0.36: # MCH03\n ei = np.array([0, 1, 2, 3, 4])\n ai = np.array([0.01945, -0.8902, 10.95, -19.67, 13.43])\n else: # CB99\n ei = np.array([1, 0, -1, -2])\n ai = np.array([2, -1./3, 4./405, 46./25515])\n return np.sum(ai * np.power(float(n), ei))","def challenge_solver(number1, number2, threshold):\n return (sum_of_n_terms(number1, threshold)\n + sum_of_n_terms(number2, threshold)\n - sum_of_n_terms(number1 * number2, threshold))","def combination(num_m: int, num_n: int) -> int:\n if num_m < num_n:\n return 0\n\n tmp_m = 1\n tmp_n = 1\n tmp_cnt = 0\n for i in range(num_n, 0, -1):\n tmp_n *= i\n tmp_m *= num_m - tmp_cnt\n tmp_cnt += 1\n\n return tmp_m / tmp_n","def hamming_dist(bytes1, bytes2):\n if type(bytes1) == str:\n bytes1 = [ord(c) for c in str1]\n if type(bytes2) == str:\n bytes2 = [ord(c) for c in str2]\n bins = [bin(o1 ^ o2) for o1, o2 in zip(bytes1, bytes2)]\n return len([i for i in ''.join(bins) if i == '1'])","def tadbit(x, n_cpus=1, verbose=True, max_tad_size=\"max\",\n no_heuristic=False, get_weights=False, use_visibility=False):\n nums, size = read_matrix(x)\n n_cpus = n_cpus if n_cpus != 'max' else 0\n max_tad_size = size if max_tad_size is \"auto\" else max_tad_size\n _, nbks, passages, _, _, bkpts, weights = \\\n _tadbit_wrapper(nums, # list of lists representing matrices\n size, # size of one row/column\n len(nums), # number of matrices\n n_cpus, # number of threads\n int(verbose), # verbose 0/1\n max_tad_size, # max_tad_size\n int(no_heuristic), # heuristic 0/1\n int(use_visibility) # TODO: remove this\n )\n\n breaks = [i for i in xrange(size) if bkpts[i + nbks * size] == 1]\n scores = [p for p in passages if p > 0]\n\n result = {'start': [], 'end' : [], 'score': []}\n for brk in xrange(len(breaks)+1):\n result['start'].append((breaks[brk-1] + 1) if brk > 0 else 0)\n result['end' ].append(breaks[brk] if brk < len(breaks) else size - 1)\n result['score'].append(scores[brk] if brk < len(breaks) else None)\n\n if get_weights:\n # in tadbit we are not using directly weights, but the\n # multiplication by the real value\n tadbit_weights = [[i/j if j else 0.0 for i, j in\n zip(nums[k], weights[k])] for k in xrange(len(nums))]\n if use_visibility:\n total = sum(nums[0])\n tadbit_weights = [[t*total for t in tadbit_weights[0]]]\n return result, tadbit_weights\n return result","def bin_cdf(n, p, x):\n\n # p C (bin_dist) ** 0 ) *(1-bin_dist)** p\n\n # n = (p)=20\n # x = x = 1 = r\n # nCr = n! / r!(n-r)\n\n \n\n\n\n\n\n\n\n\n def bin_dist(n, p, x):\n \"\"\"\n Given n number of trials, p the probability of success,\n what is the probability of having x successes?\n\n Your function should raise a ValueError if x is higher\n than n.\n\n If you need to compute combinations, you can import the\n function \"comb\" from the package \"scipy.special\"\n\n :param n: number of trials (int)\n :param p: probability of success\n :param x: number of successes (int)\n :return: probability of having x successes\n :rtype: float\n :raise ValueError: if x > n\n \"\"\"\n def factorial(x):\n if x >= 0:\n \n factorial = 1\n\n for i in range(1, x + 1):\n factorial = float(factorial * i)\n # print(f' The factorial of {x} is {factorial}') \n return factorial\n\n else:\n raise ValueError(\"Sorry x cannot be a negative number\")\n\n def combination(n, r):\n \"\"\"\n Given n total number of items,\n what is the number of possible ways\n to choose r items from it?\n\n :param n: total number of items (integer)\n :param r: number of items to arrange (int)\n :return: number of combinations\n :rtype: integer\n \"\"\"\n\n \n\n \n numerator = factorial(n)\n denominator = factorial(r)\n subtracted_answer = factorial(n-r)\n \n\n answer = numerator/(denominator * subtracted_answer)\n print(answer)\n return answer \n\n # from scipy.special import comb\n if x > n:\n raise ValueError(\"Error, x must be less than n\")\n else:\n\n\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\n\n print(prob_success)\n return prob_success \n \n # an= 1-bin_dist(n,p,x)\n # print(f'word{an}')\n # n= 12\n # p=0.25\n # # x=0??\n # ((n!)/ (x!*(n-x)!)) * (p**x) * (1-p)**(n-x)\n sum_prob = []\n for i in range(x+1):\n print(i)\n prob = bin_dist(n,p,x=i)\n sum_prob.append(prob)\n print(sum_prob)\n total =sum(sum_prob)\n print(total)","def get_witnesses(n):\n assert (n > 2) and (n % 2 == 1)\n if n < 2047:\n # References: [1], [2], [4]\n witnesses = (2,)\n elif n < 1373653: # ~1.3 million\n # References: [1], [2], [3], [4]\n witnesses = (2, 3)\n elif n < 9080191: # ~9.0 million\n # References: [3], [4]\n witnesses = (31, 73)\n elif n < 25326001: # ~25.3 million\n # References: [1], [2], [3], [4]\n witnesses = (2, 3, 5)\n elif n < 3215031751: # ~3.2 billion\n # References: [1], [2], [3], [4]\n witnesses = (2, 3, 5, 7)\n elif n < 4759123141: # ~4.7 billion\n # References: [3], [4]\n witnesses = (2, 7, 61)\n elif n < 2152302898747: # ~2.1 trillion\n # References: [1], [2], [3], [4]\n witnesses = (2, 3, 5, 7, 11)\n elif n < 3474749660383: # ~3.4 trillion\n # References: [1], [2], [3], [4]\n witnesses = (2, 3, 5, 7, 11, 13)\n elif n < 341550071728321: # ~341.5 trillion\n # References: [1], [2], [3], [4]\n witnesses = (2, 3, 5, 7, 11, 13, 17)\n elif n < 3825123056546413051: # ~3.8 million trillion\n # References: [1], [4]\n witnesses = (2, 3, 5, 7, 11, 13, 17, 19, 23)\n elif n <= 2**64:\n witnesses = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37)\n else:\n witnesses = None\n \n return witnesses","def fn(i, j, mask):\n if j == n: return 1 \n if i == m: return fn(0, j+1, mask)\n ans = 0 \n for x in 1<<2*i, 1<<2*i+1, 0b11<<2*i: \n mask0 = mask ^ x\n if mask0 & 0b11<<2*i and (i == 0 or (mask0 >> 2*i) & 0b11 != (mask0 >> 2*i-2) & 0b11): \n ans += fn(i+1, j, mask0)\n return ans % 1_000_000_007","def countbrute(m):\n nfound=0\n\n for i in range(1,m+1):\n for j in range(1,i+1):\n for k in range(1,j+1):\n d1=i*i+(j+k)*(j+k) \n if(checkpsq(d1)):\n nfound=nfound+1\n\n return nfound","def calBitLen(n, p):\n m = int(-(n*math.log(p))/BloomFilter.ln2p2)\n # round up to 32 bits\n if m%32: m += (32-m%32)\n return m","def dimensions_hamming(m: int) -> Tuple[int, int]:\n\n n = np.power(2, m) - 1\n k = n-m\n\n return n, k","def __biweight(data):\n mask = np.isfinite(data)\n if np.all(~mask):\n return (np.nan, 0.)\n\n xx = data[mask]\n med_xx = np.median(xx)\n deltas = xx - med_xx\n med_dd = np.median(np.abs(deltas))\n if med_dd == 0:\n return (med_xx, 0.)\n\n wmx = np.maximum(0, 1 - (deltas / (6 * med_dd)) ** 2) ** 2\n xbi = med_xx + np.sum(wmx * deltas) / np.sum(wmx)\n\n umn = np.minimum(1, (deltas / (9 * med_dd)) ** 2)\n sbi = np.sum(deltas ** 2 * (1 - umn) ** 4)\n sbi /= np.sum((1 - umn) * (1 - 5 * umn)) ** 2\n sbi = np.sqrt(len(xx) * sbi)\n\n return (xbi, sbi)","def calculate_bleu(candidate, reference):\n pn_sum = 0\n for n in range(1, 4):\n cand_grama, ref_grama = n_grama(candidate, n), n_grama(reference, n)\n p = calculate_p(cand_grama, ref_grama)\n if p != 0:\n # If there are no matches between n_grams,\n # don't add nothing\n pn_sum += (0.33 * math.log(p))\n bp = calculate_bp_penality(candidate, reference)\n return bp * math.exp(pn_sum)","def mw_test(n1, n2):\r\n # find smaller sample, defined historically as n2. modify the names so we\r\n # don't risk modifying data outside the scope of the function.\r\n if len(n2) > len(n1):\r\n sn1, sn2 = array(n2), array(n1)\r\n else:\r\n sn1, sn2 = array(n1), array(n2)\r\n # sum the ranks of s2 by using the searchsorted magic. the logic is that we\r\n # use a sorted copy of the data from both groups (n1 and n2) to figure out\r\n # at what index we would insert the values from sample 2. by assessing the\r\n # difference between the index that value x would be inserted in if we were\r\n # doing left insertion versus right insertion, we can tell how many values\r\n # are tied with x. this allows us to calculate the average ranks easily.\r\n data = sorted(hstack([sn1, sn2]))\r\n ssl = searchsorted(data, sn2, 'left')\r\n ssr = searchsorted(data, sn2, 'right')\r\n sum_sn2_ranks = ((ssl + ssr + 1) / 2.).sum()\r\n ln1, ln2 = sn1.size, sn2.size\r\n C = (ln1 * ln2) + (ln2 * (ln2 + 1) / 2.) - sum_sn2_ranks\r\n U = max(C, ln1 * ln2 - C)\r\n # now we calculate the pvalue using the normal approximation and the two\r\n # tailed test. our formula corrects for ties, because in the case where\r\n # there are no ties, the forumla on the bottom of pg 429=the formula on the\r\n # bottom of pg 430.\r\n numerator = (U - ln1 * ln2 / 2.)\r\n # follwing three lines give the T value in the formula on page 430. same\r\n # logic as above; we calculate the left and right indices of the unique\r\n # values for all combined data from both samples, then calculate ti**3-ti\r\n # for each value.\r\n ux = unique(data)\r\n uxl = searchsorted(data, ux, 'left')\r\n uxr = searchsorted(data, ux, 'right')\r\n T = _corr_kw(uxr - uxl).sum()\r\n denominator = sqrt(((ln1 * ln2) / float((ln1 + ln2) * (ln1 + ln2 - 1))) * (((ln1 + ln2) ** 3\r\n - (ln1 + ln2) - T) / 12.))\r\n if denominator == 0:\r\n # Warning: probability of U can't be calculated by mw_test\r\n # because all ranks of data were tied. Returning nan as pvalue.\r\n return U, nan\r\n else:\r\n pval = zprob(numerator / float(denominator))\r\n return U, pval","def combination(n, r):\n\n \n\n \n numerator = factorial(n)\n denominator = factorial(r)\n subtracted_answer = factorial(n-r)\n \n\n answer = numerator/(denominator * subtracted_answer)\n print(answer)\n return answer","def womcom(hop,num,weights):\n import logging\n import matplotlib.pyplot as plt\n import numpy as np\n from tmath.wombat.inputter import inputter\n from tmath.wombat import HOPSIZE\n hopnum=[0]\n weight=[0]\n while (hopnum[0] < 1) or (hopnum[0] > HOPSIZE):\n hopnum[0]=inputter('Enter first hopper: ','int',False)\n if (weights):\n weight[0]=inputter('Enter weight for first hopper: ','float',False)\n for i in range(1,num):\n hoploop=0\n weightloop=0\n if (num > 3):\n print('Use hopper 99 to end')\n while (hoploop < 1) or (hoploop > HOPSIZE):\n hoploop=inputter('Enter next hopper: ','int',False)\n if (hoploop == 99):\n break\n if (hoploop == 99):\n break\n if (hop[hopnum[0]].wave[0] != hop[hoploop].wave[0]) or \\\n (hop[hopnum[0]].wave[1] != hop[hoploop].wave[1]) or \\\n (hop[hopnum[0]].wave[-1] != hop[hoploop].wave[-1]):\n print('Hoppers to not have the same wavelength scale!')\n return hop\n hopnum.append(hoploop)\n if (weights):\n weightloop=inputter('Enter next weight: ','float',False)\n weight.append(weightloop)\n if (weights) and (abs(sum(weight)-1.0) > 0.00001):\n print('Weights do not add to 1.0')\n return hop\n if (not weights):\n weight=[1./len(hopnum)]*len(hopnum)\n newflux=np.zeros(len(hop[hopnum[0]].flux))\n logging.debug('Combining spectra:')\n \n for i in range(0,len(hopnum)):\n newflux=newflux+hop[hopnum[i]].flux*weight[i]\n logging.debug('Combining {} with weight {}'.format(hop[hopnum[i]].obname,\\\n weight[i]))\n hopout=0\n while (hopout < 1) or (hopout > HOPSIZE):\n hopout=inputter('Enter hopper to store combined spectrum: ','int',False)\n hop[hopout].wave=hop[hopnum[0]].wave.copy()\n hop[hopout].flux=newflux.copy()\n hop[hopout].obname=hop[hopnum[0]].obname\n hop[hopout].header=hop[hopnum[0]].header\n hop[hopout].var=hop[hopnum[0]].var.copy()\n plt.cla()\n plt.plot(hop[hopout].wave,hop[hopout].flux,drawstyle='steps-mid',color='k')\n plt.xlabel('Wavelength')\n plt.ylabel('Flux')\n plt.title(hop[hopout].obname)\n xmin,xmax=plt.xlim()\n ymin,ymax=plt.ylim()\n print('\\nPlotting combined spectrum in black, components in color\\n')\n for i in range(0,len(hopnum)):\n plt.plot(hop[hopnum[i]].wave,hop[hopnum[i]].flux,drawstyle='steps-mid')\n plt.xlim([xmin,xmax])\n plt.ylim([ymin,ymax])\n \n #FIX var\n return hop","def test_bin_addition():\n outcome1 = Outcome(\"red\", 1)\n outcome2 = Outcome(\"black\", 1)\n outcome3 = Outcome(\"low\", 5)\n outcome4 = Outcome(\"high\", 5)\n\n rng = NonRandom()\n wheel = Wheel(rng)\n\n wheel.addOutcome(1, outcome1)\n wheel.addOutcome(1, outcome3)\n wheel.addOutcome(31, outcome2)\n wheel.addOutcome(31, outcome4)\n\n # since we added only two outcomes for each of the two bins,\n # the number of outcomes for both bins should be 2 and 0 for all others\n wheel.rng.setSeed(1)\n returned_bin = wheel.next()\n outcomes = returned_bin.outcomes\n print outcomes\n assert len(outcomes) == 2\n assert outcome1 in returned_bin.outcomes\n assert outcome3 in returned_bin.outcomes\n\n wheel.rng.setSeed(31)\n returned_bin = wheel.next()\n assert outcome3, outcome2 in returned_bin.outcomes\n assert outcome3, outcome4 in returned_bin.outcomes\n\n for i in range(0, 38):\n if i not in [1, 31]:\n wheel.rng.setSeed(i)\n returned_bin = wheel.next()\n assert len(returned_bin.outcomes) == 0","def measure_partial(qubit, bits, format='sympy', normalize=True):\n m = qubit_to_matrix(qubit, format)\n\n if isinstance(bits, (SYMPY_INTS, Integer)):\n bits = (int(bits),)\n\n if format == 'sympy':\n if normalize:\n m = m.normalized()\n\n possible_outcomes = _get_possible_outcomes(m, bits)\n\n # Form output from function.\n output = []\n for outcome in possible_outcomes:\n # Calculate probability of finding the specified bits with\n # given values.\n prob_of_outcome = 0\n prob_of_outcome += (outcome.H*outcome)[0]\n\n # If the output has a chance, append it to output with found\n # probability.\n if prob_of_outcome != 0:\n if normalize:\n next_matrix = matrix_to_qubit(outcome.normalized())\n else:\n next_matrix = matrix_to_qubit(outcome)\n\n output.append((\n next_matrix,\n prob_of_outcome\n ))\n\n return output\n else:\n raise NotImplementedError(\n \"This function cannot handle non-SymPy matrix formats yet\"\n )","def gen_samp_hammersley(self, i1, i2, m, n, vectorized = True):\n dist = self.dist\n \n def hammersley_sequence (i1, i2, m, n):\n \n \n if ( i1 <= i2 ):\n i3 = +1\n else:\n i3 = -1\n \n l = abs ( i2 - i1 ) + 1\n r = np.zeros ( [ m, l ] )\n k = 0\n \n for i in range ( i1, i2 + i3, i3 ):\n \n t = np.ones ( m - 1 )\n \n t = t * i\n #\n # Carry out the computation.\n #\n prime_inv = np.zeros ( m - 1 )\n for j in range ( 0, m - 1 ):\n prime_inv[j] = 1.0 / prime ( j )\n \n r[0,k] = float ( i % ( n + 1 ) ) / float ( n )\n \n while ( 0 < np.sum ( t ) ):\n for j in range ( 0, m - 1 ):\n d = ( t[j] % prime ( j ) )\n r[j+1,k] = r[j+1,k] + float ( d ) * prime_inv[j]\n prime_inv[j] = prime_inv[j] / prime ( j )\n t[j] = ( t[j] // prime ( j ) )\n \n k = k + 1\n \n return r\n \n def prime (n):\n \n from sys import exit\n \n prime_max = 1600\n \n prime_vector = np.array ( [\n 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, \\\n 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, \\\n 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, \\\n 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, \\\n 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, \\\n 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, \\\n 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, \\\n 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, \\\n 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, \\\n 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, \\\n 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, \\\n 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, \\\n 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, \\\n 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, \\\n 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, \\\n 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, \\\n 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, \\\n 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, \\\n 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, \\\n 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, \\\n 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, \\\n 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, \\\n 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, \\\n 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, \\\n 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, \\\n 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, \\\n 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, \\\n 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, \\\n 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, \\\n 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, \\\n 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, \\\n 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, \\\n 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, \\\n 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, \\\n 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, \\\n 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, \\\n 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, \\\n 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, \\\n 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, \\\n 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, \\\n 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, \\\n 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, \\\n 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, \\\n 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, \\\n 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, \\\n 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, \\\n 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, \\\n 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, \\\n 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, \\\n 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, \\\n 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, \\\n 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, \\\n 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, \\\n 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, \\\n 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, \\\n 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, \\\n 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, \\\n 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, \\\n 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, \\\n 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, \\\n 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, \\\n 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, \\\n 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, \\\n 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, \\\n 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, \\\n 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, \\\n 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, \\\n 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, \\\n 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, \\\n 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, \\\n 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, \\\n 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, \\\n 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, \\\n 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, \\\n 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, \\\n 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, \\\n 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, \\\n 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, \\\n 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, \\\n 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, \\\n 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, \\\n 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, \\\n 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, \\\n 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, \\\n 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, \\\n 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, \\\n 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, \\\n 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, \\\n 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, \\\n 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, \\\n 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, \\\n 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, \\\n 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, \\\n 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, \\\n 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, \\\n 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, \\\n 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, \\\n 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, \\\n 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, \\\n 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, \\\n 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, \\\n 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, \\\n 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, \\\n 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, \\\n 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, \\\n 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, \\\n 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, \\\n 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, \\\n 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, \\\n 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, \\\n 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, \\\n 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, \\\n 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, \\\n 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, \\\n 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, \\\n 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, \\\n 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, \\\n 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, \\\n 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, \\\n 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, \\\n 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, \\\n 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, \\\n 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973,10007, \\\n 10009,10037,10039,10061,10067,10069,10079,10091,10093,10099, \\\n 10103,10111,10133,10139,10141,10151,10159,10163,10169,10177, \\\n 10181,10193,10211,10223,10243,10247,10253,10259,10267,10271, \\\n 10273,10289,10301,10303,10313,10321,10331,10333,10337,10343, \\\n 10357,10369,10391,10399,10427,10429,10433,10453,10457,10459, \\\n 10463,10477,10487,10499,10501,10513,10529,10531,10559,10567, \\\n 10589,10597,10601,10607,10613,10627,10631,10639,10651,10657, \\\n 10663,10667,10687,10691,10709,10711,10723,10729,10733,10739, \\\n 10753,10771,10781,10789,10799,10831,10837,10847,10853,10859, \\\n 10861,10867,10883,10889,10891,10903,10909,10937,10939,10949, \\\n 10957,10973,10979,10987,10993,11003,11027,11047,11057,11059, \\\n 11069,11071,11083,11087,11093,11113,11117,11119,11131,11149, \\\n 11159,11161,11171,11173,11177,11197,11213,11239,11243,11251, \\\n 11257,11261,11273,11279,11287,11299,11311,11317,11321,11329, \\\n 11351,11353,11369,11383,11393,11399,11411,11423,11437,11443, \\\n 11447,11467,11471,11483,11489,11491,11497,11503,11519,11527, \\\n 11549,11551,11579,11587,11593,11597,11617,11621,11633,11657, \\\n 11677,11681,11689,11699,11701,11717,11719,11731,11743,11777, \\\n 11779,11783,11789,11801,11807,11813,11821,11827,11831,11833, \\\n 11839,11863,11867,11887,11897,11903,11909,11923,11927,11933, \\\n 11939,11941,11953,11959,11969,11971,11981,11987,12007,12011, \\\n 12037,12041,12043,12049,12071,12073,12097,12101,12107,12109, \\\n 12113,12119,12143,12149,12157,12161,12163,12197,12203,12211, \\\n 12227,12239,12241,12251,12253,12263,12269,12277,12281,12289, \\\n 12301,12323,12329,12343,12347,12373,12377,12379,12391,12401, \\\n 12409,12413,12421,12433,12437,12451,12457,12473,12479,12487, \\\n 12491,12497,12503,12511,12517,12527,12539,12541,12547,12553, \\\n 12569,12577,12583,12589,12601,12611,12613,12619,12637,12641, \\\n 12647,12653,12659,12671,12689,12697,12703,12713,12721,12739, \\\n 12743,12757,12763,12781,12791,12799,12809,12821,12823,12829, \\\n 12841,12853,12889,12893,12899,12907,12911,12917,12919,12923, \\\n 12941,12953,12959,12967,12973,12979,12983,13001,13003,13007, \\\n 13009,13033,13037,13043,13049,13063,13093,13099,13103,13109, \\\n 13121,13127,13147,13151,13159,13163,13171,13177,13183,13187, \\\n 13217,13219,13229,13241,13249,13259,13267,13291,13297,13309, \\\n 13313,13327,13331,13337,13339,13367,13381,13397,13399,13411, \\\n 13417,13421,13441,13451,13457,13463,13469,13477,13487,13499 ] )\n \n if ( n < 0 or prime_max <= n ):\n print ( '' )\n print ( 'PRIME - Fatal error!' )\n print ( ' 0 <= N < %d' % ( prime_max ) )\n exit ( 'PRIME - Fatal error!' )\n \n return prime_vector[n] \n \n hamm_seq = hammersley_sequence(i1, i2, m, n)\n samp = dist.ppf(hamm_seq)\n \n if vectorized == False:\n return(samp)\n \n else: \n samp = samp.reshape(1, -1)\n return(samp)","def binning():\n def r(x):\n return 1 << (x & 7)\n\n def w(x):\n return 0x11 * (x >> 1)\n return r, w","def _getKramerStatistic_(seq, n, F):\n S = 0.0\n for i in range(n):\n S += (F(seq[i]) - (2 * i - 1) / (2 * n)) ** 2\n return 1 / (12 * n) + S","def check_sample_correctishness_bc01(f):\n\n batch_size = 5\n rows = 32\n cols = 30\n channels = 3\n pool_rows = 2\n pool_cols = 3\n\n rng = np.random.RandomState([2012, 9, 26])\n zv = rng.randn(batch_size, channels, rows,\n cols).astype(config.floatX) * 2. - 3.\n top_down_v = rng.randn(batch_size, channels, rows / pool_rows,\n cols / pool_cols).astype(config.floatX)\n\n z_th = T.TensorType(broadcastable=(False, False, False, False),\n dtype = config.floatX)()\n z_th.tag.test_value = zv\n z_th.name = 'z_th'\n\n top_down_th = T.TensorType(broadcastable=(False, False, False, False),\n dtype = config.floatX)()\n top_down_th.tag.test_value = top_down_v\n top_down_th.name = 'top_down_th'\n\n theano_rng = MRG_RandomStreams(rng.randint(2147462579))\n p_th, h_th, p_sth, h_sth = f(z_th, (pool_rows, pool_cols), top_down_th,\n theano_rng)\n\n prob_func = function([z_th, top_down_th], [p_th, h_th])\n pv, hv = prob_func(zv, top_down_v)\n\n sample_func = function([z_th, top_down_th], [p_sth, h_sth])\n\n acc_p = 0. * pv\n acc_h = 0. * hv\n\n # make sure the test gets good coverage, ie, that it includes many\n # different activation probs for both detector and pooling layer\n buckets = 10\n bucket_width = 1. / float(buckets)\n for i in xrange(buckets):\n lower_lim = i * bucket_width\n upper_lim = (i+1) * bucket_width\n\n assert np.any((pv >= lower_lim) * (pv < upper_lim))\n assert np.any((hv >= lower_lim) * (hv < upper_lim))\n\n assert upper_lim == 1.\n\n for i in xrange(10000):\n ps, hs = sample_func(zv, top_down_v)\n\n assert ps.shape == pv.shape\n assert hs.shape == hv.shape\n\n acc_p += ps\n acc_h += hs\n\n est_p = acc_p / float(i+1)\n est_h = acc_h / float(i+1)\n\n pd = np.abs(est_p-pv)\n hd = np.abs(est_h-hv)\n\n \"\"\"\n # plot maps of the estimation error, this is to see if it has some\n # spatial pattern this is useful for detecting bugs like not handling\n # the border correctly, etc.\n from pylearn2.gui.patch_viewer import PatchViewer\n\n pv = PatchViewer((pd.shape[0],pd.shape[3]),(pd.shape[1],pd.shape[2]),\n is_color = False)\n for i in xrange(pd.shape[0]):\n for j in xrange(pd.shape[3]):\n pv.add_patch( (pd[i,:,:,j] / pd.max() )* 2.0 - 1.0, rescale = False)\n pv.show()\n\n pv = PatchViewer((hd.shape[0],hd.shape[3]), (hd.shape[1],hd.shape[2]),\n is_color = False)\n for i in xrange(hd.shape[0]):\n for j in xrange(hd.shape[3]):\n pv.add_patch( (hd[i,:,:,j] / hd.max() )* 2.0 - 1.0, rescale = False)\n pv.show()\n \"\"\"\n\n \"\"\"\n plot expectation to estimate versus error in estimation\n expect bigger errors for values closer to 0.5\n\n from matplotlib import pyplot as plt\n\n #nelem = reduce( lambda x, y : x*y, pd.shape)\n #plt.scatter( pv.reshape(nelem), pd.reshape(nelem))\n #plt.show()\n\n nelem = reduce( lambda x, y : x*y, hd.shape)\n plt.scatter( hv.reshape(nelem), hd.reshape(nelem))\n plt.show()\n \"\"\"\n\n # don't really know how tight this should be\n # but you can try to pose an equivalent problem\n # and implement it in another way\n # using a numpy implementation in softmax_acc.py\n # I got a max error of .17\n assert max(pd.max(), hd.max()) < .17\n\n # Do exhaustive checks on just the last sample\n assert np.all((ps == 0) + (ps == 1))\n assert np.all((hs == 0) + (hs == 1))\n\n for k in xrange(batch_size):\n for i in xrange(ps.shape[2]):\n for j in xrange(ps.shape[3]):\n for l in xrange(channels):\n p = ps[k, l, i, j]\n h = hs[k, l, i*pool_rows:(i+1)*pool_rows,\n j*pool_cols:(j+1)*pool_cols]\n assert h.shape == (pool_rows, pool_cols)\n assert p == h.max()\n assert h.sum() <= 1\n\n \"\"\" If you made it to here, it's correctish\n (cant tell if samples are perfectly \"correct\") \"\"\"","def bits_to_probabilities(\n all_qubits: Sequence[Tuple[int, int]],\n subsys_qubits: Sequence[Tuple[int, int]],\n bits: np.ndarray,\n) -> np.ndarray:\n num_qubits = len(subsys_qubits)\n indices = [all_qubits.index(q) for q in subsys_qubits]\n bits_red = np.asarray(bits[:, indices], dtype=int)\n for i in range(num_qubits):\n bits_red[:, i] *= 2 ** (num_qubits - i - 1)\n bits = list(np.sum(bits_red, axis=1))\n p_reduced = np.bincount(bits, minlength=2 ** num_qubits)\n num_trials, _ = bits_red.shape\n return p_reduced / num_trials","def ideal_fanin(k, m):\n fanin = 0\n needed = k\n for select in range(3, m + 1, 2):\n combinations = list(itertools.combinations(range(m), select))\n if len(combinations) <= needed:\n fanin += int(math.ceil(float(len(combinations) * select) / m))\n needed -= len(combinations)\n else:\n fanin += int(math.ceil(float(needed * select) / m))\n needed = 0\n if not needed:\n break\n return fanin","def solve_brute_force(n: int, W: int, weight: List[int], value: List[int]) -> int:\n mapped_items = [{\"w\": w, \"v\": v} for i, (w, v) in enumerate(zip(weight, value))]\n\n maximum_value: int = 0\n updated: bool = False\n for i in range(1, n + 1):\n if i > 1 and not updated:\n break\n\n updated = False\n for chosen_items in list(combinations(mapped_items, i)):\n sum_weight = 0\n sum_value = 0\n for item in chosen_items:\n sum_weight += item[\"w\"]\n sum_value += item[\"v\"]\n\n if sum_weight <= W and maximum_value < sum_value:\n updated = True\n maximum_value = sum_value\n return maximum_value","def sol(n):\n p = 1\n res = 0\n \n while n:\n p*=5\n if n&1:\n res+=p\n n=n>>1\n return res%1000000007","def witHelp(x):\n t = 0\n while not (x & 1):\n x >>= 1\n t += 1\n return (t, x)","def _build_basis_slow(weight, n_bits):\n _warnings.warn((\"You're using a slow version of the basis-building code used by the disturbance calculations\"\n \" - compile pyGSTi's C extensions to make this go faster.\"))\n n_w = n_parameters_per_matrix(weight, n_bits)\n n_a = n_matrices_per_weight(weight, n_bits)\n dim = 2**n_bits\n\n my_basis = []\n my_constraints = []\n # All sets of qubits of given weight on n_bits\n pairs = list(_itertools.combinations(_np.arange(n_bits), weight))\n\n for ind in range(n_w * n_a):\n v = unit_vector(ind, n_w * n_a)\n vs = _np.reshape(v, (n_a, n_w))\n ctm = sum((swell_slow(transition_matrix(v, 2**weight), pair, n_bits)\n for v, pair in zip(vs, pairs))) - n_a * _np.eye(dim)\n my_basis += [ctm]\n my_constraints += [-_np.diag(ctm)]\n\n return my_basis, _np.array(my_constraints, dtype='int').T"],"string":"[\n \"def _get_possible_outcomes(m, bits):\\n\\n # This is filled with loads of dirty binary tricks...You have been warned\\n\\n size = max(m.shape) # Max of shape to account for bra or ket\\n nqubits = int(math.log(size, 2) + .1) # Number of qubits possible\\n\\n # Make the output states and put in output_matrices, nothing in them now.\\n # Each state will represent a possible outcome of the measurement\\n # Thus, output_matrices[0] is the matrix which we get when all measured\\n # bits return 0. and output_matrices[1] is the matrix for only the 0th\\n # bit being true\\n output_matrices = []\\n for i in range(1 << len(bits)):\\n output_matrices.append(zeros(2**nqubits, 1))\\n\\n # Bitmasks will help sort how to determine possible outcomes.\\n # When the bit mask is and-ed with a matrix-index,\\n # it will determine which state that index belongs to\\n bit_masks = []\\n for bit in bits:\\n bit_masks.append(1 << bit)\\n\\n # Make possible outcome states\\n for i in range(2**nqubits):\\n trueness = 0 # This tells us to which output_matrix this value belongs\\n # Find trueness\\n for j in range(len(bit_masks)):\\n if i & bit_masks[j]:\\n trueness += j + 1\\n # Put the value in the correct output matrix\\n output_matrices[trueness][i] = m[i]\\n return output_matrices\",\n \"def wabbits(n, k):\\n a, b = 1, 1\\n for i in range(3, n+1):\\n a, b = b, a*k + b\\n return b\",\n \"def test_get_n_bits_combinations():\\n # Check n=1 - Pass\\n assert layer_util.get_n_bits_combinations(1) == [[0], [1]]\\n # Check n=2 - Pass\\n assert layer_util.get_n_bits_combinations(2) == [[0, 0], [0, 1], [1, 0], [1, 1]]\\n\\n # Check n=3 - Pass\\n assert layer_util.get_n_bits_combinations(3) == [\\n [0, 0, 0],\\n [0, 0, 1],\\n [0, 1, 0],\\n [0, 1, 1],\\n [1, 0, 0],\\n [1, 0, 1],\\n [1, 1, 0],\\n [1, 1, 1],\\n ]\",\n \"def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\\n int]] = None,\\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,\\n num_shots: int = 100, use_param_program: bool = False,\\n use_active_reset: bool = True, show_progress_bar: bool = False) \\\\\\n -> Sequence[Sequence[Sequence[int]]]:\\n if registers is None:\\n registers = get_qubit_registers_for_adder(qc, n_bits, qubits)\\n\\n reset_prog = Program()\\n if use_active_reset:\\n reset_prog += RESET()\\n\\n add_prog = Program()\\n if use_param_program:\\n dummy_num = [0 for _ in range(n_bits)]\\n add_prog = adder(dummy_num, dummy_num, *registers, in_x_basis=in_x_basis,\\n use_param_program=True)\\n\\n all_results = []\\n # loop over all binary strings of length n_bits\\n for bits in tqdm(all_bitstrings(2 * n_bits), disable=not show_progress_bar):\\n # split the binary number into two numbers\\n # which are the binary numbers the user wants to add.\\n # They are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\\n num_a = bits[:n_bits]\\n num_b = bits[n_bits:]\\n\\n if not use_param_program:\\n add_prog = adder(num_a, num_b, *registers, in_x_basis=in_x_basis,\\n use_param_program=False)\\n\\n prog = reset_prog + add_prog\\n prog.wrap_in_numshots_loop(num_shots)\\n nat_quil = qc.compiler.quil_to_native_quil(prog)\\n exe = qc.compiler.native_quil_to_executable(nat_quil)\\n\\n if use_param_program:\\n exe.write_memory(region_name=REG_NAME, value=bits)\\n\\n # Run it on the QPU or QVM\\n results = qc.run(exe).readout_data.get('ro')\\n all_results.append(results)\\n\\n return all_results\",\n \"def bin_dist(n, p, x):\\n def factorial(x):\\n if x >= 0:\\n \\n factorial = 1\\n\\n for i in range(1, x + 1):\\n factorial = float(factorial * i)\\n # print(f' The factorial of {x} is {factorial}') \\n return factorial\\n\\n else:\\n raise ValueError(\\\"Sorry x cannot be a negative number\\\")\\n\\n def combination(n, r):\\n \\\"\\\"\\\"\\n Given n total number of items,\\n what is the number of possible ways\\n to choose r items from it?\\n\\n :param n: total number of items (integer)\\n :param r: number of items to arrange (int)\\n :return: number of combinations\\n :rtype: integer\\n \\\"\\\"\\\"\\n\\n \\n\\n \\n numerator = factorial(n)\\n denominator = factorial(r)\\n subtracted_answer = factorial(n-r)\\n \\n\\n answer = numerator/(denominator * subtracted_answer)\\n print(answer)\\n return answer \\n\\n # from scipy.special import comb\\n if x > n:\\n raise ValueError(\\\"Error, x must be less than n\\\")\\n else:\\n\\n\\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\\n\\n print(prob_success)\\n return prob_success\",\n \"def compute_thres(n_bits, fsr_min, fsr_max, half_bit=None):\\n n_bits, half_bit = parse_bits(n_bits, half_bit)\\n lsb = compute_lsb(n_bits, fsr_min, fsr_max, half_bit)\\n n_codes = compute_n_codes(n_bits, half_bit)\\n\\n range_2 = (lsb * (n_codes - 2))/2\\n avg = (fsr_max + fsr_min) / 2\\n\\n if n_codes > 2:\\n return np.linspace(-range_2, range_2, n_codes-1) + avg\\n else:\\n return np.reshape(avg, (1,))\",\n \"def compare():\\n eb = 1\\n p = 0.5\\n R = 0.5\\n N = 150 # set the error count to reach\\n\\n domain = np.linspace(0, 10, 11)\\n hard_domain = np.linspace(0, 8, 9)\\n soft_domain = np.linspace(0, 6, 7)\\n hard_decibels = 10 ** (hard_domain / 10)\\n soft_decibels = 10 ** (soft_domain / 10)\\n\\n # get results for hard decoding\\n nos = eb / hard_decibels\\n hard_results = []\\n for no in nos:\\n print(np.where(nos == no)[0][0])\\n experiment = ViterbiHard(eb, no / R)\\n bit_count = 0\\n error_count = 0\\n for output in experiment.run():\\n bit_count += 1\\n if output[0] != output[1]:\\n error_count += 1\\n if error_count == N:\\n hard_results.append(error_count / bit_count)\\n break\\n\\n # get results for soft decoding\\n nos = eb / soft_decibels\\n soft_results = []\\n for no in nos:\\n print(np.where(nos == no)[0][0])\\n experiment = ViterbiSoft(eb, no / R)\\n bit_count = 0\\n error_count = 0\\n for output in experiment.run():\\n bit_count += 1\\n if output[0] != output[1]:\\n error_count += 1\\n if error_count == N:\\n soft_results.append(error_count / bit_count)\\n break\\n\\n decibels = 10 ** (domain / 10)\\n nos = eb / decibels\\n taus = nos / 4 / np.sqrt(eb) * np.log((1 - p) / p)\\n plt.semilogy(hard_domain, np.array(hard_results), label='Hard-decision')\\n plt.semilogy(soft_domain, np.array(soft_results), label='Soft-decision')\\n plt.semilogy(domain, norm.sf((taus + np.sqrt(eb)) / np.sqrt(nos / 2)) * (1 - p) +\\n norm.sf((np.sqrt(eb) - taus) / np.sqrt(nos / 2)) * p, label='Expectation ($p=0.5$)')\\n plt.xlabel('$E_b/N_0$ (dB)')\\n plt.ylabel('Probability of bit error')\\n plt.legend(loc='lower left')\\n plt.show()\",\n \"def hamming_weight(num):\\n\\n return bin(num).count(\\\"1\\\");\",\n \"def orderByIncreasingBitCount(n):\\n res = [0] # freebie\\n biggest = 2**n - 1\\n for i in range(1, n):\\n for j in range(1, biggest):\\n if hamming_weight(j) == i:\\n res.append(j)\\n res.append(biggest) # another freebie\\n return res\",\n \"def get_success_probabilities_from_results(results: Sequence[Sequence[Sequence[int]]]) \\\\\\n -> Sequence[float]:\\n num_shots = len(results[0])\\n n_bits = len(results[0][0]) - 1\\n\\n probabilities = []\\n # loop over all binary strings of length n_bits\\n for result, bits in zip(results, all_bitstrings(2 * n_bits)):\\n # Input nums are written from (MSB .... LSB) = (a_n, ..., a_1, a_0)\\n num_a = bit_array_to_int(bits[:n_bits])\\n num_b = bit_array_to_int(bits[n_bits:])\\n\\n # add the numbers\\n ans = num_a + num_b\\n ans_bits = int_to_bit_array(ans, n_bits + 1)\\n\\n # a success occurs if a shot matches the expected ans bit for bit\\n probability = 0\\n for shot in result:\\n if np.array_equal(ans_bits, shot):\\n probability += 1. / num_shots\\n probabilities.append(probability)\\n\\n return probabilities\",\n \"def hamming_dist(a_b, b_b):\\n return sum(bin(a_b[n] ^ b_b[n]).count('1') for n in range(len(a_b)))\",\n \"def test_count_bits(n, result):\\n from count_bits import count_bits\\n assert count_bits(n) == result\",\n \"def calHash(n, m):\\n return int(m*BloomFilter.ln2/n)\",\n \"def batina_recover_weight(secret_number, guess_range, mantissa_nbits=10, max_number_of_best_candidates=10, noise=None):\\n if noise is not None:\\n add_noise_function, signal_to_noise, frequency = noise\\n # step 1: build signal for mantissa\\n mantissa_known_inputs = build_input_values(mantissa_nbits=mantissa_nbits, component='mantissa')\\n mantissa_weight_hw = np.vectorize(hamming_weight)(mantissa_known_inputs * secret_number)\\n if noise is not None:\\n mantissa_weight_hw = add_noise_function(mantissa_weight_hw, signal_to_noise, frequency)\\n\\n # step 2: build signal for exponent 8 bits\\n exponent_known_inputs = build_input_values(component='exponent')\\n exponent_weight_hw = np.vectorize(hamming_weight)(exponent_known_inputs * secret_number)\\n if noise is not None:\\n exponent_weight_hw = add_noise_function(exponent_weight_hw, signal_to_noise, frequency)\\n # step 3: build signal for sign 1 bit\\n sign_known_inputs = build_input_values(component='sign')\\n sign_weight_hw = np.vectorize(hamming_weight)(sign_known_inputs * secret_number)\\n if noise is not None:\\n sign_weight_hw = add_noise_function(sign_weight_hw, signal_to_noise, frequency)\\n\\n return recover_weight(secret_hamming_weight_set=(mantissa_weight_hw, exponent_weight_hw, sign_weight_hw),\\n input_value_set=(mantissa_known_inputs, exponent_known_inputs, sign_known_inputs),\\n guess_range=guess_range,\\n mantissa_nbits=mantissa_nbits,\\n max_number_of_best_candidates=max_number_of_best_candidates)\",\n \"def n_parameters_per_matrix(weight, n_bits):\\n return 2**weight * (2**weight - 1)\",\n \"def n_matrices_per_weight(weight, n_bits):\\n return int(_sp.special.binom(n_bits, weight))\",\n \"def pairwise_bit_scores(blastf, ss, outf, verbose=False):\\n\\n if verbose:\\n sys.stderr.write(f\\\"{bcolors.GREEN}Creating scores{bcolors.ENDC}\\\\n\\\")\\n\\n pb = {}\\n out = open(outf + \\\".tsv\\\", 'w')\\n out.write(\\\"Query\\\\tSubject\\\\tQLen\\\\tSLen\\\\tBits\\\\tnBits\\\\n\\\")\\n for b in stream_blast_results(blastf, verbose):\\n if b.query not in pb:\\n pb[b.query] = {}\\n if b.db not in pb:\\n pb[b.db] = {}\\n\\n # we normalize by the bitscore of the two proteins if we can!\\n if b.query in ss and b.db in ss:\\n nb = b.bitscore / ((ss[b.query] + ss[b.db])/2)\\n else:\\n # if we can't do that, we cheat and normalize \\n # the bit score by twice\\n # the average length of the proteins\\n # i.e. the sum of the lengths\\n nb = b.bitscore / (b.query_length + b.subject_length + 3.3)\\n\\n if b.query in pb[b.db] and pb[b.db][b.query] > nb:\\n continue\\n pb[b.db][b.query] = pb[b.db][b.query] = nb\\n out.write(f\\\"{b.query}\\\\t{b.db}\\\\t{b.query_length}\\\\t{b.subject_length}\\\\t{b.bitscore}\\\\t{nb}\\\\n\\\")\\n return pb\",\n \"def test_bit_driver_output(self):\\n\\n H = qaoa.bit_driver(range(3), 1)\\n hamiltonian = qml.Hamiltonian([1, 1, 1], [qml.PauliZ(0), qml.PauliZ(1), qml.PauliZ(2)])\\n\\n assert decompose_hamiltonian(H) == decompose_hamiltonian(hamiltonian)\",\n \"def solution(n: int = 28123) -> int:\\n\\n nums = range(1, n+1)\\n abundant = list(filter(is_abundant, nums))\\n abundant_sums = set(all_sums(abundant, n))\\n fit = set(nums) - abundant_sums\\n return fit\",\n \"def sugg(n):\\n print (\\\"%s\\\\t\\\"*3)%(\\\"p\\\", \\\"m(bytes)\\\", \\\"ok\\\")\\n for p in (0.1, 0.01, 0.001, 0.0001, 0.00001):\\n m=BloomFilter.calBitLen(n,p)\\n ok=BloomFilter.calHash(n,m)\\n print (\\\"%.5f\\\\t\\\"+\\\"%d\\\\t\\\"*2)%(p, m/8, ok)\\n for k in BloomFilter.KRange:\\n rp=BloomFilter.calPFP(n,m,k)\\n print (\\\"\\\\t\\\"*2+\\\"%d\\\\t%f\\\")%(k, rp)\",\n \"def bit_contribution_test(hash_function):\\n\\n model = hash_function()\\n hash_list = []\\n zero_str = '0' * 2048\\n for i in range(1, 2049):\\n for j in range(0, i):\\n flip_str = zero_str[:j] + '1' + zero_str[j+1:i]\\n hash_list.append(list(map(int, list(msg_to_bits.pad_msg(flip_str, i)))))\\n if i % 200 == 0:\\n print(i)\\n\\n hashed_dict = dict()\\n collisions = 0\\n i = 0\\n for to_hash in hash_list:\\n i += 1\\n hash_val = model.hash(to_hash, False).tostring()\\n if hash_val in hashed_dict:\\n collisions += 1\\n hashed_dict[hash_val] = True\\n if i % 10000 == 0:\\n print(i)\\n\\n return collisions\",\n \"def n_parameters(weight, n_bits):\\n n_w = n_parameters_per_matrix(weight, n_bits)\\n\\n # Number of ways to pick weight bits out of n_bits\\n n_a = n_matrices_per_weight(weight, n_bits)\\n\\n return n_w * n_a\",\n \"def lfriedmanchisquare(*args):\\r\\n k = len(args)\\r\\n if k < 3:\\r\\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\\r\\n n = len(args[0])\\r\\n data = apply(pstats.abut,tuple(args))\\r\\n for i in range(len(data)):\\r\\n data[i] = rankdata(data[i])\\r\\n ssbn = 0\\r\\n for i in range(k):\\r\\n ssbn = ssbn + sum(args[i])**2\\r\\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\\r\\n return chisq, chisqprob(chisq,k-1)\",\n \"def compute_probability_weights(indexing, \\n counts, \\n image, \\n binary_set_mappings): \\n S_w_cardinalities = np.zeros_like(indexing)\\n\\n countsgeq2 = sum(c>=2 for c in counts) # compute amount of indices that have count>=2\\n countseq1 = [v for v in range(indexing.shape[0]) if counts[indexing[v]]==1]\\n K_cardinalities = np.zeros_like(indexing)\\n for card,w in enumerate(countseq1[::-1]):\\n K_cardinalities[w] = card\\n\\n for w,index in enumerate(indexing):\\n if counts[index] >= 3:\\n S_w_cardinalities[w] = len(image)\\n elif counts[index] == 2:\\n offset = 1 if w==binary_set_mappings[index] else 0\\n S_w_cardinalities[w] = len(image) - 1 + offset\\n elif counts[index] == 1:\\n S_w_cardinalities[w] = countsgeq2 + K_cardinalities[w]\\n\\n return S_w_cardinalities/np.sum(S_w_cardinalities)\",\n \"def calculate_manhattan_dist(state):\",\n \"def calc_H(J, N):\\n\\n H = np.array([[0.0] * 2 ** N for i in range(2 ** N)]) # np.zeros([ 2**N, 2**N]) macht das gleiche\\n max_bin_len = len(bin(2 ** N - 1)[2:]) # need this for 2 -> 010 instead of 10\\n\\n #hier machst du dir viel mühe um die Binären zustände richtig darzustellen....\\n for n in create_n(N):\\n # ... Aber hier sagst du dem interpreter dass er das ganze wieder zu einer zahl machen soll. du kannst den\\n # gleichen Effekt also mit einem einfachen `for n_dec in range(N+1)` erreichen\\n n_dec = int(n, 2) # converts binary to integer\\n\\n for link in ['x', 'y', 'z']:\\n for i in range(N): # loop over the combinations 12, 23 and 31 (repr. as 01, 12, 20)\\n j = i + 1\\n if j == N:\\n j = 0\\n\\n # calculating l\\n new_i = (max_bin_len - 1) - i # need to preprocess i, j and k because the most left site in |01 ... 1>\\n new_j = (max_bin_len - 1) - j # is the most right digit in its binary representation\\n l = n_dec + (1 - 2*int(n[new_i])) * 2 ** i + (1 - 2 * int(n[new_j])) * 2 ** j # no -1 in power because indexing is zero based\\n\\n # bin mir nicht 100% sicher hier, aber ich glaube du brauchst hier gar keine Fallunterscheidung für\\n # x, y und z. weil du ja immer l gleich berechnest kannst du direkt alle Fälle damit füllen, falls die\\n # jeweiligen (vielleicht dann abgeänderten) bedingungen erfüllt sind\\n\\n # inserting matrix elements\\n if link == 'x':\\n H[l, n_dec] += -J[0, i, j] / 4\\n elif link == 'y':\\n if n[i] == n[j]: # check for correct sign in y link\\n H[l, n_dec] += J[1, i, j] / 4\\n else:\\n H[l, n_dec] += -J[1, i, j] / 4\\n else: # z link\\n if n[i] == n[j]: # check for sign\\n H[n_dec, n_dec] += -J[2, i, j] * h / 4\\n else:\\n H[n_dec, n_dec] += J[2, i, j] * h / 4\\n # bei der berechnung oder wertzuweisung von x23 und y23 macht der glaub ich komische sachen, konnte das nicht genau\\n # erkennen. Der rest scheint auf den ersten blick zu funktionieren. bin mir wie gesagt nicht sicher.\\n return H\",\n \"def solution2(n):\\n ones = 0\\n while n > 0:\\n if n & 1:\\n ones += 1\\n n = n >> 1\\n\\n return 0 if ones % 2 == 0 else 1\",\n \"def check_correctness_c01b(f):\\n\\n rng = np.random.RandomState([2013, 5, 6])\\n batch_size = 5\\n rows = 32\\n cols = 30\\n channels = 3\\n pool_rows = 2\\n pool_cols = 3\\n\\n # Do the python ground truth in b01c format\\n zv = rng.randn(batch_size, rows, cols,\\n channels).astype(config.floatX) * 1. - 1.5\\n top_down_v = rng.randn(batch_size, rows / pool_rows, cols / pool_cols,\\n channels).astype(config.floatX)\\n\\n p_np, h_np = max_pool_python(zv, (pool_rows, pool_cols), top_down_v)\\n\\n # Dimshuffle the inputs into c01b for the theano implementation\\n z_th = T.TensorType(broadcastable=(False, False, False, False),\\n dtype = config.floatX)()\\n z_th.tag.test_value = zv\\n z_th.name = 'z_th'\\n zr = z_th.dimshuffle(3, 1, 2, 0)\\n\\n top_down_th = T.TensorType(broadcastable=(False, False, False, False),\\n dtype = config.floatX)()\\n top_down_th.name = 'top_down_th'\\n top_down_th.tag.test_value = top_down_v\\n top_down_r = top_down_th.dimshuffle(3, 1, 2, 0)\\n\\n p_th, h_th = f(zr, (pool_rows, pool_cols), top_down_r)\\n\\n func = function([z_th, top_down_th], [p_th.dimshuffle(3, 1, 2, 0),\\n h_th.dimshuffle(3, 1, 2, 0)])\\n\\n pv, hv = func(zv, top_down_v)\\n\\n if not p_np.shape == pv.shape:\\n raise AssertionError(str((p_np.shape, pv.shape)))\\n assert h_np.shape == hv.shape\\n if not np.allclose(h_np, hv):\\n print((h_np.min(), h_np.max()))\\n print((hv.min(), hv.max()))\\n assert False\\n if not np.allclose(p_np, pv):\\n diff = abs(p_np - pv)\\n print('max diff ', diff.max())\\n print('min diff ', diff.min())\\n print('ave diff ', diff.mean())\\n assert False\\n warnings.warn(\\\"TODO: make sampling tests run on c01b format of pooling.\\\")\",\n \"def ransac_iters(w=0.5, d=min_num_pairs(), z=0.99):\\n\\n return int(np.ceil(np.log(1 - z) / np.log(1 - np.power(w,d))))\",\n \"def get_most_probable_bit_with_thres(filtered_capture, prob_threshold):\\n # Enumerate challenge/responses to build a list of\\n # (probabilities, challenge, value)\\n sorted_prob = []\\n for challenge, response in filtered_capture.items():\\n n0, n1 = response\\n n = n0 + n1\\n if n < MIN_COUNT_FOR_MEANING:\\n # Ignore challenges with not enough measures\\n continue\\n # q0 = ncr(n, n0) * pow(1 - PROB, n0) * pow(PROB, n1)\\n # q1 = ncr(n, n0) * pow(PROB, n0) * pow(1 - PROB, n1)\\n # unnormalize_q0 = pow(1 - PROB, n0) * pow(PROB, n1)\\n # unnormalize_q1 = pow(PROB, n0) * pow(1 - PROB, n1)\\n # p_b0 = unnormalized_q0 / (unnormalized_q1 + unnormalized_q0)\\n # p_b1 = unnormalized_q1 / (unnormalized_q1 + unnormalized_q0)\\n if n >= 500:\\n # Prevent \\\"OverflowError: (34, 'Numerical result out of range')\\\"\\n p_b0 = n0 / (n0 + n1)\\n p_b1 = n1 / (n1 + n0)\\n else:\\n p_b0 = 1. / (1 + pow(PROB / (1 - PROB), n0) * pow((1 - PROB) / PROB, n1))\\n p_b1 = 1. / (1. + pow(PROB / (1 - PROB), n1) * pow((1 - PROB) / PROB, n0))\\n # print(f\\\"[{n0:2}+{n1:2}={n:2}] pb0={p_b0:.3}, pb1={p_b1:.3}\\\")\\n if p_b1 > prob_threshold and p_b1 > p_b0:\\n sorted_prob.append((p_b1, challenge, 1))\\n elif p_b0 > prob_threshold and p_b0 > p_b1:\\n sorted_prob.append((p_b0, challenge, 0))\\n\\n sorted_prob.sort()\\n # print(f\\\"Trying to find a bit out of {len(sorted_prob)} challenges with p>={prob_threshold}...\\\")\\n while sorted_prob:\\n best_prob, best_chall, best_val = sorted_prob.pop()\\n best_count = count_ones(best_chall)\\n if best_count == 1:\\n print(f\\\"Found a bit: {best_chall:#x} = {best_val} (proba {best_prob})\\\")\\n return (best_chall, best_val)\\n\\n # Combine the probabilities\\n for prob, chall, val in sorted_prob.copy():\\n if chall == best_chall:\\n continue\\n # Reduce the masking with XOR\\n if chall & ~best_chall == 0:\\n # Ensure that the masking is reasonable\\n count_xor = count_ones(best_chall ^ chall)\\n if count_xor <= 2 and count_xor < best_count:\\n new_prob = prob * best_prob\\n if new_prob > prob_threshold:\\n sorted_prob.append((new_prob, chall ^ best_chall, val ^ best_val))\\n sorted_prob.sort()\\n\\n print(f\\\"Unable to found a bit with threshold={prob_threshold}\\\")\\n return None\",\n \"def calculate_weighted_results():\\n pass\",\n \"def bitwise_stats(traces, N, delta):\\n \\n X = np.zeros((N,),dtype=int)\\n padded_traces = pad_traces(traces, N)\\n num_traces = padded_traces.shape[0]\\n \\n p = np.zeros(N)\\n for j in range(N):\\n p[j] = np.sum(padded_traces[:,j])/num_traces\\n \\n c = np.concatenate((np.ones(N,), np.zeros(N,)), axis=None)\\n bounds = (0,1)\\n \\n for i in range(N):\\n A_ub = np.zeros((2*N,2*N))\\n for j in range(N):\\n for k in range(N):\\n if j == k:\\n A_ub[j,k] = -1\\n A_ub[j+N,k] = -1\\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\\n elif k > j:\\n A_ub[j,k+N] = alpha(j+1,k+1,delta)\\n A_ub[j+N,k+N] = -1*A_ub[j,k+N]\\n \\n b_ub = np.concatenate((p,-1*p), axis=None)\\n \\n A_eq0 = np.zeros((i+1,2*N))\\n b_eq0 = np.zeros(i+1)\\n for j in range(i+1):\\n A_eq0[j,j+N] = 1\\n if j==i:\\n b_eq0[j] = 0\\n else:\\n b_eq0[j] = X[j]\\n \\n A_eq1 = np.zeros((i+1,2*N))\\n b_eq1 = np.zeros(i+1)\\n for j in range(i+1):\\n A_eq1[j,j+N] = 1\\n if j==i:\\n b_eq1[j] = 1\\n else:\\n b_eq1[j] = X[j]\\n \\n res0 = linprog(c,A_ub,b_ub,A_eq0,b_eq0,bounds,method='interior-point')\\n res1 = linprog(c,A_ub,b_ub,A_eq1,b_eq1,bounds,method='interior-point')\\n if res0.fun < res1.fun:\\n X[i] = 0\\n else:\\n X[i] = 1\\n \\n return X\",\n \"def compute_n_codes(n_bits, half_bit=None):\\n n_bits, half_bit = parse_bits(n_bits, half_bit)\\n if half_bit:\\n return 2**(n_bits + 1) - 1\\n else:\\n return 2**n_bits\",\n \"def afriedmanchisquare(*args):\\r\\n k = len(args)\\r\\n if k < 3:\\r\\n raise ValueError, '\\\\nLess than 3 levels. Friedman test not appropriate.\\\\n'\\r\\n n = len(args[0])\\r\\n data = apply(pstats.aabut,args)\\r\\n data = data.astype(N.float_)\\r\\n for i in range(len(data)):\\r\\n data[i] = arankdata(data[i])\\r\\n ssbn = asum(asum(args,1)**2)\\r\\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\\r\\n return chisq, achisqprob(chisq,k-1)\",\n \"def create_samples(f: Callable[..., int], n_args: int, n_bits: int,\\n) -> Dict[Tuple[int, ...], Tuple[int, ...]]:\\n samples = {}\\n max_arg = 2 ** n_bits\\n for inputs in itertools.product((0, 1), repeat=n_args * n_bits):\\n ints = [int(\\\"\\\".join(str(bit) for bit in inputs[i:i + n_bits]), 2)\\n for i in range(0, len(inputs), n_bits)]\\n try:\\n output = f(*ints)\\n if 0 <= output < max_arg:\\n bit_string = (\\\"{:0\\\" + str(n_bits) + \\\"b}\\\").format(output)\\n samples[inputs] = tuple(int(bit) for bit in bit_string)\\n except ZeroDivisionError:\\n pass\\n return samples\",\n \"def fama2(self, n, weight, nums):\\n ws = {0}\\n for i in range(0, n):\\n ts = set()\\n for j in range(0, nums[i]):\\n for w in ws:\\n ts.add(weight[i] * (j + 1) + w)\\n ws = ws.union(ts)\\n for j in range(0, nums[i]):\\n ws.add(weight[i] * (j + 1))\\n return len(ws)\",\n \"def nac_w_optimal_r(fan_in, fan_out):\\n fan = max(fan_in + fan_out, 5)\\n r = scipy.optimize.bisect(lambda r: fan * nac_w_variance(r) - 2, 0, 10)\\n return r\",\n \"def count_bits(dqxx, n):\\n return sum([check_bit(x, n) for x in dqxx])\",\n \"def SE(H, W):\\n\\n no_real, N, N, K, M = H.shape\\n all_powers = np.swapaxes(np.swapaxes(H, 0, 1) @ hermitian(W), 0, 1)\\n all_powers = np.abs(all_powers) ** 2\\n\\n\\n\\n # (no_real, N, N, K, K)\\n # (no_real, n_t, n, k, k_neighbor)\\n # the power coming from BS n_t to User k in BS n, using the\\n # precoding of BS n_t to user k_neighbor in BS n1\\n\\n\\n p_sig = np.zeros((no_real, N, K))\\n p_int = np.zeros((no_real, N, K, N))\\n sinr = np.zeros_like(p_sig)\\n\\n\\n for r in range(no_real):\\n for n in range(N):\\n for k in range(K):\\n p_sig[r, n, k] = all_powers[r, n, n, k, k]\\n for n_t in range(N):\\n p_int[r, n, k, n_t] = all_powers[r, n_t, n, k].sum()\\n if n_t == n:\\n p_int[r, n, k, n_t] -= p_sig[r,n,k]\\n sinr = p_sig / ((p_int).sum(axis=-1) + 1)\\n return np.log2(1 + sinr), p_sig, p_int\",\n \"def check_sample_correctishness_channelwise(f):\\n\\n batch_size = 27\\n pool_size = 4\\n n = pool_size * 21\\n\\n rng = np.random.RandomState([2012, 9, 26])\\n zv = rng.randn(batch_size, n).astype(config.floatX) * 3.5 - 5.\\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\\n\\n z_th = T.matrix()\\n z_th.tag.test_value = zv\\n z_th.name = 'z_th'\\n\\n top_down_th = T.matrix()\\n top_down_th.tag.test_value = top_down_v\\n top_down_th.name = 'top_down_th'\\n\\n theano_rng = MRG_RandomStreams(rng.randint(2147462579))\\n p_th, h_th, p_sth, h_sth = f(z_th, pool_size, top_down_th, theano_rng)\\n\\n prob_func = function([z_th, top_down_th], [p_th, h_th])\\n pv, hv = prob_func(zv, top_down_v)\\n\\n sample_func = function([z_th, top_down_th], [p_sth, h_sth])\\n\\n acc_p = 0. * pv\\n acc_h = 0. * hv\\n\\n # make sure the test gets good coverage, ie, that it includes\\n # many different activation probs for both detector and pooling layer\\n buckets = 10\\n bucket_width = 1. / float(buckets)\\n print(pv.min(), pv.max())\\n print(hv.min(), hv.max())\\n for i in xrange(buckets):\\n lower_lim = i * bucket_width\\n upper_lim = (i+1) * bucket_width\\n print(lower_lim, upper_lim)\\n\\n assert np.any((pv >= lower_lim) * (pv < upper_lim))\\n assert np.any((hv >= lower_lim) * (hv < upper_lim))\\n\\n assert upper_lim == 1.\\n\\n for i in xrange(10000):\\n ps, hs = sample_func(zv, top_down_v)\\n\\n assert ps.shape == pv.shape\\n assert hs.shape == hv.shape\\n\\n acc_p += ps\\n acc_h += hs\\n\\n est_p = acc_p / float(i+1)\\n est_h = acc_h / float(i+1)\\n\\n pd = np.abs(est_p-pv)\\n hd = np.abs(est_h-hv)\\n\\n \\\"\\\"\\\"\\n # plot maps of the estimation error, this is to see if it has some\\n # spatial pattern this is useful for detecting bugs like not handling\\n # the border correctly, etc.\\n # from pylearn2.gui.patch_viewer import PatchViewer\\n\\n pv = PatchViewer((pd.shape[0],pd.shape[3]),(pd.shape[1],pd.shape[2]),\\n is_color = False)\\n for i in xrange(pd.shape[0]):\\n for j in xrange(pd.shape[3]):\\n pv.add_patch( (pd[i,:,:,j] / pd.max() )* 2.0 - 1.0, rescale = False)\\n pv.show()\\n\\n pv = PatchViewer((hd.shape[0],hd.shape[3]),(hd.shape[1],hd.shape[2]),\\n is_color = False)\\n for i in xrange(hd.shape[0]):\\n for j in xrange(hd.shape[3]):\\n pv.add_patch( (hd[i,:,:,j] / hd.max() )* 2.0 - 1.0, rescale = False)\\n pv.show()\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n plot expectation to estimate versus error in estimation\\n expect bigger errors for values closer to 0.5\\n\\n from matplotlib import pyplot as plt\\n\\n #nelem = reduce( lambda x, y : x*y, pd.shape)\\n #plt.scatter( pv.reshape(nelem), pd.reshape(nelem))\\n #plt.show()\\n\\n nelem = reduce( lambda x, y : x*y, hd.shape)\\n plt.scatter( hv.reshape(nelem), hd.reshape(nelem))\\n plt.show()\\n \\\"\\\"\\\"\\n\\n # don't really know how tight this should be\\n # but you can try to pose an equivalent problem\\n # and implement it in another way\\n # using a numpy implementation in softmax_acc.py\\n # I got a max error of .17\\n assert max(pd.max(), hd.max()) < .17\\n\\n # Do exhaustive checks on just the last sample\\n assert np.all((ps == 0) + (ps == 1))\\n assert np.all((hs == 0) + (hs == 1))\\n\\n for k in xrange(batch_size):\\n for i in xrange(ps.shape[1]):\\n p = ps[k, i]\\n h = hs[k, i*pool_size:(i+1)*pool_size]\\n assert h.shape == (pool_size,)\\n assert p == h.max()\\n assert h.sum() <= 1\\n\\n \\\"\\\"\\\" If you made it to here, it's correctish\\n (cant tell if samples are perfectly \\\"correct\\\") \\\"\\\"\\\"\",\n \"def check_correctness_sigmoid_channelwise(f):\\n\\n rng = np.random.RandomState([2012, 7, 19])\\n batch_size = 5\\n pool_size = 1\\n n = 3 * pool_size\\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\\n\\n z_th = T.matrix()\\n z_th.name = 'z_th'\\n\\n top_down_th = T.matrix()\\n top_down_th.name = 'top_down_th'\\n\\n p_th, h_th = f(z_th, pool_size, top_down_th)\\n h_s = T.nnet.sigmoid(z_th + top_down_th)\\n\\n func = function([z_th, top_down_th], [p_th, h_th, h_s])\\n\\n pv, hv, h_s = func(zv, top_down_v)\\n p_s = h_s\\n\\n assert p_s.shape == pv.shape\\n assert h_s.shape == hv.shape\\n if not np.allclose(h_s, hv):\\n print((h_s.min(), h_s.max()))\\n print((hv.min(), hv.max()))\\n assert False\\n if not np.allclose(p_s, pv):\\n diff = abs(p_s - pv)\\n print('max diff ', diff.max())\\n print('min diff ', diff.min())\\n print('ave diff ', diff.mean())\\n assert False\",\n \"def whack(code, decoder, p, N, C0, error_rate, mC, verbose, argv):\\n\\n errors = []\\n succeeds = [] # put error ops here when we decode them\\n fails = [] # if the decoder is wrong\\n\\n for i in range(N):\\n err_op = ra.binomial(1, p, (code.n,))\\n err_op = err_op.astype(numpy.int32)\\n errors.append(err_op)\\n\\n target_succeed = (1. - error_rate) * N\\n\\n i = 0\\n C = C0\\n\\n while len(succeeds) < target_succeed and len(succeeds)+len(errors) >= target_succeed:\\n\\n err_op = errors[i]\\n\\n # We use Hz to look at X type errors (bitflip errors)\\n\\n write(str(err_op.sum()))\\n\\n s = dot2(code.Hz, err_op)\\n write(\\\":s%d:\\\"%s.sum())\\n\\n op = decoder.decode(p, err_op, C=C, verbose=verbose, argv=argv)\\n\\n c = 'F'\\n success = False\\n if op is None:\\n print(i, \\\"TRY AGAIN\\\")\\n i = i+1\\n\\n else:\\n op = (op+err_op)%2\\n # Should be a codeword of Hz (kernel of Hz)\\n assert dot2(code.Hz, op).sum() == 0\\n write(\\\"%d:\\\"%op.sum())\\n\\n success = code.is_stab(op)\\n c = '.' if success else 'x'\\n\\n errors.pop(i)\\n\\n if success:\\n print(i, \\\"GOOD\\\")\\n succeeds.append(err_op)\\n else:\\n print(i, \\\"BAD\\\")\\n fails.append(err_op)\\n\\n if i==len(errors):\\n i = 0\\n C = int(ceil(C*mC))\\n print((\\\"C = \\\", C))\\n\\n write(c+' ')\\n\\n print(\\\"errors = \\\", len(errors), \\\"succeeds =\\\", len(succeeds), \\\"fails =\\\", len(fails))\\n\\n if len(succeeds) >= target_succeed:\\n print(\\\"SUCCESS\\\")\\n\\n else:\\n assert len(succeeds)+len(errors) < target_succeed\\n print(\\\"FAIL\\\")\\n\\n print()\\n print(datestr)\\n print(argv)\\n print(\\\"error rate = %.8f\\\" % (1.*(len(errors) + len(fails))/N))\\n print(\\\"fail rate = %.8f\\\" % (1.*len(fails) / N))\",\n \"def analyze_bit(key: List[Key],\\n side_length: int,\\n random_bits: str,\\n message_bits: str):\\n # Concatenate the input to get cube input.\\n cube_input = message_bits + random_bits\\n # Initialize the cube.\\n cube = Cube(cube_input=cube_input, cube_side_length=side_length)\\n\\n # Xor, Shift, and apply move onto the cube.\\n for each_key in key:\\n cube.xor()\\n cube.shift_cubie_content()\\n cube.shift(key=each_key)\\n\\n # Count number of zeros and number of ones.\\n return {\\n \\\"0\\\": cube.content.count(\\\"0\\\"),\\n \\\"1\\\": cube.content.count(\\\"1\\\")\\n }\",\n \"def get_hamming_distance(self, calc_bits):\\n\\n # Iterate through calculated bits and compare to received bits.\\n # Store number of different bits in total_distance.\\n total_distance = 0\\n for idx, bit in enumerate(calc_bits):\\n diff = abs(bit - self.received_bits[idx])\\n total_distance += diff\\n\\n return total_distance\",\n \"def getrandbits(k: int) -> int:\\n ...\",\n \"def fwht(X):\\n n = X.shape[0]\\n # number of stages\\n s = (n-1).bit_length()\\n\\n def init1():\\n Y = jnp.empty(X.shape, dtype=X.dtype)\\n A = X[0::2]\\n B = X[1::2]\\n Y = Y.at[0::2].set(A + B)\\n Y = Y.at[1::2].set(A - B)\\n return (Y, 1, 2, 4)\\n\\n def body1(state):\\n # gap between x entries\\n # number of x entries\\n X, count, gap, step = state\\n Y = jnp.empty(X.shape, dtype=X.dtype)\\n J = 0\\n k = 0\\n def body2(state):\\n Y, J, k = state\\n def body3(state):\\n Y, j, k = state\\n # compute the four parts\\n a = X[j]\\n b = X[j+gap]\\n c = X[j+1]\\n d = X[j+1+gap]\\n Y = Y.at[k].set(a+b)\\n Y = Y.at[k+1].set(a-b)\\n Y = Y.at[k+2].set(c-d)\\n Y = Y.at[k+3].set(c+d)\\n return (Y, j+2, k+4)\\n def cond3(state):\\n j = state[1]\\n return j < J+gap-1\\n # the loop\\n init3 = (Y, J, k)\\n Y, j, k = lax.while_loop(cond3, body3, init3)\\n return (Y, J + step, k)\\n\\n def cond2(state):\\n k = state[2]\\n return k < n - 1\\n\\n init2 = Y, J, 0\\n Y, J, k = lax.while_loop(cond2, body2, init2)\\n\\n return (Y, count+1, 2*gap, 2*step)\\n\\n def cond1(state):\\n count = state[1]\\n return count < s\\n\\n state = lax.while_loop(cond1, body1, init1())\\n return state[0]\",\n \"def pertube_distribution_weight(self, random_state, n_samples, multipler):\\n curr_sample_weight = np.ones((n_samples,), dtype=np.float64)\\n indices = _generate_sample_indices(random_state, n_samples)\\n sample_counts = bincount(indices, minlength=n_samples)\\n curr_sample_weight *= np.power(sample_counts, multipler)\\n return curr_sample_weight\",\n \"def measure_all_1(n, state):\\n state = state.copy()\\n\\n outs = ''\\n for i in range(n):\\n out = measure_single(n, state,\\n i) # After measuring bit0, bit0 collapses. It affects the subsequent bit1 measurement, but does not affect the 1000 independent measurements of the upper layer\\n outs = str(out) + outs # from low bit to high bit\\n return outs\",\n \"def binary_dec(A,n_iter = 1000):\\n\\n\\t### Initialization ###\\n\\n\\tp, q = np.shape(A)\\n\\t### B : to be changed\\n\\tB = np.eye(p)\\n \\t###\\n\\tC = bin_random_mat(p,q)\\n\\tlist_dist = []\\n\\tB_argmin = B\\n\\tC_argmin = C\\n\\n\\n\\n\\n\\t## temperature ##\\n\\tT_n = np.log(np.arange(2,n_iter+2,1))\\n\\t#T_n = np.arange(2,n_iter+2,1)\\n\\tfor i in range(n_iter):\\n\\t## update ##\\n\\t\\tC_0 = np.matrix(C)\\n\\t\\tlist_dist =np.append( list_dist, V_potential(np.dot(B,C_0),A) )\\n\\t\\tif V_potential(np.dot(B_argmin,C_argmin),A) == 0:\\n\\t\\t\\tbreak\\n\\t########## transition #############\\n\\t# Here we take 2 steps independent(for B and for C respectively)\\n\\t# We could also use metropolis hasting kernel.\\n\\n\\t\\tC_iter = np.matrix(Metropolis_transition_C(C))\\n\\t\\n\\n\\t\\tB_iter = B[np.random.permutation(np.arange(p))]\\n\\t\\t\\n\\t\\tif np.random.uniform(0,1,1) < \\\\\\n\\t\\t\\t\\tnp.exp(-1./T_n[i]*( V_potential(np.dot(B_iter,C_iter), A)\\\\\\n\\t\\t\\t\\t - V_potential(np.dot(B,C_0),A) ) ):\\n\\t\\t\\tC = C_iter\\n\\t\\t\\tB = B_iter\\n\\t######### end of transition ##############\\n\\n\\t\\t\\tif V_potential(np.dot(B,C),A) < np.min(list_dist):\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tB_argmin = B\\n\\t\\t\\t\\tC_argmin = np.matrix(C)\\n\\t\\t\\t# print i+1\\n\\t\\t\\t# print V_potential(np.dot(B_argmin,C_argmin),A)\\n\\t\\t\\t# print C_argmin\\n\\t\\t\\t# print '\\\\n'\\n\\n\\treturn list_dist,B_argmin, C_argmin\",\n \"def chk_hamming(data):\\n pass\",\n \"def tabulate_score(self):\\n # Generate the bit formatting string\\n n_bits = int(np.ceil(np.log2(self.max_ans)))\\n fmt_str = \\\"{0:0\\\"+str(n_bits)+\\\"b}\\\"\\n \\n # Convert answers to int\\n self.answers = self.answers.astype(np.int64)\\n\\n # Convert each element in answers to a bit string\\n bits = [fmt_str.format(ans) for ans in self.answers]\\n bit_string = \\\"\\\".join(bits)\\n \\n # Convert the combined bit string back to an integer\\n seed = int(bit_string, 2)\\n\\n return seed\",\n \"def fn(x, mask):\\n ans = size = 0 \\n for xx in range(1, 10): \\n if not mask & (1 << xx): \\n if (x, xx) not in mp or mask & 1 << mp[x, xx]: \\n ans += fn(xx, mask^(1<<xx))\\n size += 1\\n size = 9 - size\\n if m <= size <= n: ans += 1\\n return ans\",\n \"def fn(mask, k):\\n if not mask: return 0 \\n ans = inf \\n for i in range(n): \\n if mask & (1<<i): \\n ans = min(ans, (nums1[i]^nums2[k]) + fn(mask^(1<<i), k+1))\\n return ans\",\n \"def getCombination(mu1, mu2, sig1, sig2, confidence1, confidence2):\\n\\tglobal alpha, beta, gamma\\n\\n\\t#Standard Bayesian\\n\\t# sigNew = math.sqrt(math.pow(sig1, 2) + math.pow(sig2, 2))\\n\\t# muNew = u1 + u2\\n\\t# return muNew, sigNew \\n\\n\\t##In accordance with the nature papers:\\n\\tsigNew = (math.pow(sig1,2) * math.pow(sig2, 2)) \\\\\\n\\t/ float((math.pow(sig1,2) + math.pow(sig2, 2)))\\n\\tinv1 = 1 / float((math.pow(sig1, 2)))\\n\\tinv2 = 1 / float((math.pow(sig2, 2)))\\n\\tsumInverses = inv1 + inv2\\n\\n\\t##inverse standard deviations squared\\n\\t# w1 = inv1 / float(sumInverses)\\n\\t# w2 = inv2 / float(sumInverses)\\n\\n\\t## equal weighting\\n\\t# w1 = .5\\n\\t# w2 = .5\\n\\n\\t## weightings based off of confidence\\n\\t# summation = confidence1 + confidence2\\n\\t# w1 = confidence1 / float(summation)\\n\\t# w2 = confidence2 / float(summation)\\n\\n\\t##weightings with exponentials\\n\\t# w1 = w1**.001\\n\\t# w2 = w2**.001\\n\\t# newSummation = w1 + w2\\n\\t# w1 = w1 / float(newSummation)\\n\\t# w2 = w2 / float(newSummation)\\n\\n\\t##weightings with polynomial factors\\n\\tw1 = (beta * confidence1 + alpha)**gamma \\n\\tw2 = (beta * confidence2 + alpha)**gamma \\n\\tnewSummation = w1 + w2\\n\\tw1 = w1 / float(newSummation)\\n\\tw2 = w2 / float(newSummation)\\n\\n\\tmuNew = w1 * mu1 + w2 * mu2\\n\\treturn muNew, sigNew\",\n \"def weights(err):\\n w = np.power(err, -2)\\n w/= np.sum(w)\\n return w\",\n \"def get_response_with_weights(Response,zenith,azimuth,deg=True,binsize=5,cut=60.0,lookup=True):\\n\\n if lookup == True:\\n # look up, no weighting\\n rsp_mean = get_response_from_pixelhit_vector(Response,zenith,azimuth,binsize=binsize,cut=cut)\\n\\n else:\\n \\n # calculate the weighting for neighbouring pixels using their angular distance\\n # also returns the indices of which pixels to be used for response averaging\\n widx = get_response_weights_vector(zenith,azimuth,binsize,cut=cut)\\n # This is a vectorised function so that each entry gets its own weighting\\n # at the correct positions of the input angles ([:, None] is the same as \\n # column-vector multiplcation of a lot of ones)\\n\\n # check for negative weights and indices and remove\\n widx[1][widx[0][:,0,:] < 0] = 0.\\n widx[1][widx[0][:,1,:] < 0] = 0.\\n for i in range(4):\\n widx[0][i,0,widx[0][i,0,:] < 0] = 0.\\n widx[0][i,1,widx[0][i,1,:] < 0] = 0.\\n \\n # one energy bin\\n #print(Response.shape,len(Response.shape))\\n if len(Response.shape) < 4:\\n rsp0 = Response[widx[0][0,1,:],widx[0][0,0,:],:]*widx[1][0,:][:, None]\\n rsp1 = Response[widx[0][1,1,:],widx[0][1,0,:],:]*widx[1][1,:][:, None]\\n rsp2 = Response[widx[0][2,1,:],widx[0][2,0,:],:]*widx[1][2,:][:, None]\\n rsp3 = Response[widx[0][3,1,:],widx[0][3,0,:],:]*widx[1][3,:][:, None]\\n # with energy matrix included\\n elif len(Response.shape) >= 4:\\n rsp0 = Response[widx[0][0,1,:],widx[0][0,0,:],:,:,:]*widx[1][0,:][:, None, None, None]\\n rsp1 = Response[widx[0][1,1,:],widx[0][1,0,:],:,:,:]*widx[1][1,:][:, None, None, None]\\n rsp2 = Response[widx[0][2,1,:],widx[0][2,0,:],:,:,:]*widx[1][2,:][:, None, None, None]\\n rsp3 = Response[widx[0][3,1,:],widx[0][3,0,:],:,:,:]*widx[1][3,:][:, None, None, None]\\n else:\\n print('How this should really not happen ...')\\n \\n rsp_mean = rsp0 + rsp1 + rsp2 + rsp3\\n\\n # return response\\n return rsp_mean\",\n \"def compute_disturbances(n_bits, data_ref, data_test, num_bootstrap_samples=20,\\n max_weight=4, solver=\\\"SCS\\\", verbosity=1, add_one_to_data=True):\\n dist_ml, dist = compute_disturbances_bootstrap_rawdata(\\n n_bits, data_ref, data_test, num_bootstrap_samples,\\n max_weight, solver, verbosity, add_one_to_data=add_one_to_data)\\n return compute_disturbances_from_bootstrap_rawdata(dist_ml, dist)\",\n \"def check_correctness_channelwise(f):\\n\\n rng = np.random.RandomState([2012, 7, 19])\\n batch_size = 5\\n pool_size = 4\\n n = 3 * pool_size\\n zv = rng.randn(batch_size, n).astype(config.floatX) * 1. - 1.5\\n top_down_v = rng.randn(batch_size, n / pool_size).astype(config.floatX)\\n\\n p_np, h_np = max_pool_channels_python(zv, pool_size, top_down_v)\\n\\n z_th = T.matrix()\\n z_th.name = 'z_th'\\n\\n top_down_th = T.matrix()\\n top_down_th.name = 'top_down_th'\\n\\n p_th, h_th = f(z_th, pool_size, top_down_th)\\n\\n func = function([z_th, top_down_th], [p_th, h_th])\\n\\n pv, hv = func(zv, top_down_v)\\n\\n assert p_np.shape == pv.shape\\n assert h_np.shape == hv.shape\\n if not np.allclose(h_np, hv):\\n print((h_np.min(), h_np.max()))\\n print((hv.min(), hv.max()))\\n assert False\\n if not np.allclose(p_np, pv):\\n diff = abs(p_np - pv)\\n print('max diff ', diff.max())\\n print('min diff ', diff.min())\\n print('ave diff ', diff.mean())\\n assert False\",\n \"def solution(N):\\n\\tresult = 0\\n\\tcounter = 0\\n\\n\\tbin_number = \\\"{0:b}\\\".format(N)\\n\\n\\tfor num in bin_number:\\n\\t\\tif num == \\\"1\\\":\\n\\t\\t\\tif counter > result:\\n\\t\\t\\t\\tresult = counter\\n\\t\\t\\tcounter = 0\\n\\t\\telse:\\n\\t\\t\\tcounter += 1\\n\\n\\treturn result;\",\n \"def bits(self):\\n if not self.group_list:\\n return 0.0\\n # TODO: Is it worth to cache the overall result?\\n return self.bits_except_last + self.group_list[-1].bits\",\n \"def test_an_bn_1(self):\\n n = 0\\n w = 2.1\\n kz = 3.e-5\\n tp = 2.e3 \\n tz = 100.\\n vthz = 6.1e4\\n omega = 0.34\\n vz = 3.4e3\\n \\n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\\n an, bn = an/w, bn/w\\n npt.assert_allclose(an, -1.9218850625427564 + 5.595463531399411j,\\n rtol=1e-7)\\n npt.assert_allclose(bn, -102817.6686637071 + 391682.4471979587j,\\n rtol=1e-7)\\n\\n w = 0.03\\n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\\n an, bn = an/w, bn/w\\n npt.assert_allclose(an, 631.2715006824648 - 46.41868239430783j,\\n rtol=1e-7)\\n npt.assert_allclose(bn, 551271.5006824646 - 46418.68239430781j,\\n rtol=1e-7)\\n \\n n, w = 5, 0.03\\n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\\n an, bn = an/w, bn/w\\n npt.assert_allclose(bn, 1.6137363813074678e6 + 2.3743306625716157e7j,\\n rtol=1e-7)\\n npt.assert_allclose(an, -30.426402059415523 - 426.52646633023045j,\\n rtol=1e-7)\\n\\n n, w, kz, vthz = 20, 3.7, 0.11, 0.35\\n an, bn = f_abn(n, w, kz, tz, tp, vthz, omega, vz, method='numpy')\\n an, bn = an/w, bn/w\\n npt.assert_allclose(an, -0.26539669257210097 -0.0j, \\\\\\n rtol=1e-7)\\n npt.assert_allclose(bn, -902.3486484918872 + 0.0j,\\\\\\n rtol=1e-7)\",\n \"def _kuhn_munkres_algorithm(true_lab, pred_lab):\\n nclass = len(set(true_lab))\\n nobs = len(true_lab)\\n wmat = np.zeros((nclass, nclass))\\n for lab in range(nclass):\\n for plab in range(lab, nclass):\\n n_intersec = len(set(np.transpose(np.argwhere(true_lab == lab))[0]).intersection(\\n set(np.transpose(np.argwhere(pred_lab == plab))[0])))\\n w = (nobs - n_intersec) / nobs\\n if lab == plab:\\n wmat[lab, plab] = w\\n else:\\n wmat[lab, plab] = w\\n n_intersec = len(set(np.transpose(np.argwhere(true_lab == plab))[0]).intersection(\\n set(np.transpose(np.argwhere(pred_lab == lab))[0])))\\n w = (nobs - n_intersec) / nobs\\n wmat[plab, lab] = w\\n new_pred_lab = list(linear_sum_assignment(wmat)[1])\\n # print(f'Recode: {new_pred_lab}')\\n # print(f'From matrix: {wmat}')\\n pred_perm = np.array([new_pred_lab.index(i) for i in pred_lab])\\n\\n return pred_perm\",\n \"def bits(n):\\n\\n # Create a list of the first 1,000 binary numbers\\n binary_list = reverse_binary_list()\\n\\n # Start by calculating number of 1's for n\\n n_ones = num_of_ones(n, binary_list)\\n\\n # Calculate number of 1's for next value\\n next_ones = 0\\n while n_ones != next_ones:\\n n = n + 1\\n next_ones = num_of_ones(n, binary_list)\\n\\n return(n)\",\n \"def check_correctness_bc01(f):\\n\\n rng = np.random.RandomState([2012, 7, 19])\\n batch_size = 5\\n rows = 32\\n cols = 30\\n channels = 3\\n pool_rows = 2\\n pool_cols = 3\\n zv = rng.randn(batch_size, rows, cols,\\n channels).astype(config.floatX) * 1. - 1.5\\n top_down_v = rng.randn(batch_size, rows / pool_rows, cols / pool_cols,\\n channels).astype(config.floatX)\\n\\n p_np, h_np = max_pool_python(zv, (pool_rows, pool_cols), top_down_v)\\n\\n z_th = T.TensorType(broadcastable=(False, False, False, False),\\n dtype = config.floatX)()\\n z_th.name = 'z_th'\\n zr = z_th.dimshuffle(0, 3, 1, 2)\\n\\n top_down_th = T.TensorType(broadcastable=(False, False, False, False),\\n dtype = config.floatX)()\\n top_down_th.name = 'top_down_th'\\n top_down_r = top_down_th.dimshuffle(0, 3, 1, 2)\\n\\n p_th, h_th = f(zr, (pool_rows, pool_cols), top_down_r)\\n\\n func = function([z_th, top_down_th], [p_th.dimshuffle(0, 2, 3, 1),\\n h_th.dimshuffle(0, 2, 3, 1)])\\n\\n pv, hv = func(zv, top_down_v)\\n\\n assert p_np.shape == pv.shape\\n assert h_np.shape == hv.shape\\n if not np.allclose(h_np, hv):\\n print((h_np.min(), h_np.max()))\\n print((hv.min(), hv.max()))\\n assert False\\n if not np.allclose(p_np, pv):\\n diff = abs(p_np - pv)\\n print('max diff ', diff.max())\\n print('min diff ', diff.min())\\n print('ave diff ', diff.mean())\\n assert False\",\n \"def bits_loss(msg, output, message_length):\\n return reconstruction_loss(msg, output) * message_length\",\n \"def compute_disturbances_bootstrap_rawdata(n_bits, data_ref, data_test, num_bootstrap_samples=20,\\n max_weight=4, solver=\\\"SCS\\\", verbosity=1, seed=0,\\n return_resampled_data=False, add_one_to_data=True):\\n #p_ml = _np.array(data_ref) / _np.sum(data_ref)\\n #q_ml = _np.array(data_test) / _np.sum(data_test)\\n\\n if verbosity > 0:\\n print(\\\"Computing base disturbances\\\")\\n dist_by_weight_ml = compute_disturbances_with_confidence(\\n n_bits, data_ref, data_test, None, max_weight, solver=solver, verbosity=verbosity - 1)\\n\\n dist_by_weight = _np.zeros((max_weight, num_bootstrap_samples), 'd')\\n resampled_data = []\\n\\n bootstrap_data_ref = data_ref + _np.ones(len(data_ref), dtype='int')\\n bootstrap_data_test = data_test + _np.ones(len(data_test), dtype='int')\\n\\n for i in range(num_bootstrap_samples):\\n if verbosity > 0:\\n print(\\\"Analyzing bootstrap sample %d of %d...\\\" % (i + 1, num_bootstrap_samples), end='')\\n _sys.stdout.flush(); tStart = _time.time()\\n redata_ref = resample_data(bootstrap_data_ref, seed=seed + i)\\n redata_test = resample_data(bootstrap_data_test, seed=seed + num_bootstrap_samples + i)\\n if return_resampled_data:\\n resampled_data.append((redata_ref, redata_test))\\n\\n try:\\n disturbances = compute_disturbances_with_confidence(\\n n_bits, redata_ref, redata_test, None, max_weight, solver=solver, verbosity=verbosity - 2)\\n except Exception:\\n try:\\n if verbosity > 0: print(\\\"\\\\nFalling back on ECOS\\\")\\n disturbances = compute_disturbances_with_confidence(\\n n_bits, redata_ref, redata_test, None, max_weight, solver=\\\"ECOS\\\", verbosity=verbosity - 2)\\n except Exception:\\n if verbosity > 0: print(\\\"\\\\nFailed using %s and ECOS - reporting nans\\\" % solver)\\n for w in range(max_weight):\\n dist_by_weight[w, i] = _np.nan\\n\\n for w in range(max_weight):\\n dist_by_weight[w, i] = disturbances[w][0]\\n\\n if verbosity > 0:\\n print(\\\" (%.1fs)\\\" % (_time.time() - tStart))\\n\\n dist_ml = _np.array([dist_by_weight_ml[w][0] for w in range(max_weight)], 'd')\\n\\n if return_resampled_data:\\n return dist_ml, dist_by_weight, resampled_data\\n else:\\n return dist_ml, dist_by_weight\",\n \"def hpint_perm(n):\\n c_new = []\\n D_new = []\\n H_new = []\\n for i in range(2 ** n - 1):\\n c_new_i = np.zeros((n, 1))\\n binStr = bin(i + 1)[2:]\\n for j in range(len(binStr)):\\n c_new_i[n - 1 - j][0] = int(binStr[len(binStr) - 1 - j])\\n c_new.append(c_new_i)\\n D_new_i = np.diag(np.transpose(c_new_i)[0])\\n D_new.append(D_new_i)\\n H_new_i = np.diag(np.transpose(c_new_i * (-2) + 1)[0])\\n H_new.append(H_new_i)\\n\\n return c_new, D_new, H_new\",\n \"def andbits(num1,num2):\\n thingstoadd=[]\\n for i in range(31):\\n bit1=setbit(num1,i)\\n bit2=setbit(num2,i)\\n bit1=shiftleft(bit1,30 - i)\\n bit2=shiftleft(bit2,30 - i)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n bitsum=shiftright(bitsum,31 - i)\\n thingstoadd.append(bitsum)\\n bit1=setbit(num1,31)\\n bit2=setbit(num2,31)\\n bit1=shiftright(bit1,1)\\n bit2=shiftright(bit2,1)\\n bitsum=add(bit1,bit2)\\n bitsum=setbit(bitsum,31)\\n thingstoadd.append(bitsum)\\n return sum(thingstoadd)\",\n \"def potential_witnesses(n):\\n if n < 1373653: return [2, 3] # n < 1,373,653\\n if n < 9080191: return [31, 73] # n < 9,080,191\\n if n < 4759123141: return [2, 7, 61] # n < 4,759,123,141\\n if n < 2152302898747: return [2, 3, 5, 7, 11] # n < 2,152,302,898,747\\n if n < 3474749660383: return [2, 3, 5, 7, 11, 13] # n < 3,474,749,660,383\\n if n < 341550071728321: return [2, 3, 5, 7, 11, 13, 17] # n < 341,550,071,728,321\\n return [random.randint(1,n-1) for _ in xrange(0,20)] # 99.999999999909051% (1 - .25**20) accuracy for n >= 341,550,071,728,321\",\n \"def hamming_byte(bin1, bin2):\\n\\n diffs = 0\\n xored = xor(bin1, bin2)\\n for byte in xored:\\n diffs += bin(byte).count(\\\"1\\\")\\n return diffs\",\n \"def test_RULE_110():\\n\\tk, outputs = 3, [0,1,1,1,0,1,1,0]\\n\\n\\ttrue_pi0s = set(['200','111'])\\n\\ttrue_pi1s = set(['021','201','012','210'])\\n\\n\\ttdt0, tdt1 = make_transition_density_tables(k=k, outputs=outputs)\\n\\tpi0s, pi1s = find_implicants_qm(tdt0) , find_implicants_qm(tdt1)\\n\\n\\tassert (pi0s == true_pi0s) , ('Prime Implicants for 0 does not match. %s != %s' % (pi0s,true_pi0s))\\n\\tassert (pi1s == true_pi1s) , ('Prime Implicants for 1 does not match. %s != %s' % (pi1s,true_pi1s))\\n\\t# Two Symbols\\n\\ttrue_ts0s = [('200',[],[[1,2]]),('111',[],[[0,1,2]])]\\n\\ttrue_ts1s = [('201',[[0,1]],[]),('012',[[1,2]],[]),('201',[[1,2]],[]),('012',[[0,2]],[])]\\n\\n\\tts0s,ts1s = find_two_symbols_v2(k=k, prime_implicants=pi0s) , find_two_symbols_v2(k=k, prime_implicants=pi1s)\\n\\n\\tassert (ts0s == true_ts0s) , ('Two Symbol for 0 does not match. %s != %s' % (ts0s,true_ts0s))\\n\\tassert (ts1s == true_ts1s) , ('Two Symbol for 1 does not match. %s != %s' % (ts1s,true_ts1s))\",\n \"def bin_contribution_(bin_weights, card_dataset, sample_contributions):\\n bin_weight = np.sum([w for _, w in bin_weights])\\n return bin_weight / card_dataset * np.abs(np.sum(sample_contributions))\",\n \"def b_n(n):\\n if n <= 0.36: # MCH03\\n ei = np.array([0, 1, 2, 3, 4])\\n ai = np.array([0.01945, -0.8902, 10.95, -19.67, 13.43])\\n else: # CB99\\n ei = np.array([1, 0, -1, -2])\\n ai = np.array([2, -1./3, 4./405, 46./25515])\\n return np.sum(ai * np.power(float(n), ei))\",\n \"def challenge_solver(number1, number2, threshold):\\n return (sum_of_n_terms(number1, threshold)\\n + sum_of_n_terms(number2, threshold)\\n - sum_of_n_terms(number1 * number2, threshold))\",\n \"def combination(num_m: int, num_n: int) -> int:\\n if num_m < num_n:\\n return 0\\n\\n tmp_m = 1\\n tmp_n = 1\\n tmp_cnt = 0\\n for i in range(num_n, 0, -1):\\n tmp_n *= i\\n tmp_m *= num_m - tmp_cnt\\n tmp_cnt += 1\\n\\n return tmp_m / tmp_n\",\n \"def hamming_dist(bytes1, bytes2):\\n if type(bytes1) == str:\\n bytes1 = [ord(c) for c in str1]\\n if type(bytes2) == str:\\n bytes2 = [ord(c) for c in str2]\\n bins = [bin(o1 ^ o2) for o1, o2 in zip(bytes1, bytes2)]\\n return len([i for i in ''.join(bins) if i == '1'])\",\n \"def tadbit(x, n_cpus=1, verbose=True, max_tad_size=\\\"max\\\",\\n no_heuristic=False, get_weights=False, use_visibility=False):\\n nums, size = read_matrix(x)\\n n_cpus = n_cpus if n_cpus != 'max' else 0\\n max_tad_size = size if max_tad_size is \\\"auto\\\" else max_tad_size\\n _, nbks, passages, _, _, bkpts, weights = \\\\\\n _tadbit_wrapper(nums, # list of lists representing matrices\\n size, # size of one row/column\\n len(nums), # number of matrices\\n n_cpus, # number of threads\\n int(verbose), # verbose 0/1\\n max_tad_size, # max_tad_size\\n int(no_heuristic), # heuristic 0/1\\n int(use_visibility) # TODO: remove this\\n )\\n\\n breaks = [i for i in xrange(size) if bkpts[i + nbks * size] == 1]\\n scores = [p for p in passages if p > 0]\\n\\n result = {'start': [], 'end' : [], 'score': []}\\n for brk in xrange(len(breaks)+1):\\n result['start'].append((breaks[brk-1] + 1) if brk > 0 else 0)\\n result['end' ].append(breaks[brk] if brk < len(breaks) else size - 1)\\n result['score'].append(scores[brk] if brk < len(breaks) else None)\\n\\n if get_weights:\\n # in tadbit we are not using directly weights, but the\\n # multiplication by the real value\\n tadbit_weights = [[i/j if j else 0.0 for i, j in\\n zip(nums[k], weights[k])] for k in xrange(len(nums))]\\n if use_visibility:\\n total = sum(nums[0])\\n tadbit_weights = [[t*total for t in tadbit_weights[0]]]\\n return result, tadbit_weights\\n return result\",\n \"def bin_cdf(n, p, x):\\n\\n # p C (bin_dist) ** 0 ) *(1-bin_dist)** p\\n\\n # n = (p)=20\\n # x = x = 1 = r\\n # nCr = n! / r!(n-r)\\n\\n \\n\\n\\n\\n\\n\\n\\n\\n\\n def bin_dist(n, p, x):\\n \\\"\\\"\\\"\\n Given n number of trials, p the probability of success,\\n what is the probability of having x successes?\\n\\n Your function should raise a ValueError if x is higher\\n than n.\\n\\n If you need to compute combinations, you can import the\\n function \\\"comb\\\" from the package \\\"scipy.special\\\"\\n\\n :param n: number of trials (int)\\n :param p: probability of success\\n :param x: number of successes (int)\\n :return: probability of having x successes\\n :rtype: float\\n :raise ValueError: if x > n\\n \\\"\\\"\\\"\\n def factorial(x):\\n if x >= 0:\\n \\n factorial = 1\\n\\n for i in range(1, x + 1):\\n factorial = float(factorial * i)\\n # print(f' The factorial of {x} is {factorial}') \\n return factorial\\n\\n else:\\n raise ValueError(\\\"Sorry x cannot be a negative number\\\")\\n\\n def combination(n, r):\\n \\\"\\\"\\\"\\n Given n total number of items,\\n what is the number of possible ways\\n to choose r items from it?\\n\\n :param n: total number of items (integer)\\n :param r: number of items to arrange (int)\\n :return: number of combinations\\n :rtype: integer\\n \\\"\\\"\\\"\\n\\n \\n\\n \\n numerator = factorial(n)\\n denominator = factorial(r)\\n subtracted_answer = factorial(n-r)\\n \\n\\n answer = numerator/(denominator * subtracted_answer)\\n print(answer)\\n return answer \\n\\n # from scipy.special import comb\\n if x > n:\\n raise ValueError(\\\"Error, x must be less than n\\\")\\n else:\\n\\n\\n prob_success = float((combination(n, x)) * ((p**x)*((1-p)**(n-x))))\\n\\n print(prob_success)\\n return prob_success \\n \\n # an= 1-bin_dist(n,p,x)\\n # print(f'word{an}')\\n # n= 12\\n # p=0.25\\n # # x=0??\\n # ((n!)/ (x!*(n-x)!)) * (p**x) * (1-p)**(n-x)\\n sum_prob = []\\n for i in range(x+1):\\n print(i)\\n prob = bin_dist(n,p,x=i)\\n sum_prob.append(prob)\\n print(sum_prob)\\n total =sum(sum_prob)\\n print(total)\",\n \"def get_witnesses(n):\\n assert (n > 2) and (n % 2 == 1)\\n if n < 2047:\\n # References: [1], [2], [4]\\n witnesses = (2,)\\n elif n < 1373653: # ~1.3 million\\n # References: [1], [2], [3], [4]\\n witnesses = (2, 3)\\n elif n < 9080191: # ~9.0 million\\n # References: [3], [4]\\n witnesses = (31, 73)\\n elif n < 25326001: # ~25.3 million\\n # References: [1], [2], [3], [4]\\n witnesses = (2, 3, 5)\\n elif n < 3215031751: # ~3.2 billion\\n # References: [1], [2], [3], [4]\\n witnesses = (2, 3, 5, 7)\\n elif n < 4759123141: # ~4.7 billion\\n # References: [3], [4]\\n witnesses = (2, 7, 61)\\n elif n < 2152302898747: # ~2.1 trillion\\n # References: [1], [2], [3], [4]\\n witnesses = (2, 3, 5, 7, 11)\\n elif n < 3474749660383: # ~3.4 trillion\\n # References: [1], [2], [3], [4]\\n witnesses = (2, 3, 5, 7, 11, 13)\\n elif n < 341550071728321: # ~341.5 trillion\\n # References: [1], [2], [3], [4]\\n witnesses = (2, 3, 5, 7, 11, 13, 17)\\n elif n < 3825123056546413051: # ~3.8 million trillion\\n # References: [1], [4]\\n witnesses = (2, 3, 5, 7, 11, 13, 17, 19, 23)\\n elif n <= 2**64:\\n witnesses = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37)\\n else:\\n witnesses = None\\n \\n return witnesses\",\n \"def fn(i, j, mask):\\n if j == n: return 1 \\n if i == m: return fn(0, j+1, mask)\\n ans = 0 \\n for x in 1<<2*i, 1<<2*i+1, 0b11<<2*i: \\n mask0 = mask ^ x\\n if mask0 & 0b11<<2*i and (i == 0 or (mask0 >> 2*i) & 0b11 != (mask0 >> 2*i-2) & 0b11): \\n ans += fn(i+1, j, mask0)\\n return ans % 1_000_000_007\",\n \"def countbrute(m):\\n nfound=0\\n\\n for i in range(1,m+1):\\n for j in range(1,i+1):\\n for k in range(1,j+1):\\n d1=i*i+(j+k)*(j+k) \\n if(checkpsq(d1)):\\n nfound=nfound+1\\n\\n return nfound\",\n \"def calBitLen(n, p):\\n m = int(-(n*math.log(p))/BloomFilter.ln2p2)\\n # round up to 32 bits\\n if m%32: m += (32-m%32)\\n return m\",\n \"def dimensions_hamming(m: int) -> Tuple[int, int]:\\n\\n n = np.power(2, m) - 1\\n k = n-m\\n\\n return n, k\",\n \"def __biweight(data):\\n mask = np.isfinite(data)\\n if np.all(~mask):\\n return (np.nan, 0.)\\n\\n xx = data[mask]\\n med_xx = np.median(xx)\\n deltas = xx - med_xx\\n med_dd = np.median(np.abs(deltas))\\n if med_dd == 0:\\n return (med_xx, 0.)\\n\\n wmx = np.maximum(0, 1 - (deltas / (6 * med_dd)) ** 2) ** 2\\n xbi = med_xx + np.sum(wmx * deltas) / np.sum(wmx)\\n\\n umn = np.minimum(1, (deltas / (9 * med_dd)) ** 2)\\n sbi = np.sum(deltas ** 2 * (1 - umn) ** 4)\\n sbi /= np.sum((1 - umn) * (1 - 5 * umn)) ** 2\\n sbi = np.sqrt(len(xx) * sbi)\\n\\n return (xbi, sbi)\",\n \"def calculate_bleu(candidate, reference):\\n pn_sum = 0\\n for n in range(1, 4):\\n cand_grama, ref_grama = n_grama(candidate, n), n_grama(reference, n)\\n p = calculate_p(cand_grama, ref_grama)\\n if p != 0:\\n # If there are no matches between n_grams,\\n # don't add nothing\\n pn_sum += (0.33 * math.log(p))\\n bp = calculate_bp_penality(candidate, reference)\\n return bp * math.exp(pn_sum)\",\n \"def mw_test(n1, n2):\\r\\n # find smaller sample, defined historically as n2. modify the names so we\\r\\n # don't risk modifying data outside the scope of the function.\\r\\n if len(n2) > len(n1):\\r\\n sn1, sn2 = array(n2), array(n1)\\r\\n else:\\r\\n sn1, sn2 = array(n1), array(n2)\\r\\n # sum the ranks of s2 by using the searchsorted magic. the logic is that we\\r\\n # use a sorted copy of the data from both groups (n1 and n2) to figure out\\r\\n # at what index we would insert the values from sample 2. by assessing the\\r\\n # difference between the index that value x would be inserted in if we were\\r\\n # doing left insertion versus right insertion, we can tell how many values\\r\\n # are tied with x. this allows us to calculate the average ranks easily.\\r\\n data = sorted(hstack([sn1, sn2]))\\r\\n ssl = searchsorted(data, sn2, 'left')\\r\\n ssr = searchsorted(data, sn2, 'right')\\r\\n sum_sn2_ranks = ((ssl + ssr + 1) / 2.).sum()\\r\\n ln1, ln2 = sn1.size, sn2.size\\r\\n C = (ln1 * ln2) + (ln2 * (ln2 + 1) / 2.) - sum_sn2_ranks\\r\\n U = max(C, ln1 * ln2 - C)\\r\\n # now we calculate the pvalue using the normal approximation and the two\\r\\n # tailed test. our formula corrects for ties, because in the case where\\r\\n # there are no ties, the forumla on the bottom of pg 429=the formula on the\\r\\n # bottom of pg 430.\\r\\n numerator = (U - ln1 * ln2 / 2.)\\r\\n # follwing three lines give the T value in the formula on page 430. same\\r\\n # logic as above; we calculate the left and right indices of the unique\\r\\n # values for all combined data from both samples, then calculate ti**3-ti\\r\\n # for each value.\\r\\n ux = unique(data)\\r\\n uxl = searchsorted(data, ux, 'left')\\r\\n uxr = searchsorted(data, ux, 'right')\\r\\n T = _corr_kw(uxr - uxl).sum()\\r\\n denominator = sqrt(((ln1 * ln2) / float((ln1 + ln2) * (ln1 + ln2 - 1))) * (((ln1 + ln2) ** 3\\r\\n - (ln1 + ln2) - T) / 12.))\\r\\n if denominator == 0:\\r\\n # Warning: probability of U can't be calculated by mw_test\\r\\n # because all ranks of data were tied. Returning nan as pvalue.\\r\\n return U, nan\\r\\n else:\\r\\n pval = zprob(numerator / float(denominator))\\r\\n return U, pval\",\n \"def combination(n, r):\\n\\n \\n\\n \\n numerator = factorial(n)\\n denominator = factorial(r)\\n subtracted_answer = factorial(n-r)\\n \\n\\n answer = numerator/(denominator * subtracted_answer)\\n print(answer)\\n return answer\",\n \"def womcom(hop,num,weights):\\n import logging\\n import matplotlib.pyplot as plt\\n import numpy as np\\n from tmath.wombat.inputter import inputter\\n from tmath.wombat import HOPSIZE\\n hopnum=[0]\\n weight=[0]\\n while (hopnum[0] < 1) or (hopnum[0] > HOPSIZE):\\n hopnum[0]=inputter('Enter first hopper: ','int',False)\\n if (weights):\\n weight[0]=inputter('Enter weight for first hopper: ','float',False)\\n for i in range(1,num):\\n hoploop=0\\n weightloop=0\\n if (num > 3):\\n print('Use hopper 99 to end')\\n while (hoploop < 1) or (hoploop > HOPSIZE):\\n hoploop=inputter('Enter next hopper: ','int',False)\\n if (hoploop == 99):\\n break\\n if (hoploop == 99):\\n break\\n if (hop[hopnum[0]].wave[0] != hop[hoploop].wave[0]) or \\\\\\n (hop[hopnum[0]].wave[1] != hop[hoploop].wave[1]) or \\\\\\n (hop[hopnum[0]].wave[-1] != hop[hoploop].wave[-1]):\\n print('Hoppers to not have the same wavelength scale!')\\n return hop\\n hopnum.append(hoploop)\\n if (weights):\\n weightloop=inputter('Enter next weight: ','float',False)\\n weight.append(weightloop)\\n if (weights) and (abs(sum(weight)-1.0) > 0.00001):\\n print('Weights do not add to 1.0')\\n return hop\\n if (not weights):\\n weight=[1./len(hopnum)]*len(hopnum)\\n newflux=np.zeros(len(hop[hopnum[0]].flux))\\n logging.debug('Combining spectra:')\\n \\n for i in range(0,len(hopnum)):\\n newflux=newflux+hop[hopnum[i]].flux*weight[i]\\n logging.debug('Combining {} with weight {}'.format(hop[hopnum[i]].obname,\\\\\\n weight[i]))\\n hopout=0\\n while (hopout < 1) or (hopout > HOPSIZE):\\n hopout=inputter('Enter hopper to store combined spectrum: ','int',False)\\n hop[hopout].wave=hop[hopnum[0]].wave.copy()\\n hop[hopout].flux=newflux.copy()\\n hop[hopout].obname=hop[hopnum[0]].obname\\n hop[hopout].header=hop[hopnum[0]].header\\n hop[hopout].var=hop[hopnum[0]].var.copy()\\n plt.cla()\\n plt.plot(hop[hopout].wave,hop[hopout].flux,drawstyle='steps-mid',color='k')\\n plt.xlabel('Wavelength')\\n plt.ylabel('Flux')\\n plt.title(hop[hopout].obname)\\n xmin,xmax=plt.xlim()\\n ymin,ymax=plt.ylim()\\n print('\\\\nPlotting combined spectrum in black, components in color\\\\n')\\n for i in range(0,len(hopnum)):\\n plt.plot(hop[hopnum[i]].wave,hop[hopnum[i]].flux,drawstyle='steps-mid')\\n plt.xlim([xmin,xmax])\\n plt.ylim([ymin,ymax])\\n \\n #FIX var\\n return hop\",\n \"def test_bin_addition():\\n outcome1 = Outcome(\\\"red\\\", 1)\\n outcome2 = Outcome(\\\"black\\\", 1)\\n outcome3 = Outcome(\\\"low\\\", 5)\\n outcome4 = Outcome(\\\"high\\\", 5)\\n\\n rng = NonRandom()\\n wheel = Wheel(rng)\\n\\n wheel.addOutcome(1, outcome1)\\n wheel.addOutcome(1, outcome3)\\n wheel.addOutcome(31, outcome2)\\n wheel.addOutcome(31, outcome4)\\n\\n # since we added only two outcomes for each of the two bins,\\n # the number of outcomes for both bins should be 2 and 0 for all others\\n wheel.rng.setSeed(1)\\n returned_bin = wheel.next()\\n outcomes = returned_bin.outcomes\\n print outcomes\\n assert len(outcomes) == 2\\n assert outcome1 in returned_bin.outcomes\\n assert outcome3 in returned_bin.outcomes\\n\\n wheel.rng.setSeed(31)\\n returned_bin = wheel.next()\\n assert outcome3, outcome2 in returned_bin.outcomes\\n assert outcome3, outcome4 in returned_bin.outcomes\\n\\n for i in range(0, 38):\\n if i not in [1, 31]:\\n wheel.rng.setSeed(i)\\n returned_bin = wheel.next()\\n assert len(returned_bin.outcomes) == 0\",\n \"def measure_partial(qubit, bits, format='sympy', normalize=True):\\n m = qubit_to_matrix(qubit, format)\\n\\n if isinstance(bits, (SYMPY_INTS, Integer)):\\n bits = (int(bits),)\\n\\n if format == 'sympy':\\n if normalize:\\n m = m.normalized()\\n\\n possible_outcomes = _get_possible_outcomes(m, bits)\\n\\n # Form output from function.\\n output = []\\n for outcome in possible_outcomes:\\n # Calculate probability of finding the specified bits with\\n # given values.\\n prob_of_outcome = 0\\n prob_of_outcome += (outcome.H*outcome)[0]\\n\\n # If the output has a chance, append it to output with found\\n # probability.\\n if prob_of_outcome != 0:\\n if normalize:\\n next_matrix = matrix_to_qubit(outcome.normalized())\\n else:\\n next_matrix = matrix_to_qubit(outcome)\\n\\n output.append((\\n next_matrix,\\n prob_of_outcome\\n ))\\n\\n return output\\n else:\\n raise NotImplementedError(\\n \\\"This function cannot handle non-SymPy matrix formats yet\\\"\\n )\",\n \"def gen_samp_hammersley(self, i1, i2, m, n, vectorized = True):\\n dist = self.dist\\n \\n def hammersley_sequence (i1, i2, m, n):\\n \\n \\n if ( i1 <= i2 ):\\n i3 = +1\\n else:\\n i3 = -1\\n \\n l = abs ( i2 - i1 ) + 1\\n r = np.zeros ( [ m, l ] )\\n k = 0\\n \\n for i in range ( i1, i2 + i3, i3 ):\\n \\n t = np.ones ( m - 1 )\\n \\n t = t * i\\n #\\n # Carry out the computation.\\n #\\n prime_inv = np.zeros ( m - 1 )\\n for j in range ( 0, m - 1 ):\\n prime_inv[j] = 1.0 / prime ( j )\\n \\n r[0,k] = float ( i % ( n + 1 ) ) / float ( n )\\n \\n while ( 0 < np.sum ( t ) ):\\n for j in range ( 0, m - 1 ):\\n d = ( t[j] % prime ( j ) )\\n r[j+1,k] = r[j+1,k] + float ( d ) * prime_inv[j]\\n prime_inv[j] = prime_inv[j] / prime ( j )\\n t[j] = ( t[j] // prime ( j ) )\\n \\n k = k + 1\\n \\n return r\\n \\n def prime (n):\\n \\n from sys import exit\\n \\n prime_max = 1600\\n \\n prime_vector = np.array ( [\\n 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, \\\\\\n 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, \\\\\\n 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, \\\\\\n 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, \\\\\\n 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, \\\\\\n 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, \\\\\\n 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, \\\\\\n 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, \\\\\\n 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, \\\\\\n 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, \\\\\\n 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, \\\\\\n 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, \\\\\\n 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, \\\\\\n 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, \\\\\\n 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, \\\\\\n 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, \\\\\\n 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, \\\\\\n 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, \\\\\\n 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, \\\\\\n 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, \\\\\\n 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, \\\\\\n 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, \\\\\\n 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, \\\\\\n 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, \\\\\\n 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, \\\\\\n 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, \\\\\\n 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, \\\\\\n 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, \\\\\\n 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, \\\\\\n 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, \\\\\\n 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, \\\\\\n 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, \\\\\\n 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, \\\\\\n 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, \\\\\\n 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, \\\\\\n 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, \\\\\\n 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, \\\\\\n 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, \\\\\\n 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, \\\\\\n 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, \\\\\\n 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, \\\\\\n 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, \\\\\\n 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, \\\\\\n 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, \\\\\\n 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, \\\\\\n 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, \\\\\\n 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, \\\\\\n 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, \\\\\\n 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, \\\\\\n 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, \\\\\\n 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, \\\\\\n 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, \\\\\\n 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, \\\\\\n 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, \\\\\\n 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, \\\\\\n 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, \\\\\\n 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, \\\\\\n 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, \\\\\\n 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, \\\\\\n 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, \\\\\\n 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, \\\\\\n 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, \\\\\\n 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, \\\\\\n 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, \\\\\\n 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, \\\\\\n 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, \\\\\\n 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, \\\\\\n 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, \\\\\\n 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, \\\\\\n 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, \\\\\\n 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, \\\\\\n 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, \\\\\\n 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, \\\\\\n 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, \\\\\\n 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, \\\\\\n 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, \\\\\\n 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, \\\\\\n 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, \\\\\\n 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, \\\\\\n 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, \\\\\\n 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, \\\\\\n 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, \\\\\\n 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, \\\\\\n 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, \\\\\\n 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, \\\\\\n 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, \\\\\\n 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, \\\\\\n 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, \\\\\\n 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, \\\\\\n 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, \\\\\\n 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, \\\\\\n 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, \\\\\\n 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, \\\\\\n 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, \\\\\\n 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, \\\\\\n 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, \\\\\\n 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, \\\\\\n 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, \\\\\\n 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, \\\\\\n 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, \\\\\\n 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, \\\\\\n 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, \\\\\\n 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, \\\\\\n 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, \\\\\\n 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, \\\\\\n 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, \\\\\\n 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, \\\\\\n 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, \\\\\\n 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, \\\\\\n 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, \\\\\\n 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, \\\\\\n 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, \\\\\\n 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, \\\\\\n 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, \\\\\\n 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, \\\\\\n 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, \\\\\\n 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, \\\\\\n 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, \\\\\\n 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, \\\\\\n 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, \\\\\\n 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, \\\\\\n 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, \\\\\\n 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973,10007, \\\\\\n 10009,10037,10039,10061,10067,10069,10079,10091,10093,10099, \\\\\\n 10103,10111,10133,10139,10141,10151,10159,10163,10169,10177, \\\\\\n 10181,10193,10211,10223,10243,10247,10253,10259,10267,10271, \\\\\\n 10273,10289,10301,10303,10313,10321,10331,10333,10337,10343, \\\\\\n 10357,10369,10391,10399,10427,10429,10433,10453,10457,10459, \\\\\\n 10463,10477,10487,10499,10501,10513,10529,10531,10559,10567, \\\\\\n 10589,10597,10601,10607,10613,10627,10631,10639,10651,10657, \\\\\\n 10663,10667,10687,10691,10709,10711,10723,10729,10733,10739, \\\\\\n 10753,10771,10781,10789,10799,10831,10837,10847,10853,10859, \\\\\\n 10861,10867,10883,10889,10891,10903,10909,10937,10939,10949, \\\\\\n 10957,10973,10979,10987,10993,11003,11027,11047,11057,11059, \\\\\\n 11069,11071,11083,11087,11093,11113,11117,11119,11131,11149, \\\\\\n 11159,11161,11171,11173,11177,11197,11213,11239,11243,11251, \\\\\\n 11257,11261,11273,11279,11287,11299,11311,11317,11321,11329, \\\\\\n 11351,11353,11369,11383,11393,11399,11411,11423,11437,11443, \\\\\\n 11447,11467,11471,11483,11489,11491,11497,11503,11519,11527, \\\\\\n 11549,11551,11579,11587,11593,11597,11617,11621,11633,11657, \\\\\\n 11677,11681,11689,11699,11701,11717,11719,11731,11743,11777, \\\\\\n 11779,11783,11789,11801,11807,11813,11821,11827,11831,11833, \\\\\\n 11839,11863,11867,11887,11897,11903,11909,11923,11927,11933, \\\\\\n 11939,11941,11953,11959,11969,11971,11981,11987,12007,12011, \\\\\\n 12037,12041,12043,12049,12071,12073,12097,12101,12107,12109, \\\\\\n 12113,12119,12143,12149,12157,12161,12163,12197,12203,12211, \\\\\\n 12227,12239,12241,12251,12253,12263,12269,12277,12281,12289, \\\\\\n 12301,12323,12329,12343,12347,12373,12377,12379,12391,12401, \\\\\\n 12409,12413,12421,12433,12437,12451,12457,12473,12479,12487, \\\\\\n 12491,12497,12503,12511,12517,12527,12539,12541,12547,12553, \\\\\\n 12569,12577,12583,12589,12601,12611,12613,12619,12637,12641, \\\\\\n 12647,12653,12659,12671,12689,12697,12703,12713,12721,12739, \\\\\\n 12743,12757,12763,12781,12791,12799,12809,12821,12823,12829, \\\\\\n 12841,12853,12889,12893,12899,12907,12911,12917,12919,12923, \\\\\\n 12941,12953,12959,12967,12973,12979,12983,13001,13003,13007, \\\\\\n 13009,13033,13037,13043,13049,13063,13093,13099,13103,13109, \\\\\\n 13121,13127,13147,13151,13159,13163,13171,13177,13183,13187, \\\\\\n 13217,13219,13229,13241,13249,13259,13267,13291,13297,13309, \\\\\\n 13313,13327,13331,13337,13339,13367,13381,13397,13399,13411, \\\\\\n 13417,13421,13441,13451,13457,13463,13469,13477,13487,13499 ] )\\n \\n if ( n < 0 or prime_max <= n ):\\n print ( '' )\\n print ( 'PRIME - Fatal error!' )\\n print ( ' 0 <= N < %d' % ( prime_max ) )\\n exit ( 'PRIME - Fatal error!' )\\n \\n return prime_vector[n] \\n \\n hamm_seq = hammersley_sequence(i1, i2, m, n)\\n samp = dist.ppf(hamm_seq)\\n \\n if vectorized == False:\\n return(samp)\\n \\n else: \\n samp = samp.reshape(1, -1)\\n return(samp)\",\n \"def binning():\\n def r(x):\\n return 1 << (x & 7)\\n\\n def w(x):\\n return 0x11 * (x >> 1)\\n return r, w\",\n \"def _getKramerStatistic_(seq, n, F):\\n S = 0.0\\n for i in range(n):\\n S += (F(seq[i]) - (2 * i - 1) / (2 * n)) ** 2\\n return 1 / (12 * n) + S\",\n \"def check_sample_correctishness_bc01(f):\\n\\n batch_size = 5\\n rows = 32\\n cols = 30\\n channels = 3\\n pool_rows = 2\\n pool_cols = 3\\n\\n rng = np.random.RandomState([2012, 9, 26])\\n zv = rng.randn(batch_size, channels, rows,\\n cols).astype(config.floatX) * 2. - 3.\\n top_down_v = rng.randn(batch_size, channels, rows / pool_rows,\\n cols / pool_cols).astype(config.floatX)\\n\\n z_th = T.TensorType(broadcastable=(False, False, False, False),\\n dtype = config.floatX)()\\n z_th.tag.test_value = zv\\n z_th.name = 'z_th'\\n\\n top_down_th = T.TensorType(broadcastable=(False, False, False, False),\\n dtype = config.floatX)()\\n top_down_th.tag.test_value = top_down_v\\n top_down_th.name = 'top_down_th'\\n\\n theano_rng = MRG_RandomStreams(rng.randint(2147462579))\\n p_th, h_th, p_sth, h_sth = f(z_th, (pool_rows, pool_cols), top_down_th,\\n theano_rng)\\n\\n prob_func = function([z_th, top_down_th], [p_th, h_th])\\n pv, hv = prob_func(zv, top_down_v)\\n\\n sample_func = function([z_th, top_down_th], [p_sth, h_sth])\\n\\n acc_p = 0. * pv\\n acc_h = 0. * hv\\n\\n # make sure the test gets good coverage, ie, that it includes many\\n # different activation probs for both detector and pooling layer\\n buckets = 10\\n bucket_width = 1. / float(buckets)\\n for i in xrange(buckets):\\n lower_lim = i * bucket_width\\n upper_lim = (i+1) * bucket_width\\n\\n assert np.any((pv >= lower_lim) * (pv < upper_lim))\\n assert np.any((hv >= lower_lim) * (hv < upper_lim))\\n\\n assert upper_lim == 1.\\n\\n for i in xrange(10000):\\n ps, hs = sample_func(zv, top_down_v)\\n\\n assert ps.shape == pv.shape\\n assert hs.shape == hv.shape\\n\\n acc_p += ps\\n acc_h += hs\\n\\n est_p = acc_p / float(i+1)\\n est_h = acc_h / float(i+1)\\n\\n pd = np.abs(est_p-pv)\\n hd = np.abs(est_h-hv)\\n\\n \\\"\\\"\\\"\\n # plot maps of the estimation error, this is to see if it has some\\n # spatial pattern this is useful for detecting bugs like not handling\\n # the border correctly, etc.\\n from pylearn2.gui.patch_viewer import PatchViewer\\n\\n pv = PatchViewer((pd.shape[0],pd.shape[3]),(pd.shape[1],pd.shape[2]),\\n is_color = False)\\n for i in xrange(pd.shape[0]):\\n for j in xrange(pd.shape[3]):\\n pv.add_patch( (pd[i,:,:,j] / pd.max() )* 2.0 - 1.0, rescale = False)\\n pv.show()\\n\\n pv = PatchViewer((hd.shape[0],hd.shape[3]), (hd.shape[1],hd.shape[2]),\\n is_color = False)\\n for i in xrange(hd.shape[0]):\\n for j in xrange(hd.shape[3]):\\n pv.add_patch( (hd[i,:,:,j] / hd.max() )* 2.0 - 1.0, rescale = False)\\n pv.show()\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n plot expectation to estimate versus error in estimation\\n expect bigger errors for values closer to 0.5\\n\\n from matplotlib import pyplot as plt\\n\\n #nelem = reduce( lambda x, y : x*y, pd.shape)\\n #plt.scatter( pv.reshape(nelem), pd.reshape(nelem))\\n #plt.show()\\n\\n nelem = reduce( lambda x, y : x*y, hd.shape)\\n plt.scatter( hv.reshape(nelem), hd.reshape(nelem))\\n plt.show()\\n \\\"\\\"\\\"\\n\\n # don't really know how tight this should be\\n # but you can try to pose an equivalent problem\\n # and implement it in another way\\n # using a numpy implementation in softmax_acc.py\\n # I got a max error of .17\\n assert max(pd.max(), hd.max()) < .17\\n\\n # Do exhaustive checks on just the last sample\\n assert np.all((ps == 0) + (ps == 1))\\n assert np.all((hs == 0) + (hs == 1))\\n\\n for k in xrange(batch_size):\\n for i in xrange(ps.shape[2]):\\n for j in xrange(ps.shape[3]):\\n for l in xrange(channels):\\n p = ps[k, l, i, j]\\n h = hs[k, l, i*pool_rows:(i+1)*pool_rows,\\n j*pool_cols:(j+1)*pool_cols]\\n assert h.shape == (pool_rows, pool_cols)\\n assert p == h.max()\\n assert h.sum() <= 1\\n\\n \\\"\\\"\\\" If you made it to here, it's correctish\\n (cant tell if samples are perfectly \\\"correct\\\") \\\"\\\"\\\"\",\n \"def bits_to_probabilities(\\n all_qubits: Sequence[Tuple[int, int]],\\n subsys_qubits: Sequence[Tuple[int, int]],\\n bits: np.ndarray,\\n) -> np.ndarray:\\n num_qubits = len(subsys_qubits)\\n indices = [all_qubits.index(q) for q in subsys_qubits]\\n bits_red = np.asarray(bits[:, indices], dtype=int)\\n for i in range(num_qubits):\\n bits_red[:, i] *= 2 ** (num_qubits - i - 1)\\n bits = list(np.sum(bits_red, axis=1))\\n p_reduced = np.bincount(bits, minlength=2 ** num_qubits)\\n num_trials, _ = bits_red.shape\\n return p_reduced / num_trials\",\n \"def ideal_fanin(k, m):\\n fanin = 0\\n needed = k\\n for select in range(3, m + 1, 2):\\n combinations = list(itertools.combinations(range(m), select))\\n if len(combinations) <= needed:\\n fanin += int(math.ceil(float(len(combinations) * select) / m))\\n needed -= len(combinations)\\n else:\\n fanin += int(math.ceil(float(needed * select) / m))\\n needed = 0\\n if not needed:\\n break\\n return fanin\",\n \"def solve_brute_force(n: int, W: int, weight: List[int], value: List[int]) -> int:\\n mapped_items = [{\\\"w\\\": w, \\\"v\\\": v} for i, (w, v) in enumerate(zip(weight, value))]\\n\\n maximum_value: int = 0\\n updated: bool = False\\n for i in range(1, n + 1):\\n if i > 1 and not updated:\\n break\\n\\n updated = False\\n for chosen_items in list(combinations(mapped_items, i)):\\n sum_weight = 0\\n sum_value = 0\\n for item in chosen_items:\\n sum_weight += item[\\\"w\\\"]\\n sum_value += item[\\\"v\\\"]\\n\\n if sum_weight <= W and maximum_value < sum_value:\\n updated = True\\n maximum_value = sum_value\\n return maximum_value\",\n \"def sol(n):\\n p = 1\\n res = 0\\n \\n while n:\\n p*=5\\n if n&1:\\n res+=p\\n n=n>>1\\n return res%1000000007\",\n \"def witHelp(x):\\n t = 0\\n while not (x & 1):\\n x >>= 1\\n t += 1\\n return (t, x)\",\n \"def _build_basis_slow(weight, n_bits):\\n _warnings.warn((\\\"You're using a slow version of the basis-building code used by the disturbance calculations\\\"\\n \\\" - compile pyGSTi's C extensions to make this go faster.\\\"))\\n n_w = n_parameters_per_matrix(weight, n_bits)\\n n_a = n_matrices_per_weight(weight, n_bits)\\n dim = 2**n_bits\\n\\n my_basis = []\\n my_constraints = []\\n # All sets of qubits of given weight on n_bits\\n pairs = list(_itertools.combinations(_np.arange(n_bits), weight))\\n\\n for ind in range(n_w * n_a):\\n v = unit_vector(ind, n_w * n_a)\\n vs = _np.reshape(v, (n_a, n_w))\\n ctm = sum((swell_slow(transition_matrix(v, 2**weight), pair, n_bits)\\n for v, pair in zip(vs, pairs))) - n_a * _np.eye(dim)\\n my_basis += [ctm]\\n my_constraints += [-_np.diag(ctm)]\\n\\n return my_basis, _np.array(my_constraints, dtype='int').T\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.616687","0.588979","0.5826358","0.58103514","0.5805173","0.5767479","0.5664263","0.5663091","0.5662125","0.56533957","0.5645126","0.56185484","0.556853","0.55329996","0.54994404","0.5493898","0.546257","0.544698","0.5440642","0.5435228","0.5425672","0.5416836","0.5409518","0.5394075","0.5371623","0.53548694","0.5344113","0.53328395","0.53167206","0.5290786","0.52878106","0.5281823","0.52670896","0.52551806","0.52529347","0.52527213","0.52400225","0.5237468","0.5227709","0.5225048","0.5214091","0.52066976","0.5199137","0.51936245","0.518049","0.5176013","0.5172791","0.5167706","0.51667875","0.51626885","0.5157304","0.5149492","0.5140231","0.5131771","0.51110184","0.50999266","0.5095935","0.50949866","0.50907874","0.5089035","0.50803256","0.50789213","0.50784487","0.5076599","0.5075732","0.507365","0.507182","0.50663716","0.5062342","0.5059517","0.50525063","0.50512624","0.50506765","0.50491023","0.50486976","0.5045908","0.5042583","0.50408196","0.5037855","0.50309247","0.50185543","0.50156367","0.5014597","0.5011607","0.5010831","0.5007441","0.5006901","0.50033396","0.49995175","0.4998371","0.49975052","0.49900565","0.4987406","0.49871865","0.49859095","0.49841636","0.49786964","0.4976279","0.49749452","0.49729738"],"string":"[\n \"0.616687\",\n \"0.588979\",\n \"0.5826358\",\n \"0.58103514\",\n \"0.5805173\",\n \"0.5767479\",\n \"0.5664263\",\n \"0.5663091\",\n \"0.5662125\",\n \"0.56533957\",\n \"0.5645126\",\n \"0.56185484\",\n \"0.556853\",\n \"0.55329996\",\n \"0.54994404\",\n \"0.5493898\",\n \"0.546257\",\n \"0.544698\",\n \"0.5440642\",\n \"0.5435228\",\n \"0.5425672\",\n \"0.5416836\",\n \"0.5409518\",\n \"0.5394075\",\n \"0.5371623\",\n \"0.53548694\",\n \"0.5344113\",\n \"0.53328395\",\n \"0.53167206\",\n \"0.5290786\",\n \"0.52878106\",\n \"0.5281823\",\n \"0.52670896\",\n \"0.52551806\",\n \"0.52529347\",\n \"0.52527213\",\n \"0.52400225\",\n \"0.5237468\",\n \"0.5227709\",\n \"0.5225048\",\n \"0.5214091\",\n \"0.52066976\",\n \"0.5199137\",\n \"0.51936245\",\n \"0.518049\",\n \"0.5176013\",\n \"0.5172791\",\n \"0.5167706\",\n \"0.51667875\",\n \"0.51626885\",\n \"0.5157304\",\n \"0.5149492\",\n \"0.5140231\",\n \"0.5131771\",\n \"0.51110184\",\n \"0.50999266\",\n \"0.5095935\",\n \"0.50949866\",\n \"0.50907874\",\n \"0.5089035\",\n \"0.50803256\",\n \"0.50789213\",\n \"0.50784487\",\n \"0.5076599\",\n \"0.5075732\",\n \"0.507365\",\n \"0.507182\",\n \"0.50663716\",\n \"0.5062342\",\n \"0.5059517\",\n \"0.50525063\",\n \"0.50512624\",\n \"0.50506765\",\n \"0.50491023\",\n \"0.50486976\",\n \"0.5045908\",\n \"0.5042583\",\n \"0.50408196\",\n \"0.5037855\",\n \"0.50309247\",\n \"0.50185543\",\n \"0.50156367\",\n \"0.5014597\",\n \"0.5011607\",\n \"0.5010831\",\n \"0.5007441\",\n \"0.5006901\",\n \"0.50033396\",\n \"0.49995175\",\n \"0.4998371\",\n \"0.49975052\",\n \"0.49900565\",\n \"0.4987406\",\n \"0.49871865\",\n \"0.49859095\",\n \"0.49841636\",\n \"0.49786964\",\n \"0.4976279\",\n \"0.49749452\",\n \"0.49729738\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70478463"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":742,"numItemsPerPage":100,"numTotalItems":95772,"offset":74200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjY5NzQyOCwianRpIjoiMGUwMWU0OGEtZGMxOS00ZmFjLWI0ZjMtNjViZDE3ZjAwNGViIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY3MDEwMjgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.jNVuC1LKBP1OJsHZu6Xv6zuLTGmEeTAHPtIMilCEQEnhH7y_zhj5Wqpq-VWeReU4UNtn0aU9mC4drCPtHA0TBw","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 |
|---|---|---|---|---|---|---|
Retrieve link to persistance mechanism | def _link(self):
return self._interface(self.fspath) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getLink(self):",
"def getNoteStoreUrl(self, authenticationToken):\r\n pass",
"def getLink(self):\n return self.link",
"def get_url(self):\n return self.db_url",
"def url(self):\n return self.storage.url(self.name)",
"def link(self):\n \n self.__enter__()\n ... | [
"0.66899043",
"0.6360058",
"0.6057088",
"0.60436183",
"0.5956282",
"0.59523934",
"0.59127355",
"0.5892777",
"0.5855571",
"0.5855571",
"0.5855571",
"0.5832151",
"0.5825213",
"0.5808694",
"0.5808694",
"0.5795157",
"0.5773146",
"0.57467055",
"0.5686189",
"0.5640394",
"0.5640394"... | 0.53345376 | 39 |
Populate the index from a sql table | def load(cls, table_name: str, index_col: str = "operator"):
# df = Operator_Table.df
# df.operator = df.operator.apply(sp.normalize)
# df.operator_alias = df.operator_alias.apply(sp.normalize)
# df = df.rename(columns={"operator_alias": "alias"})
try:
import models
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_index():",
"def build_index():\n pass",
"def build_index(self):\n \n \n geoids = self.partitions.find_or_new(table='facilities_geoids')\n addresses = self.partitions.find_or_new(table='facilities_addresses')\n facilities = self.partitions.find(table='facilities'... | [
"0.7213231",
"0.6684144",
"0.65098643",
"0.6441818",
"0.6408963",
"0.63851833",
"0.6318164",
"0.6292551",
"0.62921697",
"0.62792414",
"0.6179801",
"0.617612",
"0.610432",
"0.60891044",
"0.6074349",
"0.6074349",
"0.6042582",
"0.5986674",
"0.5965966",
"0.59287876",
"0.592021",
... | 0.5452085 | 76 |
Look for an exact match for the target string in a list of all operator names. If found, returns the alias for that name. Otherwise, returns None. | def lookup(self, target: str) -> pd.Series:
try:
# self.refresh()
result = pd.Series(name=target)
if target is not None:
result = self.loc[target].copy()
if result.ndim > 1:
result = result.max()
result[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fuzzy_match(self, other):\n magic, fuzzy = False, False\n try:\n magic = self.alias == other.magic\n except AttributeError:\n pass\n\n if '.' in self.alias:\n major = self.alias.split('.')[0]\n fuzzy = major == other.alias \n return... | [
"0.600872",
"0.5476128",
"0.5431273",
"0.53964996",
"0.5336919",
"0.53155607",
"0.5303619",
"0.5226297",
"0.52201563",
"0.51875824",
"0.5180949",
"0.51748854",
"0.5127156",
"0.51046616",
"0.50755596",
"0.5064597",
"0.5043313",
"0.5024844",
"0.5005249",
"0.49946284",
"0.499088... | 0.54977614 | 2 |
Attempt to fuzzy match the target string to an operator name using the given scorer function. The alias for the match with the highest score is returned. If a match with a score above the cutoff is not found, None is returned | def _fuzzy_match(
self, target: str, scorer=None, score_cutoff=85, limit=1
) -> pd.Series:
scorer = scorer or self.default_scorer()
# result = pd.Series(name = target)
extracted: list = process.extractBests(
target, self.operator, scorer=scorer, limit=limit, score_cutof... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fuzzy_match(object, answer, threshold=80):\n answer_phrase = generate_ngrams(answer)\n if answer_phrase:\n best_match = [fuzz.ratio(object, phr) for phr in answer_phrase]\n if np.max(best_match)>threshold:\n return np.max(best_match), answer_phrase[np.argmax(best_match)]\n ... | [
"0.6589819",
"0.64425164",
"0.58997977",
"0.58632153",
"0.58299005",
"0.56999075",
"0.5664272",
"0.5549336",
"0.5484873",
"0.5475975",
"0.53234446",
"0.53025043",
"0.52954453",
"0.52909315",
"0.5284119",
"0.5278062",
"0.5250008",
"0.5246519",
"0.51911473",
"0.51895994",
"0.51... | 0.71131057 | 2 |
Get updated records from the database | def refresh(self):
new = self.table.records_updated_since(self.updated.max()).set_index("operator")
new = new.rename(columns={"operator_alias": "alias", "fscore": "confidence"})
if not new.empty: # TODO: this is clunky. need to fix later
self.update(new)
for idx, values... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updates(self, request, version):\n task = EtlTask.objects.get_for_model(self.queryset.model)\n if task.last_changes:\n offset = task.last_changes.strftime(\"%Y-%m-%d %H:%M\")\n queryset = self.queryset.filter(last_modify_date__gte=offset)\n else:\n offset =... | [
"0.6702553",
"0.6538225",
"0.6296629",
"0.6269668",
"0.62084794",
"0.6174577",
"0.61277586",
"0.6011581",
"0.59838617",
"0.59722775",
"0.59722775",
"0.59722775",
"0.59113353",
"0.5910794",
"0.59095263",
"0.58913016",
"0.5880948",
"0.5802331",
"0.57978505",
"0.5750909",
"0.574... | 0.5467505 | 53 |
Assess the distance between the names of the underlying operators produce a mean distance from one another. If their mean distance surpasses a certain threshold, divide the operator names at the mean and rename the alias of those aliases in the group with the larger mean. (Alternatively, classify with sklean to find a ... | def diverge(cls, alias1: str):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def group_evaluation(ops, mut):\n\n center = ops[0]\n min_distortion = distortion([ops[0]], ops, mut)\n for i in ops:\n tmp = distortion([i], ops, mut)\n if tmp < min_distortion:\n center = i\n min_distortion = tmp\n return center",
"def eval_mean_distance(played_d... | [
"0.5520021",
"0.50843334",
"0.5065839",
"0.4932081",
"0.4928756",
"0.49083254",
"0.48984692",
"0.48236924",
"0.4807179",
"0.48032764",
"0.47765797",
"0.4763124",
"0.47613123",
"0.4753312",
"0.47391325",
"0.47310758",
"0.47147945",
"0.46967348",
"0.46832567",
"0.46761087",
"0.... | 0.0 | -1 |
Populate the index from a json file. | def load(cls, path: str):
df = pd.read_json(path, convert_dates=["updated", "created"])
df = FileIndex(data=df, path=path)
if "operator" in df.columns:
df = df.set_index("operator")
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self, json_file, target_index='infinity'):\n # data = json.loads(json_file)\n with open(json_file) as f:\n data = json.load(f)\n self.elasticsearch.index(index=target_index, doc_type='image_vector', body=data)",
"def load_index_from_cache(self):\n cache = open... | [
"0.747001",
"0.6945988",
"0.6746498",
"0.6735094",
"0.66761446",
"0.66439533",
"0.6639118",
"0.6610646",
"0.62583476",
"0.61591774",
"0.61463624",
"0.6078079",
"0.6065206",
"0.6014596",
"0.60142374",
"0.5997697",
"0.5977178",
"0.59698784",
"0.59464496",
"0.5944197",
"0.594263... | 0.62580574 | 9 |
Save Index to file | def save(self) -> None:
try:
js = json.loads(
self.reset_index().to_json(orient="records", date_format="iso")
)
with open(self._fp, "w") as f:
f.writelines(json.dumps(js, indent=4))
logger.debug(f"Saved index to {self._fp}")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\n self.index.saveIndex(c.index_path('hnsw.index'))\n joblib.dump(self.ys, \"%s.ys\" % self.index_file_prefix)",
"def writeindextofile(index):\n writetofile(index[0], \"invertedindex1\")\n writetofile(index[1], \"invertedindex2\")\n writetofile(index[2], \"invertedindex3\")\... | [
"0.8103557",
"0.7670749",
"0.76576316",
"0.760385",
"0.75967723",
"0.73518753",
"0.7314572",
"0.72119933",
"0.7082714",
"0.7073918",
"0.7024572",
"0.7007928",
"0.6977166",
"0.6963725",
"0.69155496",
"0.686387",
"0.68256783",
"0.67764086",
"0.67097294",
"0.66410786",
"0.661986... | 0.7216647 | 7 |
Look for an exact match for the target string in a list of all operator names. If found, returns the alias for that name. Otherwise, returns None. | def lookup(self, target: str) -> pd.Series:
try:
# self.refresh()
result = pd.Series(name=target)
if target is not None:
result = self.loc[target].copy()
if result.ndim > 1:
result = result.max()
result[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fuzzy_match(self, other):\n magic, fuzzy = False, False\n try:\n magic = self.alias == other.magic\n except AttributeError:\n pass\n\n if '.' in self.alias:\n major = self.alias.split('.')[0]\n fuzzy = major == other.alias \n return... | [
"0.60058826",
"0.5474259",
"0.54306984",
"0.5395898",
"0.5336259",
"0.5314073",
"0.5303197",
"0.5225841",
"0.52174765",
"0.51858866",
"0.51789933",
"0.51755756",
"0.5125417",
"0.5103533",
"0.5076306",
"0.50645787",
"0.50409764",
"0.5024462",
"0.5001895",
"0.4993382",
"0.49906... | 0.54979354 | 3 |
Attempt to fuzzy match the target string to an operator name using the given scorer function. The alias for the match with the highest score is returned. If a match with a score above the cutoff is not found, None is returned | def _fuzzy_match(
self, target: str, scorer=None, score_cutoff=85, limit=1
) -> pd.Series:
scorer = scorer or self.default_scorer()
# result = pd.Series(name = target)
extracted: list = process.extractBests(
target, self.operator, scorer=scorer, limit=limit, score_cutof... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fuzzy_match(object, answer, threshold=80):\n answer_phrase = generate_ngrams(answer)\n if answer_phrase:\n best_match = [fuzz.ratio(object, phr) for phr in answer_phrase]\n if np.max(best_match)>threshold:\n return np.max(best_match), answer_phrase[np.argmax(best_match)]\n ... | [
"0.659055",
"0.64439535",
"0.59002095",
"0.5863153",
"0.5831834",
"0.5701473",
"0.5665831",
"0.5550824",
"0.54848444",
"0.5475604",
"0.5324608",
"0.53036016",
"0.52972806",
"0.5290554",
"0.5284169",
"0.52791375",
"0.5251146",
"0.52473545",
"0.5191728",
"0.51911855",
"0.518684... | 0.71132505 | 1 |
Get updated records from the database | def refresh(self):
new = self.table.records_updated_since(self.updated.max()).set_index("operator")
new = new.rename(columns={"operator_alias": "alias", "fscore": "confidence"})
if not new.empty: # TODO: this is clunky. need to fix later
self.update(new)
for idx, values... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updates(self, request, version):\n task = EtlTask.objects.get_for_model(self.queryset.model)\n if task.last_changes:\n offset = task.last_changes.strftime(\"%Y-%m-%d %H:%M\")\n queryset = self.queryset.filter(last_modify_date__gte=offset)\n else:\n offset =... | [
"0.6702509",
"0.6538232",
"0.6296598",
"0.62696797",
"0.62084246",
"0.61745894",
"0.61277264",
"0.6011599",
"0.5983865",
"0.59722954",
"0.59722954",
"0.59722954",
"0.5911353",
"0.5910805",
"0.59094757",
"0.5891323",
"0.58809704",
"0.5802351",
"0.579783",
"0.5750917",
"0.57492... | 0.5467523 | 54 |
Assess the distance between the names of the underlying operators produce a mean distance from one another. If their mean distance surpasses a certain threshold, divide the operator names at the mean and rename the alias of those aliases in the group with the larger mean. (Alternatively, classify with sklean to find a ... | def diverge(cls, alias1: str):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def group_evaluation(ops, mut):\n\n center = ops[0]\n min_distortion = distortion([ops[0]], ops, mut)\n for i in ops:\n tmp = distortion([i], ops, mut)\n if tmp < min_distortion:\n center = i\n min_distortion = tmp\n return center",
"def eval_mean_distance(played_d... | [
"0.55205715",
"0.5083899",
"0.50661826",
"0.4933381",
"0.49283728",
"0.49085572",
"0.4898324",
"0.4822347",
"0.4807188",
"0.48029503",
"0.4775096",
"0.47633815",
"0.4761373",
"0.4752688",
"0.47391406",
"0.472966",
"0.47146857",
"0.46963546",
"0.46840042",
"0.46775493",
"0.467... | 0.0 | -1 |
Populate the index from a sql table. | def load(cls):
df = Operator_Table.df
df.operator = df.operator.apply(sp.normalize)
df.operator_alias = df.operator_alias.apply(sp.normalize)
df = df.rename(columns={"operator_alias": "alias"})
return SQLIndex(data=df).set_index("operator") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_index():",
"def build_index():\n pass",
"def create_new_index(self, dict_pg_info):\n # ! Setting if fun can use default setting\n ruler = Rules()\n str_conn = ruler.pg_info_rules(dict_pg_info)\n conn = psycopg2.connect(str_conn)\n\n with conn:\n with ... | [
"0.6368501",
"0.6023515",
"0.59747756",
"0.59641385",
"0.5937889",
"0.592518",
"0.590878",
"0.5883567",
"0.5831351",
"0.58310884",
"0.5824989",
"0.5792725",
"0.5674515",
"0.56426316",
"0.5632395",
"0.5627473",
"0.5621183",
"0.5617214",
"0.5617214",
"0.5613995",
"0.55791384",
... | 0.61137277 | 1 |
Merge result into the database | def save(cls, result: pd.Series) -> None:
result = result.rename(
{"name": "operator", "alias": "operator_alias", "fscore": "confidence"}
)
result = result.to_frame().T[
["operator", "operator_alias", "confidence", "method"]
]
try:
cls.table... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_result_batch(self, results):\n session = self.session_factory()\n for result in results:\n if not self._check_row_exists(pk=result.get('id')):\n session.add(PipelineRun(**result))\n if self._get_filtered_results(id=result.get('id'), status='IN_PROGRESS'... | [
"0.6059761",
"0.6023335",
"0.5986452",
"0.58878183",
"0.58587795",
"0.5827826",
"0.57429814",
"0.5736765",
"0.57184654",
"0.5684917",
"0.5680063",
"0.56601053",
"0.56524307",
"0.5648465",
"0.56473595",
"0.56111944",
"0.5603365",
"0.55938107",
"0.55917615",
"0.55879015",
"0.55... | 0.54443294 | 34 |
Look for an exact match for the target string in a list of all operator names. If found, returns the alias for that name. Otherwise, returns None. | def lookup(self, target: str) -> pd.Series:
try:
# self.refresh()
result = pd.Series(name=target)
if target is not None:
result = self.loc[target].copy()
if result.ndim > 1:
result = result.max()
result[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fuzzy_match(self, other):\n magic, fuzzy = False, False\n try:\n magic = self.alias == other.magic\n except AttributeError:\n pass\n\n if '.' in self.alias:\n major = self.alias.split('.')[0]\n fuzzy = major == other.alias \n return... | [
"0.600872",
"0.5476128",
"0.5431273",
"0.53964996",
"0.5336919",
"0.53155607",
"0.5303619",
"0.5226297",
"0.52201563",
"0.51875824",
"0.5180949",
"0.51748854",
"0.5127156",
"0.51046616",
"0.50755596",
"0.5064597",
"0.5043313",
"0.5024844",
"0.5005249",
"0.49946284",
"0.499088... | 0.54977614 | 1 |
Attempt to fuzzy match the target string to an operator name using the given scorer function. The alias for the match with the highest score is returned. If a match with a score above the cutoff is not found, None is returned | def _fuzzy_match(
self, target: str, scorer=None, score_cutoff=85, limit=1
) -> pd.Series:
scorer = scorer or self.default_scorer()
# result = pd.Series(name = target)
extracted: list = process.extractBests(
target, self.operator, scorer=scorer, limit=limit, score_cutof... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fuzzy_match(object, answer, threshold=80):\n answer_phrase = generate_ngrams(answer)\n if answer_phrase:\n best_match = [fuzz.ratio(object, phr) for phr in answer_phrase]\n if np.max(best_match)>threshold:\n return np.max(best_match), answer_phrase[np.argmax(best_match)]\n ... | [
"0.6589819",
"0.64425164",
"0.58997977",
"0.58632153",
"0.58299005",
"0.56999075",
"0.5664272",
"0.5549336",
"0.5484873",
"0.5475975",
"0.53234446",
"0.53025043",
"0.52954453",
"0.52909315",
"0.5284119",
"0.5278062",
"0.5250008",
"0.5246519",
"0.51911473",
"0.51895994",
"0.51... | 0.71131057 | 0 |
Assess the distance between the names of the underlying operators produce a mean distance from one another. If their mean distance surpasses a certain threshold, divide the operator names at the mean and rename the alias of those aliases in the group with the larger mean. (Alternatively, classify with sklean to find a ... | def diverge(cls, alias1: str):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def group_evaluation(ops, mut):\n\n center = ops[0]\n min_distortion = distortion([ops[0]], ops, mut)\n for i in ops:\n tmp = distortion([i], ops, mut)\n if tmp < min_distortion:\n center = i\n min_distortion = tmp\n return center",
"def eval_mean_distance(played_d... | [
"0.55212533",
"0.50854033",
"0.5065224",
"0.49335217",
"0.49285668",
"0.4908087",
"0.48990777",
"0.48233825",
"0.48066035",
"0.4803067",
"0.47749212",
"0.47635058",
"0.47623038",
"0.47537285",
"0.47375804",
"0.4728953",
"0.47153434",
"0.46961704",
"0.46841297",
"0.46764016",
... | 0.0 | -1 |
Do not return anything, modify nums inplace instead. | def moveZeroes(self, n: List[int]) -> None:
w = 0
for r in range(len(n)):
if n[r] != 0:
n[r], n[w] = 0, n[r]
w += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(i):\n if i == len(nums): ans.append(nums.copy())\n for j in range(i, len(nums)): \n nums[i], nums[j] = nums[j], nums[i]\n fn(i+1)\n nums[i], nums[j] = nums[j], nums[i]",
"def double_nums(num_list):",
"def remove_dups(nums):\r\n nums[:... | [
"0.70469916",
"0.67161703",
"0.66934896",
"0.6586775",
"0.6501143",
"0.6482345",
"0.6442288",
"0.6407945",
"0.6376896",
"0.6372343",
"0.63671577",
"0.6365932",
"0.63512594",
"0.6328759",
"0.6298402",
"0.62855035",
"0.62671727",
"0.62472045",
"0.62221444",
"0.6193869",
"0.6188... | 0.0 | -1 |
Get the features from one image. Global intensity histogram per channel and local histogram on image patches. | def _get_features_from_batch_images(self, img, r, p):
tmp_feats = []
for channel in range(4):
current_img = img[channel, :, :]
tmp_feats = np.append(tmp_feats, np.histogram(current_img)[0])
# extract 8*8 patches of 64*64 px and derive 10 bins histogram
for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_color_hist_features(img, p):\n # Compute the histogram of the color channels separately\n channel1_hist = np.histogram(img[:, :, 0], bins=p.hist_bins)\n channel2_hist = np.histogram(img[:, :, 1], bins=p.hist_bins)\n channel3_hist = np.histogram(img[:, :, 2], bins=p.hist_bins)\n # Concatenate... | [
"0.7379405",
"0.73698366",
"0.7358129",
"0.7352107",
"0.73067987",
"0.72972965",
"0.72677433",
"0.7140472",
"0.7089154",
"0.7082067",
"0.6995413",
"0.6963337",
"0.6898634",
"0.68926054",
"0.6876243",
"0.6866601",
"0.6840813",
"0.6817776",
"0.6807787",
"0.68063486",
"0.6802365... | 0.78143317 | 0 |
Main features extraction function. | def _extract_features(self, all_batches, patch_size, train=True):
# manually derive basic intensities features
# takes 20 sec / 1048 images batch on my laptop in 4 cores //
p = patch_size
r = 512 // p
labels = np.empty(0)
feats = np.empty(0)
for counter, tmp in en... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_features(self):\n self.extract_features_static()\n self.extract_features_dynamic()",
"def _extract_features(self):\n # print(os.getpid())\n return {n:self._extract_feature(f) for (n,f) in self.features.items()}",
"def extractFeatures(self, datum):\n abstract",
"... | [
"0.80551636",
"0.7476482",
"0.7449748",
"0.74376774",
"0.72759044",
"0.72360015",
"0.71951854",
"0.71951854",
"0.71786666",
"0.71786666",
"0.7144344",
"0.7119816",
"0.695923",
"0.69585216",
"0.6923738",
"0.6879381",
"0.6851909",
"0.68421155",
"0.6829337",
"0.68229896",
"0.674... | 0.6427413 | 41 |
Return the largest k elements (by magnitude) of vec | def _topk(vec, k):
# on a gpu, sorting is faster than pytorch's topk method
#topkIndices = torch.sort(vec**2)[1][-k:]
# however, torch.topk is more space efficient
# topk on cuda returns what looks like uninitialized memory if
# vals has nan values in it
# saving to a zero-initialized output ar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def topk(vec, k):\n vec = torch.topk(vec, k)\n return vec.view(-1).data.tolist()",
"def _get_k_largest(lst, k):\n sorted_lst = sorted([(val, index) for index, val in enumerate(lst)])\n return list(reversed(sorted_lst[-k:]))",
"def fetch_top_k(vect, mat, k):\n resultant = np.dot(mat, vect)\n a... | [
"0.70072746",
"0.694857",
"0.67012167",
"0.6503669",
"0.64816123",
"0.6479474",
"0.6429288",
"0.63603586",
"0.6348943",
"0.6219995",
"0.6148244",
"0.6119454",
"0.6073502",
"0.6013036",
"0.6009005",
"0.6008039",
"0.59666955",
"0.59358937",
"0.5894497",
"0.584554",
"0.5819495",... | 0.6379255 | 7 |
equal area projection to spherical coorindate | def lambert_eqarea(khi,phi):
r = 2 * np.sin(khi/2.)
th = phi
return r, th | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def project(self, (lng, lat)):\n x = lng * DEG_TO_RAD\n lat = max(min(MAX_LATITUDE, lat), -MAX_LATITUDE)\n y = lat * DEG_TO_RAD\n y = math.log(math.tan((math.pi / 4) + (y / 2)))\n return (x*EARTH_RADIUS, y*EARTH_RADIUS)",
"def sphere_area(radius : number) -> number:\n area = 4*pi*radius*radius\n retur... | [
"0.6437393",
"0.63807535",
"0.6313511",
"0.61041933",
"0.60751605",
"0.6064479",
"0.6049043",
"0.6032563",
"0.6012711",
"0.5995009",
"0.5943727",
"0.5930662",
"0.59111685",
"0.5879559",
"0.58755404",
"0.5866631",
"0.5839192",
"0.5820025",
"0.5777919",
"0.5765673",
"0.5743934"... | 0.0 | -1 |
Generator for a sliding window walker; yields a new substring of sequence as well as the position of the left end of the window. | def sliding_window(sequence, width=2, step=1, seq_only=False):
for position in range(0, len(sequence) - width, step):
yield sequence[position: position + width] if seq_only else (position, sequence[position: position + width]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sliding_window(seq, n=DEFAULT_WINDOW_WIDTH):\n it = iter(seq)\n result = tuple(islice(it, n))\n if len(result) == n:\n yield result \n for elem in it:\n result = result[1:] + (elem,)\n yield result",
"def sliding_window_analysis(sequence, function,\n ... | [
"0.6834851",
"0.65151423",
"0.6398749",
"0.6279482",
"0.6083154",
"0.60000926",
"0.5993172",
"0.5971204",
"0.5971204",
"0.5791553",
"0.56396246",
"0.5636666",
"0.5559646",
"0.5535868",
"0.54835385",
"0.54810375",
"0.5475382",
"0.5470839",
"0.5463914",
"0.5445849",
"0.5411979"... | 0.7074384 | 0 |
Returns the reverse complement of a positionweight matrix. | def wc_matrix(matrix):
return [{"A": position["T"], "T": position["A"], "C": position["G"], "G": position["C"]} for position in matrix[::-1]] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverse_matrix(self):\n return SWAP.matrix @ self.matrix @ SWAP.matrix",
"def __neg__(self):\r\n return mat4(map(lambda x: -x, self.mlist))",
"def inverse(self):\n group = self.group\n r = tuple([(i, -j) for i, j in self.array_form[::-1]])\n return group.dtype(r)",
"def... | [
"0.7011902",
"0.60254407",
"0.59786683",
"0.5896039",
"0.58089143",
"0.57692766",
"0.5745344",
"0.5692964",
"0.5679361",
"0.56626594",
"0.5652216",
"0.56342137",
"0.5633222",
"0.5618562",
"0.56127685",
"0.56087816",
"0.5606974",
"0.56052554",
"0.5596738",
"0.5594267",
"0.5594... | 0.510713 | 85 |
This function is called automatically by sciunit and clones it into self.observation This checks if the experimental_data is of some desired form or magnitude. Not exactly this function but a version of this is already performed by the ValidationTestLibrary.get_validation_test | def validate_observation(self, observation, first_try=True):
print("validate_observation") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_shapes(self):\n\n # Creates a raw layer\n self.validator.adata.raw = self.validator.adata\n self.validator.adata.raw.var.drop(\"feature_is_filtered\", axis=1, inplace=True)\n self.validator.adata.X = examples.adata_non_raw.X.copy()\n self.validator.adata.uns[\"X_normaliz... | [
"0.5877965",
"0.5852415",
"0.5822772",
"0.5707541",
"0.56967235",
"0.56730175",
"0.5636447",
"0.55875695",
"0.5568945",
"0.55493855",
"0.5545418",
"0.5510037",
"0.55092335",
"0.54929996",
"0.5448216",
"0.54284984",
"0.5409777",
"0.5409752",
"0.53558064",
"0.53478",
"0.5327068... | 0.5509749 | 12 |
Generates resting Vm from soma. The function is automatically called by sciunit.Test which this test is a child of. Therefore as part of sciunit generate_prediction is mandatory. | def generate_prediction(self, model, verbose=False):
#self.confidence = confidence # set confidence for test 90%, 95% (default), 99%
#
self.observation["created_later"] = "generate_prediction"
#print(self.observation)
print(self.observation["created_later"])
return 666. | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_svm():\n backend = BasicAer.get_backend('statevector_simulator')\n random_seed = r.randint(1, 10598)\n\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\n\n # iris\n pres = \"Test pour le data set Iris (facile, classique)\"\n test_from_func(pres... | [
"0.5936731",
"0.58449227",
"0.5832882",
"0.5806163",
"0.56090754",
"0.5552659",
"0.55265224",
"0.54068804",
"0.5372567",
"0.53497547",
"0.53247535",
"0.531252",
"0.5301973",
"0.5224144",
"0.52184594",
"0.5209817",
"0.5201285",
"0.51980144",
"0.51979405",
"0.51375645",
"0.5119... | 0.52487266 | 13 |
This function like generate_pediction is called automatically by sciunit which RestingVmTest is a child of. This function must be named compute_score The prediction processed from "vm_soma" is compared against the experimental_data to get the binary score; 0 if the prediction correspond with experiment, else 1. | def compute_score(self, observation, prediction, verbose=False):
#print(observation)
score = TScore.compute( self.observation, prediction )
print("compute_score") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, test_data):\n\n\t\tpass",
"def score():\n # Get probability from our data\n data = flask.request.json\n x = np.matrix(data[\"example\"])\n x_add = scaler.transform(x[0, (0,4,5,6,7,8)])\n x_scaled = np.delete(x, [0,4,5,6,7,8], axis=1)\n x_scaled = np.insert(x_scaled, (0,3,3,3,3,3... | [
"0.6292821",
"0.6264465",
"0.6261162",
"0.6158336",
"0.61248165",
"0.60617495",
"0.6059161",
"0.6052629",
"0.5940177",
"0.5930881",
"0.59085554",
"0.59062296",
"0.58507663",
"0.58476144",
"0.5836477",
"0.5834371",
"0.58234507",
"0.5818891",
"0.58088255",
"0.58037376",
"0.5802... | 0.66401887 | 0 |
Establish the database, create an engine if needed, and register the models. | def configure_db():
global _ENGINE, sa_logger, _MAX_RETRIES, _RETRY_INTERVAL
if not _ENGINE:
billing_sql_connection = CONF.billing_sql_connection
_MAX_RETRIES = CONF.sql_max_retries
_RETRY_INTERVAL = CONF.sql_retry_interval
connection_dict = sqlalchemy.engine.url.make_url(billing... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_db():\n import cerbereapp.models\n Base.metadata.create_all(bind=engine)",
"def setup_db():\n\n engine = config['tg.app_globals'].sa_engine\n # model.init_model(engine)\n # model.metadata.create_all(engine)",
"def init_db(self):\n\n # The user can provide a custom string\n if self... | [
"0.80127066",
"0.79147583",
"0.79010004",
"0.77331024",
"0.7706037",
"0.7563964",
"0.734508",
"0.725109",
"0.7214508",
"0.71930456",
"0.719184",
"0.716469",
"0.71618533",
"0.7159122",
"0.71580553",
"0.71514654",
"0.7144555",
"0.7144555",
"0.71386635",
"0.71174407",
"0.7065824... | 0.68134224 | 32 |
Helper method to grab session | def get_session(autocommit=True, expire_on_commit=False):
global _MAKER
if not _MAKER:
assert _ENGINE
_MAKER = sqlalchemy.orm.sessionmaker(bind=_ENGINE,
autocommit=autocommit,
expire_on_commit=expire_on_com... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def session(get_session):\n return get_session()",
"def getSession():\n return call(\"getSession\")",
"def session(self):\n return self.session_store.get_session()",
"def get_session(self):\n return self.session",
"def get_session():\n request_session = requests.Session()\n\n # Try to... | [
"0.7973383",
"0.7817807",
"0.76734984",
"0.7623463",
"0.73637754",
"0.7344661",
"0.73370534",
"0.7312605",
"0.7312",
"0.7292933",
"0.72908765",
"0.7227813",
"0.7219954",
"0.71882755",
"0.71820396",
"0.71819615",
"0.71819615",
"0.7159061",
"0.7157339",
"0.71509784",
"0.7143215... | 0.0 | -1 |
Return True if error in connecting to db. | def is_db_connection_error(args):
# NOTE(adam_g): This is currently MySQL specific and needs to be extended
# to support Postgres and others.
conn_err_codes = ('2002', '2003', '2006')
for err_code in conn_err_codes:
if args.find(err_code) != -1:
return True
return F... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_db_connection(self):\n self.logger.debug('Checking database connection.')\n if self.db is None:\n try:\n self.connect_to_db()\n except Exception as e:\n print('Lost database connection.')\n self.logger.error('Lost database c... | [
"0.768802",
"0.76695615",
"0.7357796",
"0.69938886",
"0.6968846",
"0.69685704",
"0.695936",
"0.6947775",
"0.6887957",
"0.6868652",
"0.68522286",
"0.6785703",
"0.6768961",
"0.67433053",
"0.67409956",
"0.6696983",
"0.66877383",
"0.6673695",
"0.666373",
"0.6658879",
"0.6595638",... | 0.7619212 | 2 |
Retry DB connection. Copied from nova and modified. | def wrap_db_error(f):
def _wrap(*args, **kwargs):
try:
return f(*args, **kwargs)
except sqlalchemy.exc.OperationalError, e:
if not is_db_connection_error(e.args[0]):
raise
remaining_attempts = _MAX_RETRIES
while True:
L... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _retry_on_connection_error(exc):\n\n if isinstance(exc, db_exception.DBConnectionError):\n LOG.warning(\"Connection error detected. Retrying...\")\n return True\n return False",
"def _retry_occurred(self):",
"def db_auto_reconnect(func):\r\n @wraps(func)\r\n def wrapper(*args, **k... | [
"0.69502443",
"0.67862636",
"0.66337717",
"0.6532174",
"0.6528916",
"0.6525842",
"0.65242094",
"0.65150666",
"0.6500685",
"0.64712876",
"0.6449775",
"0.64261687",
"0.64096195",
"0.6382624",
"0.63109654",
"0.6287411",
"0.62764084",
"0.62584907",
"0.6249289",
"0.6226552",
"0.61... | 0.0 | -1 |
Get all project record. | def get_all_project_record(deleted=False):
session = get_session()
query = session.query(models.ProjectAccountRecord).\
filter_by(deleted=deleted).\
all()
return query | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_project_records():\r\n records = flask.request.db_api.get_all_project_record()\r\n return flask.jsonify(records=records)",
"def get_projects():\n return Project.query.all()",
"def get_projects(self):\n res = self.conn.cursor().execute(\"SELECT * FROM projects\")\n return res.... | [
"0.8395336",
"0.7698113",
"0.7534286",
"0.73463917",
"0.7295614",
"0.71893334",
"0.7128193",
"0.71230257",
"0.7120601",
"0.71182877",
"0.7017964",
"0.6991092",
"0.6973284",
"0.6909829",
"0.68773997",
"0.6870416",
"0.6786631",
"0.67659",
"0.6765425",
"0.6757861",
"0.67525625",... | 0.738502 | 3 |
Get account record for project. | def record_get_for_project(project_id, deleted=False, session=None):
session = session or get_session()
result = session.query(models.ProjectAccountRecord).\
filter_by(project_id=project_id).\
filter_by(deleted=deleted).\
first()
if not result:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_account(self):\n return self._account",
"def get_account(self):\n return self._account",
"def get_account(self, account):\n \n pass",
"def account(self, account_code):\r\n return acc.Account(self, account_code)",
"def account(self, account_id: str):\n retur... | [
"0.6873403",
"0.6873403",
"0.6768942",
"0.65608275",
"0.6481947",
"0.6471267",
"0.6470501",
"0.64585155",
"0.6380671",
"0.63713425",
"0.63052857",
"0.63029593",
"0.6294659",
"0.61823344",
"0.616734",
"0.61592054",
"0.61530197",
"0.6139093",
"0.6127555",
"0.61225945",
"0.60992... | 0.7251701 | 0 |
Create account record for project. | def record_create_for_project(project_id, values):
values['project_id'] = project_id
values['created_at'] = datetime.datetime.utcnow()
values['updated_at'] = datetime.datetime.utcnow()
session = get_session()
with session.begin():
record_ref = models.ProjectAccountRecord()
record_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_account_project(self, create):\n row = {'PROJ_NAME1': 'Some Proj', 'PROJ_NO': '121-212',\n 'SECTOR': 'IT'}\n sync.create_account(row, None)\n self.assertTrue(create.called)\n account, row, issue_map = create.call_args[0]\n self.assertEqual(account.na... | [
"0.75250834",
"0.7177558",
"0.71739244",
"0.707201",
"0.7024612",
"0.6820869",
"0.67543614",
"0.6753563",
"0.6743432",
"0.67337596",
"0.6614218",
"0.65826344",
"0.6565613",
"0.65346366",
"0.647355",
"0.6444409",
"0.64416903",
"0.6433336",
"0.6433",
"0.64252216",
"0.6414233",
... | 0.76885504 | 0 |
Update account record for project. | def record_update_for_project(project_id, values):
values['updated_at'] = datetime.datetime.utcnow()
session = get_session()
with session.begin():
record_ref = record_get_for_project(project_id, session=session)
record_ref.update(values)
record_ref.save(session=session)
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, account):\n model = models.load('Account', account)\n return self.client.update_account(model=model)",
"def update_account(row, account):\n if row['LAST_UPDATED_FROM_PAYGOV']:\n updated_at = datetime_from(row['LAST_UPDATED_FROM_PAYGOV'])\n account.donations.filter(... | [
"0.75752455",
"0.7561981",
"0.6564723",
"0.6549342",
"0.6443432",
"0.64052767",
"0.6362356",
"0.6242186",
"0.62039346",
"0.6195929",
"0.6176977",
"0.61544794",
"0.60663426",
"0.6014485",
"0.60042244",
"0.5999836",
"0.59962326",
"0.5988404",
"0.5988404",
"0.5988404",
"0.598840... | 0.5839677 | 31 |
Update account record by record_id. | def record_update_for_project_by_id(record_id, values):
values['updated_at'] = datetime.datetime.utcnow()
session = get_session()
with session.begin():
record_ref = get_project_record_by_id(record_id, session=session)
record_ref.update(values)
record_ref.save(session=session)
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def record_update_for_user(record_id, values):\n session = get_session()\n with session.begin():\n record_ref = get_user_record(record_id, session=session)\n record_ref.update(values)\n record_ref.save(session=session)",
"def update_record(conn, record_id: int, hash: str):\n cur = c... | [
"0.7288022",
"0.7048947",
"0.69176865",
"0.6763814",
"0.6732461",
"0.66992444",
"0.660613",
"0.6523691",
"0.6473934",
"0.64594585",
"0.6457677",
"0.6452143",
"0.6381156",
"0.6349426",
"0.63355607",
"0.63014734",
"0.6256432",
"0.62355167",
"0.6199448",
"0.61454207",
"0.6098174... | 0.6370856 | 13 |
Destroy account record for project. | def record_destroy_for_project(project_id):
session = get_session()
with session.begin():
session.query(models.ProjectAccountRecord).\
filter_by(project_id=project_id).\
update({'deleted': True,
'deleted_at': datetime.datetime.utcnow(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_account(self, account):\n \n pass",
"def delete_account(self):\n Credential.account_list.remove(self)",
"def delete(account):\n account.stripe_account.delete()\n account.delete()",
"def delete_account(self):\n signals.before_gameaccount_deleted.send(gameaccount=se... | [
"0.76962966",
"0.74316823",
"0.7380734",
"0.7321574",
"0.6965246",
"0.69463253",
"0.6917392",
"0.69166034",
"0.68574756",
"0.6784433",
"0.6770951",
"0.6721752",
"0.66982305",
"0.6688007",
"0.66563594",
"0.6620386",
"0.65966487",
"0.6591575",
"0.6591472",
"0.6562468",
"0.65266... | 0.77929056 | 0 |
Destroy account record for project by record id. | def destroy_project_record_by_id(record_id):
session = get_session()
with session.begin():
record_ref = get_project_record_by_id(record_id, session=session)
record_ref.delete(session=session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def record_destroy_for_project(project_id):\n session = get_session()\n with session.begin():\n session.query(models.ProjectAccountRecord).\\\n filter_by(project_id=project_id).\\\n update({'deleted': True,\n 'deleted_at': datetime.datetime.utcnow()... | [
"0.7914912",
"0.74007756",
"0.7235547",
"0.6944781",
"0.6778722",
"0.6724235",
"0.67061377",
"0.6690477",
"0.6684126",
"0.6674596",
"0.6673089",
"0.6586451",
"0.65708244",
"0.6446228",
"0.63494915",
"0.63357514",
"0.6325784",
"0.6323633",
"0.6301844",
"0.62872565",
"0.6274903... | 0.8081782 | 0 |
Get all item record for project by project id. | def get_all_item_record_for_project(project_id, deleted=False, session=None):
session = session or get_session()
result = session.query(models.ProjectItemRecord).\
filter_by(project_id=project_id).\
filter_by(deleted=deleted).\
all()
if not result... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_item_record_for_project(project):\r\n db_api = flask.request.db_api\r\n try:\r\n records = db_api.get_all_item_record_for_project(project)\r\n items = db_api.get_all_item()\r\n item_dict = dict([(i.id, i) for i in items])\r\n record_dict = {}\r\n for record in r... | [
"0.813911",
"0.7328739",
"0.69601107",
"0.67463654",
"0.6533493",
"0.63821095",
"0.63788885",
"0.634504",
"0.63328993",
"0.6316908",
"0.6295516",
"0.62620634",
"0.61942583",
"0.61678183",
"0.6166824",
"0.6155322",
"0.6145036",
"0.6108053",
"0.60920167",
"0.6046282",
"0.602754... | 0.79447895 | 1 |
Get item record for project by item id. | def item_record_get_for_project(project_id, item_id,
deleted=False, session=None):
session = session or get_session()
result = session.query(models.ProjectItemRecord).\
filter_by(project_id=project_id).\
filter_by(item_id=item_id).\
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_item(item_id):\n return Item.query.filter_by(id=item_id).first()",
"def get_project_item_record_by_name(project_id, item_name,\n deleted=False, session=None):\n session = session or get_session()\n if not item_get_by_name(item_name, session=session):\n i... | [
"0.79094803",
"0.78173584",
"0.779059",
"0.7556272",
"0.74198294",
"0.7246455",
"0.72274256",
"0.7185601",
"0.70975524",
"0.7045275",
"0.7031257",
"0.700558",
"0.69499576",
"0.69349205",
"0.69239855",
"0.6913654",
"0.6911511",
"0.68850607",
"0.68822163",
"0.6859151",
"0.67955... | 0.82235324 | 0 |
Get item record for a project by item name. | def get_project_item_record_by_name(project_id, item_name,
deleted=False, session=None):
session = session or get_session()
if not item_get_by_name(item_name, session=session):
item_create(item_name, session=session)
item = item_get_by_name(item_name, session=ses... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def item_record_get_for_project(project_id, item_id,\n deleted=False, session=None):\n session = session or get_session()\n result = session.query(models.ProjectItemRecord).\\\n filter_by(project_id=project_id).\\\n filter_by(item_id=item_i... | [
"0.7511793",
"0.6906444",
"0.6748321",
"0.6576447",
"0.657298",
"0.65694696",
"0.6549003",
"0.6524026",
"0.649842",
"0.64756",
"0.63357013",
"0.628752",
"0.6284544",
"0.6263267",
"0.6244177",
"0.61833465",
"0.6174139",
"0.6136428",
"0.61308837",
"0.6121236",
"0.61090165",
"... | 0.8403567 | 0 |
Create item record for project. | def item_record_create_for_project(project_id, values, session=None):
values['created_at'] = datetime.datetime.utcnow()
values['project_id'] = project_id
values['used'] = 0
if 'price' in values:
values['price'] = int(values['price'])
session = session or get_session()
with session.begi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_project_item_records(project, item):\r\n db_api = flask.request.db_api\r\n record = {}\r\n\r\n if flask.request.method == 'GET':\r\n try:\r\n records = db_api.get_project_item_record_by_name(project_id=project,\r\n it... | [
"0.67992556",
"0.66644853",
"0.6627822",
"0.66117144",
"0.65483904",
"0.64934033",
"0.6480519",
"0.64766985",
"0.64618635",
"0.64616525",
"0.643769",
"0.6425833",
"0.6419744",
"0.6397447",
"0.6312063",
"0.62760675",
"0.62558514",
"0.6227413",
"0.62180895",
"0.62023485",
"0.62... | 0.7986861 | 0 |
Create item record for project. | def item_record_update_for_project(project_id, values):
values['updated_at'] = datetime.datetime.utcnow()
session = get_session()
with session.begin():
record_ref = item_record_get_for_project(project_id, values["item_id"],
session=session)
p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def item_record_create_for_project(project_id, values, session=None):\n values['created_at'] = datetime.datetime.utcnow()\n values['project_id'] = project_id\n values['used'] = 0\n\n if 'price' in values:\n values['price'] = int(values['price'])\n\n session = session or get_session()\n wit... | [
"0.7986861",
"0.67992556",
"0.66644853",
"0.6627822",
"0.66117144",
"0.65483904",
"0.64934033",
"0.6480519",
"0.64766985",
"0.64618635",
"0.64616525",
"0.643769",
"0.6425833",
"0.6419744",
"0.6397447",
"0.6312063",
"0.62760675",
"0.62558514",
"0.6227413",
"0.62180895",
"0.620... | 0.0 | -1 |
Update item record by item record_id. | def update_project_item_record_by_id(record_id, values):
values['updated_at'] = datetime.datetime.utcnow()
session = get_session()
with session.begin():
record_ref = get_project_item_record(record_id, session=session)
price = values.get('price', None)
if price and price != record_r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_item_record(id):\r\n db_api = flask.request.db_api\r\n record = {}\r\n\r\n if flask.request.method == 'GET':\r\n try:\r\n record = db_api.get_project_item_record(id)\r\n except exception.ProjectItemRecordNotFound:\r\n raise webob.exc.HTTPNotFound()\r\n\r\n ... | [
"0.7118001",
"0.7086754",
"0.6939123",
"0.6875679",
"0.67684174",
"0.6705709",
"0.6603891",
"0.6562499",
"0.6495993",
"0.642799",
"0.63300025",
"0.62748045",
"0.62592906",
"0.6219607",
"0.6203007",
"0.6176232",
"0.6166459",
"0.61270183",
"0.61230475",
"0.61213315",
"0.6054235... | 0.7189731 | 0 |
Get account record for user. | def record_get_for_user(project_id, user_id, deleted=False):
session = get_session()
query = session.query(models.UserAccountRecord).\
filter_by(project_id=project_id).\
filter_by(user_id=user_id).\
filter_by(deleted=deleted)
return query.all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _GetAccountFromUser(self):\n name = self._GetAccountNameFromUser()\n number = self._GetAccountNumberFromUser()\n # Validate that the number is a number (assumes no alphabet characters in\n # the account number).\n if re.match(\"^[0-9]*$\", number) is None:\n raise ValueError(\"Account numbe... | [
"0.7582313",
"0.73810774",
"0.7379446",
"0.73619837",
"0.728641",
"0.720849",
"0.7114318",
"0.7114318",
"0.69070274",
"0.6905375",
"0.6758387",
"0.6721938",
"0.6680151",
"0.66314286",
"0.6567621",
"0.65584415",
"0.65564144",
"0.6526109",
"0.65027344",
"0.6495356",
"0.63669413... | 0.66611445 | 13 |
Get all user record. | def get_all_user_record(deleted=False):
session = get_session()
query = session.query(models.UserAccountRecord).\
filter_by(deleted=deleted).\
all()
return query | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_users():",
"def get_all_users():\n return Users.query.all()",
"def get(self):\n return get_all_users()",
"def get(self):\n return get_all_users()",
"def get(self):\n return get_all_users()",
"def get(self):\n return get_all_users()",
"def get(self):\n ... | [
"0.8148167",
"0.8062945",
"0.80126846",
"0.80126846",
"0.80126846",
"0.80126846",
"0.7990221",
"0.79466975",
"0.7916389",
"0.79000103",
"0.78579146",
"0.78118426",
"0.77407473",
"0.76903015",
"0.76642764",
"0.76446116",
"0.7603502",
"0.7577979",
"0.75728434",
"0.75572944",
"0... | 0.7046725 | 46 |
Create account record for user. | def record_create_for_user(project_id, user_id, values):
values['project_id'] = project_id
values['user_id'] = user_id
session = get_session()
with session.begin():
record_ref = models.UserAccountRecord()
record_ref.update(values)
record_ref.save(session=session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user(self) -> None:\n # update when the account was created\n self.account_created = datetime.now().date()\n self.insert_to_db()\n log(f\"An account for User:{self.id} has been created.\")",
"def create_account(self, user):\n tx = self.iroha.transaction(\n ... | [
"0.8198229",
"0.7656714",
"0.7563802",
"0.754604",
"0.7523484",
"0.7507451",
"0.7296358",
"0.7262638",
"0.7256525",
"0.72457975",
"0.723914",
"0.71757126",
"0.7168977",
"0.71368366",
"0.71026397",
"0.7088115",
"0.70726377",
"0.7044514",
"0.6994375",
"0.6966342",
"0.6965118",
... | 0.76038736 | 2 |
Create account record for user. | def record_update_for_user(record_id, values):
session = get_session()
with session.begin():
record_ref = get_user_record(record_id, session=session)
record_ref.update(values)
record_ref.save(session=session) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user(self) -> None:\n # update when the account was created\n self.account_created = datetime.now().date()\n self.insert_to_db()\n log(f\"An account for User:{self.id} has been created.\")",
"def create_account(self, user):\n tx = self.iroha.transaction(\n ... | [
"0.8198229",
"0.7656714",
"0.76038736",
"0.7563802",
"0.754604",
"0.7523484",
"0.7507451",
"0.7296358",
"0.7262638",
"0.7256525",
"0.72457975",
"0.723914",
"0.71757126",
"0.7168977",
"0.71368366",
"0.71026397",
"0.7088115",
"0.70726377",
"0.7044514",
"0.6994375",
"0.6966342",... | 0.0 | -1 |
Destroy account record for user. | def record_destroy_for_user(project_id, user_id):
session = get_session()
with session.begin():
session.query(models.UserAccountRecord).\
filter_by(project_id=project_id).\
filter_by(user_id=user_id).\
update({'deleted': True,
'dele... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_account(self, account):\n \n pass",
"def delete_user(self) -> None:\n table_dictionary = {\n 'Apple': {\n 'table': 'AppleReceipts',\n 'user_id': 'User_id'\n },\n 'ESL': {\n 'table': 'ESLReceipts',\n ... | [
"0.7598277",
"0.7517481",
"0.7431796",
"0.7385498",
"0.7362621",
"0.7354271",
"0.7324764",
"0.73033106",
"0.7242971",
"0.7206662",
"0.72000504",
"0.7199782",
"0.714332",
"0.704806",
"0.69823027",
"0.6978666",
"0.69577897",
"0.695324",
"0.69298196",
"0.69298196",
"0.69298196",... | 0.7243282 | 8 |
Destroy account record for user by record id. | def destroy_user_record_by_id(record_id):
session = get_session()
with session.begin():
session.query(models.UserAccountRecord).\
filter_by(id=record_id).\
update({'deleted': True,
'deleted_at': datetime.datetime.utcnow(),
'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_record(self, record_id):\r\n self.record.deleteObject(id=record_id)",
"def record_destroy_for_user(project_id, user_id):\n session = get_session()\n with session.begin():\n session.query(models.UserAccountRecord).\\\n filter_by(project_id=project_id).\\\n ... | [
"0.7428881",
"0.70678204",
"0.69996387",
"0.69786745",
"0.6923281",
"0.6863564",
"0.6838221",
"0.67867917",
"0.6773444",
"0.6655968",
"0.66454196",
"0.66296005",
"0.655638",
"0.65561914",
"0.6556088",
"0.6553839",
"0.6539259",
"0.65297717",
"0.65183675",
"0.6514868",
"0.65042... | 0.826225 | 0 |
Get event log for tenant or user. | def event_get(tenant_id, user_id=None): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAccessLogForUser(cls, user):\n return cls.objects.filter(user_id=user.pk).order_by('timestamp')",
"def get_eventlogs_detail(self, conn, id):\n path = urlJoin(urls.EVENT_LOG[\"GET\"], id)\n resp = conn.command(apiMethod=\"GET\", apiPath=path)\n return resp",
"def getLog(self):... | [
"0.6378935",
"0.6191199",
"0.6155786",
"0.6149457",
"0.6149457",
"0.6101304",
"0.5987789",
"0.59368587",
"0.59368587",
"0.5933352",
"0.58958244",
"0.58567405",
"0.5849712",
"0.57722425",
"0.57491046",
"0.57342017",
"0.5707942",
"0.56680214",
"0.5650455",
"0.5649152",
"0.56258... | 0.7186435 | 0 |
Create event log for tenant or user. | def event_create(tenant_id, user_id=None): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_create(sender, instance, created, **kwargs):\n if created:\n stracks.user(instance).log(\"? has been created\")",
"def create_log_entry_when_user_logs_in(sender, request, user, **kwargs):\n create_user_log(\n request=request,\n user=user,\n type=_account_const.AUTHENTICA... | [
"0.64820445",
"0.63328654",
"0.6176685",
"0.6098838",
"0.6082016",
"0.60325897",
"0.6020694",
"0.5998269",
"0.59666187",
"0.58728296",
"0.5845204",
"0.5739365",
"0.5670226",
"0.56540704",
"0.5646611",
"0.56244636",
"0.5620357",
"0.5588737",
"0.5570638",
"0.55596507",
"0.55296... | 0.7805796 | 0 |
Destroy event log for tenant or user. | def event_destroy(tenant_id, user_id=None): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_audit_delete(sender, user, request, **kwargs):\n\n try:\n UserAudit.objects.get(audit_key=request.session[constants.USERWARE_AUDIT_KEY]).delete()\n except:\n pass\n logger.info(_('User {} logged out'.format(request.user.username)))",
"def delete(self):\n backend = self._get... | [
"0.68693596",
"0.62246245",
"0.61553496",
"0.61405814",
"0.6087588",
"0.59832424",
"0.5951968",
"0.58644575",
"0.582783",
"0.58232427",
"0.5809617",
"0.5775968",
"0.57755435",
"0.5759473",
"0.57312846",
"0.570118",
"0.5697515",
"0.56482196",
"0.56314635",
"0.55968815",
"0.557... | 0.813976 | 0 |
Renvoie une Incident avec la MEDV completee (Attend une MEDV innexistante) | def predict(request):
if request.method == 'GET':
return JsonResponse(serializer.errors, status=400)
elif request.method == 'POST':
print(request)
data = JSONParser().parse(request)
serializer = IncidentSerializer(data=data)
if serializer.is_valid():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_incident(self, __assistant):\r\n\r\n _report_date = int(datetime.strptime(self.txtIncidentDate.get_text(),\r\n '%Y-%m-%d').toordinal())\r\n\r\n # Retrieve the hardware ID.\r\n _model = self.cmbHardware.get_model()\r\n _row = self.cmbH... | [
"0.49407217",
"0.49343365",
"0.48329788",
"0.47588772",
"0.4737496",
"0.4737496",
"0.47058782",
"0.47027096",
"0.46789026",
"0.46773216",
"0.46342605",
"0.46328428",
"0.46245873",
"0.46245873",
"0.46136704",
"0.46073547",
"0.46002063",
"0.45842218",
"0.45684904",
"0.45520234",
... | 0.0 | -1 |
Retrieve, update or delete a Incident. | def incident_detail(request, pk):
try:
Incident = Incident.objects.get(pk=pk)
except Incident.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = IncidentSerializer(Incident)
return JsonResponse(serializer.data)
elif request.method == ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_an_incident(self, id):\n sql = f\"SELECT * FROM incidences WHERE incidences.id={id}\"\n curr = Db().cur\n curr.execute(sql)\n output = curr.fetchone()\n return output",
"def get(*, db_session, incident_id: int) -> Optional[Incident]:\n return db_session.query(Inciden... | [
"0.57337767",
"0.5693353",
"0.56903386",
"0.54576063",
"0.5443404",
"0.5376091",
"0.5369639",
"0.53686297",
"0.53374654",
"0.5288004",
"0.5210048",
"0.51772356",
"0.51492304",
"0.50980365",
"0.5071856",
"0.5063114",
"0.5051532",
"0.50009227",
"0.4985093",
"0.4922284",
"0.4906... | 0.6207881 | 0 |
Tests the creation of an text layer via the layer factory. | def test_layer_factory(self):
self.graphic = Text('Test')
assert_layer_factory(self, 'text') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_fixed_text_layer(self):\n\t\tself.graphic = Text('text')\n\t\tself.viewport = Viewport(0, 0, 100, 100)\n\t\tself.offset_x = 10\n\t\tself.offset_y = 5\n\n\t\t# Test a static text layer first\n\t\tself.layer = text_layer.FixedStaticTextLayer(\n\t\t\tself.graphic, viewport=self.viewport,\n\t\t\toffset_x=self... | [
"0.68004715",
"0.62582254",
"0.6083502",
"0.5984313",
"0.5946537",
"0.5838513",
"0.5829028",
"0.58284557",
"0.5803945",
"0.5803416",
"0.57713497",
"0.5756482",
"0.56175125",
"0.560891",
"0.5477224",
"0.5453544",
"0.5436384",
"0.5339267",
"0.5318148",
"0.53089434",
"0.53021735... | 0.8442944 | 0 |
Tests fixed text layers. Also ensures that LiveText objects are updated. | def test_fixed_text_layer(self):
self.graphic = Text('text')
self.viewport = Viewport(0, 0, 100, 100)
self.offset_x = 10
self.offset_y = 5
# Test a static text layer first
self.layer = text_layer.FixedStaticTextLayer(
self.graphic, viewport=self.viewport,
offset_x=self.offset_x, offset_y=self.offset_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_layer_factory(self):\n\t\tself.graphic = Text('Test')\n\n\t\tassert_layer_factory(self, 'text')",
"def test_generate_mine_text(self):\n pg.font.init()\n font_surface = utils.generate_mine_text(1)\n self.assertIsInstance(font_surface, pg.Surface)",
"def test_gameAddText(self):\n ... | [
"0.6388988",
"0.59385103",
"0.5931025",
"0.5791703",
"0.57001746",
"0.5595606",
"0.5564164",
"0.55368245",
"0.5527248",
"0.5493804",
"0.54809046",
"0.5429338",
"0.5343724",
"0.53400725",
"0.53017783",
"0.5292878",
"0.5261921",
"0.5240859",
"0.5239271",
"0.52359575",
"0.522805... | 0.7963431 | 0 |
Asserts that the layer's graphic is at the expected coordinates. | def assert_layer_graphic_position(self):
expected_x = self.offset_x + self.viewport.x
expected_y = self.offset_y + self.viewport.y
graphic = self.layer.graphic
self.assertEqual(graphic.x, expected_x,
"x of layer graphic is %s, should be %s." % (graphic.x, expected_x))
self.assertEqual(graphic.y, expected_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_game_over_coordinates(self):\n pg.font.init()\n font = utils.FONT.render(\"test\", True, utils.FONT_COLOUR)\n game_over_coords = utils.game_over_coords(font)\n self.assertIsInstance(game_over_coords, pg.Rect)",
"def test_layer_ok(self):\n self.assertTrue(self.vector)",... | [
"0.6886318",
"0.6400074",
"0.61993706",
"0.6192627",
"0.61068124",
"0.6041083",
"0.6019883",
"0.6003798",
"0.59852034",
"0.59708446",
"0.5953457",
"0.594311",
"0.59375787",
"0.5932929",
"0.58274615",
"0.58258504",
"0.5810158",
"0.5809842",
"0.57834",
"0.57723904",
"0.57717806... | 0.87353176 | 0 |
Delegates user input to the handling function when activated. | def handleForever(self):
self._logger.info("Starting to handle conversation with keyword '%s'.",
self.persona)
while True:
# Print notifications until empty
notifications = self.notifier.getAllNotifications()
for notif in notifications:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_input(self, event):\n pass",
"def install_handle_input(self):\n pass",
"def handle_inputs(self):\n user_input = \"\"\n while user_input != \"exit\":\n self.print_divider()\n user_input = input()\n self.do_action_for_input(user_input)",
"... | [
"0.72647256",
"0.7187669",
"0.68825173",
"0.65996367",
"0.65698135",
"0.6506021",
"0.6504362",
"0.6443073",
"0.6431098",
"0.6333757",
"0.6307175",
"0.6221088",
"0.6143257",
"0.6126705",
"0.6095621",
"0.6084434",
"0.6000683",
"0.59981483",
"0.5921418",
"0.590317",
"0.589731",
... | 0.0 | -1 |
Performs a batch normalization followed by a ReLU. | def batch_norm_relu(inputs,
is_training,
relu=True,
init_zero=False,
data_format='channels_first'):
if init_zero:
gamma_initializer = tf.zeros_initializer()
else:
gamma_initializer = tf.ones_initializer()
if data_format == 'c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def batch_normalization(input_var=None):\n\n # Hyperparameters\n hp = Hyperparameters()\n hp('batch_size', 30)\n hp('n_epochs', 1000)\n hp('learning_rate', 0.01)\n hp('l1_reg', 0.00)\n hp('l2_reg', 0.0001)\n hp('patience', 5000)\n\n # Create connected layers\n # Input layer\n l_in ... | [
"0.692773",
"0.6830901",
"0.6740521",
"0.6675622",
"0.6608609",
"0.65809447",
"0.6534637",
"0.652944",
"0.64998734",
"0.64971787",
"0.6481464",
"0.6394366",
"0.6381936",
"0.63704985",
"0.6360569",
"0.63473797",
"0.63164675",
"0.6280415",
"0.62686515",
"0.62644416",
"0.6252339... | 0.6519259 | 8 |
Pads inputs w.r.t. data format. | def _padding(inputs, paddings, data_format):
if data_format == 'channels_first':
padded_inputs = tf.pad(
inputs, [[0, 0], [0, 0], paddings, paddings])
else:
padded_inputs = tf.pad(
inputs, [[0, 0], paddings, paddings, [0, 0]])
return padded_inputs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pad_dataset(dataset, padding=0):\n max_l = max(len(x) for x in dataset[\"input_ids\"])\n for name in PADDED_INPUTS:\n dataset[name] = [x + [padding if name != \"lm_labels\" else -100] * (max_l - len(x)) for x in dataset[name]]\n return dataset",
"def pad(data, *args, **kwargs): # pragma: no ... | [
"0.6714534",
"0.65620893",
"0.63622624",
"0.6301816",
"0.6300907",
"0.62297213",
"0.6203088",
"0.61806923",
"0.61762965",
"0.6154326",
"0.61143845",
"0.60824525",
"0.604327",
"0.60138506",
"0.5969655",
"0.5911536",
"0.5877184",
"0.5751767",
"0.5698976",
"0.5692566",
"0.564209... | 0.62052333 | 6 |
Pads the input along the spatial dimensions independently of input size. | def fixed_padding(inputs, kernel_size, data_format='channels_last'):
pad_total = kernel_size - 1
pad_beg = pad_total // 2
pad_end = pad_total - pad_beg
return _padding(inputs, (pad_beg, pad_end), data_format) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wrap_pad(input, size):\n M1 = tf.concat([input[:, :, -size[1]:, :], input, input[:, :, 0:size[1], :]], 2)\n M1 = tf.concat([M1[:, -size[0]:, :, :], M1, M1[:, 0:size[0], :, :]], 1)\n return M1",
"def pad_spatial(self, x):\n n, t, c, h, w = x.size()\n\n pad_h = (4 - h % 4) % 4\n p... | [
"0.7338553",
"0.6975063",
"0.6685168",
"0.6617578",
"0.6493419",
"0.6390938",
"0.63418573",
"0.6319363",
"0.6297954",
"0.62938833",
"0.6280606",
"0.6108473",
"0.6040027",
"0.59399575",
"0.5939143",
"0.59307957",
"0.593072",
"0.5904553",
"0.58525276",
"0.5831835",
"0.5822233",... | 0.56921554 | 29 |
Pads the input along the spatial dimensions independently of input size. | def space_to_depth_fixed_padding(inputs, kernel_size,
data_format='channels_last', block_size=2):
pad_total = kernel_size - 1
pad_beg = (pad_total // 2 + 1) // block_size
pad_end = (pad_total // 2) // block_size
return _padding(inputs, (pad_beg, pad_end), data_format) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wrap_pad(input, size):\n M1 = tf.concat([input[:, :, -size[1]:, :], input, input[:, :, 0:size[1], :]], 2)\n M1 = tf.concat([M1[:, -size[0]:, :, :], M1, M1[:, 0:size[0], :, :]], 1)\n return M1",
"def pad_spatial(self, x):\n n, t, c, h, w = x.size()\n\n pad_h = (4 - h % 4) % 4\n p... | [
"0.7338553",
"0.6975063",
"0.6685168",
"0.6617578",
"0.6493419",
"0.6390938",
"0.63418573",
"0.6319363",
"0.6297954",
"0.62938833",
"0.6280606",
"0.6108473",
"0.6040027",
"0.59399575",
"0.5939143",
"0.59307957",
"0.593072",
"0.5904553",
"0.58525276",
"0.5831835",
"0.5822233",... | 0.0 | -1 |
Fuses spacetodepth and transpose. Spacetodepth performs the following permutation, which is equivalent to tf.nn.space_to_depth. As spacetodepth has an implicitly transpose, input transpose is fused into spacetodepth transform. images = tf.reshape(images, [batch, h // block_size, block_size, w // block_size, block_size,... | def fused_transpose_and_space_to_depth(
images, block_size=2, transpose_input=True):
batch_size, h, w, c = images.get_shape().as_list()
if block_size != 0:
images = tf.reshape(images,
[batch_size, h // block_size, block_size,
w // block_size, block_size, c])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_conv2d_transpose(g, op, block):\n\n dilations = op.attr(\"dilations\")\n groups = op.attr(\"groups\")\n paddings = op.attr(\"paddings\")\n padding_algorithm = op.attr(\"padding_algorithm\")\n strides = op.attr(\"strides\")\n output_padding = op.attr(\"output_padding\") if op.attr(\"ou... | [
"0.6252821",
"0.6187393",
"0.6059542",
"0.60442156",
"0.60276586",
"0.60033554",
"0.5998148",
"0.59918356",
"0.5949912",
"0.5934507",
"0.5899734",
"0.5860573",
"0.58351976",
"0.5719159",
"0.570773",
"0.56841886",
"0.5680008",
"0.56749076",
"0.56631535",
"0.5646647",
"0.563803... | 0.7638583 | 0 |
Strided 2D convolution with explicit padding. The padding is consistent and is based only on `kernel_size`, not on the dimensions of `inputs` (as opposed to using `tf.layers.conv2d` alone). | def conv2d_fixed_padding(inputs,
filters,
kernel_size,
strides,
data_format='channels_first'):
if strides > 1:
inputs = fixed_padding(inputs, kernel_size, data_format=data_format)
outputs = tf.layers.conv2d(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conv2d_fixed_padding(inputs, filters, kernel_size, strides, data_format):\n # The padding is consistent and is based only on `kernel_size`, not on the\n # dimensions of `inputs` (as opposed to using `tf.layers.conv2d` alone).\n if strides > 1:\n inputs = fixed_padding(inputs, kernel_size, data_format)\n\... | [
"0.7897865",
"0.78809714",
"0.78273654",
"0.7678087",
"0.7575362",
"0.7527666",
"0.7510199",
"0.7343924",
"0.733184",
"0.72405255",
"0.7214543",
"0.7163506",
"0.7088934",
"0.706851",
"0.6946939",
"0.6916445",
"0.69016784",
"0.68804586",
"0.68630147",
"0.6833584",
"0.6829672",... | 0.793444 | 0 |
Standard building block for residual networks with BN after convolutions. | def residual_block(inputs, filters, is_training, strides,
use_projection=False, data_format='channels_first'):
shortcut = inputs
if use_projection:
# Projection shortcut in first layer to match filters and strides
shortcut = conv2d_fixed_padding(
inputs=inputs,
filters=fil... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_resnet(self):\r\n\r\n # INPUTS\r\n inputs_data = Input((self.data_rows, self.data_cols, 1),name='inputs_data')\r\n\r\n\r\n def residual_block(input, output_channels=64, kernel_size=(3, 3), stride=(1, 1)):\r\n x = Conv2D(output_channels, kernel_size, padding='same', strides... | [
"0.6761057",
"0.6718992",
"0.65846515",
"0.65790915",
"0.649853",
"0.64868796",
"0.64450806",
"0.64450806",
"0.6441736",
"0.6411527",
"0.64062256",
"0.6399525",
"0.63963383",
"0.63919085",
"0.6371196",
"0.63613915",
"0.62739086",
"0.62727815",
"0.6233148",
"0.623134",
"0.6202... | 0.0 | -1 |
Bottleneck block variant for residual networks with BN after convolutions. | def bottleneck_block(inputs, filters, is_training, strides,
use_projection=False, data_format='channels_first'):
shortcut = inputs
if use_projection:
# Projection shortcut only in first block within a group. Bottleneck blocks
# end with 4 times the number of filters.
filters_out = 4... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet50_base(freeze_blocks=[1,2,3], weight_regularizer=None, bias_regularizer=None):\n img_input = Input(shape=(None, None, 3))\n bn_axis = 3\n train1 = 1 not in freeze_blocks\n x = Conv2D(64, (7, 7), strides=(2, 2), padding='same', name='conv1', trainable=train1,\n kernel_regularizer=weigh... | [
"0.67967707",
"0.6790556",
"0.67886436",
"0.6717657",
"0.65665877",
"0.6537484",
"0.6519858",
"0.65195817",
"0.6465134",
"0.64170057",
"0.64149576",
"0.63950753",
"0.63930964",
"0.6377483",
"0.6363764",
"0.63319874",
"0.6259834",
"0.6256376",
"0.62512606",
"0.62451756",
"0.62... | 0.57658273 | 78 |
Creates one group of blocks for the ResNet model. | def block_group(inputs, filters, block_fn, blocks, strides, is_training, name,
data_format='channels_first'):
# Only the first block per block_group uses projection shortcut and strides.
inputs = block_fn(inputs, filters, is_training, strides,
use_projection=True, data_format=dat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_new_block(self):\n block = BasicBlock()\n self.blocks.append(block)\n return block",
"def _make_layer(self, X, name, block, num_blocks, out_channels):\n\n for i in range(0, num_blocks):\n X = block(X, name = name + '_block{}'.format(i), out_channels=out_channels)\n ... | [
"0.6954946",
"0.65904",
"0.6526099",
"0.6515287",
"0.6488976",
"0.63835907",
"0.6347426",
"0.62397134",
"0.62314355",
"0.6205652",
"0.6190623",
"0.61754125",
"0.6172874",
"0.6130437",
"0.6098664",
"0.60650057",
"0.6059756",
"0.60370356",
"0.60317415",
"0.6030886",
"0.6020759"... | 0.5980943 | 22 |
Transforms the convolution kernel for spacetodepth computation. This function transforms the kernel for spacetodepth convolution. For example, the kernel size is [7, 7, 3, 64] (conv0 in ResNet), and the block_size is 2. First the kernel is padded with (top and left) zeros to [8, 8, 3, 64]. Then, it is transformed to [4... | def transform_space_to_depth_kernel(kernel, dtype, block_size=2):
def _round_up(num, multiple):
remainder = num % multiple
if remainder == 0:
return num
else:
return num + multiple - remainder
h, w, in_d, out_d = kernel.get_shape().as_list()
pad_h = _round_up(h, block_size) - h
pad_w = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_conv2d(g, op, block):\n\n dilations = op.attr(\"dilations\")\n groups = op.attr(\"groups\")\n paddings = op.attr(\"paddings\")\n padding_algorithm = op.attr(\"padding_algorithm\")\n strides = op.attr(\"strides\")\n\n kernel = g.get_node(op.input(\"Filter\")[0])\n input_x = g.get_no... | [
"0.6796937",
"0.66202474",
"0.65691066",
"0.65528923",
"0.64849013",
"0.643785",
"0.6437256",
"0.62981987",
"0.62667286",
"0.6247232",
"0.62432134",
"0.6236941",
"0.6229701",
"0.62242377",
"0.6193961",
"0.61879545",
"0.61837673",
"0.61757994",
"0.6170011",
"0.6163105",
"0.613... | 0.7187211 | 0 |
Uses spacetodepth convolution for conv0. This function replaces the first convolution (conv0) in ResNet with spacetodepth transformation. It creates a convolution kernel, whose dimension and name are the same as those of conv0. The `inputs` is an image tensor that already has the spacetodepth transform. | def conv0_space_to_depth(inputs, filters, kernel_size, strides,
data_format='channels_last',
space_to_depth_block_size=2):
if space_to_depth_block_size != 2:
raise ValueError('Space-to-depth does not support block_size (%d).' %
space_to_depth_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _conv2d_layer(self, inputs, filters_num, kernel_size, name, use_bias=False, strides=1):\n if strides > 1: # modified 0327\n inputs = tf.pad(inputs, paddings=[[0, 0], [1, 0], [1, 0], [0, 0]], mode='CONSTANT')\n conv = tf.layers.conv2d(inputs=inputs, filters=filters_num,\n ... | [
"0.6708323",
"0.66756195",
"0.6621401",
"0.6586069",
"0.64907104",
"0.64795524",
"0.6387748",
"0.6367544",
"0.6344067",
"0.6319126",
"0.62981534",
"0.62717414",
"0.62711716",
"0.6268527",
"0.62594",
"0.6196591",
"0.6192265",
"0.61805904",
"0.61562115",
"0.61560106",
"0.614476... | 0.66131324 | 3 |
Generator for ResNet v1 models. | def resnet_v1_generator(block_fn, layers, num_classes,
data_format='channels_first', conv0_kernel_size=7,
space_to_depth_block_size=0):
def model(inputs, is_training):
"""Creation of the model graph."""
if space_to_depth_block_size != 0:
# conv0 uses space... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resnet():\n return models.resnet152(pretrained=True)",
"def resnet46(pretrained=False):\n model = ResNet(BasicBlock, [3, 6, 10, 3])\n if pretrained:\n pass\n #model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))\n return model",
"def resnet10(**kwargs):\n model = R... | [
"0.6477364",
"0.5927687",
"0.5920352",
"0.58649075",
"0.58071506",
"0.579971",
"0.57836306",
"0.57792336",
"0.57619435",
"0.5743424",
"0.5732439",
"0.57324135",
"0.57249564",
"0.57208186",
"0.57071954",
"0.57071954",
"0.56922096",
"0.5672616",
"0.5654497",
"0.56540555",
"0.56... | 0.5432183 | 62 |
Creation of the model graph. | def model(inputs, is_training):
if space_to_depth_block_size != 0:
# conv0 uses space-to-depth transform for TPU performance.
inputs = conv0_space_to_depth(
inputs=inputs,
filters=64,
kernel_size=conv0_kernel_size,
strides=2,
data_format=data_format,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_graph(self):\n\t\tself._create_placeholders()\n\t\tself._create_embedding()\n\t\tself._create_recurrent_layers()\n\t\tself._create_de_embedding()\n\t\tself._create_loss()\n\t\tself._create_optimizer()\n\t\tself._create_summaries()",
"def build_graph(self):\n self.__create_placeholders()\n ... | [
"0.7939871",
"0.7903479",
"0.76862854",
"0.7662326",
"0.76437825",
"0.752375",
"0.74270034",
"0.74230933",
"0.73559767",
"0.7346491",
"0.7346491",
"0.7310608",
"0.72618264",
"0.7238236",
"0.7205029",
"0.7205029",
"0.71261346",
"0.7120608",
"0.7120411",
"0.706077",
"0.7048368"... | 0.0 | -1 |
Returns the ResNet model for a given size and number of output classes. | def resnet_v1(resnet_depth, num_classes, data_format='channels_first',
conv0_kernel_size=7, conv0_space_to_depth_block_size=0):
model_params = {
18: {'block': residual_block, 'layers': [2, 2, 2, 2]},
34: {'block': residual_block, 'layers': [3, 4, 6, 3]},
50: {'block': bottleneck_block,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_model(model, method, num_classes, insize):\n\n if model in ['wrn', 'r50', 'r101','r110', 'r152', 'r32', 'r18', 'r56', 'r20']:\n net = get_resnet_model(model, method, num_classes, insize)\n elif model in ['r164']:\n net = get_network_slimming_model(method, num_classes)\n elif model in... | [
"0.7139012",
"0.6874386",
"0.6863167",
"0.6748865",
"0.6748865",
"0.6732016",
"0.66270846",
"0.65792286",
"0.6578705",
"0.6546086",
"0.6498878",
"0.6487927",
"0.6482792",
"0.6482792",
"0.64242315",
"0.64242315",
"0.6388637",
"0.6351621",
"0.63336664",
"0.6325872",
"0.6311921"... | 0.0 | -1 |
Prints a chain iterating its headers | def print_headers(headers_map, fork=False):
print("\nHeaders")
for header_hash in list(headers_map.keys()):
header = headers_map[header_hash]
if fork and header.hashMerkleRoot != b"\xcc" * 32:
continue
print("header hash:\t\t", header.GetHash().hex())
print()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_subheaders(self):\n for subheader in self.subheaders:\n print(subheader)",
"def printme(self):\n sys.stdout.write(self._header)\n for k in range(len(self)):\n sys.stdout.write(self.line(k))",
"def get_headers_for_print(self):\n lines_for_print = []\n ... | [
"0.65482354",
"0.64316934",
"0.6394731",
"0.6159447",
"0.6078206",
"0.60606414",
"0.60512024",
"0.6042295",
"0.6005242",
"0.59862447",
"0.58384",
"0.5827246",
"0.57998735",
"0.57509196",
"0.5744481",
"0.5736322",
"0.57327485",
"0.5727085",
"0.5698431",
"0.5691338",
"0.569043"... | 0.6886069 | 0 |
Print the interlinks of the blocks of a chain | def print_interlinks(headers_map, interlink_map):
print("\nInterlinks")
for i in interlink_map.keys():
print("Key:", i.hex()[:6], "| Level:", int(headers_map[i].compute_level()))
print_tuple(interlink_map[i])
print("+" * 32) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_paths_between_yields(paths): # pragma: no cover\n from graphviz import Digraph\n dot = Digraph(name=\"top\")\n for i, path in enumerate(paths):\n prev = None\n for block in path:\n if isinstance(block, Branch):\n label = \"if \" + astor.to_source(block.c... | [
"0.6082883",
"0.5979062",
"0.59749126",
"0.59170777",
"0.5899505",
"0.5830778",
"0.5731966",
"0.5722667",
"0.56706434",
"0.5669561",
"0.5637989",
"0.5628519",
"0.56036234",
"0.5600618",
"0.5568108",
"0.5546844",
"0.5495533",
"0.54540217",
"0.5449112",
"0.5428345",
"0.54201317... | 0.6727348 | 0 |
indices seem different than below because element is a hex string, not a byte array | def print_proof_element(element):
print("Prev header:\t", element[0:64])
# print('Version:\t', element[ 64: 66])
# print('Something:\t', element[ 66: 72])
print("Interlink hash:\t", element[72:136])
print("Merkle root:\t", element[136:200])
# print('Time:\t\t', element[200:2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_byte_array_conversion():\n ob = ConversionTest()\n\n assert ob.ByteArrayField is None\n\n ob.ByteArrayField = [0, 1, 2, 3, 4]\n array = ob.ByteArrayField\n assert len(array) == 5\n assert array[0] == 0\n assert array[4] == 4\n\n value = b\"testing\"\n ob.ByteArrayField = value\n... | [
"0.61879593",
"0.6169586",
"0.5947031",
"0.5947031",
"0.5886045",
"0.5635032",
"0.56292176",
"0.5617642",
"0.56158674",
"0.5572353",
"0.55332905",
"0.5514198",
"0.5507884",
"0.5505075",
"0.5501913",
"0.5480814",
"0.5480478",
"0.5449285",
"0.5448715",
"0.5439642",
"0.54233086"... | 0.0 | -1 |
Removes the genesis block of the proof | def remove_genesis(proof):
old_size = len(proof)
print("Removing genesis block from proof ...")
proof.pop(-1)
print("OK")
print("old size:", old_size, "-> new size:", len(proof)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_block(self, block):\n raise NotImplementedError()",
"def remove_from_block(self):\n self.enclosing_block.remove_ops([self])",
"def delete_block(self, block):\n raise NotImplementedError('delete_block')",
"def remove(self, block):\n try:\n self.blocks[block.he... | [
"0.6290408",
"0.5996669",
"0.59115857",
"0.5884244",
"0.5854443",
"0.58376217",
"0.58081526",
"0.57852006",
"0.57547975",
"0.5726658",
"0.56836265",
"0.5676911",
"0.5623997",
"0.5612229",
"0.5596398",
"0.55962217",
"0.55749035",
"0.5566368",
"0.5550208",
"0.5549425",
"0.55247... | 0.8608646 | 0 |
Changes a specific byte in a byte array | def swap_byte(byte_array, index):
if byte_array[index] == 0:
changed_byte_array = byte_array[0:index] + b"\xff" + byte_array[index + 1 :]
changed_byte_array = byte_array[0:index] + b"\x00" + byte_array[index + 1 :]
return changed_byte_array | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_bit(self, index_of_byte, index_of_bit, new_value):\n if index_of_bit >= self.binary_size:\n print(\"You tried to modify a byte at %d index. This cannot be done. The maximum index is %d.\"%(index_of_bit, self.binary_size - 1))\n else:\n new_value = str(new_value)\n ... | [
"0.7607034",
"0.7187944",
"0.6851375",
"0.6837722",
"0.6780952",
"0.6729589",
"0.6723024",
"0.6679319",
"0.64730704",
"0.6376428",
"0.6333384",
"0.62949824",
"0.62935746",
"0.6257262",
"0.6237112",
"0.6162971",
"0.6119067",
"0.6108211",
"0.61019486",
"0.609579",
"0.5928492",
... | 0.7412648 | 1 |
Changes the interlink hash in a block hash Each block is represented with a 112 bytes hash. | def change_interlink_hash(proof, block_index):
block_of_interest = proof[block_index][0]
changed_block = swap_byte(block_of_interest, 0)
changed_proof = (
proof[0:block_index]
+ [(changed_block, proof[block_index][1])]
+ proof[block_index + 1 :]
)
return changed_proof | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_block(self):\n sha = hasher.sha256()\n sha.update((str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash)).endswith('utf-8'))\n return sha.hexdigest()",
"def hash(self, hash):\n\n self._hash = hash",
"def hash(self, hash):\n\n self._hash = h... | [
"0.6883189",
"0.67876226",
"0.67876226",
"0.67761916",
"0.67401713",
"0.65702283",
"0.65575254",
"0.64846873",
"0.6470802",
"0.64679575",
"0.6459402",
"0.64477664",
"0.6369744",
"0.6369744",
"0.6367037",
"0.6361284",
"0.6347822",
"0.6322299",
"0.6299315",
"0.6297634",
"0.6277... | 0.6925265 | 0 |
Deletes a number of blocks from the proof starting from block_index | def skip_blocks(proof, block_index, skipped_blocks=1):
if block_index >= len(proof):
return proof
for i in range(block_index, block_index + skipped_blocks):
print("Deleting block", i)
del proof[i]
return proof | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __delitem__(self, index):\n def _removeBlock(blockIndex):\n block = self._doc.findBlockByNumber(blockIndex)\n if block.next().isValid(): # not the last\n cursor = QTextCursor(block)\n cursor.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor)\... | [
"0.71626973",
"0.68964684",
"0.62942344",
"0.625104",
"0.6132582",
"0.60548794",
"0.6051101",
"0.6042633",
"0.6016819",
"0.59291697",
"0.5908609",
"0.5838923",
"0.58307886",
"0.5816913",
"0.581112",
"0.5768777",
"0.5763255",
"0.5763255",
"0.5733283",
"0.5707062",
"0.5648815",... | 0.8000275 | 0 |
Replaces a block in the proof. The new block has the same interlink but different header hash | def replace_block(proof, headers_map, interlink_map, block_index):
prevous_block = proof[block_index - 1][0]
block_hash = prevous_block[36:68]
block = headers_map[block_hash]
interlink = list_flatten(interlink_map[block.GetHash()])
block_2 = mine_block(
block.hashPrevBlock, block.nBits - 1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_interlink_hash(proof, block_index):\n\n block_of_interest = proof[block_index][0]\n changed_block = swap_byte(block_of_interest, 0)\n changed_proof = (\n proof[0:block_index]\n + [(changed_block, proof[block_index][1])]\n + proof[block_index + 1 :]\n )\n return change... | [
"0.6696862",
"0.6492034",
"0.62668824",
"0.62506884",
"0.62480694",
"0.6142988",
"0.61030936",
"0.6102814",
"0.6081092",
"0.6058437",
"0.6036382",
"0.6030431",
"0.60070413",
"0.5958737",
"0.5852314",
"0.58496255",
"0.5832161",
"0.5744932",
"0.57379293",
"0.5737272",
"0.572282... | 0.8152844 | 0 |
Create, edit and print chains and proofs | def main():
parser = argparse.ArgumentParser(description="Prints the contents of a NiPoPoW")
parser.add_argument("--blocks", required=True, type=int, help="Number of blocks")
parser.add_argument(
"--output", default="proof.pkl", type=str, help="Name of exported proof"
)
args = parser.parse_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n parser = argparse.ArgumentParser(\n description=\"Create and store proof from create_blockchain_new.py\"\n )\n group = parser.add_mutually_exclusive_group()\n group.add_argument(\"--blocks\", type=int, help=\"Number of blocks\")\n group.add_argument(\"--proof\", type=str, help... | [
"0.6269092",
"0.593019",
"0.5699991",
"0.566571",
"0.558477",
"0.5554511",
"0.5437828",
"0.53985196",
"0.5362294",
"0.53594774",
"0.5350961",
"0.5350664",
"0.5346109",
"0.53326225",
"0.5318476",
"0.5311653",
"0.53101516",
"0.5306257",
"0.5296305",
"0.52940077",
"0.529166",
... | 0.68124014 | 0 |
Compute the structure factor through a fourier transform of the radial distribution function. The consdered trajectory must include valid elements. Atomic form factors are estimated by atomic number. The computed structure factor is only valid for certain values of Q. The lowest value of Q that can sufficiently be desc... | def structure_factor(trj, Q_range=(0.5, 50), n_points=1000, framewise_rdf=False, weighting_factor='fz'):
if weighting_factor not in ['fz']:
raise ValueError('Invalid weighting_factor `{}` is given.'
' The only weighting_factor currently supported is `fz`.'.format(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def StructureFactor(ID,f,hkl,z=None):\n ID=goodID(ID)\n i=complex(0,1)\n h=hkl[0]\n k=hkl[1]\n l=hkl[2]\n L=latticeType[ID]\n if L=='fcc':\n F=f*(1+np.exp(-i*np.pi*(k+l))+np.exp(-i*np.pi*(h+l))+np.exp(-i*np.pi*(h+k)))\n elif L=='bcc':\n F=f*(1+np.exp(-i*np.pi*(h+k+l))) \n elif... | [
"0.61005145",
"0.5547126",
"0.5504173",
"0.54883736",
"0.53962797",
"0.5384088",
"0.5333023",
"0.5327243",
"0.52803975",
"0.52569383",
"0.5241156",
"0.52071124",
"0.51957417",
"0.5193955",
"0.5186578",
"0.51780033",
"0.51702636",
"0.51467496",
"0.51093566",
"0.5086104",
"0.50... | 0.62520516 | 0 |
Compute r_ij(t), the distance between atom j at time t and atom i and time 0. Note that this alone is likely useless, but is an intermediate variable in the construction of a dynamic structure factor. See 10.1103/PhysRevE.59.623. | def compute_dynamic_rdf(trj):
n_atoms = trj.n_atoms
n_frames = trj.n_frames
r_ij = np.ndarray(shape=(trj.n_atoms, trj.n_atoms, trj.n_frames))
for n_frame, frame in enumerate(trj):
for atom_i in range(trj.n_atoms):
for atom_j in range(trj.n_atoms):
r_ij[atom_i, atom... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distance(ri, rj):\n return abs(ri[0] - rj[0]) + abs(ri[1] - rj[1])",
"def r(self, t):\n from scipy.optimize import fsolve\n t = YEAR_TO_SEC * t\n t_coll = fsolve(lambda x: self.r_free(x) - self.snr.r_reverse(x), 4e3)\n # 4e3 years is a typical value that works for fsolve\n ... | [
"0.5410007",
"0.52558136",
"0.52129275",
"0.51934403",
"0.5120384",
"0.50158536",
"0.49003237",
"0.48539624",
"0.48512992",
"0.4837882",
"0.48160997",
"0.4813014",
"0.48086157",
"0.48014414",
"0.47951403",
"0.47862214",
"0.47764075",
"0.47283062",
"0.47244427",
"0.47240275",
... | 0.60190296 | 0 |
This function is called to check if a username / password combination is valid. | def check_auth(username, password):
ADMIN_USER = config.CONFIG_VARS['ADMIN_USER']
ADMIN_PASS = config.CONFIG_VARS['ADMIN_PASS']
return username == ADMIN_USER and password == ADMIN_PASS | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_auth(username, password, expected_user, expected_pw):\n return username == expected_user and password == expected_pw",
"def validate_authentication(self, username, password):\n return self.user_table[username]['pwd'] == password",
"def check_auth(username, password):\n return usernam... | [
"0.8221681",
"0.81452113",
"0.79765403",
"0.79615504",
"0.788556",
"0.78595155",
"0.7838946",
"0.78279626",
"0.7815743",
"0.77989453",
"0.7786234",
"0.7770711",
"0.7761279",
"0.77546805",
"0.7753378",
"0.7752181",
"0.77496976",
"0.7731222",
"0.77148515",
"0.76884216",
"0.7686... | 0.7653261 | 27 |
Sends a 401 response that enables basic auth | def authenticate():
return Response(
'Could not verify your credentials for that url', 401,
{'WWW-Authenticate': 'Basic realm="Login Required"'}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authenticate():\n return Response('Not Authorized', 401, {'WWW-Authenticate': 'Basic realm=\"api\"'})",
"def authenticate():\n return Response(\n '', 401, {'WWW-Authenticate': 'Basic realm=\"Login Required\"'}\n )",
"def authenticate():\n return Response(\n 'You have to login with pro... | [
"0.8093736",
"0.80926424",
"0.7958403",
"0.7852648",
"0.7824419",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
"0.7810746",
... | 0.7843114 | 4 |
Moler class of Unix command mount. | def __init__(self, connection, options=None, device=None, directory=None, prompt=None, newline_chars=None,
runner=None):
super(Mount, self).__init__(connection=connection, prompt=prompt, newline_chars=newline_chars, runner=runner)
# Parameters defined by calling the command
sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mount(self):\n return self._mount",
"def mount(self, mount):\n assert mount in (ComponentBase.MOUNTS)\n if mount==self.MOUNT_HYB:\n raise Exception(\"Unsupported mount.\")\n self._mount = mount\n self._check_mount()",
"def testMountCommand(self):\n with self.assertRaises(FilePath... | [
"0.68459976",
"0.6746837",
"0.66094476",
"0.65165293",
"0.6478037",
"0.63636965",
"0.63398814",
"0.6326575",
"0.6229015",
"0.61068434",
"0.6089923",
"0.6050603",
"0.60273486",
"0.60215586",
"0.601697",
"0.6004157",
"0.5968393",
"0.59526014",
"0.59160775",
"0.59134746",
"0.587... | 0.667246 | 2 |
Read examples from path. | def _read_examples(self, train_test_val_split, path):
train_examples = []
eval_examples = []
test_examples = []
with genomics_reader.TFRecordReader(
ngs_errors.get_train_filename(path), proto=example_pb2.Example) as fin:
train_examples = list(fin)
with genomics_reader.TFRecordReader(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)",
"def load_examples(path: str) -> List['InputExample']:\n with open(path, 'rb') as fh:\n return pickle.load(fh)",
"def load_examples(path: str) -> List['InputExampl... | [
"0.7140732",
"0.7140732",
"0.7140732",
"0.70798475",
"0.7010377",
"0.6614629",
"0.6553155",
"0.65470684",
"0.6530755",
"0.65236205",
"0.6338437",
"0.6306377",
"0.6261953",
"0.6246576",
"0.61261564",
"0.61261564",
"0.61261564",
"0.61261564",
"0.61261564",
"0.61261564",
"0.6126... | 0.62074655 | 14 |
render the content for the graph container | def render_content(self, request, tag):
if self.showreel_document is not None:
graph_row_xml = XMLString(self.get_content_xml())
return graph_row_xml.load()
else:
oops_container = self.get_bad_container()
return oops_container.load() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def graphs():\n return render_template(\"graphs.html\")",
"def get_content_render(fig, index: int, content: str = ''):\n # returns a html tag\n return html.Div([\n dcc.Graph(id=f'graph_{graph_nr[index]}', figure=fig),\n html.H3(content),\n ], style={'font-family': 'Helvetica',\n ... | [
"0.7299308",
"0.71782285",
"0.68271524",
"0.6663665",
"0.664291",
"0.6620926",
"0.6457115",
"0.6414615",
"0.6356832",
"0.6356767",
"0.63431394",
"0.63144624",
"0.6310719",
"0.6260441",
"0.6242107",
"0.6227696",
"0.6209762",
"0.6199873",
"0.6185111",
"0.61758035",
"0.61743957"... | 0.6722177 | 3 |
something has gone wrong that causes the page not to render correctly return some xml to respond to this | def get_bad_container(self):
return XMLFile(
FilePath("TrackerDash/snippets/no_dash_data_container.xml")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xml():\n try:\n return Response(render_template(\n 'lti.xml.j2'), mimetype='application/xml'\n )\n except:\n app.logger.error(\"Error with XML.\")\n return return_error('''Error with XML. Please refresh and try again. If this error persists,\n please cont... | [
"0.6696877",
"0.6493592",
"0.6273593",
"0.6260683",
"0.6117754",
"0.60652006",
"0.60274285",
"0.60092545",
"0.5996741",
"0.59941775",
"0.58831203",
"0.5871651",
"0.58566284",
"0.58541214",
"0.57838386",
"0.5783325",
"0.576661",
"0.57623935",
"0.5737121",
"0.5731637",
"0.57185... | 0.0 | -1 |
get the showreel item url array | def get_showreel_item_urls(self):
links = []
rel_path = "../"
if self.display:
rel_path = rel_path * 2
for item in self.showreel_document["reels"]:
if item["item_type"] == 'dashboard':
link = "../%sdisplay/dashboard/%s" % (rel_path, item["title"])... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getURLs():",
"def url(self):\n return url_for_item(self.key)",
"def url(self):\n return url_for_item(self.key)",
"def url(self, index):\r\n return self.arraydata[index.row()][3]",
"def get_item_url(self, item):\n return self.get_absolute_url(item, 'detail')",
"def get_url(... | [
"0.6485568",
"0.645834",
"0.645834",
"0.6320854",
"0.6319648",
"0.63013756",
"0.6289393",
"0.6228144",
"0.6174826",
"0.6151455",
"0.60874134",
"0.5989771",
"0.59726894",
"0.59524935",
"0.5925669",
"0.59131056",
"0.5910598",
"0.58754987",
"0.58629525",
"0.5838614",
"0.58370227... | 0.8105406 | 0 |
We ask for owners as email addresses but LDAP needs the DN for the appropriate object | def process_group_owners(data):
owner_list = []
owners = data.split("\r\n")
for owner in owners:
if owner != "":
result = shared_ldap.find_from_email(owner)
if result is None:
shared_sd.post_comment(
"Unable to add %s as an owner as the ema... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_empty_owners():\n result = shared_ldap.find_from_email(shared.globals.REPORTER)\n if result is not None:\n shared_sd.post_comment(\n \"Adding %s as the owner of the group.\" % shared.globals.REPORTER, True)\n return [result]\n\n # OK - something stupid is happening but ... | [
"0.6519693",
"0.6108533",
"0.601819",
"0.5960598",
"0.59551305",
"0.5824557",
"0.5728829",
"0.5621332",
"0.55355567",
"0.5514881",
"0.5485151",
"0.5441718",
"0.54410255",
"0.5418896",
"0.54182565",
"0.54131806",
"0.53478324",
"0.5340073",
"0.5334549",
"0.5328107",
"0.53239036... | 0.60889524 | 2 |
Try to add the reporter as a fallback owner or if no alternative owners have been specified. This should work since only employees are allowed to use this request type and all employees are in LDAP. | def handle_empty_owners():
result = shared_ldap.find_from_email(shared.globals.REPORTER)
if result is not None:
shared_sd.post_comment(
"Adding %s as the owner of the group." % shared.globals.REPORTER, True)
return [result]
# OK - something stupid is happening but let's give our... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_user(self, requestor, requestee, default=None):\n self.lock.acquire()\n self.users.add(requestor)\n ok = requestee in self.users\n self.lock.release()\n\n # if this isn't the default app, also add the user to the default app\n if default != self and default != No... | [
"0.5346557",
"0.5095638",
"0.50383765",
"0.5028467",
"0.48953253",
"0.48707283",
"0.4851011",
"0.48406032",
"0.48377118",
"0.48243517",
"0.48027915",
"0.4784198",
"0.47707832",
"0.47077477",
"0.46895742",
"0.46746963",
"0.46505794",
"0.46497324",
"0.4624019",
"0.46179965",
"0... | 0.63934386 | 0 |
Performs the designed action, based on the logic implemented for this method by all the classes that subclass this one, and overrides this method | def play(self, rumble, **kwargs) -> Any:
pass # abstract methods does not provides an implementation in Python | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _do_action(self):\n pass",
"def _do_action(self):\n pass",
"def act(self):\n raise NotImplementedError",
"def _action(self):\n pass",
"def action(self):\n pass",
"def action(self):\n pass",
"def act(self):\n pass",
"def perform(self):\n pass... | [
"0.76621544",
"0.76621544",
"0.7254013",
"0.71458393",
"0.7133721",
"0.7133721",
"0.7113193",
"0.70026004",
"0.69369143",
"0.6874843",
"0.6846552",
"0.673988",
"0.673988",
"0.6686165",
"0.6655994",
"0.6655625",
"0.660916",
"0.65968966",
"0.65783566",
"0.65521324",
"0.65328544... | 0.0 | -1 |
From the start node assign registers as they are laid out in the ideal circuit diagram in [CDKM96]_. Assumes that the there are no dead ends in the graph, and any available neighbor can be selected from the start without any further checks. | def assign_registers_to_line_or_cycle(start: int, graph: nx.Graph, num_length: int) \
-> Tuple[Sequence[int], Sequence[int], int, int]:
if 2 * num_length + 2 > nx.number_of_nodes(graph):
raise ValueError("There are not enough qubits in the graph to support the computation.")
graph = graph.copy(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assign(self, starts):\n # Initialize the set of open and closed nodes, and the connection map\n open_set, closed_set = starts, set()\n \n # Initialize a map of assignments and associated profits\n profits = {s:0 for s in starts}\n \n while open_set:\n\n ... | [
"0.62554306",
"0.5982689",
"0.5950736",
"0.5790706",
"0.5765575",
"0.5628461",
"0.5544183",
"0.55432373",
"0.55188954",
"0.550841",
"0.54753715",
"0.5472471",
"0.5345496",
"0.5322016",
"0.53219366",
"0.5297514",
"0.5297507",
"0.5270394",
"0.52688956",
"0.5244919",
"0.52377003... | 0.6497673 | 0 |
Searches for a layout among the given qubits for the two nbit registers and two additional ancilla that matches the simple layout given in figure 4 of [CDKM96]_. This method ignores any considerations of physical characteristics of the qc aside from the qubit layout. An error is thrown if the appropriate layout is not ... | def get_qubit_registers_for_adder(qc: QuantumComputer, num_length: int,
qubits: Optional[Sequence[int]] = None)\
-> Tuple[Sequence[int], Sequence[int], int, int]:
if qubits is None:
unavailable = [] # assume this means all qubits in qc are available
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_mapping_consistency(layout):\n values = sorted(layout.values())\n keys = list(layout)\n ref_keys = [\"q\" + str(i) for i in range(len(keys))]\n if keys != ref_keys:\n raise PlacementError(\"Some physical qubits in the layout may be missing or duplicated.\")\n if values != list(rang... | [
"0.49703202",
"0.48756662",
"0.48414853",
"0.46022666",
"0.45521045",
"0.45476255",
"0.44789764",
"0.43654552",
"0.43505117",
"0.4343972",
"0.43153837",
"0.43040147",
"0.43010375",
"0.4282951",
"0.42795786",
"0.4265875",
"0.42644864",
"0.42477572",
"0.42424133",
"0.42418486",
... | 0.49284887 | 1 |
Produces a program implementing reversible adding on a quantum computer to compute a + b. This implementation is based on [CDKM96]_, which is easy to implement, if not the most efficient. Each register of qubit labels should be provided such that the first qubit in each register is expected to carry the least significa... | def adder(num_a: Sequence[int], num_b: Sequence[int], register_a: Sequence[int],
register_b: Sequence[int], carry_ancilla: int, z_ancilla: int, in_x_basis: bool = False,
use_param_program: bool = False) -> Program:
if len(num_a) != len(num_b):
raise ValueError("Numbers being added must b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addition(a, b):\n bina = [int(x) for x in bin(a)[2:]]\n binb = [int(x) for x in bin(b)[2:]]\n while len(bina) >= len(binb):\n binb = [0]+binb\n while len(bina) < len(binb)-1:\n bina = [0]+bina\n bina.reverse()\n binb.reverse()\n n = len(bina)+len(binb)\n na = len(bina)\n ... | [
"0.8332056",
"0.7943099",
"0.7541027",
"0.7422055",
"0.72869945",
"0.68409365",
"0.66323876",
"0.657023",
"0.6435118",
"0.6424183",
"0.6408739",
"0.63692945",
"0.63223016",
"0.63202614",
"0.63042223",
"0.6280893",
"0.6249376",
"0.62431586",
"0.6136598",
"0.610853",
"0.6102547... | 0.7033453 | 5 |
Convenient wrapper for collecting the results of addition for every possible pair of n_bits long summands. | def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,
registers: Optional[Tuple[Sequence[int], Sequence[int], int,
int]] = None,
qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def BitAdd(m, n, length):\n\n lmax = max(len(m), len(n))\n c = 0\n ml = [0] * (lmax - len(m)) + [int(x) for x in list(m)]\n nl = [0] * (lmax - len(n)) + [int(x) for x in list(n)]\n rl = []\n for i in range(1, lmax+1):\n if ml[-i] + nl[-i] + c == 0:\n rl.insert(0, 0)\n ... | [
"0.639511",
"0.63929343",
"0.59793633",
"0.59044194",
"0.5766572",
"0.573465",
"0.56742185",
"0.5659172",
"0.5646547",
"0.56439763",
"0.56177783",
"0.5554337",
"0.555092",
"0.5537357",
"0.5496097",
"0.549155",
"0.5491507",
"0.54769105",
"0.54585946",
"0.54068106",
"0.54036504... | 0.6577094 | 0 |
Get the probability of a successful addition for each possible pair of two n_bit summands from the results output by get_n_bit_adder_results | def get_success_probabilities_from_results(results: Sequence[Sequence[Sequence[int]]]) \
-> Sequence[float]:
num_shots = len(results[0])
n_bits = len(results[0][0]) - 1
probabilities = []
# loop over all binary strings of length n_bits
for result, bits in zip(results, all_bitstrings(2 * n_b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_n_bit_adder_results(qc: QuantumComputer, n_bits: int,\n registers: Optional[Tuple[Sequence[int], Sequence[int], int,\n int]] = None,\n qubits: Optional[Sequence[int]] = None, in_x_basis: bool = False,... | [
"0.67043245",
"0.6088592",
"0.6078585",
"0.60144264",
"0.5993007",
"0.59269917",
"0.59174794",
"0.5848427",
"0.58017844",
"0.5783029",
"0.57710576",
"0.57601815",
"0.5722196",
"0.57119036",
"0.5695961",
"0.5689013",
"0.5688207",
"0.56689256",
"0.5668077",
"0.5657879",
"0.5653... | 0.6910166 | 0 |
Get the distribution of the hamming weight of the error vector (number of bits flipped between output and expected answer) for each possible pair of two n_bit summands using results output by get_n_bit_adder_results | def get_error_hamming_distributions_from_results(results: Sequence[Sequence[Sequence[int]]]) \
-> Sequence[Sequence[float]]:
num_shots = len(results[0])
n_bits = len(results[0][0]) - 1
hamming_wt_distrs = []
# loop over all binary strings of length n_bits
for result, bits in zip(results, al... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_possible_outcomes(m, bits):\n\n # This is filled with loads of dirty binary tricks...You have been warned\n\n size = max(m.shape) # Max of shape to account for bra or ket\n nqubits = int(math.log(size, 2) + .1) # Number of qubits possible\n\n # Make the output states and put in output_matric... | [
"0.616687",
"0.588979",
"0.5826358",
"0.58103514",
"0.5805173",
"0.5767479",
"0.5664263",
"0.5663091",
"0.5662125",
"0.56533957",
"0.5645126",
"0.56185484",
"0.556853",
"0.55329996",
"0.54994404",
"0.5493898",
"0.546257",
"0.544698",
"0.5440642",
"0.5435228",
"0.5425672",
"... | 0.70478463 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.