\n for f in os.listdir(input_dir):\n source = os.path.join(base_dir, \"inputs\", dirname, f)\n if os.path.isdir(source):\n test_all_inputs_in(base_dir,os.path.join(dirname,f)) # recurse\n else:\n test_path = source\n result_path = os.path.join(base_dir,\"outputs\",dirname,f)\n try:\n os.makedirs(result_path)\n except:\n pass\n test_res = perform_test(sys.argv[1],source,result_path,sys.argv[2:])\n assert(not test_res[0] or os.path.isfile(os.path.join(output_dir,\"log\")))\n try:\n shutil.move(os.path.join(output_dir,\"log\"),os.path.join(output_dir,f+\".log\"))\n except:\n pass\n\n if not test_res[0]:\n crashes[machine].append([source,test_res[1]])\n elif test_res[3] != None:\n times[test_res[2]] = test_res[3]\n\ntest_all_inputs_in(TESTS_DIR)\nfor machine, crash_list in crashes.iteritems():\n print(\"\\nEncountered \"+str(len(crash_list))+\" program failures for \"+machine)\n for test in crash_list:\n print(\"Decompiler failed on \"+test[0]+\" - \"+str(test[1]))\n\nsorted_times = sorted(times.iteritems(), key=operator.itemgetter(1), reverse=True)\nprint(\"Slowest run in bytes/sec \"+sorted_times[0][0]+\" - \"+str(sorted_times[0][1])+\" bytes/sec\")\n\n#Dir.open(TESTS_DIR+\"/inputs\").each() {|f|\n# next if f==\".\" or f==\"..\"\n# FileUtils.mv(TESTS_DIR+\"/inputs/\"+f,TESTS_DIR+\"/outputs/\"+f) if f.end_with?(\".b\")\n#}\n#puts \"**************************************\\n\"\n","repo_name":"hakusdream/boomerang","sub_path":"regression_tester.py","file_name":"regression_tester.py","file_ext":"py","file_size_in_byte":3567,"program_lang":"python","lang":"en","doc_type":"code","dataset":"github-code","pt":"51"}
+{"seq_id":"29207878701","text":"import numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib\nfrom matplotlib import cm\nfrom mpl_toolkits.mplot3d import Axes3D\nimport os\nimport subprocess\nplt.rc('text', usetex=True)\nfrom mpi4py import MPI\nimport sys \n\n\ndef get_grid(mx, my, mz, Lx,Ly,Lz):\n #print('mx,my,mz = ',mx,my,mz)\n ix, iy, iz = Lx*np.linspace(0,1,mx), Ly*np.linspace(0,1,my), Lz*np.linspace(0,1,mz)\n x, y, z = np.meshgrid(ix,iy,iz, indexing='ij')\n #print('ix', ix), print('iy', iy), print('iz', iz)\n return x,y,z\n\ndef plot_grid(x,y,z,T, t, filename):\n def plot_boundary_only(x,y,z,T):\n #mx, my, mz = x.shape\n x[1:-1, 1:-1, 1:-1],y[1:-1, 1:-1, 1:-1],z[1:-1, 1:-1, 1:-1],T[1:-1, 1:-1, 1:-1] = np.nan, np.nan, np.nan, np.nan \\\n #This removes interior because we cannot see it anyway? reduces time to plot\n return x,y,z,T\n \n x,y,z,T = plot_boundary_only(x,y,z,T)\n fig = plt.figure(figsize=(15,15), facecolor = 'w')\n ax = fig.add_subplot(111, projection='3d')\n img = ax.scatter(x,y,z, c=T.reshape(-1), s=150, vmin = -2.5, vmax = 23, cmap=plt.inferno())\n cbar = fig.colorbar(img, orientation='horizontal', fraction=0.047, pad=0.15, aspect=15)\n plt.tick_params(axis='both', which='major', labelsize=18)\n cbar.ax.tick_params(labelsize=20)\n cbar.set_label(r'Temperature ($^oC$)', size = 22)\n \n ax.text(0,0,-15, 't = %i days'%t, fontsize=20)\n ax.set_xticklabels(['%i'%(l*W/Nw) for l in ax.get_xticks()])\n ax.set_yticklabels(['%i'%(l*L/Nl/1e3) for l in ax.get_yticks()])\n ax.set_zticklabels(['%i'%(l*D/Nd) for l in ax.get_zticks()])\n ax.set_ylabel('Y (km)', labelpad=20, fontsize=20)\n ax.set_xlabel('X (m)', labelpad=20, rotation=0, fontsize=20)\n ax.set_zlabel('Depth from surface (m)', rotation=0, fontsize=20)\n ax.invert_zaxis()\n ax.view_init(15, -20)\n #plt.tight_layout()\n #plt.savefig('tempevolution_plots/temp%s.png'%count)\n plt.savefig(filename, bbox_inches='tight')\n #plt.show()\n\n\ndef init_T(x,y,z, T_3d):\n #print('size of y = ', np.shape(y))\n T = np.zeros_like(x)\n #print('Size of T = ',np.shape(T))\n T = T_3d\n return T\n\ndef show_plot(crust, t):\n fig, ax = plt.subplots(1,1, figsize=(5,4))\n im = ax.imshow(crust, vmin=0, vmax=20, cmap = 'inferno', aspect = 1 * (Nw/Nd))\n cbar = fig.colorbar(im, ax=ax)\n cbar.set_label('$\\mathrm{Temperature\\ [K]}$', rotation=270, labelpad=15)\n ax.set_title('$\\mathrm{t = %i\\ days}$'%t)\n ax.set_xlabel('$\\mathrm{Width}$')\n ax.set_ylabel('$\\mathrm{Depth}$')\n\n\ncomm = MPI.COMM_WORLD\nNtasks = comm.Get_size()\nThisTask = comm.Get_rank()\n\n\n# Constants (currently set for Earth vals)\n\nTinit = 10 # C\nTvar = 12 # C\nTbottom = 11 # C\n\n# Diffusion constant (https://www.nature.com/articles/nature07818)\nalpha = 0.0864 # m^2 / day\n#alpha = 0.389 #m^2 / day (https://terra-docs.s3.us-east-2.amazonaws.com/IJHSR/Articles/volume4-issue3/2022_43_p17_Murgia.pdf)\n\n# times\ntyear = 11.2 # days in a year of proxima b\nti = 0 # d\ntf = 1*tyear # d\ndt = 0.1 # d\n\nTemp_day = 7 #C\ntday = 1 #day\n\n# Depth, width, length (need to keep dt < a**2/(2*alpha))\nD = 10 # m\nNd = 40\nW = 50 # m\nNw = 50\nL = 4e6 # m\nNl = 100\nad = D/Nd\nal = L/Nl\n\n\n#We will be deviding the 2D array colum-wise among the tasks\n\nindex_high = int(((ThisTask + 1) * Nl) / Ntasks) #setting upper bound of column no for each task\nindex_low = int((ThisTask * Nl) / Ntasks) #setting lower bound of column no for each task\ndel_index = int(Nl / Ntasks) #For now please provide Ntasks such that del_index is automatically int\n#print('del_index = {}'.format(del_index))\n#sys.stdout.flush()\n\n\n# Read in flare info from Vida+2019\nenergy = np.genfromtxt('vida+2019_flares.txt', usecols=3, skip_header=2)\nelen = len(energy)\n# Probability of a flare occuring in dt = number of flares / number of dt in 50 days \nflare_prob = elen / (50/dt)\n\n# energy = np.append(energy, 1e34)\n\n# Ergs in a given dt:\npcen_energy = 6.03e30 * 24*60*60 * dt\nflare_factor = 4.8*energy / pcen_energy * (Tinit+Tvar+Temp_day)\n\n\ncrust = np.full((Nd,Nl), Tinit, dtype='float')\n#crust = np.ones((Nd,Nl), dtype = 'float') * Tinit\ncrust[Nd-1] = Tbottom\n\n#initializing the cells\ncell_left = np.zeros(1)\ncell_right = np.zeros(1)\n#cell_upper = np.zeros(1)\n#cell_lower = np.zeros(1)\n\n\ncount = 0 #for plotting\n\nif ( (dt*alpha/ad**2 > 0.5) or (dt*alpha/al**2 > 0.5)):\n dt = 0.5*min(ad,al)**2/alpha\n print('dt adjusted to {}'.format(dt))\n sys.stdout.flush()\nfor t in np.arange(ti, tf+dt, dt):\n # Randomly choose if a flare happens; if yes, pick from the flare list. \n if np.random.rand() < flare_prob:\n idx = np.random.randint(elen)\n flare_change = flare_factor[idx]\n print('Careful, flare at t = %.2f days! id = %i, Tchange = %.2E K '%(\n t, idx, flare_factor[idx]))\n else:\n flare_change = 0\n \n\n # periodic heating at surface with phase shift (INCORRECT ON SUB-DAY TIMESCALE)\n phase = np.arange(Nl)/Nl\n crust[0] = Tinit + Tvar*np.sin(2*np.pi*(t/tyear+phase)) + Temp_day*np.sin(2*np.pi*(t/tday + phase)) + flare_change\n\n crust_thistask = crust[:,index_low:index_high]\n nrow, ncol = np.shape(crust_thistask)\n #print('Shape of crust_thistask is= {}, in task = {}'.format(np.shape(crust_thistask), ThisTask))\n #sys.stdout.flush()\n\n print('Parallelization begins......')\n sys.stdout.flush()\n\n if ThisTask == 0 : #rank == 0\n for i in range(1,nrow-1):\n for j in range(0,ncol-1):\n if ((j-1) < index_low):\n #cell_left = comm.irecv(source = Ntasks-1, tag = Ntasks-1)\n #print('Left cell received at task {} of {} from task {}'.format(ThisTask, Ntasks, Ntasks-1))\n #sys.stdout.flush()\n #cell_right = crust_thistask[i,j+1]\n cell_left = np.zeros(1)\n comm.isend(crust_thistask[i,j], dest = Ntasks-1, tag = 0)\n #print('Right cell sent from task {} of {} to task {}'.format(ThisTask, Ntasks, Ntasks-1))\n #sys.stdout.flush()\n #print('Waiting to receive left cell at task {}'.format(ThisTask))\n cell_left_req = comm.irecv(cell_left, source = Ntasks-1, tag = Ntasks-1)\n #cell_left_req.wait()\n #print('Left cell received at task {} of {} from task {}'.format(ThisTask, Ntasks, Ntasks-1))\n #sys.stdout.flush()\n cell_left = cell_left[0]\n cell_right = crust_thistask[i,j+1]\n cell_upper = crust_thistask[i+1,j]\n cell_lower = crust_thistask[i-1,j]\n elif ((j+1) > index_high):\n cell_left = crust_thistask[i,j-1]\n #print('Waiting to receive left cell at task {}'.format(ThisTask))\n cell_right = np.zeros(1)\n cell_right_req = comm.irecv(cell_right, source = 1, tag = 1)\n #cell_right_req.wait()\n #print('Right cell received at task {} of {} from task {}'.format(ThisTask, Ntasks, 1))\n #sys.stdout.flush()\n cell_right = cell_right[0]\n comm.isend(crust_thistask[i,j], dest = 1, tag = 0)\n #print('Left cell sent from task {} of {} to task {}'.format(ThisTask, Ntasks, 1))\n #sys.stdout.flush()\n cell_upper = crust_thistask[i+1,j]\n cell_lower = crust_thistask[i-1,j]\n else:\n cell_upper = crust_thistask[i+1,j]\n cell_lower = crust_thistask[i-1,j]\n cell_right = crust_thistask[i,j+1]\n cell_left = crust_thistask[i,j-1]\n #print('This is not a edge cell at task {}'.format(ThisTask))\n #sys.stdout.flush()\n crust_thistask[i,j] = crust_thistask[i,j] + dt * alpha * \\\n ( (cell_upper + cell_lower - 2 * crust_thistask[i,j] ) / ad**2 + \\\n (cell_right + cell_left - 2 * crust_thistask[i,j]) / al**2 )\n\n\n\n\n elif ThisTask != 0 :\n for i in range(1,nrow-1):\n for j in range(0,ncol-1):\n if ((j-1) < index_low):\n comm.isend(crust_thistask[i,j], dest=ThisTask-1, tag = ThisTask)\n #print('Right cell sent from task {} of {} to task {}'.format(ThisTask, Ntasks, ThisTask-1))\n #sys.stdout.flush()\n cell_left = np.zeros(1)\n #print('Waiting to receive left cell at task {}'.format(ThisTask))\n cell_left_req = comm.irecv(cell_left, source = ThisTask-1, tag = ThisTask-1)\n #cell_left_req.wait()\n #print('Left cell received at task {} of {} from task {}'.format(ThisTask, Ntasks, ThisTask-1))\n #sys.stdout.flush()\n cell_left = cell_left[0]\n cell_right = crust_thistask[i,j+1]\n cell_upper = crust_thistask[i+1,j]\n cell_lower = crust_thistask[i-1,j] \n elif ((j+1) > index_high): #if left cell needs to come from another task\n if (ThisTask < Ntasks-1):\n comm.isend(crust_thistask[i,j], dest = ThisTask+1, tag=ThisTask) #This is right edge, send to next task as left cell\n #print('Left cell sent from task {} of {} to task {}'.format(ThisTask, Ntasks, ThisTask+1))\n #sys.stdout.flush()\n cell_left = crust_thistask[i,j-1]\n #print('Waiting to receive left cell at task {}'.format(ThisTask))\n cell_right = np.zeros(1)\n cell_right_req = comm.irecv(cell_right, source = ThisTask+1, tag = ThisTask+1)\n #print('Right cell received at task {} of {} from task {}'.format(ThisTask-1, Ntasks, ThisTask+1))\n #sys.stdout.flush()\n cell_right = cell_right[0]\n cell_upper = crust_thistask[i+1,j]\n cell_lower = crust_thistask[i-1,j]\n else:\n comm.isend(crust_thistask[i,j], dest = 0, tag=ThisTask)\n cell_left = crust_thistask[i,j-1]\n #print('Waiting to receive left cell at task {}'.format(ThisTask))\n cell_right = np.zeros(1)\n cell_right_req = comm.irecv(cell_right, source = 0, tag = 0)\n #cell_right_req.wait()\n #print('Right cell received at task {} of {} from task {}'.format(ThisTask-1, Ntasks, ThisTask+1))\n #sys.stdout.flush()\n cell_right = cell_right[0]\n cell_upper = crust_thistask[i+1,j]\n cell_lower = crust_thistask[i-1,j]\n # elif ((j-1) < index_low):\n # comm.isend(crust_thistask[i,j], dest=ThisTask-1, tag = ThisTask)\n # cell_left = comm.irecv(source = ThisTask-1, tag = ThisTask-1)\n # cell_right = crust_thistask[i,j+1]\n else:\n cell_upper = crust_thistask[i+1,j]\n cell_lower = crust_thistask[i-1,j]\n cell_right = crust_thistask[i,j+1]\n cell_left = crust_thistask[i,j-1]\n #print('This is not a edge cell at task {}'.format(ThisTask)) \n #sys.stdout.flush()\n crust_thistask[i,j] = crust_thistask[i,j] + dt * alpha * \\\n ( (cell_upper + cell_lower - 2 * crust_thistask[i,j] ) / ad**2 + \\\n (cell_right + cell_left - 2 * crust_thistask[i,j]) / al**2 )\n\n\n crust_combined = comm.gather(crust_thistask, root = 0)\n print('Parallelization ends......')\n sys.stdout.flush()\n\n \n if (ThisTask == 0):\n #print('Shape of combined data = {}'.format(np.shape(crust_combined)))\n crust_combined = np.array(crust_combined, float)\n crust = np.zeros((Nd,Nl), float)\n #print('Shape of crust = {}'.format(np.shape(crust)))\n # index_low = i*del_index\n # index_high = (i+1) * del_index\n for i in range(np.shape(crust_combined)[0]):\n index_low = int(i*del_index)\n index_high = int((i+1) * del_index)\n #print('i, index_low, index_high = {},{},{}'.format(i, index_low, index_high))\n crust[:,index_low:index_high] = crust_combined[i,:] \n \n #print('FINAL RESULT AFTER PARALLELIZATION HAS SHAPE OF {}'.format(np.shape(crust)))\n \n if t%(tyear//5) == 0:\n crust_3d = np.zeros((Nw,Nl,Nd), float)\n \n for i in range(Nw):\n crust_3d[i,:,:] = crust.T\n \n nx, ny, nz = Nw, Nl, Nd\n Lx, Ly, Lz = nx-1, ny-1, nz-1\n x,y,z = get_grid(nx, ny, nz, Lx,Ly,Lz) # generate a grid with mesh size Δx = Δy = Δz = 1\n T = init_T(x,y,z, crust_3d)\n filename = 'test_parallel/tempevolution_plots/proxima_b_test/temp'+str(count).zfill(3)+'.png'\n plot_grid(x,y,z,T, t, filename)\n count += 1\n\n \n","repo_name":"niranjancroy/exoplanet_heat","sub_path":"heat_ftcs_parallel.py","file_name":"heat_ftcs_parallel.py","file_ext":"py","file_size_in_byte":13358,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"69924023200","text":"# coding: utf-8\n\nimport numpy as np\n\n\ndef _convert_puzzle_to_dict(puzzle):\n\tmap = {}\n\tfor x, row in enumerate(puzzle):\n\t\tfor y, cell in enumerate(row):\n\t\t\tmap[(x, y)] = cell\n\treturn map\n\n\ndef _convert_list_to_dict(list, size):\n\tmap = {}\n\tfor y in range(size):\n\t\tfor x in range(size):\n\t\t\tmap[(x, y)] = list[x * size + y]\n\treturn map\n\n\ndef _convert_to_array(dict, size):\n\tarray = np.array([0] * size * size).reshape(size, size)\n\tfor (x, y), value in dict.items():\n\t\tarray[x][y] = value\n\treturn array\n\n\ndef get_key(dict, needle):\n\tfor key, value in dict.items():\n\t\tif value == needle:\n\t\t\treturn key\n\treturn None\n\ndef _convert_puzzle_to_list(puzzle):\n\tlst = [number for line in puzzle for number in line]\n\treturn (lst)\n","repo_name":"toferrari/N-Puzzle","sub_path":"utils.py","file_name":"utils.py","file_ext":"py","file_size_in_byte":715,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"18079843660","text":"def maior (*num):\n pos = 0\n maiorValor = - 9999\n\n while(pos < len(num)):\n\n if(num[pos]> maiorValor):\n\n maiorValor = num[pos]\n pos += 1\n\n print(maiorValor)\n\nmaior(2,7,10,25,37,45,-20)","repo_name":"Gleytton/Curso_em_Video_Python","sub_path":"99.py","file_name":"99.py","file_ext":"py","file_size_in_byte":219,"program_lang":"python","lang":"pt","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"25261223726","text":"#!/usr/bin/env python3\n\n################################################################\n# Exports a text file in json format to be imported as a list\n################################################################\n\nimport json\nimport sys\nimport os\n\n# get script path from arguments\npath = str(sys.argv[0])\npath_list = list(path.split(\"/\"))\n\n# build a relative path excluding the last argument\nrel_path = ''\nfor path in path_list[0:-1]:\n rel_path = rel_path + path + os.sep\n\n# Use that as the basis for importing the file\nfilename = f\"{rel_path}files/numbers.json\"\n\nnumbers = [2, 3, 5, 7, 11, 13]\n\nwith open(filename, 'w') as f:\n json.dump(numbers, f)\n","repo_name":"gerryw1389/python","sub_path":"learning/base-language/read-write-files/write-text/write-json-list.py","file_name":"write-json-list.py","file_ext":"py","file_size_in_byte":659,"program_lang":"python","lang":"en","doc_type":"code","stars":1,"dataset":"github-code","pt":"51"}
+{"seq_id":"43468114810","text":"import fogNode\r\nimport fogUser\r\nimport random\r\nimport constants\r\nimport numpy as np\r\n\r\n### A MODULE CONTAINING SOME USEFUL FUNCTIONS USED IN VARIOUS ASPECTS THE SYSTEM ###\r\n\r\ndef initalize(k, u):\r\n # initalizing 2 lists. One of k fogNodes and one of u fogUsers\r\n nodes = [];\r\n users = [];\r\n for i in range(k):\r\n temp = fogNode.fogNode(i);\r\n nodes.append(temp)\r\n for i in range(u):\r\n temp = fogUser.fogUser(k);\r\n users.append(temp);\r\n return nodes, users;\r\n \r\n\r\ndef generateDistances(start, end, k, u):\r\n # returning a 2d list with distances between every node and every user. Rows represent nodes and columns represent users\r\n # inputs is the minimum and maximum distance (start and end) non-inclusive and the number of nodes, k and users, u\r\n lista = [];\r\n for i in range(k):\r\n row = [];\r\n for j in range(u):\r\n temp = random.randrange(start, end) + random.random();\r\n row.append(temp);\r\n lista.append(row);\r\n \r\n return np.array(lista)\r\n\r\n\r\ndef computePUK(distArray, k, theta):\r\n # Calculate the Puk value for every possible pair of Node and User. Inputs is the distance array and its number of rows and the theta factor\r\n lista = [];\r\n for i in range(k):\r\n distRow = distArray[i];\r\n maxRow = max(distRow)\r\n distRowNormalized = distRow / maxRow;\r\n finalRow = np.power(distRowNormalized, theta)\r\n lista.append(finalRow);\r\n return np.array(lista);\r\n \r\ndef computeGUK(distArray, theta):\r\n # calcalate the Guk value for every possible pair of Node and User. Inpiuts is the distance array an the theta factor\r\n newArray = 1 / distArray;\r\n return np.power(newArray, theta);\r\n\r\ndef firstRound(k, u):\r\n # a random assignment of each user to a node for the first round. Returns an array of size u with the node number.\r\n lista = [];\r\n for i in range(u):\r\n lista.append(random.randrange(k));\r\n return lista;\r\n\r\ndef indices(lista, element):\r\n # given a list @lista and an element @element, return a list of all the indices in which @element occurs\r\n return [index for index, value in enumerate(lista) if value == element]\r\n\r\n\r\ndef computeRUK(nodeList, puks, guks, curNodeList, k, u):\r\n # computing the RUK values\r\n lista = [];\r\n for i in range(u):\r\n nodeIndex = curNodeList[i];\r\n node = nodeList[nodeIndex];\r\n usersOnNode = indices(curNodeList, nodeIndex);\r\n usersOnNode.remove(i);\r\n mysum = 0 ;\r\n for user in usersOnNode:\r\n mysum += puks[nodeIndex][user] * guks[nodeIndex][user];\r\n toLog = 1 + (puks[nodeIndex][i] * guks[nodeIndex][i]) / (constants.G0 + mysum) \r\n ruk = node.WK * np.log2(toLog)\r\n lista.append(ruk);\r\n \r\n return np.array(lista);\r\n\r\ndef computeFUK(nodeList, userList, curNodeList, k, u, RBTSScores):\r\n # computing the FUK values\r\n lista = [];\r\n accScore = sum(RBTSScores);\r\n if accScore == 0:\r\n factors = np.ones(u);\r\n else:\r\n factors = RBTSScores / accScore;\r\n \r\n for i in range(u):\r\n nodeIndex = curNodeList[i];\r\n node = nodeList[nodeIndex];\r\n usersOnNode = indices(curNodeList, nodeIndex);\r\n phiSum = 0;\r\n iotaSum = 0;\r\n for user in usersOnNode:\r\n phiSum += userList[user].ongoingTask[1]\r\n iotaSum += userList[user].ongoingTask[0];\r\n fuk = userList[i].ongoingTask[1] / phiSum \r\n fuk *= 1 - iotaSum / node.BK;\r\n fuk *= node.FK;\r\n fuk *= factors[i];\r\n \r\n lista.append(fuk)\r\n \r\n return np.array(lista);\r\n\r\n\r\ndef computeTimeOverheads(userList, ruks, fuks):\r\n # computing time overheads. ie time to transmit the task\r\n lista = [];\r\n for i in range(len(userList)):\r\n overhead = userList[i].ongoingTask[0] / ruks[i] + userList[i].ongoingTask[2] / fuks[i] \r\n lista.append(overhead);\r\n \r\n return np.array(lista);\r\n\r\ndef computeEnergyOverheads(userList, u, curNodeList, puks, ruks):\r\n # compute the energy overheads ie. the amount of power we spend to complete the task\r\n lista = [];\r\n for i in range(u):\r\n nodeIndex = curNodeList[i];\r\n EO = userList[i].ongoingTask[0] * puks[nodeIndex][i] / ruks[i];\r\n lista.append(EO);\r\n \r\n return np.array(lista);\r\n\r\ndef addIUS(userList):\r\n # return the sum of all Itus from a list of users\r\n sumI = 0;\r\n for user in userList:\r\n sumI += user.ongoingTask[0];\r\n \r\n return sumI;\r\n\r\ndef randomVector(size):\r\n # returns a vector of size @size with random numbers\r\n lista = [];\r\n for i in range(size):\r\n lista.append(random.random());\r\n \r\n return np.array(lista);\r\n\r\ndef RQ(y, x):\r\n # the RQ functions as described in the WriteUp\r\n if x == 1:\r\n return 2 * y - pow(y, 2);\r\n elif x == 0:\r\n return 1 - pow(y,2);\r\n \r\n \r\ndef rewardsRange(normalizedRewards, newMax, newMin):\r\n lista = [];\r\n size = len(normalizedRewards);\r\n \r\n oldMax = max(normalizedRewards);\r\n oldMin = min(normalizedRewards);\r\n \r\n newRange = newMax - newMin;\r\n oldRange = oldMax - oldMin;\r\n \r\n if oldRange == 0:\r\n return np.ones(size) * (newMax + newMin) / 2\r\n \r\n for reward in normalizedRewards:\r\n lista.append((((reward - oldMin) * newRange)/ oldRange) + newMin)\r\n \r\n return np.array(lista)","repo_name":"stavros2/Thesis","sub_path":"src/compFunctions.py","file_name":"compFunctions.py","file_ext":"py","file_size_in_byte":5420,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"74346626077","text":"from django.conf.urls import patterns, include, url\nfrom rest_framework.urlpatterns import format_suffix_patterns\nfrom .views import PersonViewSet, OrganizationViewSet, MembershipViewSet, PostViewSet, AreaViewSet\nfrom .routers import DefaultPopsRouter\n\n# Routers provide an easy way of automatically determining the URL conf\nrouter = DefaultPopsRouter()\n\nrouter.register(r'persons', PersonViewSet)\nrouter.register(r'organizations', OrganizationViewSet)\nrouter.register(r'memberships', MembershipViewSet)\nrouter.register(r'posts', PostViewSet)\nrouter.register(r'areas', AreaViewSet)\n\n\nurlpatterns = patterns('',\n # django-rest-frameworks urls\n url(r'^', include(router.urls)),\n url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),\n)\n\n","repo_name":"openpolis/op_api3","sub_path":"api_project/pops/urls.py","file_name":"urls.py","file_ext":"py","file_size_in_byte":769,"program_lang":"python","lang":"en","doc_type":"code","stars":2,"dataset":"github-code","pt":"51"}
+{"seq_id":"9635968673","text":"# def search(data,key,min,max):\n# mid = int((min + max) / 2)\n# if data[mid] == key:\n# return mid\n# elif data[mid] > key:\n# max = mid -1\n# return search(data, key, min, max)\n# else:\n# min = mid + 1\n# return search(data, key, min, max)\n\n\ndef search2(data, key):\n min = 0\n max = len(data) - 1\n\n while max >= min:\n mid = int((min+max) / 2)\n if data[mid] == key :\n return mid\n elif data[mid] > key :\n max = mid - 1\n else:\n min = mid + 1\n\n\n\ndata = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\nkey = 7\n\n# print(search(data,7,0,len(data)-1))\n\nprint( search2(data, key))","repo_name":"HSUHAOBM/Python_note","sub_path":"other/practise/binary_search.py","file_name":"binary_search.py","file_ext":"py","file_size_in_byte":674,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"74038664797","text":"import urllib.request\nimport csv\nimport json\n\nfrom bs4 import BeautifulSoup\n\nSTATES_TO_CODE = {\n 'Alabama': 'AL',\n 'Alaska': 'AK',\n 'American Samoa': 'AS',\n 'Arizona': 'AZ',\n 'Arkansas': 'AR',\n 'California': 'CA',\n 'Colorado': 'CO',\n 'Connecticut': 'CT',\n 'Delaware': 'DE',\n 'District of Columbia': 'DC',\n 'Florida': 'FL',\n 'Georgia': 'GA',\n 'Guam': 'GU',\n 'Hawaii': 'HI',\n 'Idaho': 'ID',\n 'Illinois': 'IL',\n 'Indiana': 'IN',\n 'Iowa': 'IA',\n 'Kansas': 'KS',\n 'Kentucky': 'KY',\n 'Louisiana': 'LA',\n 'Maine': 'ME',\n 'Maryland': 'MD',\n 'Massachusetts': 'MA',\n 'Michigan': 'MI',\n 'Minnesota': 'MN',\n 'Mississippi': 'MS',\n 'Missouri': 'MO',\n 'Montana': 'MT',\n 'Nebraska': 'NE',\n 'Nevada': 'NV',\n 'New Hampshire': 'NH',\n 'New Jersey': 'NJ',\n 'New Mexico': 'NM',\n 'New York': 'NY',\n 'North Carolina': 'NC',\n 'North Dakota': 'ND',\n 'Northern Mariana Islands':'MP',\n 'Ohio': 'OH',\n 'Oklahoma': 'OK',\n 'Oregon': 'OR',\n 'Pennsylvania': 'PA',\n 'Puerto Rico': 'PR',\n 'Rhode Island': 'RI',\n 'South Carolina': 'SC',\n 'South Dakota': 'SD',\n 'Tennessee': 'TN',\n 'Texas': 'TX',\n 'Utah': 'UT',\n 'Vermont': 'VT',\n 'Virgin Islands': 'VI',\n 'Virginia': 'VA',\n 'Washington': 'WA',\n 'West Virginia': 'WV',\n 'Wisconsin': 'WI',\n 'Wyoming': 'WY'\n}\n\nMOVEMENTVOTE_URL = \"https://movement.vote/groups\" # this is a gatsby site, so doesn't have the full body hydrated\n# loaded it in a real browser and then saved to \nMOVEMENTVOTE_FILE = \"movementvote.html\"\nREQUEST_HEADERS = {'User-Agent' : \"bot\"}\nDESIRED_FIELDS = ['name', 'state', 'description', 'website', 'donation_url', 'logo_url', 'issues']\n\ndef get_page(url):\n request = urllib.request.Request(url, headers=REQUEST_HEADERS)\n connect = urllib.request.urlopen(request)\n return BeautifulSoup(connect.read(), 'html.parser')\n\ndef get_data(doc):\n data = []\n orgs_section = doc.find(\"section\", {\"class\": \"orgs-section\"})\n orgs_list = orgs_section.find(\"div\", {\"class\": \"orgs-list\"})\n for org in orgs_list.find_all(\"div\", {\"class\" : \"org\"}):\n state_name = org.find(\"div\", {\"class\": \"org-states\"}).get_text().strip()\n state_name = state_name.replace(\"National Groups\", \"\").replace(',','').strip()\n state = STATES_TO_CODE.get(state_name)\n name = org.find(\"div\", {\"class\": \"org-title\"}).get_text().strip()\n description = org.find(\"div\", {\"class\": \"org-content\"}).get_text().strip()\n image = org.find(\"img\", {\"class\": \"org-image\"})\n website = org.find(\"a\", {\"class\": \"org-link-web\"}, href=True)\n donate = org.find('a', {\"class\": \"org-link-donate\"}, href=True)\n org_tags = org.find(\"div\", {\"class\": \"org-tags\"})\n\n d = {\n 'name': name,\n 'state': state,\n 'description': description\n }\n if image:\n d['logo_url'] = image['src']\n if website:\n d['website'] = website['href']\n if donate:\n d['donation_url'] = donate['href'].replace('refcode=mvpsite', 'refcode=crush2020')\n if org_tags:\n first_tag = org_tags.find(\"div\", {\"class\": \"tagblock\"})\n if first_tag and first_tag.get_text().startswith(\"Issue Areas:\"):\n issues = first_tag.get_text().replace(\"Issue Areas: \", \"\").strip()\n d['issues'] = issues\n \n data.append(d)\n print(len(data))\n return data\n\ndef write_page(data, writer):\n for row in data:\n out_row = {k: v for k, v in row.items() if k in DESIRED_FIELDS}\n writer.writerow(out_row)\n\nwith open('../movementvote.csv', 'w') as out_file:\n out_writer = csv.DictWriter(out_file, fieldnames=DESIRED_FIELDS)\n out_writer.writeheader()\n\n # doc = get_page(MOVEMENTVOTE_URL)\n file = open(MOVEMENTVOTE_FILE, 'r')\n doc = BeautifulSoup(file.read(), 'html.parser')\n write_page(get_data(doc), out_writer)\n\n print(\"done\")\n","repo_name":"spacedogXYZ/crush2020","sub_path":"data/scripts/get_movementvote.py","file_name":"get_movementvote.py","file_ext":"py","file_size_in_byte":3994,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"73043699039","text":"import random\r\nimport os\r\n\r\nlogo = \"\"\"\r\n.------. _ _ _ _ _ \r\n|A_ _ |. | | | | | | (_) | | \r\n|( \\/ ).-----. | |__ | | __ _ ___| | ___ __ _ ___| | __\r\n| \\ /|K /\\ | | '_ \\| |/ _` |/ __| |/ / |/ _` |/ __| |/ /\r\n| \\/ | / \\ | | |_) | | (_| | (__| <| | (_| | (__| < \r\n`-----| \\ / | |_.__/|_|\\__,_|\\___|_|\\_\\ |\\__,_|\\___|_|\\_\\\\\r\n | \\/ K| _/ | \r\n `------' |__/ \r\n\"\"\"\r\n\r\ndef deal_card():\r\n \"\"\"Returns a random card from the deck.\"\"\"\r\n cards = [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]\r\n card = random.choice(cards)\r\n return card\r\n\r\n\r\ndef calculate_score(cards):\r\n if sum(cards) == 21 and len(cards) == 2:\r\n return 0\r\n if 11 in cards and sum(cards) > 21:\r\n cards.remove(11)\r\n cards.append(1)\r\n return sum(cards)\r\n\r\n\r\ndef compare(user_score, computer_score):\r\n if user_score == computer_score:\r\n return \"Its a DRAW 😶\"\r\n elif computer_score == 0:\r\n return \"Loose! Opponent has a blackjack\"\r\n elif user_score == 0:\r\n return \"Win with a blackjack 😎\"\r\n elif user_score > 21:\r\n return \"You went over. You lose!\"\r\n elif computer_score > 21:\r\n return \"Opponent went over. You WIN\"\r\n elif user_score > computer_score:\r\n return \"You win 🙂\"\r\n else:\r\n return \"You lose 😯\"\r\n\r\n\r\ndef play_game():\r\n print(logo)\r\n user_cards = []\r\n computer_cards = []\r\n con_game = True\r\n\r\n for _ in range(2):\r\n user_cards.append(deal_card())\r\n computer_cards.append(deal_card())\r\n\r\n while con_game:\r\n user_score = calculate_score(user_cards)\r\n computer_score = calculate_score(computer_cards)\r\n print(f\" Your cards: {user_cards}, score is: {user_score}\")\r\n print(f\" The computer's first card: {computer_cards[0]}\")\r\n if user_score == 0 or computer_score == 0 or user_score > 21:\r\n con_game = False\r\n else:\r\n user_should_deal = input(\"Type 'y' to take a new card or 'n' to pass: \")\r\n if user_should_deal == 'y':\r\n user_cards.append(deal_card())\r\n else:\r\n con_game = False\r\n\r\n while computer_score != 0 and computer_score < 17:\r\n computer_cards.append(deal_card())\r\n computer_score = calculate_score(computer_cards)\r\n\r\n print(f\"Your final hand is: {user_cards} and score is: {user_score}\")\r\n print(f\"The opponent's final hand is: {computer_cards} and score is: {computer_score}\")\r\n print(compare(user_score, computer_score))\r\n\r\n\r\nwhile input(\"Do you want to play a game of blackjack? Type 'y' or 'n': \") == 'y':\r\n os.system('cls')\r\n play_game()","repo_name":"aleesain/python","sub_path":"mini_game_blackjack.py","file_name":"mini_game_blackjack.py","file_ext":"py","file_size_in_byte":2801,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"38356148980","text":"\"\"\"\nThis file contains the self attention and the multi attention modules\n\nDescription :\nThe Network being implemented here produces context aware representation by applying attention to\neach pair of tokens from the input sequence\n\nThe idea is to use this network to predict the top n goals to use\nfor resubstitution in the Hindsight experience replay\n\n\"\"\"\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\ndef multiplicative_fn( x, q, linear_x, linear_q):\n \"\"\"\n\n :param x: Input token\n :param q: Query vector\n :param linear_x: Weight matrix for x\n :param linear_q: Weight matrix for query\n :return: compatibility function\n \"\"\"\n\n # Return the cosine similarity\n x_ = linear_x(x)\n q_ = linear_q(q)\n f = F.cosine_similarity(x_, q_)\n return f\n\n\ndef additive_fn( x, q, linear_x, linear_q, out_linear, num_hidden, activation):\n \"\"\"\n\n :param x: Input token\n :param q: Query vector\n :param linear_x: Weight matrix for x\n :param linear_q: Weight matrix for query\n :param num_hidden: Number of hidden layers\n :param activation: The Non linear activation function to use\n :return: compatibility function\n \"\"\"\n\n # Additive attention achieves better empirical performance\n x_ = linear_x(x)\n q_ = linear_q(q)\n o = out_linear(activation(x_ + q_))\n return o\n\n\nclass VanillaAttention(nn.Module):\n \"\"\"\n The standard attention module\n Vanilla Attention computes alignments scores of the query to each\n of the input tokens in an input sequence.\n \"\"\"\n def __init__(self, input_dim, query_dim, num_hidden, embedding_dim,\n activation, output_features,\n use_additive=True, save_attention=False,\n attention_dict=None, name=None):\n \"\"\"\n\n :param input_dim: The input dimension of the sequence or length of the sequence\n :param query_dim: The dimension of the query embedding - Current State || Desired Goal Vector\n :param num_hidden: The number of hidden layers in the network\n :param embedding_dim: The dimension of each embedding - State || Achieved Goal Vector\n :param activation: The non-linear activation function to use\n :param use_additive_fn: Boolean to determine whether to use additive or multiplicative attention\n \"\"\"\n super(VanillaAttention, self).__init__()\n self.input_dim = input_dim # n\n self.query_dim = query_dim # q\n self.num_hidden = num_hidden # h\n self.embedding_dim = embedding_dim # e\n self.output = output_features\n self.additive = use_additive\n self.activation = activation\n self.save_attention = save_attention\n self.attention_dict = attention_dict\n self.name = name\n\n # Define the linear layers\n self.linear_x = nn.Linear(in_features=embedding_dim, out_features=num_hidden)\n self.linear_q = nn.Linear(in_features=query_dim, out_features=num_hidden)\n self.out_linear = nn.Linear(in_features=num_hidden, out_features=output_features)\n self.output_softmax_scores = nn.Softmax()\n\n def forward(self, input_sequence, query_vector):\n # Returns the alignment scores\n if self.additive:\n s = additive_fn(x=input_sequence, q=query_vector, linear_x=self.linear_x,\n linear_q=self.linear_q, num_hidden=self.num_hidden, activation=self.activation,\n out_linear=self.out_linear)\n else:\n s = multiplicative_fn(x=input_sequence, q=query_vector, linear_x=self.linear_x,\n linear_q=self.linear_q)\n\n scores = self.output_softmax_scores(s)\n # A large score here for a particular x (embedding) means that it contributes\n # important information to the given query vector\n # Dimension of scores -> b x n\n expectations_of_sampling = torch.sum(torch.mul(scores, input_sequence))\n if self.save_attention:\n if self.name is not None and self.attention_dict is not None:\n self.attention_dict[self.name] = scores\n return scores, expectations_of_sampling\n\n # Weights Initialization\n def init_weights(self, init_range=0.1):\n self.linear_x.weight.data.uniform_(-init_range, init_range)\n self.linear_q.weight.data.uniform_(-init_range, init_range)\n self.out_linear.weight.data.uniform(-init_range, init_range)\n\n\nclass MultiAttention(nn.Module):\n \"\"\"\n The Mutli Attention module\n\n Alignment Score computed for each feature\n\n Score of a token pair is vector rather than a scalar\n\n Has embedding_dim indicators for embedding_dim features\n Each indicator has a probability\n distribution that is generated by applying softmax to\n the n alignment scores of the corresponding feature.\n\n\n \"\"\"\n def __init__(self, input_dim, embedding_dim, query_dim, num_hidden,\n activation, output_features,\n use_additive=True, save_attention=False,\n attention_dict=None, name=None):\n \"\"\"\n :param input_dim: The input dimension of the sequence or length of the sequence\n :param query_dim: The dimension of the query embedding - Current State || Desired Goal Vector\n :param num_hidden: The number of hidden layers in the network\n :param embedding_dim: The dimension of each embedding - State || Achieved Goal Vector\n :param activation: The non-linear activation function to use\n :param use_additive_fn: Boolean to determine whether to use additive or multiplicative attention\n \"\"\"\n super(MultiAttention, self).__init__()\n self.input_dim = input_dim\n self.query_dim = query_dim\n self.embedding_dim = embedding_dim\n self.num_hidden = num_hidden\n self.activation = activation\n self.additive = use_additive\n self.out_features = output_features\n self.save_attention = save_attention\n self.attention_dict = attention_dict\n self.name = name\n\n # Define the linear layers\n self.linear_x = nn.Linear(in_features=embedding_dim, out_features=num_hidden)\n self.linear_q = nn.Linear(in_features=query_dim, out_features=num_hidden)\n self.out_linear = nn.Linear(in_features=num_hidden, out_features=embedding_dim)\n self.output_softmax_scores = nn.Softmax()\n\n def forward(self, input_sequence, query_vector):\n if self.additive:\n s = additive_fn(x=input_sequence, q=query_vector, linear_x=self.linear_x,\n linear_q=self.linear_q, num_hidden=self.num_hidden, activation=self.activation,\n out_linear=self.out_linear)\n else:\n s = multiplicative_fn(x=input_sequence, q=query_vector, linear_x=self.linear_x,\n linear_q=self.linear_q)\n\n prob_distribution = self.output_softmax_scores(s)\n score_vectors = torch.sum(torch.bmm(prob_distribution, input_sequence))\n if self.save_attention:\n if self.attention_dict is not None and self.name is not None:\n self.attention_dict[self.name] = prob_distribution\n return score_vectors, prob_distribution\n\n # Weights Initialization\n def init_weights(self, init_range=0.1):\n self.linear_x.weight.data.uniform_(-init_range, init_range)\n self.linear_q.weight.data.uniform_(-init_range, init_range)\n self.out_linear.weight.data.uniform(-init_range, init_range)\n\n\nclass SelfAttention(nn.Module):\n \"\"\"\n The Self Attention module produces context-aware representations by\n exploring the dependency between two tokens xi and xj from the same sequence x.\n\n \"\"\"\n def __init__(self, input_dim, embedding_dim, query_dim, num_hidden,\n output_features, activation, use_additive=True,\n token2token=True, seq2token=False, attention_dict=None,\n save_attention=False, name=None):\n \"\"\"\n\n :param input_dim:\n :param embedding_dim:\n :param query_dim:\n :param num_hidden:\n :param activation:\n :param use_additive:\n :param token2token:\n :param seq2token:\n \"\"\"\n super(SelfAttention, self).__init__()\n self.token2token = token2token\n self.seq2token = seq2token\n self.input_dim = input_dim\n self.embedding_dim = embedding_dim\n self.query_dim = query_dim\n self.num_hidden = num_hidden\n self.out_features = output_features\n self.activation = activation\n self.additive = use_additive\n self.attention_dict = attention_dict\n self.save_attention = save_attention\n self.name = name\n\n # Define the linear layers\n self.linear_x = nn.Linear(in_features=self.embedding_dim, out_features=self.num_hidden)\n self.linear_q = nn.Linear(in_features=self.query_dim, out_features=self.num_hidden)\n self.out_linear = nn.Linear(in_features=self.num_hidden, out_features=self.out_features)\n self.softmax_probs = nn.Softmax()\n\n def forward(self, input_sequence):\n # In this case the query vector itself is the input sequence\n\n # Dimensions of the vectors\n # Input Dimension -> B x Seq Length x embedding_dim\n # Query Vector Dimension -> B x Seq Length x embedding_dim\n\n x = input_sequence\n query_vector = input_sequence\n\n # Dimension of x and query after linear_x and linear_q respectively\n # B x Seq Length x hidden_dim\n x_ = self.linear_x(x)\n q_ = self.linear_q(query_vector)\n\n t = nn.ReLU(x_ + q_)\n\n # Dimension of t after out_linear\n # B x Seq Length x embedding_dim\n o = self.out_linear(t)\n\n # Softmax Scores\n scores = self.softmax_probs(o)\n # Dimension of expectation of the sampling\n # B x seq length (Contrary to the paper, we are summing along the embedding dimension)\n expectation_of_sampling = torch.sum(torch.mul(scores), dim=-1)\n\n if self.save_attention:\n if self.attention_dict is not None and self.name is not None:\n self.attention_dict[self.name] = scores\n\n return scores, expectation_of_sampling\n\n # Weights Initialization\n def init_weights(self, init_range=0.1):\n self.linear_x.weight.data.uniform_(-init_range, init_range)\n self.linear_q.weight.data.uniform_(-init_range, init_range)\n self.out_linear.weight.data.uniform(-init_range, init_range)\n\n\nclass GoalNetwork(nn.Module):\n \"\"\"\n This network uses the self, multi and vanilla attention modules and returns the\n top n vectors according to the softmax probabilities.\n \"\"\"\n\n def __init__(self, input_dim, query_dim, embedding_dim, num_hidden,\n output_features, activation, use_additive, use_token2token,\n use_self_attn, save_attention=False, attention_dict=None,\n use_multi_attn=False):\n \"\"\"\n\n :param input_dim:\n :param query_dim:\n :param embedding_dim:\n :param num_hidden:\n :param output_features:\n :param activation:\n :param use_additive:\n :param use_token2token:\n :param use_self_attn:\n :param save_attention:\n :param attention_dict:\n \"\"\"\n super(GoalNetwork, self).__init__()\n self.input_dim = input_dim\n self.query_dim = query_dim\n self.embedding_dim = embedding_dim\n self.num_hidden = num_hidden\n self.output_features = output_features\n self.activation = activation\n self.additive = use_additive\n self.use_self_attn = use_self_attn\n self.token2token = use_token2token\n self.save_attn = save_attention\n self.attention_dict = attention_dict\n self.multi_attn = use_multi_attn\n self.self_attn = None\n self.self_linear = None\n\n if self.use_self_attn:\n self.self_attn = SelfAttention(input_dim=self.input_dim, embedding_dim=self.embedding_dim,\n query_dim=self.query_dim, num_hidden=self.num_hidden,\n output_features=self.embedding_dim, activation=self.activation,\n use_additive=self.additive, token2token=self.token2token,\n save_attention=self.save_attn, attention_dict=self.attention_dict,\n name='SelfAttention')\n self.self_linear = nn.Linear(in_features=1, out_features=self.num_hidden)\n\n if self.multi_attn:\n # Use multi dimensional attention\n self.attn = MultiAttention(input_dim=self.input_dim, embedding_dim=self.embedding_dim,\n query_dim=self.query_dim, num_hidden=self.num_hidden,\n output_features=self.embedding_dim, activation=self.activation,\n use_additive=self.additive,\n save_attention=self.save_attn, attention_dict=self.attention_dict,\n name='MultiAttention')\n\n else:\n # Use the traditional vanilla attention\n self.attn = VanillaAttention(input_dim=self.input_dim, embedding_dim=self.embedding_dim,\n query_dim=self.query_dim, num_hidden=self.num_hidden,\n output_features=1, activation=self.activation,\n use_additive=self.additive,\n save_attention=self.save_attn, attention_dict=self.attention_dict,\n name='VanillaAttention')\n\n self.linear_attn = nn.Linear(in_features=1, out_features=self.num_hidden)\n self.output_linear = nn.Linear(in_features=num_hidden, out_features=1)\n\n def forward(self, input_sequence, current_embedding):\n scores_self, expectations_self = None, None\n if self.self_attn is not None:\n scores_self, expectations_self = self.self_attn(input_sequence)\n scores, expectation = self.attn(input_sequence, current_embedding)\n if expectations_self is not None and self.self_linear is not None:\n expectations_self = self.self_linear(expectations_self)\n expectation = self.linear_attn(expectation)\n if expectations_self is not None:\n e = expectation + expectations_self\n else:\n e = expectation\n e = self.activation(e)\n o = self.output_linear(e)\n return o\n\n\n\n\n\n","repo_name":"navneet-nmk/pytorch-rl","sub_path":"models/attention.py","file_name":"attention.py","file_ext":"py","file_size_in_byte":14735,"program_lang":"python","lang":"en","doc_type":"code","stars":438,"dataset":"github-code","pt":"51"}
+{"seq_id":"2173185018","text":"#!/usr/bin/env python3\n# encoding: utf-8\nimport matplotlib.pyplot as plt\n\n\"\"\"\n图中图\nhttps://morvanzhou.github.io/tutorials/data-manipulation/plt/4-3-plot-in-plot/\n\"\"\"\n# 大图\nfig = plt.figure()\nx = [1, 2, 3, 4, 5, 6, 7]\ny = [1, 3, 4, 2, 5, 8, 6]\n# 4个值都是占整个figure坐标系的百分比。在这里，假设figure的大小是10x10，那么大图就被包含在由(1, 1)开始，宽8，高8的坐标系内\nleft, bottom, width, height = 0.1, 0.1, 0.8, 0.8\nax1 = fig.add_axes([left, bottom, width, height])\nax1.plot(x, y, 'r')\nax1.set_xlabel('x')\nax1.set_ylabel('y')\nax1.set_title('title')\n\n# 小图\nleft, bottom, width, height = 0.2, 0.6, 0.25, 0.25\nax2 = fig.add_axes([left, bottom, width, height])\nax2.plot(x, y, 'b')\nax2.set_xlabel('x')\nax2.set_ylabel('y')\nax2.set_title('title inside 1')\n\nplt.axes([0.6, 0.2, 0.25, 0.25])\nplt.plot(y[::-1], x, 'g') # 注意对y进行了逆序处理\nplt.xlabel('x')\nplt.ylabel('y')\nplt.title('title inside 2')\nplt.show()\n","repo_name":"wildape/PythonPractice","sub_path":"plt/4_3_plot_in_plot.py","file_name":"4_3_plot_in_plot.py","file_ext":"py","file_size_in_byte":972,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"4290392482","text":"import os\nimport configparser\n\nROOT_PATH = '/home/mnk/MegNav/Projects/Face-Recognition-from-crowd'\n\n\ndef path2src(path, num=0):\n ext = path.split(\".\")[-1]\n if ext == \"mp4\" or ext == \"avi\":\n return \"video\"\n elif ext == \"jpg\" or ext == \"png\":\n return \"image\"\n elif path == \"live\":\n if num==1:\n return 0\n return \"live\"\n else:\n raise Exception(\"Invalid source\")\n\ndef absolute_path(path):\n return os.path.abspath(path)\n\n# Congifuration file\ndef config_parse(txt):\n config = configparser.ConfigParser()\n path = ROOT_PATH + '/project.cfg'\n config.read(path)\n params={}\n try:\n for key, value in config[txt].items():\n if 'path' in key: \n params[key] = absolute_path(value)\n else:\n params[key] = value\n except KeyError as e:\n print(\"Invalid key: \", e)\n print(path) \n \n return params\n\ndef lists_equal(list1, list2):\n if len(list1) != len(list2):\n return False\n for i in range(len(list1)):\n if list1[i] != list2[i]:\n return False\n return True\n\ndef get_new_faces(list1, list2):\n new_faces = []\n for i in range(len(list1)):\n if list1[i] not in list2:\n new_faces.append(int(list1[i]))\n return new_faces\n","repo_name":"NavinKumarMNK/Face-Recognition-From-Crowd","sub_path":"utils/utils.py","file_name":"utils.py","file_ext":"py","file_size_in_byte":1313,"program_lang":"python","lang":"en","doc_type":"code","stars":6,"dataset":"github-code","pt":"51"}
+{"seq_id":"71321707037","text":"# Funções aprofundadas em Python\ndef leiaInt(msg):\n while True:\n try:\n n = int(input(msg))\n except (ValueError, TypeError):\n print('\\033[31mERRO! Por favor, digite um número inteiro válido.\\033[m')\n continue\n except KeyboardInterrupt:\n print('\\033[31mUsuário interrompeu a execução.\\033[m')\n return 0\n else:\n return n\n\n\ndef leiaFloat(msg):\n while True:\n try:\n n = float(input(msg))\n except (ValueError, TypeError):\n print('\\033[31mERRO! Por favor, digite um número real válido.\\033[m')\n continue\n except KeyboardInterrupt:\n print('\\033[31mUsuário interrompeu a execução.\\033[m')\n return 0\n else:\n return n\n\n\nnum = leiaInt('Digite um número inteiro: ')\nvalor = leiaFloat('Digite um número real: ')\nprint(f'O valor inteiro digitado foi \\033[34m{num}\\033[m e o valor real foi \\033[34m{valor}\\033[m')\n","repo_name":"miguelmendesSerrano/curso_python","sub_path":"mundo_3/aula_23/ex113.py","file_name":"ex113.py","file_ext":"py","file_size_in_byte":1005,"program_lang":"python","lang":"pt","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"71330997917","text":"\"\"\" CRUD operations for meals and macros project \"\"\"\nfrom model import db, User, CaloriesMacros, Diet, Goal, Food, UserQuestions, connect_to_db\n# from model import db, User, connect_to_db \n\ndef create_user(email, password, name, lname):\n \"\"\" create a new user \"\"\"\n\n user = User(email=email, password=password, name=name, lname=lname)\n\n db.session.add(user)\n db.session.commit()\n\n return user \n \ndef get_users():\n \"\"\"Return all users.\"\"\"\n\n return User.query.all()\n\n\ndef get_user_by_id(user_id):\n \"\"\"Return a user by primary key.\"\"\"\n\n return User.query.get(user_id)\n\n\ndef get_user_by_email(email):\n \"\"\"Return a user by email.\"\"\"\n\n return User.query.filter(User.email == email).first()\n\ndef get_all_food(user_id):\n \"\"\" returns all food \"\"\"\n return Food.query.filter(Food.user_id == user_id).all()\n \n \ndef get_food(food_name):\n \"\"\" returns all food \"\"\"\n return Food.query.filter(Food.food_name == food_name).all()\n\ndef create_cals_macros(user, daily_caloric_intake, daily_protein_goal, daily_carb_goal, daily_fat_goal):\n\n \"\"\" create calorie and macros \"\"\"\n\n calories_and_macros = CaloriesMacros(\n user=user,\n daily_caloric_intake=daily_caloric_intake, \n daily_protein_goal=daily_protein_goal, \n daily_carb_goal=daily_carb_goal, \n daily_fat_goal=daily_fat_goal\n )\n\n db.session.add(calories_and_macros)\n db.session.commit()\n\n return calories_and_macros \n\ndef create_diet(diet, user):\n\n \"\"\" create diet preference \"\"\"\n\n diet = Diet(diet=diet, user=user)\n\n db.session.add(diet)\n db.session.commit()\n\n return diet \n\ndef create_goal(user_id, strength, running, weight_loss, consistency, stretching, high_intensity_training, nutrition, overall_health):\n\n \"\"\" create user fitness goal \"\"\"\n\n goal = Goal(\n user_id=user_id,\n strength=strength,\n running=running,\n weight_loss=weight_loss,\n consistency=consistency,\n stretching=stretching, \n high_intensity_training=high_intensity_training,\n nutrition=nutrition,\n overall_health=overall_health\n )\n\n db.session.add(goal)\n db.session.commit()\n\n return goal \n\ndef get_goals(user_id):\n \"\"\" returns all food \"\"\"\n return Goal.query.filter(Goal.user_id == user_id).all()\n\n# def create_meal(user, meal_name, meal_calories, meal_protein, meal_carb, meal_fat):\n\n# \"\"\" create user meals \"\"\"\n\n# meal = User_meals(\n# user=user, \n# meal_name=meal_name, \n# meal_calories=meal_calories, \n# meal_protein=meal_protein, \n# meal_carb=meal_carb,\n# meal_fat=meal_fat,\n# )\n\n# db.session.add(meal)\n# db.session.commit()\n\n# return meal \n\ndef create_food(food_name, calories, fat, carb, protein, user_id):\n\n \"\"\" create food for user to use for tracking \"\"\" \n\n food = Food( \n food_name=food_name,\n calories=calories,\n fat=fat,\n carb=carb,\n protein=protein, \n user_id=user_id\n )\n\n db.session.add(food)\n db.session.commit()\n\n return food\n\ndef create_tracking(user, food, deduct_daily_calroies, deduct_daily_macros):\n\n \"\"\" create tracking for user to enter food throughout the day \"\"\"\n\n tracking = User_tracking(\n user=user,\n food=food,\n deduct_daily_calories=deduct_daily_calories,\n deduct_daily_macros=deduct_daily_macros,\n )\n\n db.session.add(tracking)\n db.session.commit()\n\n return tracking \n\ndef questionare(gender, age, height, weight, activity, user_id):\n\n \"\"\" questionare information \"\"\"\n\n questionare_info = UserQuestions(\n age=age,\n gender=gender,\n height=height,\n weight=weight,\n activity=activity,\n user_id=user_id\n )\n\n db.session.add(questionare_info)\n db.session.commit()\n\n return questionare_info \n\ndef new_calculator(tdee, deficit, macros, user_id, questions_id, protein_goal, fat_goal, carb_goal):\n\n \"\"\"calculate user calories and macros\"\"\"\n\n calculator_info = UserCalculcations(\n tdee=tdee,\n deficit=deficit,\n macros=macros,\n user_id=user_id,\n questions_id=questions_id,\n protein_goal=protein_goal,\n fat_goal=fat_goal,\n carb_goal=carb_goal \n )\n\n db.session.add(calculator_info)\n db.session.commit()\n\n return calculator_info \n\ndef user_exercises(exercise, user_id):\n \n \"\"\"track exercise \"\"\"\n\n exercise_info = Exercise(\n exercise=exercise, \n user_id=user_id\n )\n\n \n db.session.add(exercise_info)\n db.session.commit()\n\n return exercise_info \n\nif __name__ == '__main__':\n from server import app\n \n connect_to_db(app)\n ","repo_name":"devvynl/meals-macros-project","sub_path":"crud.py","file_name":"crud.py","file_ext":"py","file_size_in_byte":4715,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"24873640406","text":"import base64\nimport cv2\nimport socket\nimport json\n\n\ndef log_sender(message: dict, port=9010):\n \"\"\"\n ポート9010番にjson形式でメッセージを送信する\n \"\"\"\n\n message[\"image\"] = _cv_to_base64(message[\"image\"])\n\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n client.connect((\"localhost\", port))\n\n message_json = json.dumps(message)\n\n client.send(message_json.encode(\"utf-8\"))\n\n client.close()\n\n\ndef _cv_to_base64(img):\n _, encoded = cv2.imencode(\".jpg\", img)\n return base64.b64decode(encoded).decode(\"ascii\")\n","repo_name":"HaoriHakama/ImageLogger","sub_path":"image_receiver/log_sender.py","file_name":"log_sender.py","file_ext":"py","file_size_in_byte":567,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"71871876319","text":"# Review: \r\n# Create a function called greet(). \r\ndef greet():\r\n# Write 3 print statements inside the function.\r\n print(\"Hello...\")\r\n print(\"How are you?\")\r\n print(\"Are you being the best version of you?\")\r\n# Call the greet() function and run your code.\r\ngreet()\r\n\r\n# Function that allows for input\r\ndef greet_with_name(name):\r\n print(f\"Hello {name}.....\")\r\n print(f\"How are you {name}?\")\r\n\r\ngreet_with_name(\"Keelen\")\r\n\r\n# Functions with more than 1 input\r\ndef greet_with(name, location):\r\n print(f\"Hello {name}\")\r\n print(f\"{name} I am from {location}, where are you from?\")\r\n\r\ngreet_with(\"Keelen\", \"Houston\")\r\n# Positional Argument, it is important to have the order of the inputs corresponding to the parameters within the function.\r\n\r\n# -------------------------------------------------------------------------------------------------------------------------\r\n\r\n# You are painting a wall. The instructions on the paint can says that 1 can of paint can cover 5 square meters of wall. Given a random height and width of wall, calculate how many cans of paint you'll need to buy.\r\nimport math\r\n\r\ndef paint_calc(height, width, cover):\r\n multi = height * width\r\n calculated = multi / cover\r\n final_cal = math.ceil(calculated)\r\n print(f\"You'll need {final_cal} cans of paint.\")\r\n\r\n\r\ntest_h = int(input(\"Height of wall: \"))\r\ntest_w = int(input(\"Width of wall: \"))\r\ncoverage = 5\r\npaint_calc(height=test_h, width=test_w, cover=coverage)\r\n\r\n# -------------------------------------------------------------------------------------------------------------------------\r\n\r\n# You need to write a function that checks whether if the number passed into it is a prime number or not.\r\n\r\n# e.g. 2 is a prime number because it's only divisible by 1 and 2.\r\n\r\n# But 4 is not a prime number because you can divide it by 1, 2 or 4.\r\n\r\n\r\ndef prime_checker(number):\r\n is_prime = True\r\n for i in range(2, number):\r\n if number % i == 0:\r\n is_prime = False\r\n if is_prime:\r\n print(\"It's a prime number.\")\r\n else:\r\n print(\"It's not a prime number.\")\r\n\r\nn = int(input(\"Check this number: \"))\r\nprime_checker(number=n)\r\n\r\n #-------------------------------------------------------------------------------------------------------------------------\r\n\r\n# Encryption Code Challenge 1\r\n\r\nalphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\r\n\r\ndirection = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\r\ntext = input(\"Type your message:\\n\").lower()\r\nshift = int(input(\"Type the shift number:\\n\"))\r\n\r\n#TODO-1: Create a function called 'encrypt' that takes the 'text' and 'shift' as inputs.\r\ndef encrypt(plain_text, shift_amount):\r\n cipher_text = \"\"\r\n for letter in plain_text:\r\n position = alphabet.index(letter)\r\n new_position = position + shift_amount\r\n new_letter = alphabet[new_position]\r\n cipher_text += new_letter\r\n print(f\"The encoded text is {cipher_text}\")\r\n #TODO-2: Inside the 'encrypt' function, shift each letter of the 'text' forwards in the alphabet by the shift amount and print the encrypted text. \r\n #e.g. \r\n #plain_text = \"hello\"\r\n #shift = 5\r\n #cipher_text = \"mjqqt\"\r\n #print output: \"The encoded text is mjqqt\"\r\n\r\n ##HINT: How do you get the index of an item in a list:\r\n #https://stackoverflow.com/questions/176918/finding-the-index-of-an-item-in-a-list\r\n\r\n ##🐛Bug alert: What happens if you try to encode the word 'civilization'?🐛\r\n\r\n#TODO-3: Call the encrypt function and pass in the user inputs. You should be able to test the code and encrypt a message.\r\nencrypt(plain_text = text, shift_amount = shift)\r\n\r\n#-------------------------------------------------------------------------------------------------------------------------\r\n\r\n# Encryption Code Challenge 2\r\n\r\nalphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\r\n\r\ndirection = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\r\ntext = input(\"Type your message:\\n\").lower()\r\nshift = int(input(\"Type the shift number:\\n\"))\r\n\r\ndef encrypt(plain_text, shift_amount):\r\n cipher_text = \"\"\r\n for letter in plain_text:\r\n position = alphabet.index(letter)\r\n new_position = position + shift_amount\r\n cipher_text += alphabet[new_position]\r\n print(f\"The encoded text is {cipher_text}\")\r\n\r\n#TODO-1: Create a different function called 'decrypt' that takes the 'text' and 'shift' as inputs.\r\n\r\ndef decrypt(cypher_text, shift_amount):\r\n plain_text = \"\"\r\n for letter in cypher_text:\r\n position = alphabet.index(letter)\r\n new_position = position - shift_amount\r\n plain_text += alphabet[new_position]\r\n print(f\"The decoded text is {plain_text}\")\r\n \r\n #TODO-2: Inside the 'decrypt' function, shift each letter of the 'text' *backwards* in the alphabet by the shift amount and print the decrypted text. \r\n #e.g. \r\n #cipher_text = \"mjqqt\"\r\n #shift = 5\r\n #plain_text = \"hello\"\r\n #print output: \"The decoded text is hello\"\r\n\r\n\r\n#TODO-3: Check if the user wanted to encrypt or decrypt the message by checking the 'direction' variable. Then call the correct function based on that 'drection' variable. You should be able to test the code to encrypt *AND* decrypt a message.\r\nif direction == \"encode\":\r\n encrypt(plain_text=text, shift_amount=shift)\r\nelif direction == \"decode\":\r\n decrypt(cipher_text = text, shift_amount = shift)\r\n\r\n#-------------------------------------------------------------------------------------------------------------------------\r\n\r\n# Encryption Code Challenge 3\r\n\r\nalphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\r\n\r\ndirection = input(\"Type 'encode' to encrypt, type 'decode' to decrypt:\\n\")\r\ntext = input(\"Type your message:\\n\").lower()\r\nshift = int(input(\"Type the shift number:\\n\"))\r\n\r\n#TODO-1: Combine the encrypt() and decrypt() functions into a single function called caesar(). \r\ndef caesar(start_text, shift_amount, cipher_direction):\r\n end_text = \"\"\r\n if cipher_direction == \"decode\":\r\n shift_amount *= -1\r\n for letter in start_text:\r\n position = alphabet.index(letter)\r\n new_position = position + shift_amount\r\n end_text += alphabet[new_position]\r\n print(f\"The {cipher_direction}d text is {end_text}\")\r\n\r\n#TODO-2: Call the caesar() function, passing over the 'text', 'shift' and 'direction' values.\r\ncaesar(start_text = text, shift_amount = shift, cipher_direction = direction)\r\n\r\n#-------------------------------------------------------------------------------------------------------------------------\r\n\r\n\r\n","repo_name":"Keelen-Fisher/Udemy-Python","sub_path":"Day-8/Day8.py","file_name":"Day8.py","file_ext":"py","file_size_in_byte":7111,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"23685731028","text":"import time\nimport numpy as np\nimport pandas as pd\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom scipy.sparse import csr_matrix, hstack\nimport lightgbm as lgb\nfrom nltk.corpus import stopwords\nimport re\nfrom nltk.stem.porter import PorterStemmer\nimport sys\nsys.path.insert(0, '/wordbatch/')\nimport wordbatch\nfrom wordbatch.models import FTRL, FM_FTRL\nfrom wordbatch.extractors import WordBag, WordHash\n\nnotable = ['bundle', 'new', 'nwt', 'large', 'small', 'sz', 'lot', 'medium', 'xl', 'xs', 'vintage', 'nwot', 'bnwt', ]\nremove = ['for', 'and', 'vs', 'of', 'women', 'men', 'ship', 'the', 'on', 'with',\n 'in', 'one', 'boys', 'shipping', 'toddler', 'by', 'rm', 'piece', 'me', 'kids', 'fit', 'boy', 'mens', 'super',\n 'only', 'all','too', 'color', 'freeship', 'it', 'works', 'like', 'womens', 'to', 'perfect', 'woman', 'youth', 'hello', 'my',\n 'from', 'buy','go', 'is', 'at', 'wear', 'toys', 'children']\n\nstopwords = {x: 1 for x in stopwords.words('english')}\nstopwords2 = ['abcdef'] + [x for x in stopwords]\nnon_alphanums = re.compile(u'[^A-Za-z0-9]+')\n\nstemmer = PorterStemmer()\n\n\ndef rmsle(y, y0):\n assert len(y) == len(y0)\n return np.sqrt(np.mean(np.power(np.log1p(y) - np.log1p(y0), 2)))\n\n\ndef stem_tokens(tokens, stemmer):\n stemmed = []\n\n for item in tokens:\n stemmed_item = item\n try:\n stemmed_item = stemmer.stem(item)\n except Exception:\n print(\"EXCEPTION WHILE STEM\")\n print(stemmed_item)\n pass\n stemmed.append(stemmed_item)\n\n return stemmed\n\n\ndef fill_missing(df, text_cols, num_cols, bin_cols):\n for col in text_cols:\n df[col].fillna(value=\"abcdef\", inplace=True)\n for col in num_cols:\n df[col].fillna(value=df[col].mean(), inplace=True)\n for col in bin_cols:\n df[col].fillna(value=int(df[col].mean()), inplace=True)\n\n\ndef normalize_text(text):\n return u\" \".join([x for x in [y for y in non_alphanums.sub(' ', text).lower().strip().split(\" \")] if len(x) > 1 and x not in stopwords])\n\n\ndef filter_norm1(text):\n tokens = [x for x in [y for y in non_alphanums.sub(' ', text).lower().strip().split(\" \")] if\n len(x) > 1 and x not in stopwords2]\n return \" \".join(stem_tokens(tokens, stemmer))\n\n\ndef split_cat(text):\n try:\n return text.split(\"/\")\n except:\n return [\"Other\", \"Other2\", \"Other3\"]\n\n\nstart_time = time.time()\n\ntrain = pd.read_csv('train.tsv', sep='\\t')\ntest = pd.read_csv('test.tsv', sep='\\t')\nprint('[{}] Finished to load data'.format(time.time() - start_time))\nprint('Train shape: ', train.shape)\nprint('Test shape: ', test.shape)\n\nnrow_test = train.shape[0]\noutliers = train[(train.price < 1.0)]\ntrain = train.drop(train[(train.price < 1.0)].index)\n\ndel outliers['price']\nnrow_train = train.shape[0]\n\ny = np.log1p(train[\"price\"])\nall_data = pd.concat([train, outliers, test])\nsubmission = test[['test_id']]\n\nall_data['general_cat'], all_data['subcat_1'], all_data['subcat_2'] = zip(\n *all_data['category_name'].apply(lambda x: split_cat(x)))\nall_data.drop('category_name', axis=1, inplace=True)\n\ntext_cols = [\"name\", \"general_cat\", \"subcat_1\", \"subcat_2\", \"brand_name\", \"item_description\"]\nnum_cols = [\"item_condition_id\"]\nbin_cols = [\"shipping\"]\ntext_seq_cols = [\"name\", \"item_description\"]\n\nfill_missing(all_data, text_cols, num_cols, bin_cols)\n\nall_data[\"all_text\"] = all_data[\"brand_name\"].astype(str) + \" \" + all_data[\"name\"].astype(str) + \" \" + all_data[\n 'item_description']\nall_data[\"name_brand\"] = all_data[\"brand_name\"].astype(str) + \" \" + all_data[\"name\"].astype(str)\n\nwb = wordbatch.WordBatch(normalize_text, extractor=(WordBag, {\"hash_ngrams\": 1,\n # \"hash_ngrams_weights\": [1.5, 1.0],\n \"hash_size\": 2 ** 29,\n \"norm\": None,\n \"tf\": 'binary',\n \"idf\": None, }), procs=8)\nwb.dictionary_freeze = True\nX_all_text = wb.fit_transform(all_data['all_text'])\ndel (wb)\nX_all_text = X_all_text[:, np.array(np.clip(X_all_text.getnnz(axis=0) - 1, 0, 1), dtype=bool)]\nprint('[{}] Vectorize `all text` completed.'.format(time.time() - start_time))\nprint(X_all_text.shape)\n\nwb = wordbatch.WordBatch(filter_norm1, extractor=(WordBag, {\"hash_ngrams\": 2,\n \"hash_ngrams_weights\": [1.5, 1.0],\n \"hash_size\": 2 ** 29,\n \"norm\": None,\n \"tf\": 'binary',\n \"idf\": None, }), procs=8)\nwb.dictionary_freeze = True\nX_name3 = wb.fit_transform(all_data['name_brand'])\ndel (wb)\nX_name3 = X_name3[:, np.array(np.clip(X_name3.getnnz(axis=0) - 1, 0, 1), dtype=bool)]\nprint('[{}] Vectorize `name 2-gram` completed.'.format(time.time() - start_time))\nprint(X_name3.shape)\n\nwb = CountVectorizer()\nX_category1 = wb.fit_transform(all_data['general_cat'])\nX_category2 = wb.fit_transform(all_data['subcat_1'])\nX_category3 = wb.fit_transform(all_data['subcat_2'])\nprint('[{}] Count vectorize `categories` completed.'.format(time.time() - start_time))\n\nX_dummies = csr_matrix(pd.get_dummies(all_data[['item_condition_id', 'shipping']], sparse=True).values)\nprint('[{}] Get dummies on `item_condition_id` and `shipping` completed.'.format(time.time() - start_time))\n\ndel wb\n\nprint(X_dummies.shape, X_category1.shape, X_category2.shape, X_category3.shape, X_name3.shape, X_all_text.shape)\nsparse_merge = hstack((X_dummies, X_category1, X_category2, X_category3, X_all_text, X_name3)).tocsr() # X_brand\n\nprint('[{}] Create sparse merge completed'.format(time.time() - start_time))\n#\n# Remove features with document frequency <=1\nprint(sparse_merge.shape)\nsparse_merge = sparse_merge[:, np.where(sparse_merge.getnnz(axis=0) > 150)[0]]\nX = sparse_merge[:nrow_train]\nX_test = sparse_merge[nrow_test:]\nprint(sparse_merge.shape)\n\ny = np.log1p(train[\"price\"])\n\nparams = {\n 'learning_rate': 0.65,\n 'application': 'regression',\n 'max_depth': 4,\n 'num_leaves': 31,\n 'verbosity': -1,\n 'metric': 'RMSE',\n 'data_random_seed': 1,\n 'bagging_fraction': 0.8,\n 'bagging_freq': 500,\n 'feature_fraction': 0.8,\n 'nthread': 4,\n 'min_data_in_leaf': 100,\n 'max_bin': 31\n}\n\nd_train = lgb.Dataset(X, label=y)\n\nwatchlist = [d_train]\nmodel = lgb.train(params, train_set=d_train, num_boost_round=5500, valid_sets=watchlist, verbose_eval=500)\n\n\nprint('[{}] Finished training model...'.format(time.time() - start_time))\n\npreds1 = model.predict(X_test)\n\nprint('[{}] Predict LGB completed.'.format(time.time() - start_time))\n\nmodel3 = FM_FTRL(alpha=0.01, beta=0.01, L1=0.00001, L2=0.1, D=sparse_merge.shape[1], alpha_fm=0.01, L2_fm=0.0,\n init_fm=0.01,\n D_fm=200, e_noise=0.0001, iters=17, inv_link=\"identity\", threads=4)\n\nmodel3.fit(X, y)\nprint('[{}] Train FM_FTRL completed'.format(time.time() - start_time))\n\npreds3 = model3.predict(X_test)\n\nfinal_pred = 0.39479745 * preds1 + 0.60691396 * preds3\n\nsubmission['price'] = np.expm1(final_pred)\nsubmission.to_csv(\"submission_2.csv\", index=False)\n\nprint('[{}] Finished training models...'.format(time.time() - start_time))\n","repo_name":"hiflyin/Kaggle-Solutions_in_top_10pc","sub_path":"mercari_top_8pc/MM55.py","file_name":"MM55.py","file_ext":"py","file_size_in_byte":7494,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"28026888000","text":"import json\n\nimport pytest\nfrom botocore.exceptions import ClientError\nfrom moto.core import patch_resource\n\nfrom badger_api.claimable import get_latest_claimable_snapshot\nfrom helpers.enums import Network, SubgraphUrlType\nfrom rewards.aws.helpers import dynamodb\nfrom tests.utils import chains\nfrom tests.utils import mock_tree\nfrom tests.utils import set_env_vars\n\nset_env_vars()\n\n\ndef mock_download_tree(file_name: str, chain: str):\n return json.dumps(mock_tree)\n\n\n@pytest.fixture(autouse=True)\ndef mock_fns(mocker):\n mocker.patch(\"rewards.classes.TreeManager.download_tree\", mock_download_tree)\n\n\n@pytest.fixture\ndef tree():\n return mock_tree\n\n\n@pytest.fixture\ndef tokens_to_check(tree):\n return list(tree[\"tokenTotals\"].keys())\n\n\n@pytest.mark.parametrize(\"chain\", chains)\ndef test_get_latest_claimable_snapshot(chain, setup_dynamodb, mocker):\n url = f\"https://api.thegraph.com/subgraphs/name/badger-finance/badger-dao-setts-{chain}\"\n if (chain == Network.Ethereum):\n url = \"https://api.thegraph.com/subgraphs/name/badger-finance/badger-dao-setts\"\n mocker.patch(\"subgraph.subgraph_utils.subgraph_url_from_config\",\n return_value={SubgraphUrlType.Plain: url})\n patch_resource(dynamodb)\n cb_snapshot = get_latest_claimable_snapshot(chain)\n assert len(cb_snapshot) > 0\n for cb_data in cb_snapshot:\n assert 'address' in cb_data\n assert 'chain' in cb_data\n assert 'claimableBalances' in cb_data\n\n\ndef raise_client_error(chain, block):\n raise ClientError({}, \"\")\n\n\ndef test_latest_claimable_snapshot_unhappy(setup_dynamodb, mock_discord, mocker):\n patch_resource(dynamodb)\n mocker.patch(\"badger_api.claimable.get_claimable_balances\", side_effect=raise_client_error)\n with pytest.raises(ClientError):\n get_latest_claimable_snapshot(Network.Ethereum)\n # Make sure discord message was sent\n assert mock_discord.called\n # Make sure only one message was sent to discord\n assert mock_discord.call_count == 1\n","repo_name":"Badger-Finance/badger-rewards","sub_path":"tests/test_claimable.py","file_name":"test_claimable.py","file_ext":"py","file_size_in_byte":2023,"program_lang":"python","lang":"en","doc_type":"code","stars":3,"dataset":"github-code","pt":"51"}
+{"seq_id":"41712507829","text":"import requests\nfrom lxml import etree\nfrom fake_useragent import UserAgent\nimport re\nimport csv\nimport urllib\nimport urllib.request\nimport re\nimport os\n\nTYPE = '医学'\nKEY_VALUE = 'ҽѧ'\nCSV_PATH = TYPE +'.csv'\nIMG_PATH = 'C:\\\\Users\\\\Administrator\\\\Desktop\\\\图书信息\\\\'+TYPE+'\\\\原图'\nx = 1\ndef get_page(key):\n for page in range(1,20):\n url = 'http://search.dangdang.com/?key=%s&act=input&page_index=%s' % (key,page)\n headers = {\n 'User-Agent':UserAgent().random\n }\n response = requests.get(url = url,headers = headers)\n parse_page(response)\n print('page %s over!!!' % page)\n\ndef parse_page(response):\n tree = etree.HTML(response.text)\n li_list = tree.xpath('//ul[@class=\"bigimg\"]/li')\n # print(len(li_list)) # 测试\n path = IMG_PATH\n if not os.path.isdir(path):\n os.makedirs(path) # 判断没有此路径则创建\n paths = path + '\\\\' # 保存在test路径下\n global x\n flag = 0\n for li in li_list:\n data = []\n try:\n # 获取书的标题,并添加到列表中\n title = li.xpath('./p[@class=\"name\"]/a/@title')[0].strip()\n data.append(title)\n # 获取价格,并添加到列表中\n price = li.xpath('./p[@class=\"price\"]/span[1]/text()')[0]\n pub_price = re.sub('¥','',price).strip()\n data.append(pub_price)\n # 获取作者,并添加到列表中\n author = ''.join(li.xpath('./p[@class=\"search_book_author\"]/span[1]//text()')).strip()\n data.append(author)\n # 获取出版社,并添加到列表中\n press = ''.join(li.xpath('./p[@class=\"search_book_author\"]/span[3]//text()')).strip()\n pub_press = re.sub('/','',press).strip()\n data.append(pub_press)\n # 获取出版时间,并添加到列表中\n time = li.xpath('./p[@class=\"search_book_author\"]/span[2]/text()')[0]\n pub_time = re.sub('/','',time).strip()\n data.append(pub_time)\n # 获取书本的简介,并添加到列表中.由于有些书本没有简介，所以要用try\n commodity_detail = ''\n commodity_detail = li.xpath('./p[@class=\"detail\"]/text()')[0]\n data.append(commodity_detail)\n # 获取书的标题,并添加到列表中\n if(flag != 0):\n imgurl =''.join(li.xpath('./a/img/@data-original'))\n else:\n imgurl =''.join(li.xpath('./a/img/@src'))\n flag = flag + 1\n urllib.request.urlretrieve(imgurl, '{0}{1}.jpg'.format(paths, x)) # 打开imglist,下载图片到本地\n img_path = '' + str(x) + \".jpg\"\n data.append(img_path)\n x = x + 1\n except Exception as e:\n pass\n save_data(data)\n\ndef save_data(data):\n writer.writerow(data)\n\ndef main():\n key = KEY_VALUE # input('Please input key:')\n get_page(key) \nfp = open(CSV_PATH,'w+',encoding = 'utf-8-sig',newline = '')\nwriter = csv.writer(fp)\nheader = ['书名','价格','作者','出版社','出版时间','简介','图片名']\nwriter.writerow(header)\nmain()\nfp.close()","repo_name":"qxpineapple/CrawlerInAndResultHandle","sub_path":"Python/getDoubanBook.py","file_name":"getDoubanBook.py","file_ext":"py","file_size_in_byte":3235,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"70219551839","text":"import os\nfrom io import BytesIO\nfrom PIL import Image, ImageDraw\nfrom sys import stdin, stdout\n\nif __name__ == '__main__':\n image_data = stdin.buffer.read(int(os.environ['CONTENT_LENGTH']))\n cgi_headers = [\n \"SERVER_SOFTWARE\", \"SERVER_NAME\", \"GATEWAY_INTERFACE\",\n \"SERVER_PROTOCOL\", \"SERVER_PORT\", \"REQUEST_METHOD\",\n \"QUERY_STRING\", \"SCRIPT_NAME\", \"REMOTE_HOST\",\n \"CONTENT_TYPE\", \"CONTENT_LENGTH\"]\n header_output = '\\n'.join([ os.environ[x] for x in cgi_headers ])\n with Image.open(BytesIO(image_data)) as im:\n resized_image = im.resize((800,800))\n draw = ImageDraw.Draw(resized_image)\n draw.multiline_text((10,10), header_output, fill=\"black\")\n resized_image.save(stdout, 'png')","repo_name":"cwgem/python-deployment-protocols","sub_path":"cgi/cgi_application.py","file_name":"cgi_application.py","file_ext":"py","file_size_in_byte":748,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"1619203656","text":"from queue import PriorityQueue\nfrom sklearn.model_selection import ParameterGrid\nimport copy\nimport heapq\nimport time\n\nclass Vertex():\n def __init__(self, v_id):\n assert type(v_id) == tuple\n assert len(v_id) == 2\n\n self.v_id = v_id\n self.collision_set = frozenset()\n self.g = 1e6\n self.f = None\n self.back_set = dict()\n self.back_ptr = None\n self.forward_pointer = None\n \n @property\n def is_standard(self):\n return self.v_id[0] == self.v_id[1]\n \n def add_collision(self, other_collision_set):\n # print(\"other col set: {}\".format(other_collision_set))\n other_col_set2 = []\n # make work with single set or sets of sets:\n for temp in other_collision_set:\n if type(temp) == frozenset:\n other_col_set2.append(temp)\n else:\n other_col_set2.append(other_collision_set)\n break\n #assert len(other_collision_set) > 1\n assert self._check_valid_collision_set() == True\n for other_collision_set in other_col_set2:\n to_merge = []\n keep_same = []\n for i in other_collision_set:\n for existing_set in self.collision_set:\n if i in existing_set:\n if not existing_set in to_merge:\n to_merge.append(existing_set)\n else:\n keep_same.append(existing_set)\n to_merge.append(other_collision_set)\n #remove sets in keep_same which is also in to_marge\n keep_same = [k for k in keep_same if not k in to_merge]\n if len(to_merge) == 0:\n keep_same.append(other_collision_set)\n else:\n big_set = []\n for item in to_merge:\n for i2 in item:\n big_set.append(i2)\n big_set = frozenset(big_set)\n new_col_set = []\n new_col_set.append(big_set)\n for k in keep_same:\n new_col_set.append(k)\n new_col_set = frozenset(new_col_set)\n self.collision_set = new_col_set\n # print(\"Added col set {}\".format(self.collision_set))\n # if len(other_collision_set) == 0:\n # return\n # #assert len(other_collision_set) > 1\n # assert self._check_valid_collision_set() == True\n # to_merge = []\n # keep_same = []\n # for i in other_collision_set:\n # for existing_set in self.collision_set:\n # if i in existing_set:\n # if not existing_set in to_merge:\n # to_merge.append(existing_set)\n # else:\n # keep_same.append(existing_set)\n # to_merge.append(other_collision_set)\n # #remove sets in keep_same which is also in to_marge\n # keep_same = [k for k in keep_same if not k in to_merge]\n # if len(to_merge) == 0:\n # keep_same.append(other_collision_set)\n # else:\n # big_set = []\n # for item in to_merge:\n # for i2 in item:\n # big_set.append(i2)\n # big_set = frozenset(big_set)\n # new_col_set = []\n # new_col_set.append(big_set)\n # for k in keep_same:\n # new_col_set.append(k)\n # new_col_set = frozenset(new_col_set)\n # self.collision_set = new_col_set\n # print(\"new col set: {}\".format(new_col_set))\n\n def _check_valid_collision_set(self):\n temp = dict()\n flag = True\n for item in self.collision_set:\n if type(item) == frozenset:\n for it in item:\n if not it in temp:\n temp[it] = it\n else:\n flag = False\n else:\n raise Exception(\"invalid object type in collision set\")\n return flag\n\n # def is_col_subset(self, other_set):\n # flag = False\n # for sub in self.collision_set:\n # if other_set.issubset(sub):\n # flag = True\n # if len(other_set) == 0:\n # flag = True\n # return flag\n def is_col_subset(self, other_set):\n #make work with set of sets and single set:\n other_set2 = []\n is_sets_of_sets = [True if type(i) == frozenset else False for i in other_set]\n if True in is_sets_of_sets:\n assert all(is_sets_of_sets)\n if False in is_sets_of_sets:\n is_sets_of_sets_cpy = [True if i==False else True for i in is_sets_of_sets]\n assert all(is_sets_of_sets_cpy)\n \n if all(is_sets_of_sets) and len(is_sets_of_sets)!=0:\n for s in other_set:\n other_set2.append(s)\n else:\n other_set2.append(other_set)\n\n col_set_flat = []\n is_sets_of_sets = [True if type(i) == frozenset else False for i in self.collision_set]\n if True in is_sets_of_sets:\n assert all(is_sets_of_sets)\n if False in is_sets_of_sets:\n is_sets_of_sets_cpy = [True if i==False else True for i in is_sets_of_sets]\n assert all(is_sets_of_sets_cpy)\n\n if all(is_sets_of_sets) and len(is_sets_of_sets)!=0:\n for s in self.collision_set:\n col_set_flat.append(s)\n else:\n col_set_flat.append(self.collision_set)\n\n #Check if otherset is subset of collision set\n other_set_dict = {other: False for other in other_set2}\n for k in other_set_dict.keys():\n for sub in col_set_flat:\n if k.issubset(sub):\n other_set_dict[k] = True\n flag = all(list(other_set_dict.values()))\n return flag\n\n\n def add_back_set(self, new_v):\n assert isinstance(new_v, type(self)), \"Input is not a Vertex class\"\n self.back_set[new_v.v_id] = new_v\n \n def get_back_set(self):\n return self.back_set.values()\n \n #For priority que:\n def __eq__(self, other_v):\n return self.g == other_v.g\n def __gt__(self, other_v):\n return self.g > other_v.g\n def __ge__(self, other_v):\n return self.g >= other_v.g\n def __lt__(self, other_v):\n return self.g < other_v.g\n def __le__(self, other_v):\n return self.g <= other_v.g\n\n\nclass SimplePriorityQ():\n def __init__(self):\n self.q = []\n def push(self, item):\n heapq.heappush(self.q, item)\n def pop(self):\n (_, n) = heapq.heappop(self.q)\n return n\n def empty(self):\n if len(self.q) == 0:\n return True\n else:\n return False\n\nclass PriorityQueue2(SimplePriorityQ):\n '''PQ which implements __contains__ member'''\n def __init__(self):\n super().__init__()\n self.lookup_table = {}\n def add_lookup(self, item):\n if item[-1].v_id in self.lookup_table:\n self.lookup_table[item[-1].v_id] += 1\n else:\n self.lookup_table[item[-1].v_id] = 1\n def remove_lookup(self, v):\n if v.v_id in self.lookup_table:\n if self.lookup_table[v.v_id] < 2:\n del self.lookup_table[v.v_id]\n else:\n self.lookup_table[v.v_id] -= 1\n def push(self, item):\n super().push(item)\n self.add_lookup(item)\n def pop(self):\n result = super().pop()\n self.remove_lookup(result)\n return result\n # def get(self):\n # result = super().pop()\n # self.remove_lookup(result)\n # return result\n def __contains__(self, key):\n return key.v_id in self.lookup_table\n\nclass AllVertex():\n '''Keeps track of all nodes created\n such that nodes are created only once '''\n def __init__(self):\n self.all_v = dict()\n #self.intermediate = use_intermediate_nodes\n def get(self, v_id):\n if v_id in self.all_v:\n return self.all_v[v_id]\n else:\n self.all_v[v_id] = Vertex(v_id)\n return self.all_v[v_id]\n \nclass Mstar_ODr():\n def __init__(self, end, expand_position, get_next_joint_policy_position, get_shortest_path_cost, sub_graphs = None, inflation = None):\n '''\n This class implements subdimensional expansion with a star as the search algorithm.\n It assumes the following functions which are external to the class:\n -- expand_position: returns the neighbouring vertices of a single position\n -- get_next_joint_policy_position: Returns the next vertex of a particular agents \n joint policy action\n where the joint policy is the shortest path action\n where there is no other agents.\n -- het_shortest_path_cost = the shortest path cost of single agent.\n -- get_SIC: returns the sum of individual cost (individual \n optimal path cost from vertex vk to vf)\n '''\n if type(end) == list:\n end = tuple(end)\n \n if type(end) == tuple:\n end = {i:v for i,v in enumerate(end)}\n\n assert type(end) == dict\n self.v_len = len(end)\n self.end_dict = end\n self.agent_ids = frozenset(end.keys())\n self.expand_position = expand_position\n self.get_next_joint_policy_position = get_next_joint_policy_position\n self.heuristic_shortest_path_cost = get_shortest_path_cost\n self.all_v = AllVertex()\n\n if inflation is None:\n self.inflation = 1.0\n else:\n self.inflation = inflation\n\n\n if sub_graphs is None:\n self.sub_graphs = dict()\n else:\n self.sub_graphs = sub_graphs\n \n self._init_own_sub_graph()\n\n \n def _init_own_sub_graph(self):\n hldr = list(self.end_dict.keys())\n hldr.sort()\n own_id = tuple(hldr)\n if not own_id in self.sub_graphs:\n self.sub_graphs[own_id] = self.retrieve_next_optimal_pos\n print(\"Creating sub graph: {}\".format(own_id))\n else:\n print(\"_init_own_sub_graph called but id already in sub_graph\")\n\n\n def query_sub_graph_optimal_policy(self, this_graph_sub_id, sub_start_v):\n '''this_graph_sub_id the collision set in this instance of rM*. \n sub_start_v the full position tuple of the vertex which has the collision '''\n #map this_graph_sub_id to global ids\n # create sub_start_dic and sub_end_dict\n # get next sub_graph position\n # map next_sub_graph position back to dict with keys of this_sub_graph_id\n if type(this_graph_sub_id) == int:\n this_graph_sub_id = frozenset([this_graph_sub_id])\n assert type(this_graph_sub_id) == frozenset\n def sort_iterable(variable):\n a = list(variable)\n a.sort()\n return a\n this_graph_sub_id = frozenset(sort_iterable(this_graph_sub_id))\n #assume v positions always arranged in ascending order of global id keys\n true_ids = sort_iterable(self.end_dict.keys())\n sub_start_dict = dict()\n for id in this_graph_sub_id:\n sub_start_dict[true_ids[id]] = sub_start_v[id]\n \n sub_end_dict = dict()\n for id in this_graph_sub_id:\n sub_end_dict[true_ids[id]] = self.end_dict[true_ids[id]]\n\n graph_id = tuple(sort_iterable(sub_start_dict.keys()))\n assert graph_id == tuple(sort_iterable(sub_end_dict.keys()))\n\n if not graph_id in self.sub_graphs:\n if len(graph_id) > 1:\n print(\"End dict is {}\".format(sub_end_dict))\n temp = type(self)(sub_end_dict, self.expand_position, \\\n self.get_next_joint_policy_position, self.heuristic_shortest_path_cost, self.sub_graphs, inflation=self.inflation)\n if not graph_id in self.sub_graphs:\n print(\"Id is: {} Sub end dict is: {}\".format(graph_id, sub_end_dict))\n next_sub_v = self.sub_graphs[graph_id](sub_start_dict, sub_end_dict)\n elif len(graph_id) == 1:\n agent_id = graph_id[0]\n pos = sub_start_dict[agent_id]\n next_sub_v = {agent_id: self.get_next_joint_policy_position(agent_id, pos)[-1]}\n else:\n raise Exception(\"Graph id has to be len >= 1\")\n else:\n assert len(graph_id) > 1\n next_sub_v = self.sub_graphs[graph_id](sub_start_dict, sub_end_dict)\n \n #map glabal keys back to relative keys:\n next_sub_v_relative_id = {}\n this_graph_sub_id_keys =[k for k in this_graph_sub_id]\n this_graph_sub_id_keys.sort()\n for i,val in enumerate(next_sub_v.values()):\n next_sub_v_relative_id[this_graph_sub_id_keys[i]] = val\n return next_sub_v_relative_id\n\n def retrieve_next_optimal_pos(self, start_dict, end_dict):\n def sort_iterable(variable):\n a = list(variable)\n a.sort()\n return a\n \n assert self.end_dict == end_dict\n assert type(start_dict) == dict\n assert set(start_dict.keys()) == set(end_dict.keys())\n start_tup = []\n for k in sort_iterable(start_dict.keys()):\n start_tup.append(start_dict[k])\n start_tup = tuple(start_tup)\n end_tup = []\n for k in sort_iterable(end_dict.keys()):\n end_tup.append(end_dict[k])\n end_tup = tuple(end_tup)\n \n start_v = (start_tup, start_tup)\n end_v = (end_tup, end_tup)\n actions = self.search(start_tup, end_tup)\n v = self.all_v.all_v[start_v]\n next_v_tup = None\n if v.v_id == end_v:\n next_v_tup = start_v\n elif v.forward_pointer is None:\n assert actions is None\n next_v_tup = None\n else:\n next_v = v.forward_pointer\n cntr = 0\n while (not next_v is None) and next_v.is_standard == False:\n next_v = next_v.forward_pointer\n cntr += 1\n if cntr > 50000:\n raise Exception(\"Infinite while loop\")\n if next_v is None:\n next_v_tup = None\n else:\n next_v_tup = next_v.v_id\n if not next_v_tup is None:\n assert next_v_tup[0] == next_v_tup[1]\n next_v_dict = {}\n inter_v, root_v = next_v_tup\n for k, inter_pos, root_pos in zip(sort_iterable(end_dict.keys()), inter_v, root_v):\n next_v_dict[k] = inter_pos #(inter_pos, root_pos)\n else:\n next_v_dict = None\n return next_v_dict\n\n \n def search(self,start_pos, end_pos, OD = True):\n open = PriorityQueue2()\n start_v = (start_pos, start_pos)\n end_v = (end_pos, end_pos)\n if len(self.all_v.all_v) > 1:\n for k,v in self.all_v.all_v.items():\n v.collision_set = frozenset()\n v.g = 1e6\n v.f = None\n v.back_set = dict()\n v.back_ptr = None\n \n vs = self.all_v.get(start_v)\n vs.g = 0\n vs.f = vs.g + self.heuristic_SIC(vs.v_id)\n open.push((vs.f, vs))\n if OD:\n expand_function = self.expand_rOD\n else:\n print(\"Not implemented\")\n\n while not open.empty():\n vk = open.pop()\n test = vk.v_id\n if vk.v_id == end_v or vk.forward_pointer is not None:\n if vk.v_id == end_v:\n self._set_forward_pointers(vk)\n return self._back_track(vk)\n else:\n self._set_forward_pointers(vk)\n cntr1 = 0\n while vk.forward_pointer is not None:\n vk = vk.forward_pointer\n cntr1 +=1\n assert cntr1 < 50000\n assert vk.v_id == end_v\n return self._back_track(vk)\n \n for vl_id in expand_function(vk, self.end_dict):\n # Intermediate nodes not part of backprop\n #For standard v only\n vl = self.all_v.get(vl_id)\n v_pos = vl.v_id[-1]\n col = self._is_pos_colliding(v_pos)\n if vl.is_standard:\n vl.add_back_set(vk)\n vl.add_collision(col)\n self._backprop(vk, vl.collision_set, open)\n if (len(col) == 0 or vl.is_standard==False) and vk.g + self.get_move_cost(vk,vl, end_pos) < vl.g:\n vl.g = vk.g + self.get_move_cost(vk,vl, end_pos)\n vl.f = vl.g + self.heuristic_SIC(vl.v_id)\n vl.back_ptr = vk\n open.push((vl.f, vl))\n print(\"returning no solution\")\n print(\"This graph is {}\".format(tuple(list(self.end_dict.keys()))))\n for k,v in self.all_v.all_v.items():\n f_ptr = None\n if not v.forward_pointer is None:\n f_ptr = v.forward_pointer.v_id\n print(\"V: {} Forward_ptr: {} \".format(k, f_ptr))\n return None\n\n def _backprop(self, v_k, c_l, open):\n if v_k.is_standard:\n if not v_k.is_col_subset(c_l):\n v_k.add_collision(c_l)\n if not v_k in open:\n priority = v_k.g + self.heuristic_SIC(v_k.v_id)\n open.push((priority, v_k))\n for v_m in v_k.get_back_set():\n self._backprop(v_m, v_k.collision_set, open)\n\n def euristic_SICh(self, v_id):\n (inter_tup, vertex_pos_tup) = v_id\n total_cost = 0\n true_id = list(self.end_dict.keys())\n for i, pos in enumerate(inter_tup):\n i_true = true_id[i]\n if pos == \"_\":\n total_cost += self.heuristic_shortest_path_cost(i_true, vertex_pos_tup[i])\n else:\n total_cost += self.heuristic_shortest_path_cost(i_true, pos)\n return total_cost * self.inflation\n \n def _is_pos_colliding(self, v_pos):\n '''Returns set of coll agents '''\n hldr = set()\n for i, vi in enumerate(v_pos):\n for i2, vi2 in enumerate(v_pos):\n if i != i2:\n if vi == vi2:\n hldr.add(i)\n hldr.add(i2)\n hldr = frozenset([i for i in hldr])\n return hldr \n\n def get_move_cost(self, vk, vn, end_pos):\n '''Cost of moving from vertex vk to vn '''\n #It is possible for vk and vn to both be standard nodes. Need to account for this in cost\n # Due to subdimensional expansion, expanded node neighbours are not always 1 appart. \n # eg. expanding a standard node where x agents follow individually optimal policies\n \n assert len(end_pos) == self.v_len\n end = list(end_pos)\n # Four possible conditions for vk and vn being either standard or\n if vk.is_standard:\n if vn.is_standard:\n cost = self.v_len\n #count number of transitions from goal to goal pos\n num_agents_stay_on_goal = 0\n for gp, pk,pn in zip(end, vk.v_id[0], vn.v_id[0]):\n if pk == gp and pn == gp:\n num_agents_stay_on_goal += 1\n cost -= num_agents_stay_on_goal\n assert cost >= 0\n else:\n #vk should be root node of vn\n assert vk.v_id[1] == vn.v_id[1]\n cnt_vn = 0\n for g, pn,pk in zip(end, vn.v_id[0], vk.v_id[0]):\n if not pn == '_':\n if pn == g and pk == g: #if agent stayed on goal\n cnt_vn += 0\n else:\n cnt_vn += 1\n cost = cnt_vn\n else:\n if vn.is_standard:\n num_pos_canged = 0\n cost = 0\n for gp, pk, pn, pk_root in zip(end, vk.v_id[0], vn.v_id[0], vk.v_id[1]):\n if pk == '_':\n assert not pn == \"_\"\n num_pos_canged += 1\n if pn == gp and pk_root == gp:\n cost += 0\n else:\n cost += 1\n assert num_pos_canged == 1\n else:\n num_pos_canged = 0\n cost = 0\n for gp, pk, pn, pk_root in zip(end, vk.v_id[0], vn.v_id[0], vk.v_id[1]):\n if pk == '_' and not pn == \"_\":\n num_pos_canged += 1\n if pn == gp and pk_root == gp:\n cost += 0\n else:\n cost += 1\n assert num_pos_canged == 1\n \n assert cost >= 0 #vn should always be of higher count\n return cost\n \n\n def expand_rOD(self, v, end_dict):\n assert len(end_dict) == self.v_len\n (inter_tup, vertex_pos_tup) = v.v_id\n next_inter_tup = [] #list(inter_tup)\n # If standard node create next intermediate node base\n # else convert current inter_tup to list\n if not \"_\" in inter_tup: #if stadard node\n assert(v.is_standard)\n collision_set = v.collision_set\n next_tup = {i:None for i in range(self.v_len)}\n this_all_ids = frozenset([i for i in range(self.v_len)])\n for c in collision_set:\n if len(c) == len(self.agent_ids):\n assert len(collision_set) == 1\n assert c == this_all_ids\n for i in this_all_ids:\n next_tup[i] = \"_\"\n else:\n n_p = self.query_sub_graph_optimal_policy(c, v.v_id[0])\n hldr = set([i for i in c])\n hldr2 = set(n_p.keys())\n assert hldr == hldr2\n for k,val in n_p.items():\n assert next_tup[k] is None\n next_tup[k] = val\n all_col_ids = []\n for c in collision_set:\n for c2 in c:\n all_col_ids.append(c2)\n all_col_ids = frozenset(all_col_ids)\n diff = this_all_ids.difference(all_col_ids)\n\n #Get next shortest path position for non-colliding agents\n for d in diff:\n assert not \"_\" in next_inter_tup\n n_pos = self.query_sub_graph_optimal_policy(d, v.v_id[0])\n for k,val in n_pos.items():\n assert next_tup[k] is None\n next_tup[k] = val\n next_inter_tup = list(next_tup.values())\n assert not None in next_inter_tup\n else:\n next_inter_tup = list(inter_tup)\n \n #Deterimine intermediate node level\n this_inter_level = None\n for i,p in enumerate(next_inter_tup):\n if p == '_':\n this_inter_level = i\n break\n \n all_next_inter_tup = []\n if not this_inter_level is None:\n #if not a standard vertex\n pos = vertex_pos_tup[this_inter_level]\n positions_taken = [p for p in next_inter_tup if p != '_']\n n_pos = self.expand_position(i, pos)\n valid_n_pos = [p for p in n_pos if not p in positions_taken]\n\n if len(valid_n_pos) == 0:\n return []\n for p in valid_n_pos:\n next_inter_tup[this_inter_level] = p \n all_next_inter_tup.append(tuple(next_inter_tup))\n else:\n all_next_inter_tup.append(tuple(next_inter_tup))\n assert not \"_\" in next_inter_tup #should be standard node\n\n #Make v_id's:\n v_ids = []\n for inter_v in all_next_inter_tup:\n if not \"_\" in inter_v:\n v_ids.append((tuple(inter_v), tuple(inter_v)))\n else:\n v_ids.append((tuple(inter_v), vertex_pos_tup))\n return v_ids\n \n\n def expand_joint_actions(self, v):\n raise Exception(\"This function should not be called\")\n (inter_tup, vertex_pos_tup) = v.v_id\n assert inter_tup == vertex_pos_tup\n num_agents = len(vertex_pos_tup)\n all_positions = dict()\n collisions = v.collision_set\n for i,p in enumerate(vertex_pos_tup):\n if i in collisions:\n\n all_positions[i] = self.expand_position(i, p)\n else:\n n_pos = self.get_next_joint_policy_position(i, p)\n all_positions[i] = n_pos \n joint_positions = ParameterGrid(all_positions)\n next_v_id = []\n for j_pos in joint_positions:\n v_id = tuple([j_pos[i] for i in range(num_agents)])\n v_id = (v_id, v_id)\n next_v_id.append(v_id)\n return next_v_id\n \n def _set_forward_pointers(self, goal_v):\n this_v = goal_v\n while not this_v.back_ptr is None:\n back_v = this_v.back_ptr\n back_v.forward_pointer = this_v\n this_v = back_v\n\n def _back_track(self, goal_v):\n '''Returns a dictionary of actions for the optimal path '''\n self.pos_act = {(0,1):2,\n (1,0):3,\n (0,-1):4,\n (-1,0):1,\n (0,0): 0}\n \n #get vertices:\n all_v = []\n all_v.append(goal_v.v_id[-1])\n next_v = goal_v.back_ptr\n while not next_v is None:\n if next_v.is_standard:\n all_v.append(next_v.v_id[-1])\n next_v = next_v.back_ptr\n #Get actions from vertices:\n all_actions = []\n prev_v = all_v[-1]\n for v in reversed(all_v[:-1]):\n actions = {}\n for i, (previous_position, next_postion) in enumerate(zip(prev_v, v)):\n position_diff = self._add_tup(next_postion, self._mult_tup(previous_position, -1))\n actions[i] = self.pos_act[position_diff]\n prev_v = v\n all_actions.append(actions)\n return all_actions\n\n def _add_tup(self, a,b):\n assert len(a) == len(b)\n ans = []\n for ia,ib in zip(a,b):\n ans.append(ia+ib)\n return tuple(ans)\n\n def _mult_tup(self, a, m):\n ans = []\n for ai in a:\n ans.append(ai*m)\n return tuple(ans)\n\n\n\n","repo_name":"Jamesellis51015/Multi-Agent-Path-Finding-with-Reinforcement-Learning","sub_path":"utils/ODrM_star.py","file_name":"ODrM_star.py","file_ext":"py","file_size_in_byte":26862,"program_lang":"python","lang":"en","doc_type":"code","stars":22,"dataset":"github-code","pt":"51"}
+{"seq_id":"23059665812","text":"#!/usr/bin/env python\n\nimport os\nimport sys\nimport argparse\nimport logging\nimport pandas\nimport matplotlib\nimport matplotlib.pyplot as plt\n\n\nlogger = logging.getLogger(__name__)\n\n\nLOG_FORMAT = \"%(asctime)-15s %(levelname)s %(relativeCreated)dms \" \\\n \"%(filename)s::%(funcName)s():%(lineno)d %(message)s\"\n\n\nclass Formatter(argparse.ArgumentDefaultsHelpFormatter,\n argparse.RawDescriptionHelpFormatter):\n pass\n\n\ndef _parse_arguments(desc, args):\n \"\"\"\n Parses command line arguments\n :param desc:\n :param args:\n :return:\n \"\"\"\n parser = argparse.ArgumentParser(description=desc,\n formatter_class=Formatter)\n parser.add_argument('csvfile', help='Input CSV file')\n parser.add_argument('--matplotlibgui', default='Qt4Agg',\n help='Library to use for plotting')\n parser.add_argument('--logconf', default=None,\n help='Path to python logging configuration file in '\n 'this format: https://docs.python.org/3/library/'\n 'logging.config.html#logging-config-fileformat '\n 'Setting this overrides -v parameter which uses '\n ' default logger. (default None)')\n parser.add_argument('--verbose', '-v', action='count', default=0,\n help='Increases verbosity of logger to standard '\n 'error for log messages in this module '\n '. Messages are '\n 'output at these python logging levels '\n '-v = ERROR, -vv = WARNING, -vvv = INFO, '\n '-vvvv = DEBUG, -vvvvv = NOTSET (default no '\n 'logging)')\n\n return parser.parse_args(args)\n\n\ndef _setup_logging(args):\n \"\"\"\n Sets up logging based on parsed command line arguments.\n If args.logconf is set use that configuration otherwise look\n at args.verbose and set logging for this module and the one\n in ndexutil specified by TSV2NICECXMODULE constant\n :param args: parsed command line arguments from argparse\n :raises AttributeError: If args is None or args.logconf is None\n :return: None\n \"\"\"\n\n if args.logconf is None:\n level = (50 - (10 * args.verbose))\n logging.basicConfig(format=LOG_FORMAT,\n level=level)\n logger.setLevel(level)\n return\n\n # logconf was set use that file\n logging.config.fileConfig(args.logconf,\n disable_existing_loggers=False)\n\n\ndef run(theargs):\n \"\"\"\n Using pandas this function reads in the csvfile input file and\n generates 2 figures with subplots in each figure. The first\n figure contains scatter subplots and the second figure is a\n histogram plot for each column of the data.\n\n NOTE: In this implementation matplotlib will pause after\n creating the figures\n so the caller must close the figures for the program to exit\n\n :param theargs: arguments from ArgParse\n :return: 0 upon success otherwise failure\n \"\"\"\n matplotlib.use(theargs.matplotlibgui)\n df = pandas.read_csv(theargs.csvfile, delimiter=',',\n header=None)\n csvfilename = os.path.basename(theargs.csvfile)\n\n fig, axes = plt.subplots(nrows=2, ncols=3)\n fig.suptitle(csvfilename + ' plots', fontsize=16)\n fig.set_size_inches((18, 11))\n # nodes vs number clusters\n ax = df.plot(ax=axes[1, 0], kind='scatter', x=1, y=6, color='red')\n ax.set_xlabel('# of Nodes')\n ax.set_ylabel('# of clusters')\n axes[1, 0].set_title('# of nodes')\n\n # edges vs number clusters\n ax = df.plot(ax=axes[0, 0], kind='scatter', x=2, y=6, color='green')\n ax.set_xlabel('# of edges')\n ax.set_ylabel('# of clusters')\n axes[0, 0].set_title('# of edges')\n\n # density vs number clusters\n ax = df.plot(ax=axes[1, 1], kind='scatter', x=3, y=6, color='blue')\n ax.set_xlabel('Density')\n ax.set_ylabel('# of clusters')\n axes[1, 1].set_title('Density')\n\n # DegreeMean vs number clusters\n logger.debug(df.head())\n ax = df.plot(ax=axes[1, 2], kind='scatter', x=4, y=6, color='yellow')\n ax.set_xlabel('DegreeMean')\n ax.set_ylabel('# of clusters')\n axes[1, 2].set_title('DegreeMean')\n\n # number nodes vs number edges\n logger.debug(df.head())\n ax = df.plot(ax=axes[0, 2], kind='scatter', x=1, y=2, color='pink')\n ax.set_xlabel('# of nodes')\n ax.set_ylabel('# of edges')\n axes[0, 2].set_title('# nodes vs # edges')\n\n # Degree Stddev vs number clusters\n ax = df.plot(ax=axes[0, 1], kind='scatter', x=5, y=6, color='orange')\n ax.set_xlabel('DegreeStddev')\n ax.set_ylabel('# of clusters')\n axes[0, 1].set_title('Degree Stddev')\n\n # display figure 1 (the scatter plots) and dont pause (block=False)\n plt.show(block=False)\n\n # histogram plot using pandas feature df.hist that\n # creates a figure with 6 subplots (one for each column)\n hist = df.hist(column=[1, 2, 3, 4, 5, 6], figsize=(11, 8))\n hist[0][0].title.set_text('# nodes histogram')\n logger.debug(hist[0][0])\n hist[0][1].title.set_text('# edges histogram')\n hist[1][0].title.set_text('Density histogram')\n hist[1][1].title.set_text('Degree mean histogram')\n hist[2][0].title.set_text('Degree stddev histogram')\n hist[2][1].title.set_text('# clusters histogram')\n hfig = plt.figure(2)\n hfig.suptitle(csvfilename + ' histogram plots', fontsize=16)\n\n # display figure 2 (histograms) and wait (block=True)\n logger.info('Displaying figures and '\n 'waiting for user to close figures')\n plt.show(block=True)\n\n return 0\n\n\ndef main(args):\n \"\"\"\n Main entry point for program\n :param args:\n :return:\n \"\"\"\n desc = \"\"\"\n \n Plots hierarchy stats\n\n \"\"\"\n theargs = _parse_arguments(desc, args[1:])\n theargs.program = args[0]\n\n try:\n _setup_logging(theargs)\n return run(theargs)\n except Exception as e:\n logger.exception('Caught exception')\n return 2\n finally:\n logging.shutdown()\n\n\nif __name__ == '__main__': # pragma: no cover\n sys.exit(main(sys.argv))\n","repo_name":"coleslaw481/ud985","sub_path":"plot_hierarchystats.py","file_name":"plot_hierarchystats.py","file_ext":"py","file_size_in_byte":6242,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"38582391507","text":"def Bubble_Sort(A):\n\tFlag=1\n\twhile Flag==1:\n\t\tFlag=0\n\t\tfor j in range(len(A)-1):\n\t\t\tif(A[j] > A[j+1]):\n\t\t\t\tA[j], A[j+1] = A[j+1], A[j]\n\t\t\t\tFlag=1\n\t\t\t\t\nA = list(range(900,0,-1))\nBubble_Sort(A)\nprint(A)\n","repo_name":"ashwek/Python_Algorithms","sub_path":"2_Sorting_and_Order_Statistics/Bubble_Sort.py","file_name":"Bubble_Sort.py","file_ext":"py","file_size_in_byte":201,"program_lang":"python","lang":"en","doc_type":"code","stars":3,"dataset":"github-code","pt":"51"}
+{"seq_id":"23059603942","text":"import streamlit as st\nfrom simulation import main\nimport plotly.graph_objects as go\n\nst.set_page_config(page_title=\"Liverpool Vs. Real Madrid Penalty Shoutout Simulation\", page_icon=\"🏆\", layout=\"centered\", initial_sidebar_state=\"expanded\")\n\nhide_streamlit_style = \"\"\"\n \n \"\"\"\nst.markdown(hide_streamlit_style, unsafe_allow_html=True) \n\nst.markdown(\"Penalty Shootout Simulation
\", unsafe_allow_html=True)\n\nst.markdown(\"Simulation Results
\", unsafe_allow_html=True)\n\nlp_wins, lp_win_prob = st.columns(2)\n\nwith lp_wins:\n st.markdown(f\"Liverpool Wins
\", unsafe_allow_html=True)\n\n liverpool_wins = st.empty()\n\nwith lp_win_prob:\n st.markdown(f\"Liverpool FC Win Probability
\", unsafe_allow_html=True)\n\n liverpool_win_probs = st.empty()\n\nrm_wins, rm_win_prob = st.columns(2)\n\nwith rm_wins:\n st.markdown(f\"Real Madrid Wins
\", unsafe_allow_html=True)\n\n real_madrid_wins = st.empty()\n\nwith rm_win_prob:\n st.markdown(f\"Real Madrid Win Probability
\", unsafe_allow_html=True)\n\n real_madrid_win_probs = st.empty()\n\nchart = st.empty()\n\nwith st.sidebar:\n st.markdown(\"Simulation Parameters
\", unsafe_allow_html=True)\n with st.form('Enter the number of simulations to run'):\n number_of_simulations = st.number_input(\"Number of simulations\", min_value=1, max_value=1000000, value=1000)\n\n\n button = st.form_submit_button(\"Run Simulation\")\n # If hover over any button it will darken the button\n st.markdown('', unsafe_allow_html=True)\n\n\n if button: \n results = main(number_of_simulations)\n\n liverpool_stats = results[0]\n real_madrid_stats = results[1]\n\n liverpool_win_count = liverpool_stats[0]\n liverpool_win_probability = liverpool_stats[1]\n\n real_madrid_win_count = real_madrid_stats[0]\n real_madrid_win_probability = real_madrid_stats[1]\n\n\n liverpool_wins.markdown(f\"\"\"{liverpool_win_count.__format__(',.0f')}
\"\"\", unsafe_allow_html=True)\n\n liverpool_win_probs.markdown(f\"{str(liverpool_win_probability.__format__('.2f'))}%
\", unsafe_allow_html=True)\n\n real_madrid_wins.markdown(f\"\"\"{real_madrid_win_count.__format__(',.0f')}
\"\"\", unsafe_allow_html=True)\n\n real_madrid_win_probs.markdown(f\"{str(real_madrid_win_probability.__format__('.2f'))}%
\", unsafe_allow_html=True)\n\n \n\n fig = go.Figure(data=[go.Bar(x=['Liverpool Wins', 'Real Madrid Wins'], y=[liverpool_win_count, real_madrid_win_count], name='Wins')])\n fig.update_layout(title_text='Wins', xaxis_title='Results', yaxis_title='Count')\n \n # Change the color of each bar\n fig.update_traces(marker_color=['#F0544F', '#C6D8D3', '#D81E5B'])\n\n fig.update_layout(title_text=\"Simulation Results\", title_x=0.5)\n\n chart.plotly_chart(fig)\n\n\n\n\n \n\n","repo_name":"colesmcintosh/penalty-shootout-simulation","sub_path":"app.py","file_name":"app.py","file_ext":"py","file_size_in_byte":3910,"program_lang":"python","lang":"en","doc_type":"code","stars":1,"dataset":"github-code","pt":"51"}
+{"seq_id":"38004980318","text":"from enum import Enum\n\nFILE_BOOKS = \"books.json\"\nFILE_CUSTOMER = \"customer.json\"\nFILE_LOANS = \"loans.json\"\n\n'''\nconstant varible menu for the main class\n'''\n\nclass Menu(Enum):\n ADD_A_NEW_CUSTOMER = '1'\n DISPLAY_ALL_CUSTOMERS = '2'\n FIND_CUSTOMER_BY_NAME = '3'\n REMOVE_CUSTOMER = '4'\n ADD_A_NEW_BOOK = '5'\n DISPLAY_ALL_BOOKS = '6'\n FIND_BOOK_BY_NAME = '7'\n REMOVE_BOOK = '8'\n LOAN_A_BOOK = '9'\n RETURN_A_BOOK = '10'\n DISPLAY_ALL_LOANS = '11'\n DISPLAY_LATE_LOANS = '12'\n EXIT = '13'","repo_name":"oferkarp/MyLibory","sub_path":"constant.py","file_name":"constant.py","file_ext":"py","file_size_in_byte":519,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"11270095214","text":"import sys\r\ninput = sys.stdin.readline\r\n\r\nn = int(input())\r\ntree = {}\r\n\r\nfor _ in range(n):\r\n root, left, right = input().split()\r\n tree[root] = [left, right]\r\n\r\n# 전위순회 = 루트, 왼쪽, 오른쪽\r\ndef preorder(root):\r\n if root != '.':\r\n print(root, end='')\r\n preorder(tree[root][0])\r\n preorder(tree[root][1])\r\n\r\n# 중위순회 = 왼쪽, 루트, 오른쪽\r\ndef inorder(root):\r\n if root != '.':\r\n inorder(tree[root][0])\r\n print(root, end='')\r\n inorder(tree[root][1])\r\n\r\n# 후위순회 = 왼쪽, 오른쪽, 루트 \r\ndef postorder(root):\r\n if root != '.':\r\n postorder(tree[root][0])\r\n postorder(tree[root][1])\r\n print(root, end='')\r\n\r\npreorder('A')\r\nprint()\r\ninorder('A')\r\nprint()\r\npostorder('A')","repo_name":"nevertheless0404/Keep_studying","sub_path":"백준/Silver/1991. 트리 순회/트리 순회.py","file_name":"트리 순회.py","file_ext":"py","file_size_in_byte":779,"program_lang":"python","lang":"en","doc_type":"code","stars":2,"dataset":"github-code","pt":"51"}
+{"seq_id":"27324781901","text":"\"\"\"A module for dicovering raw two-level rules from a set of carefully chosen examples\n\nExamples, contexts and rules are treated in terms of strings without any\nfinite-state machinery or rule compilation. Examples and contexts are\nspace separated sequences of pair-symbols. \n\n© Kimmo Koskenniemi, 2017-2018. Free software under the GPL 3 or later.\n\"\"\"\n\nimport sys\nimport re\nimport cfg\nimport twexamp\n\npair_symbols_for_input = {} # key: input symbol, value: set of pair symbols\npair_symbols_for_output = {}\n\ndef relevant_contexts(pair_symbol):\n \"\"\"Select positive and negative contexts for a given pair-symbol\n \n pair_symbol -- the pair-symbol for which the contexts are selected\n \n returns a tuple of:\n \n pos_context_set -- a set of contexts in the examples where the\n pair_symbol occurs\n \n neg_context_set -- a set of contexts where the input-symbol of the\n pair_symbol occurs with another output-symbol but so that there is\n no example in the example_set where the pair_symbol occurs in such a\n context\n \"\"\"\n input_symbol, output_symbol = cfg.pairsym2sympair(pair_symbol)\n positive_context_set = set()\n negative_context_set = set()\n pairsymlist = [re.sub(r\"([}{])\", r\"\\\\\\1\", psym)\n for psym\n in pair_symbols_for_input[input_symbol]]\n # print(\"pairsymlist:\", pairsymlist) ##\n pattern = re.compile(\"|\".join(pairsymlist))\n for example in cfg.example_set:\n for m in pattern.finditer(example):\n i1 = m.start()\n i2 = m.end()\n # print('\"' + example[0:i1] +'\"', '\"' + example[i2:] + '\"') ##\n left_context = \".#. \" + example[0:i1-1]\n centre = example[i1:i2]\n if i2 >= len(example):\n right_context = \".#.\"\n else:\n right_context = example[i2+1:] + \" .#.\"\n context = (left_context, right_context)\n # print(centre, context) ##\n if centre == pair_symbol:\n positive_context_set.add(context)\n else:\n negative_context_set.add(context)\n negative_context_set = negative_context_set - positive_context_set\n return positive_context_set, negative_context_set\n \ndef ppcontexts(ctxs, title):\n \"\"\"Print a list of context for tracing and debugging\"\"\"\n print(title)\n for lc, rc in sorted(ctxs):\n print(lc, \"_\", rc)\n\ndef shorten_contexts(contexts, left_length, right_length):\n if cfg.verbosity >= 25:\n print(\"left and right length:\", left_length, right_length)\n ppcontexts(contexts, \"contexts as given to shorten_contexts()\")\n new_contexts = set()\n for left_context, right_context in contexts:\n left_lst = left_context.split(\" \")\n start = max(0, len(left_lst) - left_length)\n new_lc = \" \".join(left_lst[start:])\n # print(\"start:\", start, \"new_lc:\", new_lc)\n right_lst = right_context.split(\" \")\n new_rc = \" \".join(right_lst[0:right_length])\n new_contexts.add((new_lc, new_rc))\n return(new_contexts)\n\ndef minimal_contexts(pair_symbol, pos_contexts, neg_contexts):\n \"\"\"Shortens the left and right contexts step by step\n \n Finds shortest contexts which accept correct occurrences of\n pair_symbol and still reject the incorrect occurrences of it.\n \n pair_symbol -- a pair-symbol, e.g. '{aä}:a' for which the optimal\n contexts are computed\n \n pos_context, neg_contexts -- selected from the examples\n \n returns a tuple: (positive_contexts, negative_contexts)\n \"\"\"\n if cfg.verbosity >= 25:\n ppcontexts(pos_contexts, \"positive contexts for \" + pair_symbol)\n ppcontexts(neg_contexts, \"negative contexts for \" + pair_symbol)\n # find maximum lengths (in psyms) of left and right contexts\n left_len = 0\n right_len = 0\n for left_context, right_context in pos_contexts:\n lcount = left_context.count(\" \")\n if lcount >= left_len: left_len = lcount + 1\n rcount = right_context.count(\" \")\n if rcount >= right_len: right_len = rcount + 1\n for left_context, right_context in neg_contexts:\n lcount = left_context.count(\" \")\n if lcount >= left_len: left_len = lcount + 1\n rcount = right_context.count(\" \")\n if rcount >= right_len: right_len = rcount + 1\n\n # shorten the contexts stepwise while the positive and\n # the negative contexts stay disjoint\n p_contexts = pos_contexts.copy()\n n_contexts = neg_contexts.copy()\n left_incomplete = True\n right_incomplete = True\n while left_incomplete or right_incomplete:\n # print(left_len, right_len) ##\n if left_incomplete and left_len > 0:\n new_p_contexts = shorten_contexts(p_contexts, left_len-1, right_len)\n new_n_contexts = shorten_contexts(n_contexts, left_len-1, right_len)\n if new_p_contexts.isdisjoint(new_n_contexts):\n # print(\"still disjoint\") ##\n p_contexts = new_p_contexts\n n_contexts = new_n_contexts\n left_len = left_len - 1\n else:\n if cfg.verbosity >= 25:\n print(\"left side now complete\") ##\n ppcontexts(new_p_contexts & new_n_contexts,\n \"intersection of new pos and neg contexts\")\n left_incomplete = False\n elif right_incomplete and right_len > 0:\n new_p_contexts = shorten_contexts(p_contexts, left_len, right_len-1)\n new_n_contexts = shorten_contexts(n_contexts, left_len, right_len-1)\n if new_p_contexts.isdisjoint(new_n_contexts):\n # print(\"still disjoint\") ##\n p_contexts = new_p_contexts\n n_contexts = new_n_contexts\n right_len = right_len - 1\n else:\n # print(\"left side now complete\") ##\n right_incomplete = False\n else:\n break\n if cfg.verbosity >= 25:\n ppcontexts(p_contexts, \"positive contexts\")\n ppcontexts(n_contexts, \"negative contexts\")\n return p_contexts, n_contexts\n\ndef print_rule(pair_symbol, operator, contexts):\n \"\"\"Prints one rule\"\"\"\n print(pair_symbol, operator)\n rule_lst = [\" {} _ {}\".format(lc, rc) for lc, rc in contexts]\n print(\",\\n\".join(rule_lst) + \" ;\")\n return\n\ndef context_to_output_str(pairsym_str):\n pairsym_lst = pairsym_str.split(\" \")\n sympair_lst = [cfg.pairsym2sympair(psym) for psym in pairsym_lst]\n outsym_lst = [outsym for insym, outsym in sympair_lst]\n return \"\".join(outsym_lst)\n\nif __name__ == \"__main__\":\n import argparse\n arpar = argparse.ArgumentParser(\"python3 twdiscov.py\")\n arpar.add_argument(\"examples\", help=\"example pair strings file\",\n default=\"test.pstr\")\n arpar.add_argument(\"-s\", \"--symbol\",\n help=\"input symbol for which to find rules\",\n default=\"\")\n arpar.add_argument(\"-v\", \"--verbosity\",\n help=\"level of diagnostic output\",\n type=int, default=0)\n args = arpar.parse_args()\n\n cfg.verbosity = args.verbosity\n \n twexamp.read_examples(filename=args.examples, build_fsts=False)\n if cfg.verbosity >= 5:\n print(\"--- all examples read in ---\")\n \n for insym in cfg.input_symbol_set:\n pair_symbols_for_input[insym] = set()\n for insym, outsym in cfg.symbol_pair_set:\n pair_symbol = cfg.sympair2pairsym(insym, outsym)\n pair_symbols_for_input[insym].add(pair_symbol)\n\n if args.symbol:\n pair_set = pair_symbols_for_input[args.symbol]\n pair_lst = []\n for pairsym in pair_set:\n insym, outsym = cfg.pairsym2sympair(pairsym)\n pair_lst.append((insym, outsym))\n if cfg.verbosity >= 10:\n print(\"pair_lst:\", pair_lst)\n else:\n pair_lst = sorted(cfg.symbol_pair_set)\n\n for insym, outsym in pair_lst:\n if len(pair_symbols_for_input[insym]) <= 1:\n continue\n pair_symbol = cfg.sympair2pairsym(insym, outsym)\n posi_contexts, nega_contexts = relevant_contexts(pair_symbol)\n pos_contexts, neg_contexts = minimal_contexts(pair_symbol,\n posi_contexts.copy(),\n nega_contexts.copy())\n if len(pos_contexts) <= len(neg_contexts) or cfg.verbosity > 0:\n print_rule(pair_symbol, \"=>\", pos_contexts)\n else:\n print_rule(pair_symbol, \"/<=\", neg_contexts)\n if args.verbosity >= 5:\n for lc, rc in posi_contexts:\n l_str = context_to_output_str(lc)\n r_str = context_to_output_str(rc)\n print(\"{:>30}<{}>{}\".format(l_str, outsym, r_str))\n","repo_name":"koskenni/pytwolc","sub_path":"twdiscov.py","file_name":"twdiscov.py","file_ext":"py","file_size_in_byte":8824,"program_lang":"python","lang":"en","doc_type":"code","stars":3,"dataset":"github-code","pt":"51"}
+{"seq_id":"38338190662","text":"# ! /usr/bin/env python\n# -*- coding: utf-8 -*-\nimport datetime\nimport os\nimport json\nimport importlib\nfrom multiprocessing import Process\nimport time\nfrom django.http import JsonResponse\nfrom django.http import HttpResponse\nfrom django.shortcuts import render, redirect\nfrom django.views.decorators.csrf import csrf_exempt\nfrom django.db import connection\nfrom oauthlib.oauth2.rfc6749.tokens import random_token_generator\nfrom django.db import transaction as db_transaction\nfrom django.template.loader import get_template\nfrom django.core.files import File\nimport pathlib2 as pathlib\nfrom django.utils import timezone\n\nfrom el_t01.settings import MEDIA_ROOT, BASE_DIR\n\nfrom el_t01_app.service.service import get_main_args\nfrom el_t01_app.models import Profile, Devices_list, Ticket_type, Device_history\n\nimport requests\nfrom el_t01.env import TOKEN_DEVICE, TOKEN_SERVER, URL_PHOTO, URL_RESULT, URL_FREE\n\n# from rest_framework.permissions import IsAuthenticated\nfrom rest_framework.response import Response\nfrom rest_framework.views import APIView\nfrom rest_framework import permissions\nfrom rest_framework import status\n\nclass CustomerAccessPermission(permissions.BasePermission):\n message = 'Adding customers not allowed.'\n\n def has_permission(self, request, view):\n print (\"has_permission --\")\n # body_unicode = request.body.decode('utf-8')\n # try:\n # body = json.loads(body_unicode)\n # except:\n # body = {}\n m_headers = request.headers\n m_token = m_headers.get(\"Token\", \"\")\n print (\"m_token = \", m_token)\n m_Devices_list = Devices_list.objects.filter(api_token=m_token)\n if m_Devices_list.count() > 0:\n m_Devices_list = m_Devices_list[0]\n return True\n else:\n return False\n\nclass FileUploadView_Vvs(APIView):\n print (\"FileUploadView_Vvs\")\n permission_classes = [CustomerAccessPermission]\n # parser_classes = (FileUploadView_Vvs, )\n\n def post(self, request, format='jpg'):\n m_return = {\"status\": \"error\"}\n m_headers = request.headers\n m_token = m_headers.get(\"Token\", \"\")\n m_jellyfish_type = m_headers.get(\"JellyfishType\", \"\")\n m_ticket_type = m_headers.get(\"TicketType\", \"\")\n m_ticketid = m_headers.get(\"TicketId\", \"\")\n\n print (\"m_token = \", m_token )\n print (\"m_jellyfish_type = \", m_jellyfish_type )\n print (\"m_ticket_type = \", m_ticket_type )\n print (\"m_ticketid = \", m_ticketid )\n\n # если новая система - ищем запись\n # если старвя система - создаем запись\n\n # найти запись в истории\n try:\n t_ticket_history = Device_history.objects.get(id=m_ticketid)\n except:\n pass\n\n m_Devices_list = Devices_list.objects.filter(api_token=m_token)\n print (\"m_Devices_list.count() = \", m_Devices_list.count() )\n # ToDo\n if m_Devices_list.count() > 0:\n m_Devices_item = m_Devices_list[0]\n else:\n m_Devices_item = None\n\n if m_Devices_item is not None:\n if request.FILES:\n print (\"FILES YES\")\n if 'image' in request.FILES:\n file_to_upload = request.FILES['image']\n m_time_now = datetime.datetime.strftime(datetime.datetime.now(), \"%Y%m%d%H%M%S\")\n m_dir_short = os.path.join('media', 'ticket_in', str(m_Devices_item.id))\n m_file_name = \"in_{}_{}_{}.png\".format(m_ticketid, m_ticket_type, m_time_now )\n m_file_short = os.path.join(m_dir_short, m_file_name)\n m_dir_full = os.path.join(BASE_DIR, m_dir_short)\n m_file_full = os.path.join(m_dir_full, m_file_name)\n print (\"m_file_full = \", m_file_full)\n file_in = File(file_to_upload)\n with open(m_file_full, 'wb+') as file_out:\n for chunk in file_in.chunks():\n file_out.write(chunk)\n\n m_return = {\"status\": \"ok\"}\n\n if t_ticket_history.game_type.verbal == \"01\":\n from el_t01_app.service.v003.def_ticket_01 import TicketJob\n elif t_ticket_history.game_type.verbal == \"02\":\n from el_t01_app.service.v003.def_ticket_02 import TicketJob\n elif t_ticket_history.game_type.verbal == \"03\":\n from el_t01_app.service.v003.def_ticket_03 import TicketJob\n elif t_ticket_history.game_type.verbal == \"04\":\n from el_t01_app.service.v003.def_ticket_04 import TicketJob\n elif t_ticket_history.game_type.verbal == \"05\":\n from el_t01_app.service.v003.def_ticket_05 import TicketJob\n\n if m_ticket_type == \"01\":\n t_ticket_history.img_01 = m_file_short\n t_ticket_history.step_ticket = m_ticket_type\n t_ticket_history.save()\n ItemJob = TicketJob(item_ticket_job=t_ticket_history)\n m_return = ItemJob.run_job_01()\n\n if m_ticket_type == \"02\":\n t_ticket_history.img_02 = m_file_short\n t_ticket_history.step_ticket = m_ticket_type\n t_ticket_history.save()\n ItemJob = TicketJob(item_ticket_job=t_ticket_history)\n m_return = ItemJob.run_job_02()\n\n else:\n print (\"FILES NO\")\n\n return Response(m_return)\n\n\nclass Tickets_Get_Vvs(APIView):\n print (\"Tickets_Get_Vvs\")\n permission_classes = [CustomerAccessPermission]\n # parser_classes = (FileUploadView_Vvs, )\n\n def post(self, request, format='jpg'):\n m_return = {\"status\": \"error\"}\n m_headers = request.headers\n m_token = m_headers.get(\"Token\", \"\")\n m_jellyfish_type = m_headers.get(\"JellyfishType\", \"\")\n m_ticket_type = m_headers.get(\"TicketType\", \"\")\n m_ticketid = m_headers.get(\"TicketId\", \"\")\n\n try:\n m_Devices_item = Devices_list.objects.get(api_token=m_token)\n except:\n return Response([])\n\n ## api_token\n\n print (\"m_token = \", m_token )\n print (\"m_jellyfish_type = \", m_jellyfish_type )\n print (\"m_ticket_type = \", m_ticket_type )\n print (\"m_ticketid = \", m_ticketid, type(m_ticketid) )\n\n body_unicode = request.body.decode('utf-8')\n print (\"body_unicode = \", body_unicode )\n body_data = json.loads(body_unicode)\n print (\"body_data = \", body_data )\n m_tickets_in = body_data.get('JobTickets',[])\n print (\"m_tickets_in = \", m_tickets_in )\n\n m_device_ticket_list = []\n for item_ticket in m_tickets_in:\n t_history = Device_history()\n t_history.req_id = item_ticket\n t_history.req_dt = timezone.now()\n t_history.step_job = \"\"\n t_history.type_ticket = m_Devices_item.t_type.verbal\n t_history.status = \"00\"\n t_history.type_jellyfish = \"02\"\n t_history.t_dev_id = m_Devices_item.id\n t_history.save()\n m_device_ticket_list.append(t_history.id)\n\n t_history.send_free = True\n t_history.save()\n\n m_return = {\"status\": \"ok\", \"ticket_list\": m_device_ticket_list}\n return Response(m_return)\n","repo_name":"Never11n/el_t01","sub_path":"el_t01_app/views_vvs_rest.py","file_name":"views_vvs_rest.py","file_ext":"py","file_size_in_byte":7626,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"30532545034","text":"# https://leetcode.com/problems/basic-calculator/solutions/1662949/python-actually-working-shunting-yard-that-passes-all-edge-cases/\n\nfrom machine import Stack\nimport re\nEPSILON = 'ε'\nPRECEDENCE = {'|': 1, '%': 1, '?': 2, '@': 2, '#': 2}\n\n\n# Shunting Yard algorithm\ndef shunting_yard(expression):\n postfix = ''\n tempStack = []\n formatted_regex = clean_regex(expression)\n print(formatted_regex)\n for char in formatted_regex:\n if char == '(':\n tempStack.append(char)\n elif char == ')':\n while tempStack[-1] != '(':\n postfix += tempStack.pop()\n tempStack.pop()\n # Operator\n else:\n while len(tempStack) > 0:\n top_char = tempStack[-1]\n current_char_precedence = get_precedence(char)\n top_char_precedence = get_precedence(top_char)\n if top_char_precedence >= current_char_precedence:\n postfix += tempStack.pop()\n else:\n break\n tempStack.append(char)\n while tempStack:\n # Processing the postfix\n postfix += tempStack.pop()\n return postfix\n\n\n# We need to explicitly include '.' between concats\n# This is needed to create valid postfix expressions for shunting yard\ndef clean_regex(expression):\n ans = ''\n # Both of the ones below can be extended to support many operation types (*/** etc)\n ops = set(['?', '#', '|', '@', '%'])\n bOps = set(['|', '%'])\n for i in range(len(expression)):\n char1 = expression[i]\n if i + 1 < len(expression):\n char2 = expression[i + 1]\n ans += char1\n if char1 != '(' and char2 != ')' and char2 not in ops and char1 not in bOps:\n ans += '%'\n ans += expression[-1]\n return ans\n\n\n\"\"\"\n this is needed to create valid postfix expressions for shunting yard\n eg: 1 - (-2) creates a postfix of 1 2 - - which is invalid\n instead we convert to 1 0 2 - -\n\"\"\"\n\n\ndef get_precedence(char):\n return PRECEDENCE.get(char, 6)\n\n\n# Shunting Yard algorithm\nclass ShuntingYard:\n\n # Operator precedence dictionary\n PRECEDENCE = {'|': 1, '%': 1, '?': 2, '@': 2, '#': 2}\n OPERATORS = set(PRECEDENCE.keys())\n SYMBOLS = OPERATORS.union({'(', ')', EPSILON})\n\n def __init__(this):\n this.stack = Stack()\n this.output = []\n this.post_result = \"\"\n\n def concatenation(this, regex):\n reg_len = len(regex) - 1\n symbols = set([\"(\", \"|\", \"?\", \"#\", \"%\", \"@\", \")\"])\n result = []\n for i in range(reg_len):\n result.append(regex[i])\n if regex[i] not in symbols and (regex[i+1] not in symbols or regex[i+1] == '('):\n result.append(\"%\")\n else:\n case = {\n regex[i] in {\"@\", \"?\", \")\"} and regex[i+1] == \"(\": \"%\",\n regex[i] in {\"@\", \"?\", \"#\", \")\"} and regex[i+1] not in symbols: \"%\",\n }.get(True, \"\")\n result.append(case)\n result.append(regex[reg_len])\n return \"\".join(result)\n\n def revision(this, char):\n try:\n a = this.PRECEDENCE[char]\n b = this.PRECEDENCE[this.stack.peek()]\n return a <= b if a >= 0 and b >= 0 else False\n except KeyError:\n return False\n\n def to_postfix(this, regex):\n exp = this.concatenation(regex)\n for i in exp:\n if i.isalnum() or i == EPSILON:\n if this.stack.peek() in (\"@\", \"#\", \"?\"):\n this.output.append(this.stack.pop())\n this.output.append(i)\n elif i == '(':\n this.stack.push(i)\n elif i == ')':\n while not this.stack.is_empty() and this.stack.peek() != '(':\n a = this.stack.pop()\n this.output.append(a)\n if this.stack.is_empty() or this.stack.peek() != '(':\n return -1\n else:\n this.stack.pop()\n else:\n while not this.stack.is_empty() and this.revision(i):\n this.output.append(this.stack.pop())\n this.stack.push(i)\n while not this.stack.is_empty():\n this.output.append(this.stack.pop())\n this.post_result = \"\".join(this.output)\n return this.post_result\n","repo_name":"DavidDLM/Lab-D-Lenguajes","sub_path":"postfix.py","file_name":"postfix.py","file_ext":"py","file_size_in_byte":4396,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"71190856158","text":"from sklearn.metrics import average_precision_score\nimport numpy as np\nimport pandas as pd\nimport geopandas as gpd\nfrom deepforest.utilities import check_file\nfrom deepforest import IoU\nfrom shapely.geometry import box\n\n\n\n\ndef evaluate(m, csv='val_samples/val_samples.csv', folder=\"./val_samples\"):\n results = m.evaluate(csv, folder)\n p = results['box_precision']\n r = results['box_recall']\n\n if (p + r) == 0:\n f1 = 0\n else:\n f1 = 2 * p * r / (p + r)\n return results, f1, results['AP']\n\n\ndef evaluate_image(predictions, ground_df):\n \"\"\"\n Compute intersection-over-union matching among prediction and ground truth boxes for one image\n Args:\n df: a pandas dataframe with columns name, xmin, xmax, ymin, ymax, label. The 'name' column should be the path relative to the location of the file.\n summarize: Whether to group statistics by plot and overall score\n Returns:\n result: pandas dataframe with crown ids of prediciton and ground truth and the IoU score.\n \"\"\"\n plot_names = predictions[\"image_path\"].unique()\n if len(plot_names) > 1:\n raise ValueError(\"More than one plot passed to image crown: {}\".format(plot_name))\n else:\n plot_name = plot_names[0]\n\n predictions['geometry'] = predictions.apply(\n lambda x: box(x.xmin, x.ymin, x.xmax, x.ymax), axis=1)\n predictions = gpd.GeoDataFrame(predictions, geometry='geometry')\n\n ground_df['geometry'] = ground_df.apply(\n lambda x: box(x.xmin, x.ymin, x.xmax, x.ymax), axis=1)\n ground_df = gpd.GeoDataFrame(ground_df, geometry='geometry')\n\n # match\n result = IoU.compute_IoU(ground_df, predictions)\n\n # add the label classes\n result[\"predicted_label\"] = result.prediction_id.apply(lambda x: predictions.label.loc[x] if pd.notnull(x) else x)\n result[\"true_label\"] = result.truth_id.apply(lambda x: ground_df.label.loc[x])\n result['predicted_area'] = predictions['geometry'].apply(lambda x: x.area)\n return result\n\n\ndef evaluate2(predictions,\n ground_df,\n root_dir,\n iou_threshold=0.4):\n \"\"\"\n Takes as an input the prediction and ground trouth to compute IoU for predictions and calculate AP\n Args:\n predictions: a pandas dataframe, if supplied a root dir is needed to give the relative path of files in df.name. The labels in ground truth and predictions must match. If one is numeric, the other must be numeric.\n ground_df: a pandas dataframe, if supplied a root dir is needed to give the relative path of files in df.name\n root_dir: location of files in the dataframe 'name' column.\n Returns:\n results: a dataframe of match bounding boxes\n box_recall: proportion of true positives of box position, regardless of class\n box_precision: proportion of predictions that are true positive, regardless of class\n class_recall: a pandas dataframe of class level recall and precision with class sizes\n AP: average precision\n \"\"\"\n\n check_file(ground_df)\n check_file(predictions)\n\n # Run evaluation on all plots\n results = []\n box_recalls = []\n box_precisions = []\n recalls = []\n precisions = []\n for image_path, group in ground_df.groupby(\"image_path\"):\n # clean indices\n image_predictions = predictions[predictions[\"image_path\"] == image_path].reset_index(drop=True)\n\n # If empty, add to list without computing IoU\n if image_predictions.empty:\n result = pd.DataFrame(\n {\"truth_id\": group.index.values, \"prediction_id\": None, \"IoU\": 0, \"predicted_label\": None,\n \"score\": None, \"match\": None, \"true_label\": group.label})\n # An empty prediction set has recall of 0, precision of NA.\n box_recalls.append(0)\n results.append(result)\n continue\n else:\n group = group.reset_index(drop=True)\n result = evaluate_image(predictions=image_predictions,\n ground_df=group)\n\n result[\"image_path\"] = image_path\n result['IoU'] = result['IoU'].fillna(0)\n result[\"match\"] = result.IoU > iou_threshold\n true_positive = sum(result[\"match\"])\n recall = true_positive / result.shape[0]\n precision = true_positive / image_predictions.shape[0]\n box_recalls.append(recall)\n box_precisions.append(precision)\n results.append(result)\n\n results = pd.concat(results)\n box_precision = np.mean(box_precisions)\n box_recall = np.mean(box_recalls)\n\n # Per class recall and precision\n class_recall_dict = {}\n class_precision_dict = {}\n class_size = {}\n\n box_results = results[results.predicted_label.notna()]\n if box_precision > 0 and box_recall > 0:\n results2 = results.dropna(subset=['score'])\n results2['match'] = results2.IoU > iou_threshold\n AP = average_precision_score(results2['match'], results2['score'])\n else:\n AP = 0\n if box_results.empty:\n print(\"No predictions made\")\n box_recall = 0\n box_precision = 0\n class_recall = pd.DataFrame()\n return {\"results\": results, \"box_precision\": box_precision, \"box_recall\": box_recall,\n \"class_recall\": class_recall, 'AP': 0}\n\n for name, group in box_results.groupby(\"true_label\"):\n class_recall_dict[name] = sum(group.true_label == group.predicted_label) / group.shape[0]\n number_of_predictions = group[group.predicted_label == name].shape[0]\n if number_of_predictions == 0:\n class_precision_dict[name] = 0\n else:\n class_precision_dict[name] = sum(group.true_label == group.predicted_label) / number_of_predictions\n class_size[name] = group.shape[0]\n\n class_recall = pd.DataFrame({\"label\": class_recall_dict.keys(), \"recall\": pd.Series(class_recall_dict),\n \"precision\": pd.Series(class_precision_dict),\n \"size\": pd.Series(class_size)}).reset_index(drop=True)\n\n return {\"results\": results, \"box_precision\": box_precision, \"box_recall\": box_recall, \"class_recall\": class_recall,\n \"AP\": AP}\n\n","repo_name":"DeadmanIQ445/maskrcnn_v2","sub_path":".ipynb_checkpoints/evaluation-checkpoint.py","file_name":"evaluation-checkpoint.py","file_ext":"py","file_size_in_byte":6201,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"30075145503","text":"from requests.adapters import HTTPAdapter\n#from requests.packages.urllib3.util.retry import Retry\nfrom urllib3.util import Retry\n\nfrom bs4 import BeautifulSoup\nimport requests\nimport re\nimport tkinter as tk\nlogin = 'login'\npassword = 'password'\n\ndef requests_retry_session(\n retries=30,\n backoff_factor=0.3,\n status_forcelist=(500, 502, 504),\n session=None,\n):\n session = session or requests.Session()\n retry = Retry(\n total=retries,\n read=retries,\n connect=retries,\n backoff_factor=backoff_factor,\n status_forcelist=status_forcelist,\n )\n adapter = HTTPAdapter(max_retries=retry)\n session.mount('http://', adapter)\n session.mount('https://', adapter)\n return session\n\n\ndef get_html(url):\n headers = {\n 'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36'\n }\n\n values = {'login': login,\n 'password': password\n }\n with requests.Session() as sesh:\n #response = requests_retry_session(session=s).get('https://www.peterbe.com')\n r = requests_retry_session(session=sesh).get(url, headers=headers)\n r = requests_retry_session(session=sesh).post(url, data=values)\n r = requests_retry_session(session=sesh).get(\"http://172.11.1.11:8080/published?uuid=fctsListView\")\n return r.text\n\ndef bs4Soup(html):\n soup = BeautifulSoup(html, 'lxml')\n html_list = soup.find_all('span')\n list1 = []\n dicct = {}\n for i in html_list:\n list = re.findall(r'[А-яA-z]+|[0-9]+', i.text)\n txt = \" \".join(list)\n if \"СПБ\" in txt or txt.isdigit() == True:\n list1.append(txt)\n\n print(len(list1))\n print(list1)\n\n for y in range(1,60,3):\n try:\n dicct[list1[y]] = list1[y+1]\n except:\n pass\n\n string = \"\"\n global amount\n amount = 0\n for key in dicct:\n dicct[key] = int(dicct[key])\n amount += dicct[key]\n print(key + \" - \" + str(dicct[key]))\n print(key.replace(\"СПБ\", \"\").replace('МЕД', '').replace(\"Очередь\", '').replace('проекта', '')\\\n .replace('1', '').replace('2', '').replace('3', '').strip() + \" - \" + str(dicct[key]))\n string += key.replace(\"СПБ\", \"\").replace('МЕД', '').replace(\"медицинская\", \"мед.\").replace(\"Консультация\", \"Конс.\").replace(\"приложению\", \"��рил.\").replace(\"Очередь\", '').replace('проекта', '')\\\n .replace('1', '').replace(\"Общая очередь Xup\", \"Xoup\").replace('2', '').replace('3', '').strip() + \" - \" + str(dicct[key]) + \"\\n\"\n #string += key.replace(\"Общая очередь Xoup\", 'Xoup')\n return string + \"\\n\" + \"Всего - \" + str(amount)\n\ndef main():\n url = \"http://172.11.1.11:8080/\"\n bs4Soup(get_html(url))\n\ndef Draw():\n global text\n frame=tk.Frame(window,width=1000,height=1000,bd=100,bg ='#a9aeb0')\n frame.place(relx=.5, rely=.5, anchor=\"center\")\n text=tk.Label(window)\n text.pack(fill = 'both', expand=True)\n\ndef Refresher():\n url = \"http://172.11.1.11:8080/\"\n global text\n try:\n if int(bs4Soup(get_html(url))[-4:]) > 50:\n bg = '#eb6788'\n elif int(bs4Soup(get_html(url))[-4:]) > 70:\n bg = '#e3869d'\n else:\n #bg = '#333333'\n bg = '#a9aeb0'\n except:\n #bg = '#333333'\n bg = '#a9aeb0'\n text.configure(text=bs4Soup(get_html(url)), font=(\"Verdana\", 55, \"bold\"), fg=\"black\", bg=bg)\n #fg='#CCCCCC'\n window.after(5000, Refresher) # every second...\n\nwindow = tk.Tk()\nwindow.title(\"Гарант\")\nwindow.geometry(\"518x170\")\nwindow.configure(background='#333333')\n#window.configure(background='#a9aeb0')\nwindow.wm_attributes('-fullscreen', True) # Windows\n#window.attributes('-zoomed', True)\n\nDraw()\nRefresher()\nwindow.mainloop()\n","repo_name":"Mythological/Python-BS4-ParseNaumen","sub_path":"NaumenQueue.py","file_name":"NaumenQueue.py","file_ext":"py","file_size_in_byte":3947,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"73777961439","text":"import pandas as pd\nimport numpy as np\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.model_selection import KFold\n\ntrain_data = pd.read_csv('dataset/train.csv')\ntest_data = pd.read_csv('dataset/test.csv')\n\n# 결측치 확인 함수\ndef check_missing_col(dataframe):\n missing_col = []\n counted_missing_col = 0\n for i, col in enumerate(dataframe.columns):\n missing_values = sum(dataframe[col].isna())\n is_missing = True if missing_values >= 1 else False\n if is_missing:\n counted_missing_col += 1\n print(f'결측치가 있는 칼럼은: {col}입니다')\n print(f'해당 칼럼에 총 {missing_values}개의 결측치가 존재합니다')\n missing_col.append([col, dataframe[col].dtype])\n if counted_missing_col == 0:\n print('결측치가 존재하지 않습니다.')\n return missing_col\n\n# 데이터 확인\ntrain_missing_col = check_missing_col(train_data)\n\ntrain_preprocessed = train_data.dropna(subset=['Sex'])\ntrain_preprocessed = train_preprocessed.fillna(0)\n\ntrain_missing_col = check_missing_col(train_preprocessed)\n\ndef make_label_map(dataframe):\n label_maps = {}\n for col in dataframe.columns:\n if dataframe[col].dtype == 'object':\n label_map = {'unknown':0}\n for i, key in enumerate(train_data[col].unique()):\n label_map[key] = i + 1\n label_maps[col] = label_map\n return label_maps\n\ndef label_encoder(dataframe, label_map):\n for col in dataframe.columns:\n if dataframe[col].dtype == 'object':\n dataframe[col] = dataframe[col].map(label_map[col])\n dataframe[col] = dataframe[col].fillna(label_map[col]['unknown'])\n return dataframe\n\nlabel_map = make_label_map(train_preprocessed)\nlabeled_train = label_encoder(train_preprocessed, label_map)\n\nprint(label_map)\n\ndef RMSE(true, pred):\n score = np.sqrt(np.mean(np.square(true-pred)))\n return score\n\ntarget = labeled_train[\"Body Mass (g)\"]\nfeature = labeled_train.drop(['id', 'Body Mass (g)'], axis=1)\n\nlr = LinearRegression()\n\nkfold = KFold(n_splits=5)\n\ncv_rmse = [] # 각 cv회차의 rmse 점수를 계산하여 넣어줄 리스트를 생성합니다. 이후 RMSE값의 평균을 구하기 위해 사용됩니다.\nn_iter = 0 # 반복 횟수 값을 초기 설정해줍니다. 이후 프린트문에서 각 교차검증의 회차를 구분하기 위해 사용됩니다.\n\n# K값이 5이므로 이 반복문은 5번 반복하게 됩니다.\nfor train_index, test_index in kfold.split(feature): # feautres 데이터를 위에서 지정한 kfold 숫자로 분할합니다. 인덱스 값을 분할해줍니다.\n x_train, x_test = feature.iloc[train_index], feature.iloc[test_index] # feature로 사용할 값을 나눠진 인덱스값에 따라 설정합니다.\n y_train, y_test = target.iloc[train_index], target.iloc[test_index] # label로 사용할 값을 나눠진 인덱스값에 따라 설정합니다.\n\n lr = lr.fit(x_train, y_train) # 모델 학습\n pred = lr.predict(x_test) # 테스트셋 예측\n n_iter += 1 # 반복 횟수 1회 증가\n\n error = RMSE(y_test, pred) # RMSE 점수를 구합니다.\n train_size = x_train.shape[0] # 학습 데이터 크기\n test_size = x_test.shape[0] # 검증 데이터 크기\n\n print('\\n{0}번째 교차 검증 RMSE : {1}, 학습 데이터 크기 : {2}, 검증 데이터 크기 : {3}'\n .format(n_iter, error, train_size, test_size))\n print('{0}번째 검증 세트 인덱스 : {1}'.format(n_iter, test_index))\n cv_rmse.append(error)\n\nprint('\\n==> 이 방정식의 평균 에러(RMSE)는 {} 입니다.'.format(np.mean(cv_rmse))) # 모델의 평균정확도를 확인합니다.\n\ntest_missing_col = check_missing_col(test_data)\n\ntest_data['Sex'] = test_data['Sex'].fillna(\"MALE\")\ntest_preprocessed = test_data.fillna(0)\n\ntest_missing_col = check_missing_col(test_preprocessed)\n\nlabeled_test = label_encoder(test_preprocessed, label_map)\n\nlabeled_test = labeled_test.drop(['id'], axis=1)\n\npredict_test = lr.predict(labeled_test)\nprint(predict_test)\n\nsubmission = pd.read_csv('dataset/sample_submission.csv')\nsubmission['Body Mass (g)'] = predict_test\n\nsubmission.to_csv(\"submission.csv\", index=False)","repo_name":"dntjq0815/Penguins_Weight_Prediction","sub_path":"main.py","file_name":"main.py","file_ext":"py","file_size_in_byte":4248,"program_lang":"python","lang":"ko","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"69983564640","text":"from os import getcwd, rename, remove, makedirs\nfrom os.path import isfile, exists\nfrom pathlib import Path\n\n\ndef validar_diretorio_downloads():\n\n diretorio = str(Path(getcwd(), 'downloads'))\n\n if not exists(diretorio):\n makedirs(diretorio)\n\n\ndef retornar_full_path_downloads():\n\n return str(Path(getcwd(), 'downloads'))\n\n\ndef renomear_download(cnes):\n\n caminho_arquivos = str(Path(getcwd(), 'downloads'))\n nome_antigo = str(Path(caminho_arquivos, 'fichaCompletaEstabelecimento.pdf'))\n\n if isfile(nome_antigo):\n\n nome_atual = cnes + '.pdf'\n nome_novo = str(Path(caminho_arquivos, nome_atual))\n\n try:\n rename(nome_antigo, nome_novo)\n except Exception:\n remove(nome_antigo)\n","repo_name":"lleooNS/PRIME_ROBOT_CHALLENGE","sub_path":"libraries/helpers.py","file_name":"helpers.py","file_ext":"py","file_size_in_byte":747,"program_lang":"python","lang":"pt","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"32083456460","text":"from webscrapper_class_freesound import get_page_number as PG\nfrom webscrapper_class_freesound import get_page_content as GC\nfrom credentials import USERNAME, PASSWORD, host, db_user, db_password, db_name\nfrom webscrapper_class_freesound import sample_more_search_result as SR\nfrom webscrapper_class_freesound import get_sound_link as SL\nfrom pprint import pprint as p\nfrom webscrapper_class_freesound import sample_page_number as SM\nfrom webscrapper_class_freesound import get_file_meta as FM\nfrom webscrapper_mysql_libraries_freesound import *\n\ndb = connection(host, db_user, db_password, db_name)\n\nif check_table_if_exists(db) == 1146:\n create_table(db)\nelse:\n print('Table already exists!')\n\npage_nr = PG('https://www.freesound.org/search/?q=&page=1#sound')\n\npage_nr = int(page_nr)\n\nprint(page_nr)\n\ncurr_page = input(\"Page number to start!\")\ncurr_page = int(curr_page)\n\nerror_link_array = []\n\ndef mainLoop(curr_page):\n\n while curr_page <= page_nr:\n\n try:\n print(str(curr_page) + ' -> current page')\n\n page_content = GC('https://www.freesound.org/search/?q=&page=' + str(curr_page) + '#sound',\n error_link_array)\n\n sample_links = SR('https://www.freesound.org/search/?q=&page=' + str(curr_page) + '#sound')\n\n sample_content = []\n\n sound_array = []\n\n for sam in sample_links:\n if SM(sam) is not None:\n page_size = int(SM(sam))\n else:\n page_size = 1\n\n print(str(page_size) + ' -> number of pages')\n\n curr_sample_page = 1\n\n while curr_sample_page <= page_size:\n sample_content.append(\n GC(sam + '&advanced=&page=' + str(curr_sample_page) + '#sound', error_link_array))\n curr_sample_page += 1\n\n if page_content is not None:\n sound_array.append(SL(page_content))\n\n for sound in sample_content:\n if sound is not None:\n sound_array.append(SL(sound))\n\n for ss in sound_array:\n if ss is not None:\n for sounds in ss:\n meta_data = FM(sounds)\n insert_into_table(db, meta_data)\n except:\n print(curr_page)\n continue\n\n curr_page += 1\n\nmainLoop(curr_page)\n\ndestroy_connection(db)","repo_name":"terror2012/music_scrapper","sub_path":"webscrapper_main_freesound.py","file_name":"webscrapper_main_freesound.py","file_ext":"py","file_size_in_byte":2449,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"8604030826","text":"# -*-coding: utf-8-*-\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport tensorflow as tf\nfrom tensorflow import keras\n\nprint(tf.__version__)\n\n\n# 加载官方数据，加载速度会受网络环境影响\ndef load_fashion_mnist():\n fashion_mnist = keras.datasets.fashion_mnist\n (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()\n\n # Explore数据\n print('train_images_shape:', train_images.shape)\n print('train_labels:', train_labels)\n print('train_labels_length:', len(train_labels))\n print('test_images_shape:', test_images.shape)\n print('test_images_length:', len(test_labels))\n\n # 归一化\n train_images = train_images / 255.0\n test_images = test_images / 255.0\n\n return train_images, train_labels, test_images, test_labels\n\n\ndef build_model():\n # 使用TensorFlow2.0 提供的KerasAPI构建模型\n model = keras.Sequential([\n keras.layers.Flatten(input_shape=(28, 28)),\n keras.layers.Dense(128, activation='relu'),\n keras.layers.Dense(10, activation='softmax')\n ])\n\n model.compile(optimizer='adam',\n loss='sparse_categorical_crossentropy',\n metrics=['accuracy'])\n\n return model\n\n\nif __name__ == \"__main__\":\n # 数据标签种类\n class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n # 模型保存路径\n OUTPUT_PATH = '/home/output'\n # 批次大小\n BATCH_SIZE = 64\n # 迭代次数\n EPOCHS = 10\n\n # 加载数据\n train_images, train_labels, test_images, test_labels = load_fashion_mnist()\n\n # 搭建模型\n model = build_model()\n\n # 训练\n model.fit(train_images, train_labels, epochs=EPOCHS, batch_size=BATCH_SIZE)\n\n # 评估模型\n test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\n print('\\n Test accuracy:', test_acc)\n\n # 保存模型\n model.save(OUTPUT_PATH)\n","repo_name":"aefuimn/TensorFlow2.0-Tutorial","sub_path":"classify_images/classify_images_of_clothing.py","file_name":"classify_images_of_clothing.py","file_ext":"py","file_size_in_byte":2020,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"41172420349","text":"try:\n import onnx.backend.test\nexcept ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed\")\n\nimport test_cases\nimport unittest\nimport backend as mxnet_backend\nimport logging\n\noperations = ['import', 'export']\nbackends = ['mxnet', 'gluon']\n# This is a pytest magic variable to load extra plugins\npytest_plugins = \"onnx.backend.test.report\",\n\n\ndef test_suite(backend_tests): # type: () -> unittest.TestSuite\n '''\n TestSuite that can be run by TestRunner\n This has been borrowed from onnx/onnx/backend/test/runner/__init__.py,\n since Python3 cannot sort objects of type 'Type' as Runner.test_suite()\n expects.\n '''\n suite = unittest.TestSuite()\n for case in backend_tests.test_cases.values():\n suite.addTests(unittest.defaultTestLoader.loadTestsFromTestCase(case))\n return suite\n\n\ndef prepare_tests(backend, oper):\n \"\"\"\n Prepare the test list\n :param backend: mxnet/gluon backend\n :param oper: str. export or import\n :return: backend test list\n \"\"\"\n BACKEND_TESTS = onnx.backend.test.BackendTest(backend, __name__)\n implemented_ops = test_cases.IMPLEMENTED_OPERATORS_TEST.get('both', []) + \\\n test_cases.IMPLEMENTED_OPERATORS_TEST.get(oper, [])\n\n for op_test in implemented_ops:\n BACKEND_TESTS.include(op_test)\n\n basic_models = test_cases.BASIC_MODEL_TESTS.get('both', []) + \\\n test_cases.BASIC_MODEL_TESTS.get(oper, [])\n\n for basic_model_test in basic_models:\n BACKEND_TESTS.include(basic_model_test)\n\n std_models = test_cases.STANDARD_MODEL.get('both', []) + \\\n test_cases.STANDARD_MODEL.get(oper, [])\n\n for std_model_test in std_models:\n BACKEND_TESTS.include(std_model_test)\n\n # Tests for scalar ops are in test_node.py\n BACKEND_TESTS.exclude('.*scalar.*')\n\n return BACKEND_TESTS\n\n\nfor bkend in backends:\n for operation in operations:\n log = logging.getLogger(bkend + operation)\n if bkend == 'gluon' and operation == 'export':\n log.warning('Gluon->ONNX export not implemented. Skipping tests...')\n continue\n log.info('Executing tests for ' + bkend + ' backend: ' + operation)\n mxnet_backend.MXNetBackend.set_params(bkend, operation)\n BACKEND_TESTS = prepare_tests(mxnet_backend, operation)\n unittest.TextTestRunner().run(test_suite(BACKEND_TESTS.enable_report()))\n","repo_name":"hpi-xnor/BMXNet-v2","sub_path":"tests/python-pytest/onnx/backend_test.py","file_name":"backend_test.py","file_ext":"py","file_size_in_byte":2417,"program_lang":"python","lang":"en","doc_type":"code","stars":225,"dataset":"github-code","pt":"51"}
+{"seq_id":"10561646089","text":"import math\nimport time\nimport SIM868\n\n\nSIM = SIM868.SIM868()\nSIM.write(\"AT+CGNSPWR=1\")\nSIM.write(\"AT+CGNSURC=1\")\n\nn_cont = \"y\"\nwhile n_cont != \"n\":\n SIM.get()\n n_cont = input(\"continue?\")\n\nCommand = input(\"command: \")\nwhile Command is not \"\":\n SIM.write(Command)\n Command = input(\"command: \")\n\n# AT+CGNSURC\n","repo_name":"Tysseract/RPi-GPS-Tracker","sub_path":"WindowsDebug.py","file_name":"WindowsDebug.py","file_ext":"py","file_size_in_byte":320,"program_lang":"python","lang":"en","doc_type":"code","stars":2,"dataset":"github-code","pt":"51"}
+{"seq_id":"71707229277","text":"import sys\n\ndef _red(txt):\n RED=\"\\x1b[1;31m\"\n NORMAL=\"\\x1b[0m\"\n return RED + txt + NORMAL\n\nparts = sys.stdin.readline().strip().split()\nbranch = parts.pop(0).ljust(10)\npath = parts.pop(-1)\nflags = ' '.join(parts)\nclean = (flags == '0 0 0 0 0 0')\n\nline=\"%s %s %s\" % ( flags, branch, path )\n\nif clean:\n print(line)\nelse:\n print(_red(line))\n","repo_name":"bryanhann/.local.bin","sub_path":"lib/fixline.py","file_name":"fixline.py","file_ext":"py","file_size_in_byte":356,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"827302744","text":"# -*- coding: utf-8 -*-\n\nfrom collective.documentgenerator.adapters import GenerablePODTemplatesAdapter\n\nfrom plone import api\n\n\nclass GenerableDashboardPODTemplatesAdapter(GenerablePODTemplatesAdapter):\n \"\"\" \"\"\"\n def __init__(self, context):\n self.context = context\n\n def get_all_pod_templates(self):\n catalog = api.portal.get_tool(name='portal_catalog')\n brains = catalog.unrestrictedSearchResults(portal_type=\"DashboardPODTemplate\", sort_on='getObjPositionInParent')\n pod_templates = [self.context.unrestrictedTraverse(brain.getPath()) for brain in brains]\n\n return pod_templates\n","repo_name":"IMIO/Products.urban","sub_path":"src/Products/urban/docgen/adapter.py","file_name":"adapter.py","file_ext":"py","file_size_in_byte":627,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"24620575887","text":"import torch\nimport torch.nn as nn\n\nfrom openselfsup.utils import print_log\n\nfrom . import builder\nfrom .registry import MODELS\n\n\n@MODELS.register_module\nclass DetCo(nn.Module):\n '''MOCO.\n Part of the code is borrowed from:\n \"https://github.com/facebookresearch/moco/blob/master/moco/builder.py\".\n '''\n\n def __init__(self,\n backbone,\n neck_1=None,\n neck_2=None,\n neck_3=None,\n neck_4=None,\n neck_p1=None,\n neck_p2=None,\n neck_p3=None,\n neck_p4=None,\n head=None,\n pretrained=None,\n queue_len=65536,\n feat_dim=128,\n momentum=0.999,\n **kwargs):\n super(DetCo, self).__init__()\n self.backbone_q = builder.build_backbone(backbone)\n self.backbone_k = builder.build_backbone(backbone)\n self.encoder_q_necks = nn.Sequential(builder.build_neck(neck_1),\n builder.build_neck(neck_2),\n builder.build_neck(neck_3),\n builder.build_neck(neck_4))\n self.encoder_k_necks = nn.Sequential(builder.build_neck(neck_1),\n builder.build_neck(neck_2),\n builder.build_neck(neck_3),\n builder.build_neck(neck_4))\n self.encoder_q_patch_necks = nn.Sequential(builder.build_neck(neck_p1),\n builder.build_neck(neck_p2),\n builder.build_neck(neck_p3),\n builder.build_neck(neck_p4))\n self.encoder_k_patch_necks = nn.Sequential(builder.build_neck(neck_p1),\n builder.build_neck(neck_p2),\n builder.build_neck(neck_p3),\n builder.build_neck(neck_p4))\n # self.backbone = self.encoder_q[0]\n for param in self.backbone_k.parameters():\n param.requires_grad = False\n for param in self.encoder_k_necks.parameters():\n param.requires_grad = False\n for param in self.encoder_k_patch_necks.parameters():\n param.requires_grad = False\n self.head = builder.build_head(head)\n self.init_weights(pretrained=pretrained)\n\n self.queue_len = queue_len\n self.momentum = momentum\n\n # create the queue\n self.register_buffer(\"queue_2\", torch.randn(feat_dim, queue_len))\n self.queue_2 = nn.functional.normalize(self.queue_2, dim=0)\n self.register_buffer(\"queue_3\", torch.randn(feat_dim, queue_len))\n self.queue_3 = nn.functional.normalize(self.queue_3, dim=0)\n self.register_buffer(\"queue_4\", torch.randn(feat_dim, queue_len))\n self.queue_4 = nn.functional.normalize(self.queue_4, dim=0)\n self.register_buffer(\"queue_5\", torch.randn(feat_dim, queue_len))\n self.queue_5 = nn.functional.normalize(self.queue_5, dim=0)\n self.register_buffer(\"local_queue_2\", torch.randn(feat_dim, queue_len))\n self.local_queue_2 = nn.functional.normalize(self.local_queue_2, dim=0)\n self.register_buffer(\"local_queue_3\", torch.randn(feat_dim, queue_len))\n self.local_queue_3 = nn.functional.normalize(self.local_queue_3, dim=0)\n self.register_buffer(\"local_queue_4\", torch.randn(feat_dim, queue_len))\n self.local_queue_4 = nn.functional.normalize(self.local_queue_4, dim=0)\n self.register_buffer(\"local_queue_5\", torch.randn(feat_dim, queue_len))\n self.local_queue_5 = nn.functional.normalize(self.local_queue_5, dim=0)\n self.register_buffer(\"queue_ptr\", torch.zeros(1, dtype=torch.long))\n # self.register_buffer(\"local_queue_ptr\", torch.zeros(1, dtype=torch.long))\n\n def init_weights(self, pretrained=None):\n if pretrained is not None:\n print_log('load model from: {}'.format(pretrained), logger='root')\n self.backbone_q.init_weights(pretrained=pretrained)\n self.backbone_k.init_weights(pretrained=pretrained)\n for neck in self.encoder_q_necks:\n neck.init_weights(init_linear='kaiming')\n for neck in self.encoder_k_necks:\n neck.init_weights(init_linear='kaiming')\n for neck in self.encoder_q_patch_necks:\n neck.init_weights(init_linear='kaiming')\n for neck in self.encoder_k_patch_necks:\n neck.init_weights(init_linear='kaiming')\n\n \"\"\"for param_q, param_k in zip(self.encoder_q.parameters(),\n self.encoder_k.parameters()):\n param_k.data.copy_(param_q.data)\"\"\"\n\n @torch.no_grad()\n def _momentum_update_key_encoder(self):\n \"\"\"\n Momentum update of the key encoder\n \"\"\"\n \"\"\"for param_q, param_k in zip(self.encoder_q.parameters(),\n self.encoder_k.parameters()):\n param_k.data = param_k.data * self.momentum + \\\n param_q.data * (1. - self.momentum)\"\"\"\n for param_q, param_k in zip(self.backbone_q.parameters(), self.backbone_k.parameters()):\n param_k.data = param_k.data * self.momentum + \\\n param_q.data * (1. - self.momentum)\n for param_q, param_k in zip(self.encoder_q_necks.parameters(), self.encoder_k_necks.parameters()):\n param_k.data = param_k.data * self.momentum + \\\n param_q.data * (1. - self.momentum)\n for param_q, param_k in zip(self.encoder_q_patch_necks.parameters(), self.encoder_k_patch_necks.parameters()):\n param_k.data = param_k.data * self.momentum + \\\n param_q.data * (1. - self.momentum)\n\n\n @torch.no_grad()\n def _dequeue_and_enqueue(self, k_2, k_3, k_4, k_5, k_l_2, k_l_3, k_l_4, k_l_5):\n # gather keys before updating queue\n keys_2 = concat_all_gather(k_2)\n keys_3 = concat_all_gather(k_3)\n keys_4 = concat_all_gather(k_4)\n keys_5 = concat_all_gather(k_5)\n local_keys_2 = concat_all_gather(k_l_2)\n local_keys_3 = concat_all_gather(k_l_3)\n local_keys_4 = concat_all_gather(k_l_4)\n local_keys_5 = concat_all_gather(k_l_5)\n\n batch_size = keys_2.shape[0]\n\n ptr = int(self.queue_ptr)\n # local_ptr = int(self.local_queue_ptr)\n assert self.queue_len % batch_size == 0 # for simplicity\n\n # replace the keys at ptr (dequeue and enqueue)\n self.queue_2[:, ptr:ptr + batch_size] = keys_2.transpose(0, 1)\n self.queue_3[:, ptr:ptr + batch_size] = keys_3.transpose(0, 1)\n self.queue_4[:, ptr:ptr + batch_size] = keys_4.transpose(0, 1)\n self.queue_5[:, ptr:ptr + batch_size] = keys_5.transpose(0, 1)\n self.local_queue_2[:, ptr:ptr + batch_size] = local_keys_2.transpose(0, 1)\n self.local_queue_3[:, ptr:ptr + batch_size] = local_keys_3.transpose(0, 1)\n self.local_queue_4[:, ptr:ptr + batch_size] = local_keys_4.transpose(0, 1)\n self.local_queue_5[:, ptr:ptr + batch_size] = local_keys_5.transpose(0, 1)\n ptr = (ptr + batch_size) % self.queue_len # move pointer\n # local_ptr = (local_ptr + batch_size) % self.queue_len # move pointer\n self.queue_ptr[0] = ptr\n # self.local_queue_ptr[0] = local_ptr\n\n @torch.no_grad()\n def _batch_shuffle_ddp(self, x, x_patch):\n \"\"\"\n Batch shuffle, for making use of BatchNorm.\n *** Only support DistributedDataParallel (DDP) model. ***\n \"\"\"\n # gather from all gpus\n batch_size_this = x.shape[0]\n x_gather = concat_all_gather(x)\n batch_size_all = x_gather.shape[0]\n # x_patch_gather = concat_all_gather(x_patch.view(-1, 9, x_patch.size(1), x_patch.size(2), x_patch.size(3)))\n x_patch_gather = concat_all_gather(torch.cat([patch.unsqueeze(0) for patch in x_patch.split(9, dim=0)], dim=0))\n\n num_gpus = batch_size_all // batch_size_this\n\n # random shuffle index\n idx_shuffle = torch.randperm(batch_size_all).cuda()\n\n # broadcast to all gpus\n torch.distributed.broadcast(idx_shuffle, src=0)\n\n # index for restoring\n idx_unshuffle = torch.argsort(idx_shuffle)\n\n # shuffled index for this gpu\n gpu_idx = torch.distributed.get_rank()\n idx_this = idx_shuffle.view(num_gpus, -1)[gpu_idx]\n\n return x_gather[idx_this], \\\n torch.cat([q.squeeze() for q in x_patch_gather[idx_this].split(1, dim=0)], dim=0), \\\n idx_unshuffle\n\n @torch.no_grad()\n def _batch_unshuffle_ddp(self, x, x_patch, idx_unshuffle):\n \"\"\"\n Undo batch shuffle.\n *** Only support DistributedDataParallel (DDP) model. ***\n \"\"\"\n # gather from all gpus\n batch_size_this = x.shape[0]\n x_gather = concat_all_gather(x)\n batch_size_all = x_gather.shape[0]\n # x_patch_gather = concat_all_gather(x_patch.view(-1, 9, x_patch.size(1), x_patch.size(2), x_patch.size(3)))\n x_patch_gather = concat_all_gather(torch.cat([patch.unsqueeze(0) for patch in x_patch.split(9, dim=0)], dim=0))\n\n num_gpus = batch_size_all // batch_size_this\n\n # restored index for this gpu\n gpu_idx = torch.distributed.get_rank()\n idx_this = idx_unshuffle.view(num_gpus, -1)[gpu_idx]\n\n return x_gather[idx_this], \\\n torch.cat([q.squeeze() for q in x_patch_gather[idx_this].split(1, dim=0)], dim=0)\n\n def forward_train(self, img, patch, **kwargs):\n assert img.dim() == 5, \\\n \"Input must have 5 dims, got: {}\".format(img.dim())\n im_q = img[:, 0, ...].contiguous()\n im_k = img[:, 1, ...].contiguous()\n patch_q = torch.cat([p.squeeze() for p in patch[:, 0, ...].contiguous().split(1, dim=0)], dim=0)\n patch_k = torch.cat([p.squeeze() for p in patch[:, 1, ...].contiguous().split(1, dim=0)], dim=0)\n # compute query features\n q_2, q_3, q_4, q_5 = self.backbone_q(im_q) # queries: NxC\n q_2 = nn.functional.normalize(self.encoder_q_necks[0](q_2)[0], dim=1)\n q_3 = nn.functional.normalize(self.encoder_q_necks[1](q_3)[0], dim=1)\n q_4 = nn.functional.normalize(self.encoder_q_necks[2](q_4)[0], dim=1)\n q_5 = nn.functional.normalize(self.encoder_q_necks[3](q_5)[0], dim=1)\n p_q_2, p_q_3, p_q_4, p_q_5 = self.backbone_q(patch_q)\n # p_q_2 = nn.functional.normalize(self.encoder_q_patch_neck2(p_q_2), dim=1)\n def temp(x):\n z = []\n for p in x.split(9, dim=0):\n y = []\n for q in p.split(1, dim=0):\n y.append(q.squeeze())\n z.append(torch.cat(y, dim=0).unsqueeze(0))\n return z\n q_l_2 = nn.functional.normalize(self.encoder_q_patch_necks[0](torch.cat(temp(p_q_2), dim=0))[0], dim=1)\n q_l_3 = nn.functional.normalize(self.encoder_q_patch_necks[1](torch.cat(temp(p_q_3), dim=0))[0], dim=1)\n q_l_4 = nn.functional.normalize(self.encoder_q_patch_necks[2](torch.cat(temp(p_q_4), dim=0))[0], dim=1)\n q_l_5 = nn.functional.normalize(self.encoder_q_patch_necks[3](torch.cat(temp(p_q_5), dim=0))[0], dim=1)\n # q_l_2 = nn.functional.normalize(self.encoder_q_patch_necks[0](p_q_2.view(-1, 9 * p_q_2.size(1), p_q_2.size(2), p_q_2.size(3)))[0], dim=1)\n # q_l_3 = nn.functional.normalize(self.encoder_q_patch_necks[1](p_q_3.view(-1, 9 * p_q_3.size(1), p_q_3.size(2), p_q_3.size(3)))[0], dim=1)\n # q_l_4 = nn.functional.normalize(self.encoder_q_patch_necks[2](p_q_4.view(-1, 9 * p_q_4.size(1), p_q_4.size(2), p_q_4.size(3)))[0], dim=1)\n # q_l_5 = nn.functional.normalize(self.encoder_q_patch_necks[3](p_q_5.view(-1, 9 * p_q_5.size(1), p_q_5.size(2), p_q_5.size(3)))[0], dim=1)\n\n\n # compute key features\n with torch.no_grad(): # no gradient to keys\n self._momentum_update_key_encoder() # update the key encoder\n\n # shuffle for making use of BN\n im_k, patch_k, idx_unshuffle = self._batch_shuffle_ddp(im_k, patch_k)\n\n k_2, k_3, k_4, k_5 = self.backbone_k(im_k) # keys: NxC\n k_2 = nn.functional.normalize(self.encoder_k_necks[0](k_2)[0], dim=1)\n k_3 = nn.functional.normalize(self.encoder_k_necks[1](k_3)[0], dim=1)\n k_4 = nn.functional.normalize(self.encoder_k_necks[2](k_4)[0], dim=1)\n k_5 = nn.functional.normalize(self.encoder_k_necks[3](k_5)[0], dim=1)\n\n p_k_2, p_k_3, p_k_4, p_k_5 = self.backbone_k(patch_k)\n k_l_2 = nn.functional.normalize(self.encoder_k_patch_necks[0](torch.cat(temp(p_k_2), dim=0))[0], dim=1)\n k_l_3 = nn.functional.normalize(self.encoder_k_patch_necks[1](torch.cat(temp(p_k_3), dim=0))[0], dim=1)\n k_l_4 = nn.functional.normalize(self.encoder_k_patch_necks[2](torch.cat(temp(p_k_4), dim=0))[0], dim=1)\n k_l_5 = nn.functional.normalize(self.encoder_k_patch_necks[3](torch.cat(temp(p_k_5), dim=0))[0], dim=1)\n \"\"\"k_l_2 = nn.functional.normalize(\n self.encoder_k_patch_necks[0](p_k_2.view(-1, 9 * p_k_2.size(1), p_k_2.size(2), p_k_2.size(3)))[0], dim=1)\n k_l_3 = nn.functional.normalize(\n self.encoder_k_patch_necks[1](p_k_3.view(-1, 9 * p_k_3.size(1), p_k_3.size(2), p_k_3.size(3)))[0], dim=1)\n k_l_4 = nn.functional.normalize(\n self.encoder_k_patch_necks[2](p_k_4.view(-1, 9 * p_k_4.size(1), p_k_4.size(2), p_k_4.size(3)))[0], dim=1)\n k_l_5 = nn.functional.normalize(\n self.encoder_k_patch_necks[3](p_k_5.view(-1, 9 * p_k_5.size(1), p_k_5.size(2), p_k_5.size(3)))[0], dim=1)\"\"\"\n\n # undo shuffle\n # k, p_k = self._batch_unshuffle_ddp(k, p_k, idx_unshuffle)\n k_2, p_k_2 = self._batch_unshuffle_ddp(k_2, p_k_2, idx_unshuffle)\n k_3, p_k_3 = self._batch_unshuffle_ddp(k_3, p_k_3, idx_unshuffle)\n k_4, p_k_4 = self._batch_unshuffle_ddp(k_4, p_k_4, idx_unshuffle)\n k_5, p_k_5 = self._batch_unshuffle_ddp(k_5, p_k_5, idx_unshuffle)\n\n q_l = [q_l_2, q_l_3, q_l_4, q_l_5]\n q = [q_2, q_3, q_4, q_5]\n k_l = [k_l_2, k_l_3, k_l_4, k_l_5]\n k = [k_2, k_3, k_4, k_5]\n\n # compute logits\n # Einstein sum is more intuitive\n queue_l = [self.local_queue_2, self.local_queue_3, self.local_queue_4, self.local_queue_5]\n queue_g = [self.queue_2, self.queue_3, self.queue_4, self.queue_5]\n\n gg_pos, gg_neg = self.compute_logits(q, k, queue_g)\n gl_pos, gl_neg = self.compute_logits(q_l, k, queue_g)\n ll_pos, ll_neg = self.compute_logits(q_l, k_l, queue_l)\n\n losses = self.head(gg_pos, gg_neg, gl_pos, gl_neg, ll_pos, ll_neg)\n self._dequeue_and_enqueue(k_2, k_3, k_4, k_5, k_l_2, k_l_3, k_l_4, k_l_5)\n\n return losses\n\n def compute_logits(self, q, k, queue):\n # positive logits: Nx1\n pos_2 = torch.einsum('nc,nc->n', [q[0], k[0]]).unsqueeze(-1)\n pos_3 = torch.einsum('nc,nc->n', [q[1], k[1]]).unsqueeze(-1)\n pos_4 = torch.einsum('nc,nc->n', [q[2], k[2]]).unsqueeze(-1)\n pos_5 = torch.einsum('nc,nc->n', [q[3], k[3]]).unsqueeze(-1)\n # negative logits: NxK\n neg_2 = torch.einsum('nc,ck->nk', [q[0], queue[0].clone().detach()])\n neg_3 = torch.einsum('nc,ck->nk', [q[1], queue[1].clone().detach()])\n neg_4 = torch.einsum('nc,ck->nk', [q[2], queue[2].clone().detach()])\n neg_5 = torch.einsum('nc,ck->nk', [q[3], queue[3].clone().detach()])\n\n return [pos_2, pos_3, pos_4, pos_5], [neg_2, neg_3, neg_4, neg_5]\n\n def forward_test(self, img, **kwargs):\n pass\n\n def forward(self, img, patch, mode='train', **kwargs):\n if mode == 'train':\n return self.forward_train(img, patch, **kwargs)\n elif mode == 'test':\n return self.forward_test(img, **kwargs)\n elif mode == 'extract':\n return self.backbone_q(img)\n else:\n raise Exception(\"No such mode: {}\".format(mode))\n\n\n# utils\n@torch.no_grad()\ndef concat_all_gather(tensor):\n \"\"\"\n Performs all_gather operation on the provided tensors.\n *** Warning ***: torch.distributed.all_gather has no gradient.\n \"\"\"\n tensors_gather = [\n torch.ones_like(tensor)\n for _ in range(torch.distributed.get_world_size())\n ]\n torch.distributed.all_gather(tensors_gather, tensor, async_op=False)\n\n output = torch.cat(tensors_gather, dim=0)\n return output\n","repo_name":"Qianna00/openselfsup","sub_path":"openselfsup/models/detco.py","file_name":"detco.py","file_ext":"py","file_size_in_byte":16784,"program_lang":"python","lang":"en","doc_type":"code","stars":1,"dataset":"github-code","pt":"51"}
+{"seq_id":"70267708000","text":"#! /usr/bin/env python3\nimport argparse, build_utils, common, os, platform, subprocess, sys\n\ndef main():\n os.chdir(common.basedir)\n classpath = common.deps() + [\n \"dev\",\n \"test\",\n build_utils.fetch_maven(\"org.clojure\", \"tools.namespace\", build_utils.deps_version(\"tools.namespace\")),\n build_utils.fetch_maven(\"org.clojure\", \"java.classpath\", \"1.0.0\"),\n build_utils.fetch_maven(\"org.clojure\", \"tools.reader\", \"1.3.6\"),\n build_utils.fetch_maven(\"criterium\", \"criterium\", build_utils.deps_version(\"criterium\"), repo = common.clojars),\n build_utils.fetch_maven(\"com.clojure-goes-fast\", \"clj-async-profiler\", build_utils.deps_version(\"clj-async-profiler\"), repo = common.clojars),\n ]\n \n parser = argparse.ArgumentParser()\n parser.add_argument('--ns', default='examples')\n (args, _) = parser.parse_known_args()\n\n return subprocess.call([\"java\",\n \"--class-path\", build_utils.classpath_join(classpath),\n \"-ea\",\n \"-Djdk.attach.allowAttachSelf\",\n # \"-XX:+UnlockDiagnosticVMOptions\",\n # \"-XX:+DebugNonSafepoints\",\n \"clojure.main\", \"-m\", \"user\", \"--ns\", args.ns])\n\nif __name__ == '__main__':\n sys.exit(main())\n","repo_name":"HumbleUI/HumbleUI","sub_path":"script/repl.py","file_name":"repl.py","file_ext":"py","file_size_in_byte":1146,"program_lang":"python","lang":"en","doc_type":"code","stars":928,"dataset":"github-code","pt":"51"}
+{"seq_id":"41104691533","text":"nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']\ndictionary = {}\ndata = input()\nwhile data not in nums:\n name, phone = data.split('-')\n dictionary[name] = phone\n data = input()\nlast_data = data\n\nfor _ in range(int(last_data)):\n name=input()\n if name in dictionary:\n print(f\"{name} -> {dictionary[name]}\")\n else:\n print(f\"Contact {name} does not exist.\")","repo_name":"simeon1534/Python-Advanced","sub_path":"tuples_sets_exercises/phonebook2.py","file_name":"phonebook2.py","file_ext":"py","file_size_in_byte":394,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"3953843894","text":"import pytesseract\nfrom PIL import Image\nimport argparse\n\nimport re\n\nimport twitter_manager\n\ntweeter_handle_regex = re.compile('(?<=^|(?<=[^a-zA-Z0-9-_\\.]))@([A-Za-z]+[A-Za-z0-9]+)')\n\n\ndef get_text_from_image(image_path):\n\ttext = pytesseract.image_to_string(Image.open(image_path))\n\t# print(text)\n\treturn text\n\n\ndef get_tweet_handles(text):\n\ttweeter_handles = tweeter_handle_regex.findall(text)\n\treturn tweeter_handles\n\n\ndef get_handle_tweet_pair(chunks):\n\tpairs = []\n\n\tfor i in range(len(chunks)):\n\t\thandles = tweeter_handle_regex.findall(chunks[i])\n\t\tif handles == []:\n\t\t\thandle = None\n\t\telse:\n\t\t\thandle = handles[0]\n\t\tif handle is not None:\n\t\t\ttweet = chunks[i+1].replace('\\n', ' ')\n\t\t\tpairs.append((handle, tweet))\n\n\tprint(pairs)\n\treturn pairs\n\n\ndef get_chunks(text):\n\ttext = text.strip()\n\tchunks = text.strip().split('\\n\\n')\n\tfor chunk in chunks:\n\t\tif tweeter_handle_regex.findall(chunk) == []:\n\t\t\tchunks = chunks[1:]\n\t\telse:\n\t\t\tbreak\n\treturn chunks\n\t\n\ndef check_if_fake_tweet(image_path):\n\ttext = get_text_from_image(image_path)\n\tchunks = get_chunks(text)\n\thandle_tweet_pairs = get_handle_tweet_pair(chunks)\n\n\tfor pair in handle_tweet_pairs:\n\t\thandle, tweet = pair\n\t\tprint(u\"Searching for \\n {}: {}\".format(handle, tweet))\n\t\turl = twitter_manager.search_tweet(handle, tweet)\n\t\tif url is not None:\n\t\t\tprint(url)\n\t\telse:\n\t\t\tprint(\"NOT FOUND, May wish to Check Manually!\")\n\n\nif __name__ == '__main__':\n\tap = argparse.ArgumentParser()\n\tap.add_argument(\"-i\", \"--image\", required=True, help=\"path to tweet image to be OCR'd\")\n\targs = vars(ap.parse_args())\n\n\timage_path = args['image']\n\n\tcheck_if_fake_tweet(image_path)","repo_name":"priyankpalod/did_they_tweet_this","sub_path":"tweet_detector.py","file_name":"tweet_detector.py","file_ext":"py","file_size_in_byte":1618,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"74224086558","text":"import boto3\n\n\ndef get_aws_account_info():\n # Create an IAM client\n iam_client = boto3.client(\"iam\")\n response = iam_client.get_account_summary()\n print(response)\n try:\n # Get information about the AWS account\n response = iam_client.get_account_summary()\n\n # Print relevant information\n account_id = response[\"SummaryMap\"][\"AccountSummary\"][\"AccountMFAEnabled\"]\n account_name = response[\"SummaryMap\"][\"AccountSummary\"][\"AccountName\"]\n\n print(f\"AWS Account ID: {account_id}\")\n print(f\"AWS Account Name: {account_name}\")\n\n except Exception as e:\n print(f\"Error: {e}\")\n\n\nif __name__ == \"__main__\":\n # Get information about the AWS account\n get_aws_account_info()\n","repo_name":"mezni/work02","sub_path":"old/test/get_account.py","file_name":"get_account.py","file_ext":"py","file_size_in_byte":740,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}
+{"seq_id":"39713810811","text":"import numpy\n\n# Change as necessary\n#myfile = \"examples/mixedtie.csv\"\n#myfile = \"examples/triad.csv\"\n#myfile = \"examples/mostextreme.csv\"\n#myfile = \"examples/mostextreme_rivals.csv\"\n#myfile = \"examples/Level1Clusters_Active_Size_2_1_Inf_2_2_P_0.01_InnerSortedCorrelations.csv\"\n#myfile = \"examples/COPD.pvalued.csv\"\n#myfile = \"examples/Never/Never_9A/Never.pvalued.csv\"\n#myfile = \"examples/Social_networks/Karate/karate.csv\"\n\n#f = open(myfile, 'r')\n\n# Get the first line (names)\n#firstline = f.readline()\n#bacteria = firstline.split(',')\n#bacteria.remove('\\\"\\\"')\n\ndef pncentrality(bacteria, G):\n n = len(bacteria)\n m = numpy.zeros([n, n])\n bacteria[len(bacteria)-1] = bacteria[len(bacteria)-1].strip()\n for key in G.adj:\n for key2 in G.adj[key]:\n # TMC need to fix this, breaks for either CSV or GML\n if (bacteria[0].count(\"\\\"\") == 0):\n index1 = bacteria.index(key)\n index2 = bacteria.index(key2)\n else:\n index1 = bacteria.index(\"\\\"\"+key+\"\\\"\")\n index2 = bacteria.index(\"\\\"\"+key2+\"\\\"\")\n w = G.adj[key][key2]['weight']\n m[index1][index2] = w\n m[index2][index1] = w\n # Make the identity matrix I\n # and the adjacency matrix A\n # and the positive matrix P\n # and the negative matrix N\n #m = []\n p = []\n nv = []\n z = []\n for i in range(n):\n #mc = []\n zc = []\n pc = []\n nc = []\n #contents = line.split(',')\n for j in range(n):\n value = float(m[i][j])\n #mc.append(value)\n zc.append(0)\n if (value > 0):\n pc.append(value)\n nc.append(0)\n else:\n pc.append(0)\n nc.append(-value)\n #m.append(mc)\n z.append(zc)\n p.append(pc)\n nv.append(nc)\n\n # Check to make sure all entries (i, i) are 0\n for i in range(n):\n m[i][i] = 0\n p[i][i] = 0\n nv[i][i] = 0\n\n # Added TMC December 23, 2014\n onemat = []\n for i in range(n):\n omc = []\n for j in range(n):\n omc.append(1)\n onemat.append(omc)\n OneMatrix = numpy.matrix(onemat) \n\n\n ADJ = numpy.matrix(m)\n P = numpy.matrix(p)\n N = numpy.matrix(nv)\n #A = P - 2*N\n\n A = P - 2*N\n\n for i in range(n):\n z[i][i] = 1\n I = numpy.matrix(z)\n\n # Make the vector of ones\n Ones = []\n for i in range(n):\n Ones.append([1])\n O = numpy.matrix(Ones)\n\n # Compute hStar (traditional centrality)\n PN = ((I - (1.0/(2*n-2))*A).getI()) * O\n\n arr = PN.getA()\n retval = []\n for i in range(n):\n retval.append(arr[i][0])\n return retval\n #tuples = []\n #for i in range(n):\n # tuples.append([arr[i][0], bacteria[i].strip()])\n\n #tuples.sort()\n #tuples.reverse()\n #from tabulate import tabulate\n","repo_name":"movingpictures83/MATria","sub_path":"PNcentrality.py","file_name":"PNcentrality.py","file_ext":"py","file_size_in_byte":2560,"program_lang":"python","lang":"en","doc_type":"code","stars":0,"dataset":"github-code","pt":"51"}