0 and joueur <= len(liste_joueurs_tournois):\n if joueur not in joueurs:\n joueurs.append(joueur)\n else:\n print(\"Vous avez deja saisi ce joueur.\")\n x += 1\n else:\n x += 1\n x -= 1\n\n y = 1\n nom_joueurs = []\n for arg in liste_joueurs_tournois:\n arg = arg[:-15]\n nom_joueurs.append(str(arg).replace(\"Indice joueur : {}\\n \".format(y), \"\").replace(\"\\n \", \"\"))\n y += 1\n joueurs = Joueur.get_joueurs_tournoi(joueurs, nom_joueurs)\n\n print(\"\\n---------------------------\")\n temps_choix = 0\n while temps_choix != 1 or temps_choix != 2 or temps_choix != 3:\n try:\n temps_choix = int(input(\"\\nContrôle de temps\\n1 - Bullet\\\n \\n2 - Blitz\\n3 - Coup rapide\\n\\nVotre choix : \"))\n except ValueError:\n print(\"\\nVous n'avez pas saisi une valeur valide.\")\n sl(2)\n continue\n if temps_choix == 1:\n temps = \"Bullet\"\n break\n if temps_choix == 2:\n temps = \"Blitz\"\n break\n if temps_choix == 3:\n temps = \"Coup rapide\"\n break\n\n print(\"\\n---------------------------\")\n while len(note) == 0:\n try:\n note = str(input(\"\\nDescription : \"))\n except ValueError:\n print(\"\\nVous n'avez pas saisi une valeur valide.\")\n sl(2)\n continue\n if len(note) == 0:\n break\n return nom, lieu, date, nb_tours, joueurs, temps, note","def lines_move(plateau, sens):\n if sens != 0 and sens != 1:\n return \"Erreur !\"\n if sens == 1:\n for j in range(0, 4): # ligne de 0 a 4\n line_move(plateau, j ,sens)\n else:\n for j in range(0, 4): # ligne de 0 a 4\n line_move(plateau, j ,sens)","def SetMoneda(num, simbolo=\"$\", n_decimales=2):\n #con abs, nos aseguramos que los dec. sea un positivo.\n n_decimales = abs(n_decimales)\n\n #se redondea a los decimales idicados.\n num = round(num, n_decimales)\n\n #se divide el entero del decimal y obtenemos los string\n num, dec = str(num).split(\".\")\n\n #si el num tiene menos decimales que los que se quieren mostrar,\n #se completan los faltantes con ceros.\n dec += \"0\" * (n_decimales - len(dec))\n\n #se invierte el num, para facilitar la adicion de comas.\n num = num[::-1]\n\n #se crea una lista con las cifras de miles como elementos.\n l = [num[pos:pos+3][::-1] for pos in range(0,50,3) if (num[pos:pos+3])]\n l.reverse()\n\n #se pasa la lista a string, uniendo sus elementos con comas.\n num = str.join(\",\", l)\n\n #si el numero es negativo, se quita una coma sobrante.\n try:\n if num[0:2] == \"-,\":\n num = \"-%s\" % num[2:]\n except IndexError:\n pass\n\n #si no se especifican decimales, se retorna un numero entero.\n if not n_decimales:\n return \"%s %s\" % (simbolo, num)\n\n return \"%s %s.%s\" % (simbolo, num, dec)","def __init__(self, lista_enlazada): \n\t\tself.lista = lista_enlazada\n\t\tself.anterior = None\n\t\tself.actual = lista_enlazada.prim\n\t\tself.pila_anteriores = Pila()\n\t\tself.posicion = 0","def solution(self):\n return [(\"the\", 1561900)] * 100","def preberi_pot(ukazi):\r\n x_k = 0\r\n y_k = 0\r\n\r\n p = 1\r\n pot = []\r\n pot += (0, 0),\r\n\r\n ukazi = ukazi.split('\\n')\r\n\r\n for m in ukazi:\r\n\r\n if m == \"DESNO\":\r\n if p == 1:\r\n p = 4\r\n else:\r\n p -= 1\r\n elif m == \"LEVO\":\r\n if p == 4:\r\n p = 1\r\n else:\r\n p += 1\r\n elif m.isalnum():\r\n if p == 3:\r\n y_k += int(m)\r\n elif p == 4:\r\n x_k += int(m)\r\n elif p == 1:\r\n y_k -= int(m)\r\n elif p == 2:\r\n x_k -= int(m)\r\n pot += (x_k, y_k),\r\n\r\n return pot","def escolher_posicao_auto(tab, jog, str1):\r\n if not eh_tabuleiro(tab) or not (jog in [-1,1] and type(jog)==int) or not (str1 in ['basico','normal','perfeito'] and type(str1)==str):\r\n raise ValueError('escolher_posicao_auto: algum dos argumentos e invalido') \r\n else:\r\n \r\n #vitoria_1: tabuleiro X inteiro -> posicao\r\n \r\n def vitoria_1(tab,jog):\r\n \"\"\"\r\n vitoria_1 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o jogador tiver duas\r\n das suas pecas em linha e uma posicao livre entao retorna essa posicao livre.\r\n \"\"\"\r\n for i in range(1,4):\r\n win = [(0,jog,jog), (jog,0,jog), (jog,jog,0)]\r\n coluna = obter_coluna(tab, i)\r\n linha = obter_linha(tab, i) \r\n if coluna in win:\r\n return i+3*win.index(coluna)\r\n elif linha in win:\r\n return 3*i-2+win.index(linha) \r\n if i!=3:\r\n diagonal = obter_diagonal(tab, i)\r\n if diagonal in win:\r\n if i==1:\r\n return i+4*win.index(diagonal)\r\n\r\n else:\r\n return 7-2*win.index(diagonal)\r\n \r\n #bloqueio_2: tabuleiro X inteiro -> posicao \r\n \r\n def bloqueio_2(tab,jog):\r\n \"\"\"\r\n bloqueio_2 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o adversario tiver duas\r\n das suas pecas em linha e uma posicao livre entao retorna essa posicao livre.\r\n \"\"\"\r\n jog*=-1\r\n return vitoria_1(tab,jog) \r\n \r\n #bifurcacao_3: tabuleiro X inteiro -> lista de posicoes\r\n \r\n def bifurcacao_3(tab, jog):\r\n \"\"\"\r\n bifurcacao_3 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o jogador tiver duas\r\n linhas/colunas/diagonais que se intersectam, onde cada uma contem uma das\r\n suas pecas entao retorna uma lista com todas as posicoes de intersecao \r\n (criando duas formas de vencer na jogada seguinte).\r\n \"\"\"\r\n pos = []\r\n for i in range(1,4):\r\n for j in range(1,4):\r\n if obter_coluna(tab,i).count(jog)==1 and obter_linha(tab,j).count(jog)==1 and eh_posicao_livre(tab, i+3*j-3):\r\n pos+=[i+3*j-3]\r\n for k in range(1,3):\r\n if k==1:\r\n if obter_coluna(tab,i).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 1+4*(i-1)):\r\n pos+=[1+4*(i-1)]\r\n if obter_linha(tab,j).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 1+4*(i-1)):\r\n pos+=[1+4*(i-1)]\r\n if obter_diagonal(tab,1).count(jog)==1 and obter_diagonal(tab,2).count(jog)==1 and eh_posicao_livre(tab, 5):\r\n pos+=[5]\r\n if k==2:\r\n if obter_coluna(tab,i).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 7-2*(i-1)):\r\n pos+=[7-2*(i-1)]\r\n if obter_linha(tab,j).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 3+2*(i-1)):\r\n pos+=[3+2*(i-1)] \r\n return pos\r\n \r\n #bloqueio_de_bifurcacao_4: tabuleiro X inteiro -> posicao\r\n \r\n def bloqueio_de_bifurcacao_4(tab,jog): \r\n \"\"\"\r\n bloqueio_de_bifurcacao_4 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o adversario tiver apenas uma bifurcacao\r\n entao retorna a posicao de bloqueio dessa bifurcacao, caso contrario, retorna a posicao\r\n em que se cria um dois em linha para forcar o oponente a defender, desde que a defesa nao\r\n resulte na criacao de uma bifurcacao para o oponente.\r\n \"\"\" \r\n if len(bifurcacao_3(tab,-1*jog)) == 1 :\r\n return bifurcacao_3(tab,-1*jog)[0]\r\n else:\r\n for i in range(1,4):\r\n if obter_coluna(tab,i).count(jog)==1:\r\n col = obter_coluna(tab,i)\r\n for j in range(3):\r\n if col[j]==0:\r\n pos1=3*j+i\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1\r\n \r\n if obter_linha(tab,i).count(jog)==1:\r\n linha = obter_linha(tab,i)\r\n for j in range(3):\r\n if linha[j]==0:\r\n pos1=j+1+3*(i-1)\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1\r\n \r\n if i < 3 and obter_diagonal(tab,i).count(jog)==1:\r\n diagonal = obter_diagonal(tab,i)\r\n for j in range(3):\r\n if i==1:\r\n if diagonal[j]==0:\r\n pos1=4*j+i\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1\r\n else:\r\n if diagonal[j]==0:\r\n pos1=7-2*j\r\n newtab = marcar_posicao(tab, jog, pos1)\r\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\r\n return pos1 \r\n \r\n #centro_5: tabuleiro X inteiro -> posicao\r\n \r\n def centro_5(tab, jog):\r\n \"\"\"\r\n centro_5 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e devolve a posicao\r\n central (5) no caso da mesma estar livre.\r\n \"\"\"\r\n if eh_posicao_livre(tab, 5):\r\n return 5\r\n \r\n #canto_oposto_6: tabuleiro X inteiro -> posicao\r\n \r\n def canto_oposto_6(tab, jog):\r\n \"\"\"\r\n canto_oposto_6 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o adversario estiver num\r\n canto e se o canto diagonalmente oposto for uma posicao livre entao\r\n retorna a posicao desse canto oposto.\r\n \"\"\"\r\n jog*=-1\r\n if obter_linha(tab,1)[0]==jog and eh_posicao_livre(tab,9):\r\n return 9\r\n if obter_linha(tab,1)[2]==jog and eh_posicao_livre(tab,7):\r\n return 7\r\n if obter_linha(tab,3)[0]==jog and eh_posicao_livre(tab,3):\r\n return 3\r\n if obter_linha(tab,3)[2]==jog and eh_posicao_livre(tab,1):\r\n return 1 \r\n \r\n #canto_vazio_7: tabuleiro X inteiro -> posicao\r\n \r\n def canto_vazio_7(tab, jog):\r\n \"\"\"\r\n canto_vazio_7 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e se um canto for uma posicao\r\n livre entao devolve a posicao correspondente a esse canto.\r\n \"\"\"\r\n for x in [1,3,7,9]:\r\n if eh_posicao_livre(tab,x):\r\n return x \r\n \r\n #lateral_vazio_8: tabuleiro X inteiro -> posicao\r\n \r\n def lateral_vazio_8(tab, jog):\r\n \"\"\"\r\n lateral_vazio_8 recebe um tabuleiro e um inteiro correspondente ao jogador \r\n (1 para o jogador 'X' e -1 para o jogador 'O') e se uma posicao lateral\r\n (que nem e o centro, nem um canto) for livre, entao retorna a posicao\r\n correspondente a essa posicao lateral.\r\n \"\"\"\r\n for x in [2,4,6,8]:\r\n if eh_posicao_livre(tab,x):\r\n return x \r\n \r\n if str1=='basico':\r\n for i in range(2):\r\n if i==0: res = centro_5(tab, jog)\r\n if i==1: res = canto_vazio_7(tab, jog)\r\n if res!=None:\r\n return res\r\n return lateral_vazio_8(tab, jog) \r\n \r\n \r\n elif str1=='normal':\r\n for i in range(5):\r\n if i==0: res = vitoria_1(tab,jog)\r\n if i==1: res = bloqueio_2(tab,jog)\r\n if i==2: res = centro_5(tab, jog)\r\n if i==3: res = canto_oposto_6(tab, jog)\r\n if i==4: res = canto_vazio_7(tab, jog)\r\n if res!=None:\r\n return res\r\n return lateral_vazio_8(tab, jog)\r\n \r\n \r\n elif str1=='perfeito':\r\n for i in range(7):\r\n if i==0: res = vitoria_1(tab,jog)\r\n if i==1: res = bloqueio_2(tab,jog)\r\n if i==2: \r\n res = bifurcacao_3(tab, jog)\r\n if res!=[]:\r\n res = bifurcacao_3(tab, jog)[0]\r\n else:\r\n res=None\r\n if i==3: \r\n res = bloqueio_de_bifurcacao_4(tab,jog)\r\n if res!=[]:\r\n res = bloqueio_de_bifurcacao_4(tab,jog)\r\n else:\r\n res=None \r\n if i==4: res = centro_5(tab, jog)\r\n if i==5: res = canto_oposto_6(tab, jog)\r\n if i==6: res = canto_vazio_7(tab, jog)\r\n if res!=None:\r\n return res\r\n return lateral_vazio_8(tab, jog)","async def tamere(self):\n tamere = [\n \"Ta mère est tellement grosse que pour la voir entièrement, on doit reculer de trois pas.\",\n \"Ta mère est tellement grosse qu'il faut deux pokéflutes pour la réveiller.\",\n \"Ta mère est tellement grosse qu'il y a un décalage horaire entre ses deux fesses.\",\n \"Ta mère est tellement radine que, quand elle vomit, elle sert les dents pour garder les morceaux.\",\n \"Ta mère est tellement moche que ton père est capable de l'emmener au travail pour éviter de lui dire au revoir en l'embrassant.\",\n \"Ta mère est tellement vieille que quand elle pète, elle fait de la poussière.\",\n \"Ta mère est tellement desséchée que ses morpions ne se baladent jamais sans leur gourde perso.\",\n \"Ta mère est tellement grosse qu'elle a décroché le rôle de la grosse pierre roulante au casting d'Indiana Jones.\",\n \"Ta mère est tellement grosse qu'elle a été baptisée en mer.\",\n \"Ta mère est tellement pauvre que ce sont les pigeons qui lui jettent du pain.\",\n \"Ta mère est tellement moche que quand elle va à la banque ils coupent les caméras.\",\n \"Ta mère est tellement grosse que quand elle met des talons aiguilles, elle trouve du pétrole !\",\n \"Ta mère est tellement petite que sa tête pue des pieds.\",\n \"Ta mère est tellement vieille qu'elle fait du lait en poudre.\",\n \"Ta mère a tellement mauvaise haleine qu'on a l'impression qu'elle a l'anus derrière les dents.\",\n \"Si tu vois un bateau qui flotte sur l'eau c'est que ta mère n'est pas à bord.\",\n \"Ta mère est tellement grosse que lorsqu'elle tombe du lit elle tombe des deux bords.\",\n \"Ta mère est tellement grosse que pour la photographier il faut un satellite.\",\n \"Ta mère est tellement grosse que quand elle mange des cacahuètes, elle chie des Snickers.\",\n \"Ta mère est tellement grosse que lorsqu'elle se pèse, c'est son numéro de téléphone qui s'affiche !\",\n \"Si les femmes sont des fleurs, il faudrait changer l'eau de ta mère.\",\n \"Ta mère est tellement bête que quand ton père l'a demandée en mariage elle a dit oui\"\n ]\n print('Blague sur les daronnes')\n await self.bot.say(random.choice(tamere))","def joueCoup(position,coup):\n nouvelle_pos = clonePosition(position) # on duplique pour ne pas modifier l'original\n n = nouvelle_pos['taille']\n trait = nouvelle_pos['trait']\n # on transforme coup en indice\n if trait == 'SUD':\n indice_depart = coup-1\n else:\n indice_depart = 2*n-coup\n # retrait des graines de la case de depart\n nbGraines = nouvelle_pos['tablier'][indice_depart]\n nouvelle_pos['tablier'][indice_depart] = 0\n # on seme les graines dans les cases a partir de celle de depart\n indice_courant = indice_depart\n while nbGraines > 0:\n indice_courant = (indice_courant + 1) % (2*n)\n if (indice_courant != indice_depart): # si ce n'est pas la case de depart\n nouvelle_pos['tablier'][indice_courant] += 1 # on seme une graine\n nbGraines -= 1\n # la case d'arrivee est dans le camp ennemi ?\n if (trait == 'NORD'):\n estChezEnnemi = (indice_courant < n)\n else:\n estChezEnnemi = (indice_courant >= n)\n # realisation des prises eventuelles\n while estChezEnnemi and (nouvelle_pos['tablier'][indice_courant] in range(2,4)):\n nouvelle_pos['graines'][trait] += nouvelle_pos['tablier'][indice_courant]\n nouvelle_pos['tablier'][indice_courant] = 0\n indice_courant = (indice_courant - 1) % (2*n)\n if (trait == 'NORD'):\n estChezEnnemi = (indice_courant < n)\n else:\n estChezEnnemi = (indice_courant >= n)\n # mise a jour du camp au trait\n if trait == 'SUD':\n nouvelle_pos['trait'] = 'NORD'\n else:\n nouvelle_pos['trait'] = 'SUD'\n return nouvelle_pos","def criaColuns():\n\n #Preencher Colunas\n numColunsVaz = 5\n numColuns = 2\n coluns = \"\"\n\n while(numColuns > 0): #preenchendo colunas de linha\n while(numColunsVaz > 0): #preenchendo espacos vazios das colunas de cada linha\n coluns += \" \"\n numColunsVaz -= 1\n\n coluns += \"|\"\n numColunsVaz = 5\n numColuns -= 1\n\n coluns += \" \"\n print(espacamento ,coluns ,espacamento)","def ubicar_submarino(): #esta clase de barcos no tiene orientacion\n tamano = Submarinos.tamano #se importa el tamano del barco desde su clase\n cantidad = Submarinos.cantidad #se importa la cantidad de barcos desde su clase\n while cantidad > 0:\n mal_ubicado = \"no\"\n coor_fila = randint(1,numero_filas)\n coor_columna = randint(1,numero_columnas)\n ubicacion = (coor_fila, coor_columna)\n for x in lista_ubicacion_barco:\n if x == ubicacion:\n mal_ubicado = \"si\"\n #validacion para que los barcos no queden contiguos entre otros ya posicionados\n elif (ubicacion[0] == x[0] or (ubicacion[0]+1) == x[0] or (ubicacion[0]-1) == x[0]) and ((ubicacion[1]) == x[1] or (ubicacion[1]+1) == x[1] or (ubicacion[1]- 1) == x[1]): \n mal_ubicado = \"si\"\n if mal_ubicado == \"no\":\n cantidad -= 1 #se resta uno a la cantidad de los barcos porque ya este se posiciono correctamente\n lista_ubicacion_barco.append(ubicacion) #si el barco no es contiguo con ningun otro barco se agrega a la lista de los barcos ya posicionados\n elif mal_ubicado == \"si\":\n cantidad = cantidad #la cantidad de barcos se mantiene igual porque el barco quedo contiguo a otro, se repite el proceso d eubicacion para este barco","def __init__(self, mot):\n premiere_cellule = None\n self.taille = 0\n for lettre in reversed(mot):\n premiere_cellule = Cellule(lettre, premiere_cellule)\n self.taille += 1\n self.tete = premiere_cellule","def solution(self):\n return [(\"the\", 1579644)] * 100"],"string":"[\n \"def reemplaza_tildes(palabra):\",\n \"def affiche_plateau(plateau):\\n remplissage = ' ' * 30\\n print(remplissage, end='')\\n for i in range(1, 7, 2):\\n print(\\\" \\\" + str(i), sep='', end='')\\n print()\\n for i in range(get_nb_lignes(plateau[0])):\\n print(remplissage, end='')\\n if i % 2 == 0:\\n print(' ', sep='', end='')\\n else:\\n print(str(i), sep='', end='')\\n for j in range(get_nb_colonnes(plateau[0])):\\n print(to_char(get_valeur(plateau[0], i, j)), end='')\\n if i % 2 == 0:\\n print(' ', sep='', end='')\\n else:\\n print(str(i), sep='', end='')\\n print()\\n print(' ', sep='', end='')\\n print(remplissage, end='')\\n for i in range(1, 7, 2):\\n print(\\\" \\\" + str(i), sep='', end='')\\n print()\",\n \"def juego_nuevo():\\n show_title(\\\"Crear sopa de NxN letras\\\")\\n nxn = pedir_entero(\\\"Ingrese un numero entero de la cantidad de\\\\nfilas y columnas que desea (Entre 10 y 20):\\\\n\\\",10,20)\\n n_palabras = pedir_entero(\\\"Ingrese un numero entero de la cantidad de\\\\npalabas que deasea agregar (Entre 0 y %d):\\\\n\\\"%(nxn/2),0,(nxn/2))\\n palabras = []\\n palabra_min_caracteres = 3\\n palabra_repetida = False\\n while len(palabras)<n_palabras:\\n if palabra_repetida :\\n show_msg(\\\"Ingreso una palabra repetida\\\")\\n palabra_repetida = False\\n # Pedir una palabra que cumpla con los requisitos\\n palabra = pedir_palabra(\\\"[%d|%d]Ingrese una palabra entre %d y %d caracteres: \\\"%(len(palabras)+1,n_palabras,palabra_min_caracteres,(nxn/2)),palabra_min_caracteres,(nxn/2))\\n if palabra in palabras:\\n palabra_repetida = True\\n else :\\n palabras.append(palabra)\\n matrix = crear_matrix(nxn)\\n matrix,posiciones,salteadas = procesar_palabras(matrix, nxn, palabras)\\n matrix = completar_matrix(matrix, nxn)\\n return procesar_juego(matrix,nxn,n_palabras,salteadas,posiciones)\",\n \"def otra_partida():\\r\\n\\r\\n for jugador_1 in juego.get_jugadores():\\r\\n\\r\\n \\\"\\\"\\\"Va Iterando sobre todos los jugadores disponibles de uno en uno\\\"\\\"\\\"\\r\\n color.utilizarVerde()\\r\\n print(\\\"\\\\nEmpieza: {}\\\".format(jugador_1.get_jugado_nombre()))\\r\\n num1, num2 = juego.get_rangos()\\r\\n print(\\\"Rango de {} al {}\\\".format(num1, num2))\\r\\n jugador_1.set_jugador_intentos(4)\\r\\n intentos = jugador_1.get_jugador_intentos()\\r\\n numero_oculto = randint(num1, num2)\\r\\n puntos = jugador_1.get_jugador_puntuacion_total()\\r\\n\\r\\n while intentos >= 0:\\r\\n\\r\\n \\\"\\\"\\\"Empieza la partida con 4 Intentos hasta que se quede en 0\\\"\\\"\\\"\\r\\n\\r\\n try:\\r\\n color.utilizarVerde()\\r\\n numero = int(input(\\\"\\\\nIntroduce un Número: \\\"))\\r\\n color.utilizarAmarillo()\\r\\n print(\\\"Intetos Restantes: {}\\\".format(intentos - 1))\\r\\n if numero_oculto < numero and intentos != 1:\\r\\n color.utilizarRojoClarito()\\r\\n print(\\\"\\\\nEs Demasiado Grande\\\\n\\\")\\r\\n intentos -= 1\\r\\n jugador_1.set_jugador_intentos(intentos)\\r\\n\\r\\n elif numero_oculto > numero and intentos != 1:\\r\\n color.utilizarRojoClarito()\\r\\n print(\\\"\\\\nEs Demasiado Pequeño\\\\n\\\")\\r\\n intentos -= 1\\r\\n jugador_1.set_jugador_intentos(intentos)\\r\\n\\r\\n elif numero == numero_oculto:\\r\\n color.utilizarAzul()\\r\\n print(\\\"\\\\nHas Ganado en el {0} intento\\\".format(intentos))\\r\\n puntos += 1\\r\\n jugador_1.set_jugador_puntuacion_total(puntos)\\r\\n input(\\\"Pulse enter para continuar...\\\")\\r\\n break\\r\\n\\r\\n elif numero != numero_oculto and intentos == 1:\\r\\n color.utilizarVerdeClarito()\\r\\n print(\\\"\\\\nEl número era {} :(\\\\n\\\".format(numero_oculto))\\r\\n color.utilizarRojo()\\r\\n print(format(\\\"GAME OVER\\\", \\\"-^75\\\"))\\r\\n input(\\\"Pulse enter para continuar...\\\")\\r\\n break\\r\\n\\r\\n except (ValueError, NameError):\\r\\n print(\\\"\\\\nError: Tiene que ser un número ...\\\")\",\n \"def NuevaPartida(self,):\\n\\t\\\"\\\"\\\" Numeros Disponibles \\\"\\\"\\\"\\n\\tDisponibles[0] = True\\n\\tDisponibles[1] = True\\n\\tDisponibles[2] = True\\n\\tDisponibles[3] = True\\n\\tDisponibles[4] = True\\n\\tDisponibles[5] = True\\n\\t\\\"\\\"\\\" Jugador Uno \\\"\\\"\\\"\\n\\tJ1[0] = 0\\n\\tJ1[1] = 0\\n\\tJ1[2] = 0\\n\\tJ1[3] = 0\\n\\tJ1[4] = 0\\n\\tJ1[5] = 0\\n\\t\\\"\\\"\\\" Jugador Dos \\\"\\\"\\\"\\n\\tJ2[0] = 0\\n\\tJ2[1] = 0\\n\\tJ2[2] = 0\\n\\tJ2[3] = 0\\n\\tJ2[4] = 0\\n\\tJ2[5] = 0\\n\\t\\\"\\\"\\\" Jugador Tres \\\"\\\"\\\"\\n\\tJ3[0] = 0\\n\\tJ3[1] = 0\\n\\tJ3[2] = 0\\n\\tJ3[3] = 0\\n\\tJ3[4] = 0\\n\\tJ3[5] = 0\\n\\t\\\"\\\"\\\" Jugador Cuatro \\\"\\\"\\\"\\n\\tJ4[0] = 0\\n\\tJ4[1] = 0\\n\\tJ4[2] = 0\\n\\tJ4[3] = 0\\n\\tJ4[4] = 0\\n\\tJ4[5] = 0\",\n \"def subtest_Plateau_hauteur():\\n _out =''\\n klass = tp.Plateau\\n for i in range(2,7):\\n for j in range(2,13):\\n try:\\n p = klass(i,j)\\n except:\\n print(\\\"Constructeur Plateau({},{}) failed\\\".format(i,j))\\n _out += 'E'\\n return _out\\n prop = p.hauteur == j if j%2 == 1 else p.hauteur == 5\\n v = 5 if j%2 == 0 else j\\n _out += check_property(prop,\\n \\\"largeur expected {} got {}\\\"\\n \\\"\\\".format(v,p.hauteur))\\n return _out\",\n \"def reais(um, dois, tres):\\n print(f'Aposta 1 -> R${um:.2f}, Aposta 2 -> '\\n f'R${dois:.2f}, Aposta 3 -> R${tres:.2f}')\",\n \"def solution(self):\\n return [(\\\"simple 1\\\", 1.),\\n (\\\"simple 2\\\", 1.),\\n (\\\"simple 3\\\", 1.),\\n (\\\"simple 4\\\", 1.),\\n (\\\"simple 5\\\", 1.),\\n (\\\"simple 10\\\", 1.),\\n (\\\"simple 15\\\", 1.),\\n (\\\"thai 1\\\", 1.),\\n (\\\"thai 2\\\", 1.),\\n (\\\"thai 3\\\", 1.),\\n (\\\"thai 4\\\", 1.),\\n (\\\"thai 5\\\", 1.),\\n (\\\"thai 10\\\", 1.),\\n (\\\"thai 15\\\", 1.),\\n ]\",\n \"def canto_vazio_7(tab, jog):\\r\\n for x in [1,3,7,9]:\\r\\n if eh_posicao_livre(tab,x):\\r\\n return x\",\n \"def spiel(self, *args, **kwargs):\\n\\t\\t\\n if kwargs.get('h'):\\n print(\\\"\\\\nSpiel ( FussballToto, 7 Mannschaften )\\\\n\\\")\\n print(\\\"Aufruf t . spiel( /[ tipp ] /[, m ] )\\\\n\\\")\\n print(\\\" t Toto-Objekt\\\")\\n print(\\\" tipp abgegebener Tipp (Liste mit 7 Zahlen aus {0, 1, 2})\\\")\\t\\t\\t\\n print(\\\" fehlt die Angabe, wird ein zufälliger Tipp angenom-\\\")\\n print(\\\" men\\\")\\t\\t\\t\\n print(\\\" m Anzahl Spiele (mit dem gleichen Tipp); Standard=1\\\\n\\\")\\n print(\\\"Zusatz z=ja Es wird ein zufälliger Tipp angenommen\\\")\\n print(\\\" (ein eventuell angegebener Tipp wird nicht beachtet)\\\")\\n print(\\\" d=ja Bei Angabe von m > 1 Rückgabe einer DatenReihe\\\")\\n print(\\\" mit der Anzahl Richtige je Spiel\\\\n\\\")\\t\\t\\t\\n return\\t\\t\\t\\n\\t \\n def zuf_tipp()\\t :\\n return zuf_zahl((0, 2), 7)\\t\\t\\n\\t \\n zufall = False\\t \\n if len(args) not in (0, 1, 2):\\n print('zufall: 0 bis 2 Argumente angeben')\\n return\\n if len(args) == 0:\\n m = 1\\n zufall = True\\t\\t\\t\\n elif len(args) == 1:\\n m = args[0]\\n if isinstance(m, (int, Integer)):\\t\\n zufall = True\\t\\t\\t\\n elif isinstance(m, (list, tuple)):\\n tipp = m\\n m = 1\\n else:\\t\\t\\t\\t\\n print('zufall: positive ganze Zahl oder Tipp-Liste angeben')\\n elif len(args) == 2:\\n tipp, m = args\\t\\n\\n if m <= 0:\\n print('zufall: Anzahl der Spiele >= 1 angeben')\\n return\\t\\n\\n if kwargs.get('z'):\\n zufall = True\\n\\n if zufall:\\n tipp = zuf_tipp()\\n\\t\\t\\t\\n if len(tipp) != 7 or not all([x in (0,1,2) for x in tipp]):\\t\\t\\t\\n print('zufall: Tipp als Liste von 7 Zahlen aus (0,1,2) angeben')\\n return\\t\\t\\t\\n\\t\\t\\t\\n ergebnisse = zuf_tipp()\\t\\t\\t\\n\\n def dm(x):\\n return display(Math(x))\\t\\t\\t\\t\\n\\n print(' ')\\n\\t\\t\\t\\n if m == 1:\\n if not zufall:\\t\\t\\n dm('\\\\\\\\text{Tipp}' + '\\\\\\\\quad\\\\\\\\quad \\\\,:' + latex(tipp))\\n else:\\n dm('\\\\\\\\text{Tipp}' + '\\\\\\\\quad\\\\\\\\quad :\\\\;' + latex(tipp) + '\\\\;\\\\;\\\\\\\\text{(zufällig)}')\\n dm('\\\\\\\\text{Ergebnisse :} \\\\;' + latex(ergebnisse))\\t\\n erg = 0\\t\\t\\t\\n for i, t in enumerate(tipp):\\n if t == ergebnisse[i]:\\n erg += 1\\n if erg == 1:\\t\\t\\t\\t\\t\\n dm(latex(erg) + '\\\\;\\\\\\\\text{Richtiger}')\\t\\n else:\\t\\t\\t\\t\\t\\n dm(latex(erg) + '\\\\;\\\\\\\\text{Richtige}')\\t\\n else:\\t\\t\\t\\n summen = {}\\n dr = []\\t\\t\\t\\n for i in range(m):\\n erg = zuf_tipp()\\n sum = 0\\t\\t\\t\\t\\n for j, t in enumerate(tipp):\\n if t == erg[j]:\\n sum += 1\\n if kwargs.get('d'):\\n dr += [sum]\\t\\t\\t\\t\\t\\t\\n try:\\t\\t\\t\\t\\t\\t\\n summen[sum] += 1\\n except KeyError:\\n summen[sum] = 1\\n dm(latex(m) + '\\\\; \\\\\\\\text{Spiele}')\\n dm('\\\\\\\\text{Spielergebnisse (Richtige : Anzahl Spiele, relative Häufigkeit, \\\\\\n \\t\\t\\ttheoretische}') \\n dm('\\\\\\\\text{Wahrscheinlichkeit)}')\\t\\t\\t\\n u = Urne([0, 1, 2], 7, f=anzahl(1), info=False)\\t\\t\\t\\n for s in summen:\\n sum = summen[s]\\t\\t\\n dm(latex(s) + '\\\\\\\\text{ : } \\\\\\\\quad' + latex(sum) + '\\\\\\\\quad' + \\\\\\n\\t\\t\\t\\t latex(format(float(sum/m), '.4f')) + '\\\\\\\\quad ' + \\\\\\n\\t\\t\\t\\t latex(format(float(u.P(s)), '.4f')) + '=' + latex(u.P(s)))\\n print(' ') \\n if kwargs.get('d'):\\n print('Rückgabe einer DatenReihe (Anzahl Richtige je Spiel)')\\t\\t\\n return DatenReihe(dr)\",\n \"def affiche_cartes():\\n for i in range(nbjoueurs):\\n fenetre.blit(dos_carte,(920+i*145,100)) # soit 920,1065,1210,1355 pour 4 joueurs\",\n \"def iniciar():\\n \\n for sala in range(3):\\n for fila_letra in range(21):\\n for numero_poltrona in range(20):\\n poltrona[sala,fila_letra,numero_poltrona],faturamentoSala[sala,fila_letra,numero_poltrona]=0,0.0\",\n \"def get_mvts(self, plateau):\\n if self.type == \\\"p\\\": #Pion\\n if self.color == \\\"w\\\":\\n diags = [[self.x-1, self.y+1],[self.x+1, self.y+1]] #Mouvements possibles de diagonales\\n faces = [[self.x, self.y+1]] #Mouvements possibles de face\\n if not self.moved: #Si le pion n'a pas encore bougé de la partie\\n faces.append([self.x, self.y+2])\\n else:\\n diags = [[self.x-1, self.y-1], [self.x+1, self.y-1]]\\n faces = [[self.x, self.y-1]] #Mouvements possibles de \\n if not self.moved:\\n faces.append([self.x, self.y-2])\\n pos = [] #Position de déplacement validées\\n for d in diags:\\n if verif_case(d[0], d[1]): #Si la case est sur le plateau \\n pion = plateau.get_pion(d[0],d[1])\\n if pion != None and pion.color != self.color: #Si il y a un pion ennemi\\n pos.append(d)\\n for f in faces: \\n if verif_case(f[0],f[1]):\\n pion = plateau.get_pion(f[0], f[1])\\n if pion == None: #Si il n'y a pas de pion\\n pos.append(f)\\n return pos\\n elif self.type == \\\"t\\\": #Tour\\n pos = []\\n dir = [[1,0],[-1,0],[0,1],[0,-1]] #4 directions possibles\\n for d in dir:\\n x,y = self.x+d[0],self.y+d[1] #Projection de position\\n while verif_case(x,y): #Tant que (x, y) est sur le plateau\\n pion = plateau.get_pion(x, y)\\n if pion != None: #Si il y a un pion\\n if pion.color != self.color: #Si il n'est pas allié\\n pos.append([x,y])\\n break\\n pos.append([x,y])\\n x += d[0]\\n y += d[1]\\n return pos\\n elif self.type == \\\"c\\\": #Cavalier\\n l = [-2,-1,1,2]\\n mvts = [[x,y] for x in l for y in l if abs(x)!=abs(y)]\\n pos = []\\n for m in mvts:\\n x = self.x + m[0]\\n y = self.y + m[1]\\n if verif_case(x,y):\\n pion = plateau.get_pion(x, y)\\n if pion == None or pion.color != self.color:\\n pos.append([x, y])\\n return pos\\n elif self.type == \\\"f\\\": #Fou\\n dir = [[1,1],[-1,1],[-1,-1],[1,-1]]\\n pos = []\\n for d in dir:\\n x,y = self.x+d[0],self.y+d[1]\\n while verif_case(x,y):\\n pion = plateau.get_pion(x, y)\\n if pion != None:\\n if pion.color != self.color:\\n pos.append([x,y])\\n break\\n pos.append([x,y])\\n x += d[0]\\n y += d[1]\\n return pos\\n elif self.type == \\\"k\\\": #Roi\\n mvts = [[1,0],[-1,1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]] #4 mouvements possibles\\n pos = []\\n for m in mvts:\\n x = self.x + m[0]\\n y = self.y + m[1]\\n if verif_case(x, y):\\n pion = plateau.get_pion(x, y)\\n if pion == None or pion.color != self.color:\\n pos.append([self.x + m[0], self.y + m[1]])\\n return pos\\n elif self.type == \\\"q\\\": #Dame\\n pos = []\\n dir = [[1,0],[1,-1],[0,-1],[-1,-1],[-1,0],[-1,1],[0,1],[1,1]]\\n for d in dir:\\n x,y = self.x+d[0],self.y+d[1]\\n while verif_case(x,y):\\n pion = plateau.get_pion(x, y)\\n if pion != None:\\n if pion.color != joueur:\\n pos.append([x,y])\\n break\\n pos.append([x,y])\\n x += d[0]\\n y += d[1]\\n return pos\",\n \"def primos_permitidos():\\r\\n parejas_permitidas = [(31,23),(47,19),(7,19),(17,41),(31,7),(29,47),(37,23),(2,79),(43,17),(7,37),(5,61),\\r\\n (17,31),(23,19),(23,7),(11,83),(17,7),(71,3),(37,29),(7,79),(11,59),(37,3),(3,59),(13,53),(79,11),(89,3),\\r\\n (2,97),(23,5),(13,41),(89,2),(5,97),(89,7),(41,7),(59,7),(19,41),(31,13),(29,19),(79,5),(83,7),\\r\\n (83,3),(43,7),(23,17),(23,29),(3,41),(17,47),(37,13),(37,11),(53,5),(43,3),(5,83),(7,67),(89,5),\\r\\n (19,53),(29,17),(53,11),(11,41),(5,47),(73,13),(13,23),(47,29),(5,89),(17,23),(5,43),(71,11),(67,5),\\r\\n (149,3),(7,47),(19,37),(127,7),(109,7),(7,53),(67,2),(19,41),(67,11),(7,97),(3,103),(3,131),(163,2),(11,61),\\r\\n (113,5),(73,5),(17,7),(61,5),(97,5),(43,13),(157,5),(2,107),(71,5),(3,151),(5,29),(2,151),(137,3),\\r\\n (13,29),(59,11),(137,5),(47,11),(13,47),(2,197),(53,17),(239,3),(229,2),(23,37),(53,13),(11,73)]\\r\\n return parejas_permitidas\",\n \"def ubicar_portaviones():\\n tamano = Portaviones.tamano #se importa el tamano del barco desde su clase\\n cantidad = Portaviones.cantidad #se importa la cantidad de barcos de este tamano desde su clase\\n orientacion = orientaciones[(randint(0, 1))] #elige aleatoriamente el index de la tupla orientaciones = (\\\"Vertical\\\", \\\"Horizontal\\\")\\n while cantidad > 0:\\n if orientacion == \\\"Vertical\\\":\\n #se eligen random las filas y las columnas\\n coor_fila = randint(1, numero_filas) \\n coor_columna = randint(1, numero_columnas)\\n while (coor_fila + tamano) > 10: #como su orientacion es vertical la fila incial del barco mas su tamano (3) no puede ser mayor que 10 porque se saldria del mapa\\n coor_fila = randint(1,numero_filas)\\n ubicacion = (coor_fila, coor_columna)\\n lista_temporal.append(ubicacion) #lista donde se ubicaran temporalmente las ubicaciones de los barcos\\n while len(lista_temporal) < tamano: #sacar las posiciones restantes \\n coor_fila += 1\\n ubicacion = (coor_fila, coor_columna)\\n lista_temporal.append(ubicacion)\\n cantidad -= 1\\n elif orientacion == \\\"Horizontal\\\":\\n #se eligen random las filas y las columnas\\n coor_fila = randint(1, numero_filas)\\n coor_columna = randint(1, numero_columnas)\\n while (coor_columna + tamano) > 10: #como su orientacion es horizontal la columna incial del barco mas su tamano (3) no puede ser mayor que 10 porque se saldria del mapa\\n coor_columna = randint(1, numero_columnas)\\n ubicacion = (coor_fila, coor_columna)\\n lista_temporal.append(ubicacion)\\n while len(lista_temporal) < tamano: #sacar las posiciones restantes\\n coor_columna += 1\\n ubicacion = (coor_fila, coor_columna)\\n lista_temporal.append(ubicacion)\\n for x in lista_temporal:\\n lista_ubicacion_barco.append(x) #se agregan las ubicaciones ya validadas a una lista general donde iran todas las posiciones de los barcos\\n coordenadas_portaviones.append(x)\\n lista_temporal.clear() #se limpia la lista para que pueda ser usada en los siguientes barcos\\n cantidad -= 1\",\n \"def encontrar_mejor_sitio(ubicaciones):\\n\\ttorretas_adicionales = ubicaciones.count(\\\"t\\\") # obtengo cuantas t (torretas adicionales) hay en ubicaciones\\n\\tif torretas_adicionales == 0:\\n\\t\\tprint \\\"Posicion: 5\\\"\\n\\tif torretas_adicionales == 4:\\n\\t\\tprint \\\"Posicion: \\\",\\n\\t\\tfor i in range(len(ubicaciones)):\\n\\t\\t\\tif ubicaciones[i] == \\\"o\\\":\\n\\t\\t\\t\\tprint i,\",\n \"def affiche_table(nombre: int) -> None:\\n for k in range(1, 10):\\n ## Version classique\\n #print(nombre, \\\"x\\\", k, \\\"=\\\", k * nombre, sep=\\\"\\\")\\n\\n ## Version f-string ; recommandée\\n print(f\\\"{nombre}x{k}={k * nombre}\\\")\",\n \"def powiekszoneParzysteZZerami(L): #[!] drobny błąd\\n wynik = []\\n for n in L:\\n if parzysta(n)==True:\\n wynik.append(n+1) # Jesli wolisz: wynik += [n+1]\\n else:\\n wynik.append(n)\\n wynik.append(0) # Znowu, mozna: wynik += [0]\\n return wynik\",\n \"def scrolls(publications, ):\\n return (int(publications)) // 11\",\n \"def print_components_sizes(distance, points):\\n SortedX = sorted([point for point in points], key = abscisse)\\n\\n result = prochesX(SortedX, distance)\\n dernier_pointX_1 = result[len(result)-1]\\n dernier_indice = SortedX.index(dernier_pointX_1)\\n\\n origine = Point([0.0, 0.0])\\n segment_1 = Segment([Point([dernier_pointX_1.x, 0]), Point([dernier_pointX_1.x, 1])])\\n\\n SortedY = sorted([point for point in result], key = ordonnee)\\n result_bis = prochesY(SortedY, distance)\\n dernier_pointXbis_1 = result_bis[len(result_bis)-1]\\n dernier_indice_bis = SortedX.index(dernier_pointXbis_1)\\n\\n segment_2 = Segment([Point([0, dernier_pointXbis_1.y]), Point([1, dernier_pointXbis_1.y])])\\n tycat(origine, points, (segment_1, segment_2))\\n \\\"\\\"\\\"\\n affichage des tailles triees de chaque composante\\n \\\"\\\"\\\"\\n segments = []\\n research_base = [point for point in points]\\n origine = Point([0.0, 0.0])\\n total = research_base.copy()\\n s = 0\\n enveloppe = []\\n while len(research_base) > 0:\\n current = research_base[0]\\n research_base.pop(0)\\n for point in research_base:\\n if current.distance_to(point) < distance:\\n s += 1\\n segments.append(Segment([current, point]))\\n enveloppe.append(s)\\n tycat(origine, total, segments)\",\n \"def enchere(self):\\n\\n i = 0\\n while i < 5 and self.annonce < 4:\\n paroleJ = self.joueurs[i].parler(self.annonce)\\n if paroleJ != 0:\\n self.annonce = paroleJ\\n self.indiceJoueurQuiPrend = i\\n i += 1\\n\\n print(\\\"joueur qui prend : \\\" + str(self.indiceJoueurQuiPrend))\\n if self.indiceJoueurQuiPrend != -1:\\n print(\\\"annonce : \\\" + str(self.annonce))\\n if self.annonce == 1 or self.annonce == 2:\\n self.joueurs[self.indiceJoueurQuiPrend].possedeChien = True\\n self.joueurs[self.indiceJoueurQuiPrend].construireChien()\\n self.debuterPartie()\\n\\n else:\\n self.finirPartie()\",\n \"def afficher_damier_ascii(infojeu):\\n lignes = []\\n lignes += list(\\\"Légende: 1=\\\"+ str(infojeu[\\\"joueurs\\\"][0][\\\"nom\\\"])+\\n ', 2='+str(infojeu[\\\"joueurs\\\"][1][\\\"nom\\\"]) + \\\"\\\\n\\\")\\n lignes += list(\\\" \\\"+\\\"-\\\"*35+\\\"\\\\n\\\")\\n for i in range(1, 10):\\n lignes += str(10-i) + \\\" | \\\"\\n for j in range(1, 9):\\n strplayer = \\\".\\\"\\n if [j, 10-i] == infojeu[\\\"joueurs\\\"][0][\\\"pos\\\"]:\\n strplayer = \\\"1\\\"\\n elif [j, 10-i] == infojeu[\\\"joueurs\\\"][1][\\\"pos\\\"]:\\n strplayer = \\\"2\\\"\\n if [j+1, 10-i] in infojeu[\\\"murs\\\"][\\\"verticaux\\\"]:\\n lignes += list(strplayer + \\\" | \\\")\\n elif [j+1, 9-i] in infojeu[\\\"murs\\\"][\\\"verticaux\\\"]:\\n lignes += list(strplayer + \\\" | \\\")\\n else:\\n lignes += list(strplayer + \\\" \\\")\\n if [9, 10-i] == infojeu[\\\"joueurs\\\"][0][\\\"pos\\\"]:\\n lignes += list(\\\"1 |\\\")\\n elif [9, 10-i] == infojeu[\\\"joueurs\\\"][1][\\\"pos\\\"]:\\n lignes += list(\\\"2 |\\\")\\n else:\\n lignes += list(\\\". |\\\")\\n if i != 9:\\n lignes += list(\\\"\\\\n |\\\")\\n for k in range(1, 9):\\n if i != 9:\\n if [k, 10-i] in infojeu[\\\"murs\\\"][\\\"horizontaux\\\"]:\\n lignes += list(\\\"----\\\")\\n elif [k-1, 10-i] in infojeu[\\\"murs\\\"][\\\"horizontaux\\\"] and \\\\\\n [k+1, 9-i] in infojeu[\\\"murs\\\"][\\\"verticaux\\\"]:\\n lignes += list(\\\"---|\\\")\\n elif [k-1, 10-i] in infojeu[\\\"murs\\\"][\\\"horizontaux\\\"]:\\n lignes += list(\\\"--- \\\")\\n elif [k+1, 9-i] in infojeu[\\\"murs\\\"][\\\"verticaux\\\"]:\\n lignes += list(\\\" |\\\")\\n else:\\n lignes += list(\\\" \\\")\\n if i != 9:\\n if [8, 10-i] in infojeu[\\\"murs\\\"][\\\"horizontaux\\\"]:\\n lignes += list(\\\"---|\\\")\\n else:\\n lignes += list(\\\" |\\\")\\n lignes += list(\\\"\\\\n\\\")\\n lignes += list(\\\"--|\\\"+ \\\"-\\\"*35+\\\"\\\\n\\\")\\n lignes += list(\\\" | 1 2 3 4 5 6 7 8 9\\\")\\n lignes = ''.join(lignes)\\n print(lignes)\",\n \"def pyramida(zakladna, orientacia, centrovanie):\\n nova_pyramida = []\\n if orientacia not in [\\\"normalna\\\", 'obratena']:\\n print(\\\"Pyramida moze byt iba [normalna] alebo [obratena]\\\")\\n return False\\n\\n if centrovanie != \\\"center\\\" and centrovanie != \\\"vlavo\\\":\\n print(\\\"Centrovanie pyramidy moze byt iba [center] alebo [vlavo]\\\")\\n return False\\n\\n if centrovanie == \\\"center\\\":\\n if orientacia == \\\"normalna\\\":\\n\\n cislo_riadka = -1\\n for i in range(1, zakladna + 1, 2): #pocet hviezdiciek rastie po 2\\n #print(f\\\"{'*' * i:^{zakladna}}\\\")\\n cislo_riadka +=1\\n riadok = []\\n for j in range(cislo_riadka,zakladna//2): #vyska pyramidy = polovica zakladne\\n riadok.append(\\\" \\\") #kolky riadok, tolko medzier vlavo\\n for j in range(0, i):\\n riadok.append(\\\"*\\\")\\n for j in range(cislo_riadka,zakladna//2): # aj v pravo\\n riadok.append(\\\" \\\")\\n nova_pyramida.append(riadok)\\n else:\\n cislo_riadka = -1\\n for i in range(zakladna, 0, -2): #pocet hviezdiciek\\n #print(f\\\"{'*' * i:^{zakladna}}\\\")\\n cislo_riadka +=1\\n riadok = []\\n for j in range(0,cislo_riadka):\\n riadok.append(\\\" \\\")\\n for j in range(0,i):\\n riadok.append(\\\"*\\\")\\n for j in range(0,cislo_riadka):\\n riadok.append(\\\" \\\")\\n nova_pyramida.append(riadok)\\n else:\\n if orientacia == \\\"normalna\\\":\\n for i in range(zakladna):\\n #print(f\\\"{'*' * (i + 1)}\\\")\\n riadok = []\\n for j in range(0,i):\\n riadok.append(\\\"*\\\")\\n nova_pyramida.append(riadok)\\n else:\\n for i in range(zakladna):\\n riadok = []\\n #print(f\\\"{'*' * (zakladna - i)}\\\")\\n for j in range(zakladna, i, -1):\\n riadok.append(\\\"*\\\")\\n nova_pyramida.append(riadok)\\n return nova_pyramida\",\n \"def nom(meal, i1):\\n # Iterators\\n #numOfIts = len(meal)\\n #its = [i1 for i1 in range(0,numOfIts)]\\n #its = [0,2,1,6, len(meal)]\\n #its = createIts(meal)\\n numOfIts = len(its)\\n \\n newnom = 0\\n for i2 in range(0,numOfIts):\\n newnom += int(meal[its[i2]+i1]) + primes[i2]\\n #print(primes[i2])\\n #print(\\\"newnom =\\\", newnom)\\n \\n newnom = str(newnom % 10)\\n return newnom\",\n \"def line_move(plateau, num_lig, sens):\\n if check_room(plateau, num_lig, 3) == False or (sens != 1 and sens != 0): # si plateau n est pas valide ou sens != 1 et 0\\n return \\\"Erreur !\\\"\\n if sens==1:\\n for i in range(0,3):\\n if is_room_empty(plateau, num_lig, i): # si existe un 0 donc tasse a partir de 0\\n line_pack(plateau, num_lig, i, sens)\\n break\\n # si val == val+1 et val % 3 donc val * 2 et tasse a partir de val+1\\n if get_value(plateau, num_lig, i)==get_value(plateau, num_lig, i+1) and get_value(plateau, num_lig, i) % 3 == 0:\\n set_value(plateau, num_lig, i, get_value(plateau, num_lig, i) * 2)\\n line_pack(plateau, num_lig, i+1, sens)\\n break\\n # si val = 1 et val+1 = 2 ou l inverse : val + val+1 et tasse a partir de val+1\\n if get_value(plateau, num_lig, i)==1 and get_value(plateau, num_lig, i+1) == 2:\\n set_value(plateau, num_lig, i, 3)\\n line_pack(plateau, num_lig, i+1, sens)\\n break\\n if get_value(plateau, num_lig, i) == 2 and get_value(plateau, num_lig, i+1) == 1:\\n set_value(plateau, num_lig, i, 3)\\n line_pack(plateau, num_lig, i+1, sens)\\n break\\n\\n\\n else:\\n for i in range(3,0,-1):\\n if is_room_empty(plateau, num_lig, i):\\n line_pack(plateau, num_lig, i, sens)\\n break\\n if get_value(plateau, num_lig,i) == get_value(plateau, num_lig, i-1)and get_value(plateau, num_lig, i) % 3 == 0:\\n set_value(plateau, num_lig, i, get_value(plateau, num_lig, i) * 2)\\n line_pack(plateau, num_lig, i-1, sens)\\n break\\n if get_value(plateau, num_lig, i) == 1 and get_value(plateau, num_lig, i-1) == 2:\\n set_value(plateau, num_lig, i, 3)\\n line_pack(plateau, num_lig, i-1, sens)\\n break\\n if get_value(plateau, num_lig, i) == 2 and get_value(plateau, num_lig, i-1) == 1:\\n set_value(plateau, num_lig, i, 3)\\n line_pack(plateau, num_lig, i-1, sens)\\n break\",\n \"def JUEGOPAREJAS():\\r\\n cuadrados=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]\\r\\n ##############Primeramente, definimos los cuadrados de nuestra pizarra##############\\r\\n Cuadrado1=Rect(420,140,100,100)\\r\\n Cuadrado2=Rect(520,140,100,100)\\r\\n Cuadrado3=Rect(620,140,100,100)\\r\\n Cuadrado4=Rect(720,140,100,100)\\r\\n Cuadrado5=Rect(420,240,100,100)\\r\\n Cuadrado6=Rect(520,240,100,100)\\r\\n Cuadrado7=Rect(620,240,100,100)\\r\\n Cuadrado8=Rect(720,240,100,100)\\r\\n Cuadrado9=Rect(420,340,100,100)\\r\\n Cuadrado10=Rect(520,340,100,100)\\r\\n Cuadrado11=Rect(620,340,100,100)\\r\\n Cuadrado12=Rect(720,340,100,100)\\r\\n Cuadrado13=Rect(420,440,100,100)\\r\\n Cuadrado14=Rect(520,440,100,100)\\r\\n Cuadrado15=Rect(620,440,100,100)\\r\\n Cuadrado16=Rect(720,440,100,100)\\r\\n\\r\\n Totalcuadrados=(Cuadrado1,Cuadrado2,Cuadrado3,Cuadrado4,Cuadrado5,Cuadrado6,Cuadrado7,Cuadrado8,Cuadrado9,Cuadrado10,Cuadrado11,Cuadrado12,Cuadrado13,Cuadrado14,Cuadrado15,Cuadrado16)\\r\\n listafiguras=[]\\r\\n def ventanaprincipal():\\r\\n \\\"\\\"\\\"\\\"\\r\\n Esta funcion, genera la ventana principal de nuestro juego de parejas. Contiene\\r\\n cada uno de los titulos e imagenes del juego.\\r\\n :return None\\r\\n \\\"\\\"\\\"\\r\\n titulo_principal=pygame.image.load(\\\"../recursor/Imagenes juegos/parejas_1.png\\\")\\r\\n ventana.blit(titulo_principal, (405,0))\\r\\n logo_plaython=pygame.image.load(\\\"../recursor/Imagenes juegos/plaython.png\\\")#Cargamos la imagen del logo\\r\\n imagen_decoracion=pygame.image.load(\\\"../recursor/Imagenes juegos/imagenpc.png\\\")\\r\\n imagen_decoracion = pygame.transform.scale(imagen_decoracion, (210, 210))\\r\\n ventana.blit(logo_plaython, (900, 180))\\r\\n ventana.blit(imagen_decoracion,(100,240))\\r\\n titulo_plaython = pygame.image.load(\\\"../recursor/Imagenes juegos/TITULOPLAYTHON.png\\\")\\r\\n titulo_plaython = pygame.transform.scale(titulo_plaython, (240, 150))\\r\\n ventana.blit(titulo_plaython, (505, 550))\\r\\n\\r\\n def dibujarcirculos(x,color):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion, dibuja cada uno de las figuras de forma circular del juego en base a su generacion aleatoria.\\r\\n :param int x: Representa la casilla elegida, y en base a este valor, se dibuja un cuadrado en determinado lugar\\r\\n :param tuple color: Representa un color determinado, el cual se encuentra escrito en base a sus valores RGB\\r\\n :return None\\r\\n \\\"\\\"\\\"\\r\\n if x==1:\\r\\n pygame.draw.circle(ventana,color,(470,190),30)\\r\\n elif x==2:\\r\\n pygame.draw.circle(ventana,color,(570,190),30)\\r\\n elif x==3:\\r\\n pygame.draw.circle(ventana,color,(670,190),30)\\r\\n elif x==4:\\r\\n pygame.draw.circle(ventana,color,(770,190),30)\\r\\n elif x==5:\\r\\n pygame.draw.circle(ventana,color,(470,290),30)\\r\\n elif x==6:\\r\\n pygame.draw.circle(ventana,color,(570,290),30)\\r\\n elif x==7:\\r\\n pygame.draw.circle(ventana,color,(670,290),30)\\r\\n elif x==8:\\r\\n pygame.draw.circle(ventana,color,(770,290),30)\\r\\n elif x==9:\\r\\n pygame.draw.circle(ventana,color,(470,390),30)\\r\\n elif x==10:\\r\\n pygame.draw.circle(ventana,color,(570,390),30)\\r\\n elif x==11:\\r\\n pygame.draw.circle(ventana,color,(670,390),30)\\r\\n elif x==12:\\r\\n pygame.draw.circle(ventana,color,(770,390),30)\\r\\n elif x==13:\\r\\n pygame.draw.circle(ventana,color,(470,490),30)\\r\\n elif x==14:\\r\\n pygame.draw.circle(ventana,color,(570,490),30)\\r\\n elif x==15:\\r\\n pygame.draw.circle(ventana,color,(670,490),30)\\r\\n elif x==16:\\r\\n pygame.draw.circle(ventana,color,(770,490),30)\\r\\n\\r\\n def dibujarcuadrados(x,color):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion, dibuja cada uno de las figuras de forma cuadrada del juego en base a su generacion aleatoria.\\r\\n :param int x: Representa la casilla elegida, y en base a este valor, se dibuja un cuadrado en determinado lugar\\r\\n :param tuple color: Representa un color determinado, el cual se encuentra escrito en base a sus valores RGB\\r\\n :return None\\r\\n \\\"\\\"\\\"\\r\\n if x==1:\\r\\n pygame.draw.rect(ventana,color,Rect(440,160,60,60))\\r\\n elif x==2:\\r\\n pygame.draw.rect(ventana,color,Rect(540,160,60,60))\\r\\n elif x==3:\\r\\n pygame.draw.rect(ventana,color,Rect(640,160,60,60))\\r\\n elif x==4:\\r\\n pygame.draw.rect(ventana,color,Rect(740,160,60,60))\\r\\n elif x==5:\\r\\n pygame.draw.rect(ventana,color,Rect(440,260,60,60))\\r\\n elif x==6:\\r\\n pygame.draw.rect(ventana,color,Rect(540,260,60,60))\\r\\n elif x==7:\\r\\n pygame.draw.rect(ventana,color,Rect(640,260,60,60))\\r\\n elif x==8:\\r\\n pygame.draw.rect(ventana,color,Rect(740,260,60,60))\\r\\n elif x==9:\\r\\n pygame.draw.rect(ventana,color,Rect(440,360,60,60))\\r\\n elif x==10:\\r\\n pygame.draw.rect(ventana,color,Rect(540,360,60,60))\\r\\n elif x==11:\\r\\n pygame.draw.rect(ventana,color,Rect(640,360,60,60))\\r\\n elif x==12:\\r\\n pygame.draw.rect(ventana,color,Rect(740,360,60,60))\\r\\n elif x==13:\\r\\n pygame.draw.rect(ventana,color,Rect(440,460,60,60))\\r\\n elif x==14:\\r\\n pygame.draw.rect(ventana,color,Rect(540,460,60,60))\\r\\n elif x==15:\\r\\n pygame.draw.rect(ventana,color,Rect(640,460,60,60))\\r\\n elif x==16:\\r\\n pygame.draw.rect(ventana,color,Rect(740,460,60,60))\\r\\n\\r\\n def dibujardiamantes(x,color):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion, dibuja cada uno de las figuras de forma de diamante del juego en base a su generacion aleatoria.\\r\\n :param int x: Representa la casilla elegida, y en base a este valor, se dibuja un cuadrado en determinado lugar\\r\\n :param tuple color: Representa un color determinado, el cual se encuentra escrito en base a sus valores RGB\\r\\n :return None\\r\\n \\\"\\\"\\\"\\r\\n if x==1:\\r\\n pygame.draw.polygon(ventana,color,( (430,190),(470,160),(510,190),(470,220)))\\r\\n elif x==2:\\r\\n pygame.draw.polygon(ventana,color,( (530,190),(570,160),(610,190),(570,220) ))\\r\\n elif x==3:\\r\\n pygame.draw.polygon(ventana,color,( (630,190),(670,160),(710,190),(670,220) ))\\r\\n elif x==4:\\r\\n pygame.draw.polygon(ventana,color,( (730,190),(770,160),(810,190),(770,220) ))\\r\\n elif x==5:\\r\\n pygame.draw.polygon(ventana,color,( (430,290),(470,260),(510,290),(470,320) ))\\r\\n elif x==6:\\r\\n pygame.draw.polygon(ventana,color,( (530,290),(570,260),(610,290),(570,320) ))\\r\\n elif x==7:\\r\\n pygame.draw.polygon(ventana,color,( (630,290),(670,260),(710,290),(670,320) ))\\r\\n elif x==8:\\r\\n pygame.draw.polygon(ventana,color,( (730,290),(770,260),(810,290),(770,320) ))\\r\\n elif x==9:\\r\\n pygame.draw.polygon(ventana,color,( (430,390),(470,360),(510,390),(470,420) ))\\r\\n elif x==10:\\r\\n pygame.draw.polygon(ventana,color,( (530,390),(570,360),(610,390),(570,420) ))\\r\\n elif x==11:\\r\\n pygame.draw.polygon(ventana,color,( (630,390),(670,360),(710,390),(670,420) ))\\r\\n elif x==12:\\r\\n pygame.draw.polygon(ventana,color,( (730,390),(770,360),(810,390),(770,420) ))\\r\\n elif x==13:\\r\\n pygame.draw.polygon(ventana,color,( (430,490),(470,460),(510,490),(470,520) ))\\r\\n elif x==14:\\r\\n pygame.draw.polygon(ventana,color,( (530,490),(570,460),(610,490),(570,520) ))\\r\\n elif x==15:\\r\\n pygame.draw.polygon(ventana,color,( (630,490),(670,460),(710,490),(670,520) ))\\r\\n elif x==16:\\r\\n pygame.draw.polygon(ventana,color,( (730,490),(770,460),(810,490),(770,520) ))\\r\\n def dibujartriangulos(x,color):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion, dibuja cada uno de las figuras de forma triangular del juego en base a su generacion aleatoria.\\r\\n :param int x: Representa la casilla elegida, y en base a este valor, se dibuja un cuadrado en determinado lugar\\r\\n :param tuple color: Representa un color determinado, el cual se encuentra escrito en base a sus valores RGB\\r\\n :return None\\r\\n \\\"\\\"\\\"\\r\\n if x==1:\\r\\n pygame.draw.polygon(ventana,color,( (430,160),(510,160),(470,220) ))\\r\\n elif x==2:\\r\\n pygame.draw.polygon(ventana,color,( (530,160),(610,160),(570,220) ))\\r\\n elif x==3:\\r\\n pygame.draw.polygon(ventana,color,( (630,160),(710,160),(670,220) ))\\r\\n elif x==4:\\r\\n pygame.draw.polygon(ventana,color,( (730,160),(810,160),(770,220) ))\\r\\n elif x==5:\\r\\n pygame.draw.polygon(ventana,color,( (430,260),(510,260),(470,320)))\\r\\n elif x==6:\\r\\n pygame.draw.polygon(ventana,color,( (530,260),(610,260),(570,320) ))\\r\\n elif x==7:\\r\\n pygame.draw.polygon(ventana,color,( (630,260),(710,260),(670,320) ))\\r\\n elif x==8:\\r\\n pygame.draw.polygon(ventana,color,( (730,260),(810,260),(770,320) ))\\r\\n elif x==9:\\r\\n pygame.draw.polygon(ventana,color,( (430,360),(510,360),(470,420) ))\\r\\n elif x==10:\\r\\n pygame.draw.polygon(ventana,color,( (530,360),(610,360),(570,420) ))\\r\\n elif x==11:\\r\\n pygame.draw.polygon(ventana,color,( (630,360),(710,360),(670,420) ))\\r\\n elif x==12:\\r\\n pygame.draw.polygon(ventana,color,( (730,360),(810,360),(770,420) ))\\r\\n elif x==13:\\r\\n pygame.draw.polygon(ventana,color,( (430,460),(510,460),(470,520) ))\\r\\n elif x==14:\\r\\n pygame.draw.polygon(ventana,color,( (530,460),(610,460),(570,520) ))\\r\\n elif x==15:\\r\\n pygame.draw.polygon(ventana,color,( (630,460),(710,460),(670,520) ))\\r\\n elif x==16:\\r\\n pygame.draw.polygon(ventana,color,( (730,460),(810,460),(770,520) ))\\r\\n\\r\\n def iniciarjuego():\\r\\n \\\"\\\"\\\"\\\"\\r\\n Esta funcion, crea cuatro figuras de cada una de las posibles, dos de ellas con diferente color de las otras dos.\\r\\n \\\"\\\"\\\"\\r\\n for i in range(4):\\r\\n if i == 1 or i == 0:\\r\\n color = (250,208,120,98)\\r\\n else:\\r\\n color = (159, 250, 120,98)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujarcuadrados(x, color)\\r\\n cuadrados.remove(x)\\r\\n\\r\\n for i in range(4):\\r\\n if i == 0 or i == 1:\\r\\n color = (195, 139, 255,100)\\r\\n else:\\r\\n color = (250, 242, 120,98)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujarcirculos(x, color)\\r\\n cuadrados.remove(x)\\r\\n\\r\\n for i in range(4):\\r\\n if i == 0 or i == 1:\\r\\n color = (250, 145, 137,98)\\r\\n else:\\r\\n color = (126, 139, 250,98)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujartriangulos(x, color)\\r\\n cuadrados.remove(x)\\r\\n\\r\\n for i in range(4):\\r\\n if i == 0 or i == 1:\\r\\n color = (176, 255, 237,100)\\r\\n else:\\r\\n color = (255, 176, 228,100)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujardiamantes(x, color)\\r\\n cuadrados.remove(x)\\r\\n\\r\\n def mostrar(posicion_del_mouse):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion muestra segun la casilla que clickee el jugador.\\r\\n :param tuple posicion_del_mouse: Este parametro representa segun clickee el jugador (posicion en x y y).\\r\\n \\\"\\\"\\\"\\r\\n numerodecuadrado = numerocuadrado(posicion_del_mouse)\\r\\n ubicaciondelcuadrado=ubicacion_cuadrado(posicion_del_mouse)\\r\\n if ubicaciondelcuadrado==0 or ubicaciondelcuadrado==1:\\r\\n color = (250,208,120,98)\\r\\n dibujarcuadrados(numerodecuadrado,color)\\r\\n elif ubicaciondelcuadrado==2 or ubicaciondelcuadrado==3:\\r\\n color = (159, 250, 120,98)\\r\\n dibujarcuadrados(numerodecuadrado,color)\\r\\n elif ubicaciondelcuadrado==4 or ubicaciondelcuadrado==5:\\r\\n color = (195, 139, 255,100)\\r\\n dibujarcirculos(numerodecuadrado,color)\\r\\n elif ubicaciondelcuadrado==6 or ubicaciondelcuadrado==7:\\r\\n color = (250, 242, 120,98)\\r\\n dibujarcirculos(numerodecuadrado,color)\\r\\n elif ubicaciondelcuadrado==8 or ubicaciondelcuadrado==9:\\r\\n color = (250, 145, 137,98)\\r\\n dibujartriangulos(numerodecuadrado,color)\\r\\n elif ubicaciondelcuadrado==10 or ubicaciondelcuadrado==11:\\r\\n color = (126, 139, 250,98)\\r\\n dibujartriangulos(numerodecuadrado,color)\\r\\n elif ubicaciondelcuadrado==12 or ubicaciondelcuadrado==13:\\r\\n color = (176, 255, 237,100)\\r\\n dibujardiamantes(numerodecuadrado,color)\\r\\n elif ubicaciondelcuadrado==14 or ubicaciondelcuadrado==15:\\r\\n color = (255, 176, 228,100)\\r\\n dibujardiamantes(numerodecuadrado,color)\\r\\n\\r\\n def esconderfichas(posicion_del_mouse):\\r\\n \\\"\\\"\\\"\\\"\\r\\n Esta funcion, esconde las fichas, si la seleccion del usuario no es la correcta.\\r\\n :param tuple posicion_del_mouse: :param tuple primeraeleccion: Representa la posicion de donde clickeo el jugador (tanto en el ejex como en el eje y).\\r\\n \\\"\\\"\\\"\\r\\n numerodecuadrado=numerocuadrado(posicion_del_mouse)\\r\\n for j in range(16):\\r\\n if numerodecuadrado==j+1:\\r\\n pygame.draw.rect(ventana,(135,206,250),Totalcuadrados[j].inflate(-10,-10))\\r\\n\\r\\n def encontrarparejas(primeraeleccion,segundaeleccion):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion determina si se encontro una pareja.\\r\\n :param tuple primeraeleccion: Representa la posicion de donde clickeo el jugador (tanto en el ejex como en el eje y).\\r\\n :param tuple segundaeleccion: Representa la segunda posicion de donde clickeo el jugador (tanto en el ejex como en el eje y).\\r\\n Retorna un booleano\\r\\n \\\"\\\"\\\"\\r\\n x=ubicacion_cuadrado(primeraeleccion)\\r\\n y=ubicacion_cuadrado(segundaeleccion)\\r\\n if (x==0 and y==1 or x==1 and y==0)\\\\\\r\\n or (x == 2 and y == 3 or x == 3 and y == 2) \\\\\\r\\n or (x == 4 and y == 5 or x == 5 and y == 4)\\\\\\r\\n or (x == 6 and y == 7 or x == 7 and y == 6)\\\\\\r\\n or (x == 8 and y == 9 or x == 9 and y == 8) \\\\\\r\\n or (x==10 and y==11 or x==11 and y==10)\\\\\\r\\n or (x==12 and y==13 or x==13 and y==12)\\\\\\r\\n or (x==14 and y==15 or x==15 and y==14):\\r\\n return True\\r\\n\\r\\n def ubicacion_cuadrado(posicion_del_mouse):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion, retorna la figura que se encuentra en determinado indice segun se clickee.\\r\\n :param tuple posicion_del_mouse: Representa la posicion de donde clickeo el jugador (tanto en el ejex como en el eje y).\\r\\n Retorna la figura de determinado indice\\r\\n \\\"\\\"\\\"\\r\\n for j in range(16):\\r\\n if Totalcuadrados[j].collidepoint(posicion_del_mouse):\\r\\n return listafiguras.index(j+1)\\r\\n\\r\\n def dibujartablero():\\r\\n \\\"\\\"\\\"\\\"\\r\\n Esta funcion, dibuja los cuadrados que hacen nuestro tablero.\\r\\n :return None\\r\\n \\\"\\\"\\\"\\r\\n ventana.fill((135,206,250)) #colocamos el color de fondo de nuestra pantalla\\r\\n for j in range(16): #iteramos entre los cuadrados ya diseñados, eligiendo parametros como el color y el grueso de sus lineas.\\r\\n pygame.draw.rect(ventana,(255,255,255),Totalcuadrados[j],10)\\r\\n\\r\\n def numerocuadrado(posicion_del_mouse):\\r\\n \\\"\\\"\\\"\\r\\n Esta funcion, retorna el indice de determinado cuadrado segun se clickee.\\r\\n :param tuple posicion_del_mouse: Representa la posicion de donde clickeo el jugador (tanto en el ejex como en el eje y).\\r\\n Retorna el indice de terminada posicion\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n for j in range(16):\\r\\n if Totalcuadrados[j].collidepoint(posicion_del_mouse):\\r\\n return j+1\\r\\n\\r\\n def main():\\r\\n \\\"\\\"\\\"\\\"\\r\\n Funcion proncipal del juego.\\r\\n :return None\\r\\n \\\"\\\"\\\"\\r\\n pygame.init()\\r\\n global ventana\\r\\n ventana= pygame.display.set_mode((1280,700))\\r\\n ventana.fill((135,206,250))\\r\\n pygame.display.set_caption('Encuentra las parejas')\\r\\n logo = pygame.image.load(\\\"../recursor/icono.ico\\\")\\r\\n pygame.display.set_icon(logo)\\r\\n pygame.display.update()\\r\\n dibujartablero()\\r\\n iniciarjuego()\\r\\n titulo_principal=pygame.image.load(\\\"../recursor/Imagenes juegos/parejas_2.png\\\")\\r\\n ventana.blit(titulo_principal, (405,0))\\r\\n pygame.display.update()\\r\\n pygame.time.wait(3000)\\r\\n dibujartablero()\\r\\n ventanaprincipal()\\r\\n pygame.display.update()\\r\\n prueba=0\\r\\n eleccioncorrecta=[]\\r\\n while True:\\r\\n for event in pygame.event.get():\\r\\n if event.type==QUIT:\\r\\n pygame.quit()\\r\\n sys.exit()\\r\\n elif event.type==pygame.MOUSEBUTTONUP:\\r\\n posicion_del_mouse=pygame.mouse.get_pos()\\r\\n mostrar(posicion_del_mouse)\\r\\n pygame.display.update()\\r\\n if prueba==0:\\r\\n primeraeleccion=posicion_del_mouse\\r\\n if numerocuadrado(primeraeleccion) in eleccioncorrecta:\\r\\n prueba=0\\r\\n else:\\r\\n prueba=1\\r\\n else:\\r\\n segundaeleccion=posicion_del_mouse\\r\\n if numerocuadrado(segundaeleccion) in eleccioncorrecta:\\r\\n prueba=1\\r\\n else:\\r\\n prueba=0\\r\\n if not (numerocuadrado(primeraeleccion) in eleccioncorrecta) and not numerocuadrado(segundaeleccion) in eleccioncorrecta:\\r\\n if encontrarparejas(primeraeleccion,segundaeleccion):\\r\\n eleccioncorrecta.append(numerocuadrado(primeraeleccion))\\r\\n eleccioncorrecta.append(numerocuadrado(segundaeleccion))\\r\\n else:\\r\\n pygame.time.wait(1000)\\r\\n esconderfichas(primeraeleccion)\\r\\n esconderfichas(segundaeleccion)\\r\\n pygame.display.update()\\r\\n\\r\\n if len(eleccioncorrecta)==16:\\r\\n ganador=pygame.image.load('../recursor/Imagenes juegos/Ganadorgg0000.png')\\r\\n ventana.blit(ganador,(420, 140))\\r\\n pygame.display.update()\\r\\n time.sleep(4)\\r\\n pygame.quit()\\r\\n break\\r\\n\\r\\n main()\",\n \"def vitoria_1(tab,jog):\\r\\n for i in range(1,4):\\r\\n win = [(0,jog,jog), (jog,0,jog), (jog,jog,0)]\\r\\n coluna = obter_coluna(tab, i)\\r\\n linha = obter_linha(tab, i) \\r\\n if coluna in win:\\r\\n return i+3*win.index(coluna)\\r\\n elif linha in win:\\r\\n return 3*i-2+win.index(linha) \\r\\n if i!=3:\\r\\n diagonal = obter_diagonal(tab, i)\\r\\n if diagonal in win:\\r\\n if i==1:\\r\\n return i+4*win.index(diagonal)\\r\\n\\r\\n else:\\r\\n return 7-2*win.index(diagonal)\",\n \"def canto_oposto_6(tab, jog):\\r\\n jog*=-1\\r\\n if obter_linha(tab,1)[0]==jog and eh_posicao_livre(tab,9):\\r\\n return 9\\r\\n if obter_linha(tab,1)[2]==jog and eh_posicao_livre(tab,7):\\r\\n return 7\\r\\n if obter_linha(tab,3)[0]==jog and eh_posicao_livre(tab,3):\\r\\n return 3\\r\\n if obter_linha(tab,3)[2]==jog and eh_posicao_livre(tab,1):\\r\\n return 1\",\n \"def multiplicaciones(): #906609 tiene que darme\\n ultimo_palindromo = 0\\n total = 0\\n for primer_numero in range(100, 1000):\\n for segundo_numero in range(100, 1000):\\n #total se encarga de hacer la multiplicacion entre los numeros\\n total = primer_numero * segundo_numero\\n # llamamos a la funcion que verifica si la multiplicacion que envia es un palindromo\\n if obtener_palindromo(total):\\n #luego de verificar que la multiplicacion era palindromo pasamos a evaluarla hasta llegar al ultimo palindromo\\n #entre 100 y 1000\\n if ultimo_palindromo < total:\\n ultimo_palindromo = total\\n return ultimo_palindromo\",\n \"def showp():\\n def show1(i):\\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.offsetAz' % (i+1) ,qmax_)\\n e=SAC.queryDouble('carma.Ovro%d.Drive.Point.offsetEl' % (i+1) ,qmax_)\\n return (a,e)\\n print ' ant dAz dEl'\\n for i in range(6):\\n (a,e) = show1(i)\\n print ' 00%d %7.3f %7.3f' % (i+1,a,e)\",\n \"def separar_vardado(self,numvar=4):\\n c = 0\\n\\n for i in range(0,len(self.dado),numvar):\\n self.h.insert(c,self.dado[i])\\n \\n self.nO.insert(c,self.dado[i+1]*1e6)\\n self.nN2.insert(c,self.dado[i+2]*1e6) # O produto por 1e6 é para passar de cm^-3 para m^-3\\n self.nO2.insert(c,self.dado[i+3]*1e6)\\n \\n #print(c,self.h2[c],self.nN2[c],self.nO2[c],self.nO[c],\\\"\\\\n gv_MSISE\\\")\\n #print(\\\"\\\\n\\\",i,\\\"\\\\n\\\")\\n\\n c = c + 1\",\n \"def __numero_terme_sup(synthese, lg):\\n tb_synthese = []\\n for i in synthese:\\n synth = []\\n nu = 1\\n pteur = 1\\n for j in range(lg):\\n if i & pteur:\\n synth.append(nu)\\n nu += 1\\n pteur <<= 1\\n tb_synthese.append(synth)\\n return tb_synthese\",\n \"def pauta(lst_splen, lst_pauta):\\n\\n tmp=''\\n\\n #inicio do bloco \\n tmp+='\\\\t<story>\\\\n'\\n\\n for dicsp in lst_splen:\\n\\n #sessao plenaria\\n if dicsp['sessao']!=None:\\n tmp+='\\\\t\\\\t<para style=\\\"P0\\\">' + dicsp['sessao'].replace('&','&') +', EM ' + dicsp['datasessao'].replace('&','&')+ '</para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n if dicsp['ind_audiencia'] == 1:\\n tmp+='\\\\t\\\\t<para style=\\\"P1\\\"></para>\\\\n'\\n else:\\n tmp+='\\\\t\\\\t<para style=\\\"P1\\\">(Pauta da Ordem do Dia)</para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"12\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n\\n\\n #inicio do bloco que contem os flowables\\n \\n for dic in lst_pauta:\\n #espaco inicial\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"10\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n\\n #condicao para a quebra de pagina\\n tmp+='\\\\t\\\\t<condPageBreak height=\\\"5mm\\\"/>\\\\n'\\n\\n #pauta\\n if dic['num_ordem']!=None:\\n tmp+='\\\\t\\\\t<para style=\\\"P4\\\"><font color=\\\"#222\\\"><b>Item nº ' + str(dic['num_ordem']) + '</b></font></para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n if dic['id_materia']!=None:\\n if dic['cod_materia']!='':\\n tmp+='\\\\t\\\\t<para style=\\\"P4\\\"><b><font color=\\\"#126e90\\\"><u>' + dic['link_materia']+'</u></font> - '+ dic['nom_autor'] + '</b></para>\\\\n'\\n if dic['cod_parecer']!='': \\n tmp+='\\\\t\\\\t<para style=\\\"P4\\\"><b><font color=\\\"#126e90\\\"><u>' + dic['link_materia']+'</u></font> - '+ dic['nom_autor'] + ', que '+ dic['txt_materia'] + '</b></para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n if dic['txt_ementa']!=None:\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\">' + dic['txt_ementa'].replace('&','&') + '</para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n\\n if dic['des_turno']!='':\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\"><b>Turno</b>: '+ dic['des_turno'] +' | <b>Quorum</b>: '+ dic['des_quorum']+' | <b>Tipo de Votação</b>: '+ dic['tip_votacao'] + '' + '</para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"8\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n\\n if dic['parecer']!= 0 and dic['parecer']!= '':\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\"><b><u>PARECERES:</u></b></para>\\\\n\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n for item in dic['pareceres']:\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\"><b><font color=\\\"#126e90\\\">' + item[\\\"link_materia\\\"] + '</font> - ' + item[\\\"conclusao\\\"] + '</b> ' + item[\\\"relatoria\\\"] + '</para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n\\n if dic['substitutivo']!= 0 and dic['substitutivo']!= '':\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\"><b><u>SUBSTITUTIVOS:</u></b></para>\\\\n\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n' \\n for substitutivo in dic['substitutivos']:\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\"><b><font color=\\\"#126e90\\\">' + substitutivo[\\\"id_substitutivo\\\"] + '</font> - ' + substitutivo[\\\"autoria\\\"] + '</b> - ' + substitutivo[\\\"txt_ementa\\\"] + '</para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n\\n if dic['emenda']!= 0 and dic['emenda']!= '':\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\"><b><u>EMENDAS:</u></b></para>\\\\n\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n' \\n for emenda in dic['emendas']:\\n tmp+='\\\\t\\\\t<para style=\\\"P3\\\"><b><font color=\\\"#126e90\\\">' + emenda[\\\"id_emenda\\\"] + '</font> - ' + emenda[\\\"autoria\\\"] + '</b> - ' + emenda[\\\"txt_ementa\\\"] + '</para>\\\\n'\\n tmp+='\\\\t\\\\t<para style=\\\"P2\\\" spaceAfter=\\\"4\\\">\\\\n'\\n tmp+='\\\\t\\\\t\\\\t<font color=\\\"white\\\"> </font>\\\\n'\\n tmp+='\\\\t\\\\t</para>\\\\n'\\n return tmp\",\n \"def bolinish_alomatlari(son):\\n for n in range(1,11):\\n if not son % (n):\\n print(f\\\"{son} {n} ga qoldiqsiz bo'linadi \\\")\",\n \"def n_wyraz(a1,nr_wyrazu,r):\\n return a1+(nr_wyrazu-1)*r\",\n \"def reprographie():\\n nombreDePhotocopie = int(input(\\\"Entrez le nombre de photocopie a effectuer \\\"))\\n PREMIER_PRIX = 0.10\\n DEUXIEME_PRIX = 0.09\\n TROISIEME_PRIX = 0.08\\n PREMIERE_TRANCHE = 10\\n DEUXIEME_TRANCHE = 20\\n TROISIEME_TRANCHE = 30\\n resultat = 0\\n if(nombreDePhotocopie>TROISIEME_TRANCHE):\\n resultat = DEUXIEME_TRANCHE*DEUXIEME_PRIX+1+(nombreDePhotocopie-30)*TROISIEME_PRIX\\n elif(nombreDePhotocopie<=TROISIEME_TRANCHE):\\n if(nombreDePhotocopie/10>1):\\n resultat = (nombreDePhotocopie-10)*DEUXIEME_PRIX+(PREMIERE_TRANCHE*PREMIER_PRIX)\\n else:\\n resultat = nombreDePhotocopie*PREMIER_PRIX\\n return resultat\",\n \"def creer_jeu():\\r\\n jeu = []\\r\\n for i in range(1, 14):\\r\\n for j in range(1, 5):\\r\\n jeu.append((i, j))\\r\\n return jeu\",\n \"def numero_a_letras(n):\\n especiales = {0: 'cero', 10: 'diez', 11: 'once', 12: 'doce', 13: 'trece', 14: 'catorce', 15: 'quince', 20: 'veinte', 100: 'cien', 1000: 'mil'}\\n if n in especiales:\\n return especiales[n]\\n if n < 100:\\n cifras = ['', 'una', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve']\\n decenas = ['', 'dieci', 'veinti', 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta', 'noventa']\\n if n % 10 == 0:\\n return decenas[n // 10]\\n if n < 30:\\n return f\\\"{decenas[n // 10]}{cifras[n % 10]}\\\"\\n return f\\\"{decenas[n // 10]} y {cifras[n % 10]}\\\"\\n elif n < 1000:\\n centenas = ['', 'ciento', 'doscientas', 'trescientas', 'cuatrocientas', 'quinientas', 'seiscientas', 'setecientas', 'ochocientas', 'novecientas']\\n if n % 100 == 0:\\n return centenas[n // 100]\\n return f\\\"{centenas[n // 100]} {numero_a_letras(n % 100)}\\\"\\n elif n < 10**6:\\n if n < 2000:\\n return f\\\"mil {numero_a_letras(n % 1000)}\\\"\\n if n % 1000 == 0:\\n return f\\\"{numero_a_letras(n // 1000)} mil\\\"\\n return f\\\"{numero_a_letras(n // 1000)} mil {numero_a_letras(n % 1000)}\\\"\\n else:\\n raise ValueError(\\\"Numero demasiado grande\\\")\",\n \"def lateral_vazio_8(tab, jog):\\r\\n for x in [2,4,6,8]:\\r\\n if eh_posicao_livre(tab,x):\\r\\n return x\",\n \"def generar_polinomio(self):\\n\\t\\tself.poli = 0\\n\\t\\tfor i in range(len(self.v)):\\n\\t\\t\\tpoli2 = n(self.diferencias_divididas(self.v[0:i+1]))\\n\\t\\t\\tfor j in range(i):\\n\\t\\t\\t\\tpoli2 *= self.x-self.v[j][0]\\n\\t\\t\\tself.poli = self.poli + poli2\",\n \"def obter_posicoes_livres(tab):\\r\\n if not eh_tabuleiro(tab):\\r\\n raise ValueError('obter_posicoes_livres: o argumento e invalido') \\r\\n else: \\r\\n return tuple([i for i in range(1,10) if eh_posicao_livre(tab,i)])\",\n \"def mezclar_bolsa(self):\",\n \"def pentakis(self):\\n return self.nlegomena(5)\",\n \"def __init__(self,limite):\\n\\t\\tj = 0\\n\\t\\t\\\"\\\"\\\"definicion de variable j\\\"\\\"\\\"\\n\\t\\ti = float(3)\\n\\t\\t\\\"\\\"\\\"definicion de variable i-trasformacion del numero 3 en float\\\"\\\"\\\"\\n\\t\\tflag = False\\n\\t\\t\\\"\\\"\\\"definicion de bandera es False\\\"\\\"\\\"\\n\\t\\tpi = float(4)\\n\\t\\t\\\"\\\"\\\"tomar num para convertirla en float definicion en Pi\\\"\\\"\\\"\\n\\t\\tnround = self.Nround(limite)\\n\\t\\t\\\"\\\"\\\"de la clase , tomar el metodo Nround\\\"\\\"\\\"\\n\\t\\tprint \\\"It \\\\t\\\\t Num\\\"\\n\\t\\t\\\"\\\"\\\"Impresion con tabla con el It y Num\\\"\\\"\\\"\\n\\t\\twhile True:\\n\\t\\t\\t\\\"\\\"\\\"Mientras sea verdad se haga el ciclo\\\"\\\"\\\"\\n\\t\\t\\t#print \\\"--------------------------------\\\"\\n\\t\\t\\tif flag:\\n\\t\\t\\t\\t\\\"\\\"\\\"si bandera\\\"\\\"\\\"\\n\\t\\t\\t\\tpi = pi + (4/i)\\n\\t\\t\\t\\t\\\"\\\"\\\"Pi toma el valor de la operacion indicada\\\"\\\"\\\"\\n\\t\\t\\t\\tflag = False\\n\\t\\t\\t\\t\\\"\\\"\\\"La bandera toma el valor False\\\"\\\"\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\t\\\"\\\"\\\"Sino\\\"\\\"\\\"\\n\\t\\t\\t\\tpi = pi - (4/i)\\n\\t\\t\\t\\t\\\"\\\"\\\"Pi toma el valor de la operacion indicada\\\"\\\"\\\"\\n\\t\\t\\t\\tflag = True\\n\\t\\t\\t\\t\\\"\\\"\\\"La bandera toma el valor True\\\"\\\"\\\"\\n\\t\\t\\ti = i+2\\n\\t\\t\\t\\\"\\\"\\\"El contador aumenta en 2\\\"\\\"\\\"\\n\\t\\t\\tprint str(j)+\\\" \\\\t\\\\t \\\"+str(pi)\\n\\t\\t\\t\\\"\\\"\\\"Impresion de la variable j y pi tipo string\\\"\\\"\\\"\\n\\t\\t\\t#print round(pi,nround)\\n\\t\\t\\t#print limite\\n\\t\\t\\tif round(pi,nround) == limite:\\n\\t\\t\\t\\t\\\"\\\"\\\"Si el valor dado por pi y nround es igual a limite\\\"\\\"\\\"\\n\\t\\t\\t\\tprint pi\\n\\t\\t\\t\\t\\\"\\\"\\\"Imprime pi\\\"\\\"\\\"\\n\\t\\t\\t\\tprint \\\"Iteraciones: \\\" + str(j)\\n\\t\\t\\t\\t\\\"\\\"\\\"imprime el numero de Iteraciones con j convertirla en string\\\"\\\"\\\"\\n\\t\\t\\t\\tsys.exit();\\n\\t\\t\\t\\t\\\"\\\"\\\"invoca la salida\\\"\\\"\\\"\\n\\t\\t\\tj = j + 1\\n\\t\\t\\t\\\"\\\"\\\"asigna al acumulador uno mas\\\"\\\"\\\"\\n\\t\\t\\t#if j == 100:\\n\\t\\t\\t#\\tsys.exit();\",\n \"def bloqueio_de_bifurcacao_4(tab,jog): \\r\\n if len(bifurcacao_3(tab,-1*jog)) == 1 :\\r\\n return bifurcacao_3(tab,-1*jog)[0]\\r\\n else:\\r\\n for i in range(1,4):\\r\\n if obter_coluna(tab,i).count(jog)==1:\\r\\n col = obter_coluna(tab,i)\\r\\n for j in range(3):\\r\\n if col[j]==0:\\r\\n pos1=3*j+i\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n \\r\\n if obter_linha(tab,i).count(jog)==1:\\r\\n linha = obter_linha(tab,i)\\r\\n for j in range(3):\\r\\n if linha[j]==0:\\r\\n pos1=j+1+3*(i-1)\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n \\r\\n if i < 3 and obter_diagonal(tab,i).count(jog)==1:\\r\\n diagonal = obter_diagonal(tab,i)\\r\\n for j in range(3):\\r\\n if i==1:\\r\\n if diagonal[j]==0:\\r\\n pos1=4*j+i\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n else:\\r\\n if diagonal[j]==0:\\r\\n pos1=7-2*j\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\",\n \"def genera_vacios(lista_anidada):\\n lista_vacios = [ ]\\n letras = [\\\"A\\\",\\\"B\\\",\\\"C\\\",\\\"D\\\",\\\"E\\\",\\\"F\\\",\\\"G\\\",\\\"H\\\",\\\"I\\\",\\\"J\\\"]\\n\\n for n, x in enumerate(lista_anidada):\\n for i, y in enumerate(x):\\n if y == \\\"0\\\":\\n fila = letras[n]\\n lugar = str(i+1)\\n estacionamiento = fila,lugar\\n lista_vacios.append(\\\"\\\".join(estacionamiento))\\n return lista_vacios\",\n \"def verteileKarten(anzahlSpieler):\\n pass\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def preberi_pot(ukazi):\",\n \"def nr_pare(lista):\\n nr_elemente_pare = 0\\n for i in lista:\\n if i % 2 == 0:\\n nr_elemente_pare += 1\\n return nr_elemente_pare\",\n \"def plans():\",\n \"def obtener_preguntas_juego(num_preguntas=0, categ=\\\"none\\\", subcateg=\\\"none\\\", nivel=0):\\r\\n\\r\\n if not (is_categoria(categ)):\\r\\n categ = \\\"none\\\"\\r\\n\\r\\n preguntas_juego = [] # Lista preguntas juego\\r\\n\\r\\n if num_preguntas != 0:\\r\\n if categ == \\\"CM\\\":\\r\\n preguntas_archivo = arch.leer_archivo(\\\"Ciencias.txt\\\")\\r\\n renglones_preguntas = obtener_renglones(preguntas_archivo, subcateg, nivel)\\r\\n lista_aux = []\\r\\n while num_preguntas != 0:\\r\\n num_random = num_rand(0, len(preguntas_archivo))\\r\\n if num_random in renglones_preguntas:\\r\\n lista_aux = []\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 3))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 4))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 5))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 6))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 7))\\r\\n preguntas_juego.append(lista_aux)\\r\\n renglones_preguntas.remove(num_random)\\r\\n num_preguntas -= 1\\r\\n elif categ == \\\"SC\\\":\\r\\n preguntas_archivo = arch.leer_archivo(\\\"Sociales.txt\\\")\\r\\n renglones_preguntas = obtener_renglones(preguntas_archivo, subcateg, nivel)\\r\\n lista_aux = []\\r\\n while num_preguntas != 0:\\r\\n num_random = num_rand(0, len(preguntas_archivo))\\r\\n if num_random in renglones_preguntas:\\r\\n lista_aux = []\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 3))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 4))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 5))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 6))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 7))\\r\\n preguntas_juego.append(lista_aux)\\r\\n renglones_preguntas.remove(num_random)\\r\\n num_preguntas -= 1\\r\\n elif categ == \\\"CT\\\":\\r\\n preguntas_archivo = arch.leer_archivo(\\\"Cultura.txt\\\")\\r\\n renglones_preguntas = obtener_renglones(preguntas_archivo, subcateg, nivel)\\r\\n lista_aux = []\\r\\n while num_preguntas != 0:\\r\\n num_random = num_rand(0, len(preguntas_archivo))\\r\\n if num_random in renglones_preguntas:\\r\\n lista_aux = []\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 3))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 4))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 5))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 6))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 7))\\r\\n preguntas_juego.append(lista_aux)\\r\\n renglones_preguntas.remove(num_random)\\r\\n num_preguntas -= 1\\r\\n elif categ == \\\"ET\\\":\\r\\n preguntas_archivo = arch.leer_archivo(\\\"Entretenimiento.txt\\\")\\r\\n renglones_preguntas = obtener_renglones(preguntas_archivo, subcateg, nivel)\\r\\n lista_aux = []\\r\\n while num_preguntas != 0:\\r\\n num_random = num_rand(0, len(preguntas_archivo))\\r\\n if num_random in renglones_preguntas:\\r\\n lista_aux = []\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 3))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 4))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 5))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 6))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 7))\\r\\n preguntas_juego.append(lista_aux)\\r\\n renglones_preguntas.remove(num_random)\\r\\n num_preguntas -= 1\\r\\n elif categ == \\\"none\\\":\\r\\n preguntas_archivo = arch.leer_archivo(\\\"Ciencias.txt\\\")\\r\\n preguntas_archivo.extend(arch.leer_archivo(\\\"Sociales.txt\\\"))\\r\\n preguntas_archivo.extend(arch.leer_archivo(\\\"Cultura.txt\\\"))\\r\\n preguntas_archivo.extend(arch.leer_archivo(\\\"Entretenimiento.txt\\\"))\\r\\n renglones_preguntas = obtener_renglones(preguntas_archivo, nivel=nivel)\\r\\n lista_aux = []\\r\\n while num_preguntas != 0:\\r\\n num_random = num_rand(0, len(preguntas_archivo))\\r\\n if num_random in renglones_preguntas:\\r\\n lista_aux = []\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 3))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 4))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 5))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 6))\\r\\n lista_aux.append(arch.obtener_dato(preguntas_archivo, num_random, 7))\\r\\n preguntas_juego.append(lista_aux)\\r\\n renglones_preguntas.remove(num_random)\\r\\n num_preguntas -= 1\\r\\n \\r\\n return preguntas_juego\",\n \"def line_pack(plateau, num_lig, debut, sens):\\n if check_room(plateau,num_lig,debut) == False or (sens != 1 and sens != 0): # si plateau n est pas valide ou sens != 1 et 0\\n return \\\"Erreur !\\\"\\n if sens == 1:\\n i = debut # tasser a partie de i\\n while i <3:\\n set_value(plateau, num_lig, i, get_value(plateau, num_lig, i+1)) # remplacer la valeur avec la valeur suivant\\n i += 1\\n set_value(plateau, num_lig, i, 0)\\n else:\\n i = debut\\n while i > 0:\\n set_value(plateau, num_lig, i, get_value(plateau, num_lig, i-1)) # remplacer la valeur avec la valeur precedente\\n i -= 1\\n set_value(plateau, num_lig, i, 0)\",\n \"def chequear_movimientos(a):\\n\\n res = detectar_constantes_btc()\\n if res != 0 and a != 3 and a != 7 and a!= 8 and a != 12:\\n mail.resumen_alerta_btc(res)\\n a += 3\\n\\n res = detectar_constantes_doge()\\n if res != 0 and a != 4 and a != 7 and a != 9 and a != 12:\\n mail.resumen_alerta_doge(res)\\n a += 4\\n\\n res = detectar_constantes_eth()\\n if res != 0 and a != 5 and a != 9 and a != 8 and a != 12:\\n mail.resumen_alerta_eth(res)\\n a += 5\\n return a\",\n \"def limite(tam_palavra):\\n return tam_palavra\",\n \"def limite(tam_palavra):\\n return tam_palavra\",\n \"def limite(tam_palavra):\\n return tam_palavra\",\n \"def create_numbers_table():\\n work_tuples = parse_columns()\\n print('\\\\n\\\\n\\\\n ----- Tableau récapitulatif -----')\\n print('-----------------------')\\n for ii in work_tuples:\\n line = '|'\\n for ij in ii:\\n line += ' ij |'\\n print(line)\\n print('-----------------------')\",\n \"def celex_pron_loc(language, lemma):\\n pron = 5\\n if language == \\\"german\\\" or language== \\\"dutch\\\": pron = pron -2 #german one less\\n if lemma == \\\"wordform\\\": pron += 1\\n return pron\",\n \"def entrenamiento(self,cantidad_autovectores,porcentaje_prueba):\\n self.gestor_muestra.cargar(porcentaje_prueba)\\n self.gestor_pca.entrenamiento(self.gestor_muestra.muestra,cantidad_autovectores)\\n sujeto=[]\\n aciertos=0\\n for i in self.gestor_muestra.muestra.sujetos:\\n sujeto.append([i.nombre,0,0,0,0,0,0])\\n cant_muestras = 0\\n for i in self.gestor_muestra.muestra.sujetos:\\n \\n for j in i.imagenes_prueba:\\n cant_muestras+=1\\n x,y,z=self.gestor_pca.identificacion_sujeto(j)\\n if i.nombre == y:\\n \\n sujeto[int(i.nombre[1:])-1][3]+=1\\n aciertos+=1\\n else:\\n sujeto[int(i.nombre[1:])-1][1]+=1\\n sujeto[int(y[1:])-1][2]+=1\\n\\n for i in sujeto:\\n \\n try:\\n i[4]=i[3]/(i[3]+i[1])\\n except:\\n i[4]=None\\n \\n try:\\n i[5]=i[3]/(i[3]+i[2])\\n except:\\n i[5]=None\\n \\n try:\\n i[6]=(2*i[5]*i[4])/(i[4]+i[5])\\n except:\\n i[6]=None\\n \\n return sujeto\",\n \"def est_magique(n: int, grille: list) -> bool:\\n somme = sum(grille[0]) # la somme de la première ligne\\n # les autres lignes ?\\n if any(sum(ligne) != somme\\n for ligne in grille):\\n return False\\n # les autres colonnes ?\\n if any(sum(grille[i][j] for i in range(n)) != somme\\n for j in range(n)):\\n return False\\n # les diagonales ?\\n if sum(grille[i][i] for i in range(n)) != somme:\\n return False\\n if sum(grille[i][-i-1] for i in range(n)) != somme:\\n return False\\n # tous les nombres de 1 à n² sont-ils présents ?\\n # On enlève 1, pour un indice dans un tableau\\n n_carré = n * n\\n déjà_vu = [False for _ in range(n_carré)]\\n for i in range(n):\\n for j in range(n):\\n if 0 < grille[i][j] <= n_carré:\\n if déjà_vu[grille[i][j] - 1]:\\n return False\\n déjà_vu[grille[i][j] - 1] = True\\n else:\\n return False\\n # Alors tout est bon, le carré est magique\\n return True\",\n \"def __init__(self):\\n self.nombre_roues = 4\\n self.nombre_fauteils = 1\\n self.moteur = False\\n self.volant = True\",\n \"def tabelaOrareve():\\n \\n linja = 1\\n kpm = \\\"3\\\"\\n\\n #print(f\\\"linja {oraret['linja1']} mberrin ne {kpm} minuta\\\")\\n print(f\\\"Oraret per linjen 1 :\\\\n {oraret['linja1']}\\\\n, {oraret['linja2']}\\\\n, {oraret['linja3']}\\\\n\\\")\",\n \"def get_puzzel(size, puz) :\\n if (len(puz)!= size) :\\n print(\\\"Error : Size given and the size of the puzzle doesn't concorde\\\\nThe puzzle is not well formatted.. ciao\\\")\\n exit()\\n else :\\n lst_ret = []\\n for i in puz:\\n line = list(filter(None, re.split(r'\\\\n| ', i)))\\n if (len (line) == size) :\\n for j in line :\\n temp_val = check_int(j)\\n if (temp_val < size ** 2):\\n if (temp_val not in lst_ret) :\\n lst_ret.append(temp_val)\\n else :\\n print(\\\"Error : Duplicate element in the puzzle [{}]\\\".format(temp_val))\\n exit()\\n else :\\n print(\\\"Error : Element in the puzzle is too large [{}] size^2 [{}]\\\".format(temp_val, size**2))\\n exit()\\n else :\\n print(\\\"Error: Puzzle not well formatted [{}] should be {} elements, ciao \\\".format(line, size))\\n exit()\\n return (lst_ret)\",\n \"def terning(antal_kast): #Definere en funktion der tager 1 argument\\n import random # importere random pakken til at generere tal\\n for i in range(antal_kast): #kører et loop de antal gange specificeret i argumentet\\n x = random.random()# generere et tal mellem 0 og 1 (er inde i parrentesen for at hver kast bliver forskelligt)\\n if x < 1/6:\\n print(1)\\n elif x < 2/6:\\n print(2)\\n elif x < 3/6:\\n print(3)\\n elif x < 4/6:\\n print(4)\\n elif x < 5/6:\\n print(5)\\n else:\\n print(6)\",\n \"def centro_5(tab, jog):\\r\\n if eh_posicao_livre(tab, 5):\\r\\n return 5\",\n \"def gerarPalavraSecreta():\\n global palavraOculta\\n for _ in range(len(palavraDoJogo)):\\n palavraOculta += '*'\\n print(palavraOculta)\",\n \"def borrosificador(x):\\n pos = []\\n vel = []\\n sup = support() # obtengo los soportes de los conjuntos borrosos\\n\\n med_pos_N = (sup[1][1] + sup[1][0]) * 0.3 / 2\\n med_pos_P = (sup[3][1] + sup[3][0]) * 0.3 / 2\\n\\n med_vel_N = (sup[6][1] + sup[6][0]) * 0.7 / 2\\n med_vel_P = (sup[8][1] + sup[8][0]) * 0.7 / 2\\n\\n # -------------------------------------------------\\n # - VALORES DE LA PARTICION BORROSA POSICION -\\n # -------------------------------------------------\\n\\n pos.append(membership(x[0], sup[0], 0, -1))\\n pos.append(membership(x[0], sup[1], med_pos_N))\\n pos.append(membership(x[0], sup[2]))\\n pos.append(membership(x[0], sup[3], med_pos_P))\\n pos.append(membership(x[0], sup[4], 0, 1))\\n\\n # -------------------------------------------------\\n # - VALORES DE LA PARTICION BORROSA VELOCIDAD -\\n # -------------------------------------------------\\n\\n vel.append(membership(x[1], sup[5], 0, -1))\\n vel.append(membership(x[1], sup[6], med_vel_N))\\n vel.append(membership(x[1], sup[7]))\\n vel.append(membership(x[1], sup[8], med_vel_P))\\n vel.append(membership(x[1], sup[9], 0, 1))\\n\\n return pos + vel\",\n \"def mejor_ajuste(memoria, procesos):\\n\\n no_colocados = [] # Procesos que no se pudieron colocar en la memoria\\n\\n for proc in procesos:\\n exito = False\\n menor_desperdicio = None # Posición de la partición que produce menor\\n # desperdicio.\\n \\n for part in memoria:\\n if part[1] == None and part[0] >= proc[1]:\\n if menor_desperdicio == None:\\n menor_desperdicio = memoria.index(part)\\n elif part[0] - proc[1] < memoria[menor_desperdicio][0] - proc[1]:\\n menor_desperdicio = memoria.index(part)\\n\\n exito = True\\n\\n if exito:\\n memoria[menor_desperdicio][1] = proc[0]\\n else:\\n no_colocados.append(proc[0])\\n\\n return memoria, no_colocados\",\n \"def prueba_descenso_colinas(problema=ProblemaNreinas(8), repeticiones=10):\\n start = time.time()\\n print(\\\"\\\\n\\\\n\\\" + \\\"intento\\\".center(10) +\\n \\\"estado\\\".center(60) + \\\"costo\\\".center(10))\\n for intento in range(repeticiones):\\n solucion = blocales.descenso_colinas(problema)\\n print(str(intento).center(10) +\\n str(solucion).center(60) +\\n str(problema.costo(solucion)).center(10))\\n end = time.time()\\n print(\\\"Segundos..: \\\" + str(end - start))\",\n \"def showm():\\n def show1(i):\\n coeff=[]\\n for m in range(5):\\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.Constants.m%d' % (i+1,m+1) ,qmax_)\\n coeff.append(a)\\n for o in range(3):\\n a=SAC.queryDouble('carma.Ovro%d.Drive.Point.Constants.o%d' % (i+1,o+1) ,qmax_)\\n coeff.append(a)\\n return coeff\\n print ' ant m1 m2 m3 m4 m5 o1 o2 o3'\\n for i in range(6):\\n m = show1(i)\\n print ' 00%d %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f' % (i+1,m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7])\",\n \"def incarcaPieseMozaic(params):\\n \\n print('Incarcam piesele pentru mozaic din director.')\\n\\n pieseMozaic = []\\n # for img_path in sorted(glob.glob(params.numeDirector\\n # + '*.'\\n # + params.tipImagine),\\n # key=lambda name: int(name[len(params.numeDirector)\\n # :-4])):\\n for img_path in glob.glob(params.numeDirector\\n + '*.'\\n + params.tipImagine):\\n img = cv2.imread(img_path)\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n pieseMozaic.append(img)\\n pieseMozaic = np.array(pieseMozaic)\\n\\n if params.afiseazaPieseMozaic:\\n # afiseaza primele 100 de piese ale mozaicului\\n if pieseMozaic.shape[0] < 100:\\n raise Exception(\\\"Numarul de piese este mai mic decat 100!\\\")\\n\\n plt.figure()\\n plt.suptitle('Primele 100 de piese ale mozaicului sunt:')\\n idxImg = 0\\n for i in range(10):\\n for j in range(10):\\n idxImg += 1\\n plt.subplot(10, 10, idxImg)\\n plt.axis('off')\\n plt.imshow(pieseMozaic[idxImg - 1])\\n\\n plt.show()\\n\\n # gray image\\n if params.imgReferinta.shape[2] == 1:\\n pieseMozaicG = []\\n for i in range(pieseMozaic.shape[0]):\\n img = cv2.cvtColor(pieseMozaic[i], cv2.COLOR_RGB2GRAY)\\n img = img[:, :, None]\\n pieseMozaicG.append(img)\\n pieseMozaicG = np.array(pieseMozaicG)\\n params.pieseMozaic = pieseMozaicG\\n else:\\n params.pieseMozaic = pieseMozaic\\n\\n if params.hexagon == 1:\\n params = getHexagonMatrix(params,\\n pieseMozaic[0].shape[0],\\n pieseMozaic[0].shape[1])\\n\\n return params\",\n \"def primer_ajuste(memoria, procesos):\\n\\n no_colocados = [] # Procesos que no se pudieron colocar en la memoria\\n\\n for proc in procesos:\\n exito = False\\n \\n for part in memoria:\\n if part[1] == None and part[0] >= proc[1]:\\n part[1] = proc[0]\\n exito = True\\n break\\n\\n if not exito:\\n no_colocados.append(proc[0])\\n\\n return memoria, no_colocados\",\n \"def testEjemploTp(self):\\n azul = [0, 4, 5, 0]\\n rojo = [1, 7, 4, 0]\\n amarillo = [3, 6, 8, 0]\\n negro = [6, 10, 10, 0]\\n magenta = [7, 8, 12, 0]\\n verde = [9, 11, 11, 0]\\n perfiles = []\\n perfiles.append(azul)\\n perfiles.append(rojo)\\n perfiles.append(amarillo)\\n perfiles.append(negro)\\n perfiles.append(magenta)\\n perfiles.append(verde)\\n perfil = Perfil.Perfil()\\n resultadoEsperado = [0, 4, 1, 7, 4, 6, 6, 10, 9, 11, 11, 8, 12]\\n for x in range(10000):\\n inicial = random_integers(6, 0)\\n inicial = inicial*4\\n perfilOriginal = []\\n for i in range (inicial, len(perfiles)+inicial, 1):\\n perfilOriginal += perfiles[i%len(perfiles)]\\n \\n resultado = perfil.calcularPerfil(perfilOriginal, 0)\\n self.assertEqual(resultadoEsperado, resultado)\",\n \"def sema(self):\\n ...\",\n \"def truncatable_primes():\\n list_tp = []\\n i = 8\\n while len(list_tp) < 11:\\n if is_truncatable(i):\\n list_tp.append(i)\\n i += 1\\n if i % 100 == 0:\\n print(\\\"i : \\\", i)\\n return list_tp, sum(list_tp)\",\n \"def francois_viete():\\n\\n print(\\\"Francois Viete\\\\n==============\\\")\\n\\n iterations = 28 # 28 to 1000000000 makes no diff\\n numerator = 0.0\\n pi = 1.0\\n\\n for i in range(1, iterations + 1):\\n numerator = math.sqrt(2.0 + numerator)\\n pi*= (numerator / 2.0)\\n \\n pi = (1.0 / pi) * 2.0\\n\\n print(\\\"iterations: \\\" + str(iterations))\\n print_as_text(pi)\",\n \"def iniciarjuego():\\r\\n for i in range(4):\\r\\n if i == 1 or i == 0:\\r\\n color = (250,208,120,98)\\r\\n else:\\r\\n color = (159, 250, 120,98)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujarcuadrados(x, color)\\r\\n cuadrados.remove(x)\\r\\n\\r\\n for i in range(4):\\r\\n if i == 0 or i == 1:\\r\\n color = (195, 139, 255,100)\\r\\n else:\\r\\n color = (250, 242, 120,98)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujarcirculos(x, color)\\r\\n cuadrados.remove(x)\\r\\n\\r\\n for i in range(4):\\r\\n if i == 0 or i == 1:\\r\\n color = (250, 145, 137,98)\\r\\n else:\\r\\n color = (126, 139, 250,98)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujartriangulos(x, color)\\r\\n cuadrados.remove(x)\\r\\n\\r\\n for i in range(4):\\r\\n if i == 0 or i == 1:\\r\\n color = (176, 255, 237,100)\\r\\n else:\\r\\n color = (255, 176, 228,100)\\r\\n x = random.choice(cuadrados)\\r\\n listafiguras.append(x)\\r\\n dibujardiamantes(x, color)\\r\\n cuadrados.remove(x)\",\n \"def peor_ajuste(memoria, procesos):\\n\\n no_colocados = [] # Procesos que no se pudieron colocar en la memoria\\n\\n for proc in procesos:\\n exito = False\\n mayor_desperdicio = None # Posición de la partición que produce mayor\\n # desperdicio.\\n \\n for part in memoria:\\n if part[1] == None and part[0] >= proc[1]:\\n if mayor_desperdicio == None:\\n mayor_desperdicio = memoria.index(part)\\n elif part[0] - proc[1] > memoria[mayor_desperdicio][0] - proc[1]:\\n mayor_desperdicio = memoria.index(part)\\n\\n exito = True\\n\\n if exito:\\n memoria[mayor_desperdicio][1] = proc[0]\\n else:\\n no_colocados.append(proc[0])\\n\\n return memoria, no_colocados\",\n \"def calcular_tres_marcas_menor_produccion(lista):\\r\\n lista_ordenada_menor_a_mayor = ordenar_lista_menor_a_mayor_produccion(lista)\\r\\n lista_marcas_menor_produccion = []\\r\\n for i in range(3):\\r\\n lista_marcas_menor_produccion.append(lista_ordenada_menor_a_mayor[i][0])\\r\\n \\r\\n return lista_marcas_menor_produccion\",\n \"def creeFichierInstancePourcentage(nomFichier, pourcentage):\\n if not os.path.isdir(\\\"./Instances\\\"):\\n os.mkdir(\\\"./Instances\\\")\\n \\n n = 0\\n cpt = 0\\n with open(nomFichier, \\\"r\\\") as s:\\n with open(\\\"temp.txt\\\", \\\"w\\\") as f:\\n premiereLigne = s.readline().split()\\n nbRangees = int(int(premiereLigne[0])*int(pourcentage)/100)\\n premiereLigne[0] = int(nbRangees)\\n premiereLigne[3] = int(int(premiereLigne[3])*int(pourcentage)/100)\\n premiereLigne[4] = int(int(premiereLigne[4])*int(pourcentage)/100)\\n while(n<int(premiereLigne[2])):\\n n=n+1\\n ligne = s.readline()\\n ligne1 = ligne.split()\\n if(int(ligne1[0])<nbRangees):\\n f.write(ligne)\\n cpt = cpt+1\\n \\n premiereLigne[2] = cpt\\n premiereLigneBis = map(str, premiereLigne) \\n premiereLigneBis = ' '.join(premiereLigneBis) \\n f.close()\\n \\n with open(str(\\\"Instances/\\\"+nomFichier.split('.')[0])+'_'+str(pourcentage)+\\\".txt\\\",\\\"w\\\") as k:\\n k.write(premiereLigneBis+'\\\\n')\\n with open(\\\"temp.txt\\\", \\\"r\\\") as f:\\n k.write(f.read())\\n f.close()\\n n=0\\n while(n<premiereLigne[4]):\\n n=n+1\\n k.write(s.readline())\\n \\n k.close()\\n s.close()\\n \\n return str(\\\"Instances/\\\"+nomFichier.split('.')[0])+'_'+str(pourcentage)+\\\".txt\\\"\",\n \"def obtenerTabla(numero, limite):\\n\\tcontador = 1\\n\\tcadena = \\\"\\\"\\n\\t# tambien se puede utilizar un for \\n\\twhile contador <= limite:\\n\\t\\tmultiplicacion = numero + contador\\n\\t\\tcadena = \\\"%s%d * %d = %d\\\\n\\\" % (cadena, numero, contador, multiplicacion) \\n\\t\\tcontador = contador + 1 \\n\\t\\t\\n\\treturn cadena\",\n \"def terning2(antal_kast): #Definere en funktion der tager 1 argument\\n import random # importere random pakken til at generere tal\\n values = []\\n for i in range(antal_kast): #kører et loop de antal gange specificeret i argumentet\\n x = random.random()# generere et tal mellem 0 og 1 (er inde i parrentesen for at hver kast bliver forskelligt)\\n if x < 1/6:\\n values.append(1)\\n elif x < 2/6:\\n values.append(2)\\n elif x < 3/6:\\n values.append(3)\\n elif x < 4/6:\\n values.append(4)\\n elif x < 5/6:\\n values.append(5)\\n else:\\n values.append(6)\\n return(values)\",\n \"def affichePosition(position):\\n print('* * * * * * * * * * * * * * * * * * * *')\\n n = position['taille']\\n buffer = 'col:'\\n for i in range(0,n):\\n buffer += ' ' + str(i+1) + ' \\\\t'\\n print(buffer)\\n print('\\\\t\\\\tNORD (prises: '+str(position['graines']['NORD'])+')')\\n print('< - - - - - - - - - - - - - - -')\\n buffer = ''\\n for i in range(2*n-1,n-1,-1): # indices n..(2n-1) pour les cases NORD\\n buffer += '\\\\t[' + str(position['tablier'][i]) + ']'\\n print(buffer)\\n buffer = ''\\n for i in range(0,n): # indices 0..(n-1) pour les cases SUD\\n buffer += '\\\\t[' + str(position['tablier'][i]) + ']'\\n print(buffer)\\n print('- - - - - - - - - - - - - - - >')\\n print('\\\\t\\\\tSUD (prises: '+str(position['graines']['SUD'])+')')\\n print('-> camp au trait: '+position['trait']);\",\n \"def __init__(self, noms_joueurs, nb_human=0, nb_ai=0, ):\\n self.nb_joueurs = nb_human + nb_ai\\n #assert self.nb_joueurs >= 2\\n self.nb_human = nb_human\\n self.joueurs = [Joueur(str(noms_joueurs[i])) for i in range(nb_human)]\\n\\n if nb_ai > 0:\\n for i in range(nb_ai):\\n self.joueurs.append(JoueurAlgo(str(noms_joueurs[nb_human+i])))\\n\\n self.nb_jetons_du_pot = NOMBRE_DE_JETONS_DU_JEU\\n self.premier = 0\\n self.joueur_courant = None\\n self.phase = 0\\n self.nb_maximum_lancer = 3\\n self.end_tour = False\",\n \"def affichage_creation_tournoi():\\n nom = \\\"\\\"\\n lieu = \\\"\\\"\\n date = \\\"\\\"\\n nb_tours = 4\\n joueurs = []\\n temps = \\\"\\\"\\n note = \\\"\\\"\\n\\n print(\\\"\\\\n---------------------------\\\")\\n while len(nom) == 0:\\n try:\\n nom = str(input(\\\"\\\\nNom : \\\"))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi un nom valide.\\\")\\n sl(2)\\n continue\\n\\n print(\\\"\\\\n---------------------------\\\")\\n while len(lieu) == 0:\\n try:\\n lieu = str(input(\\\"\\\\nLieu : \\\"))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi un lieu valide.\\\")\\n sl(2)\\n continue\\n\\n print(\\\"\\\\n---------------------------\\\")\\n while len(date) == 0:\\n try:\\n date = str(input(\\\"\\\\nDate\\\\nFormat : jj/mm/aaaa : \\\"))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi une date valide.\\\")\\n sl(2)\\n continue\\n test_date = OutilsControleurs.test_date(date)\\n if test_date == 0:\\n print(\\\"\\\\nVous avez saisi une valeur trop grande.\\\")\\n date = \\\"\\\"\\n if test_date == 1:\\n print(\\\"\\\\nVous avez saisi une valeur trop petite.\\\")\\n date = \\\"\\\"\\n if test_date == 2:\\n break\\n if test_date == 3:\\n print(\\\"\\\\nVous avez saisi un format de date incorrect.\\\")\\n date = \\\"\\\"\\n\\n print(\\\"\\\\n---------------------------\\\")\\n nb_tours_modif = \\\"\\\"\\n while nb_tours_modif != 2 or nb_tours_modif != 1:\\n try:\\n print(\\\"\\\\nNombre de tours\\\\nPar default le nombre est de 4\\\\nVoulez-vous modifier cette valeur ?\\\")\\n nb_tours_modif = int(input(\\\"\\\\n1 - Oui\\\\n2 - Non\\\\n\\\\nVotre choix: \\\"))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi un nombre valide.\\\")\\n sl(2)\\n continue\\n if nb_tours_modif == 1:\\n while nb_tours == 4:\\n try:\\n nb_tours = int(input(\\\"\\\\nNombre de tours : \\\"))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi un nombre valide.\\\")\\n sl(2)\\n continue\\n if nb_tours == 4:\\n break\\n break\\n if nb_tours_modif == 2:\\n break\\n\\n print(\\\"\\\\n---------------------------\\\\n\\\\nListe des joueurs :\\\\n\\\")\\n liste_joueurs_tournois = Joueur.joueurs_tournoi()\\n if liste_joueurs_tournois == 0:\\n print(\\\"Il n'y a pas ou pas suffisament de joueurs pour organiser un tounois.\\\")\\n print(\\\"Veuillez ajouter des joueurs via le menu.\\\")\\n input(\\\"\\\\nAppuyer sur entrer pour continuer\\\")\\n return\\n\\n for arg in liste_joueurs_tournois:\\n print(arg)\\n x = 8\\n while x != 0:\\n try:\\n joueur = int(input(\\\"Saisir encore {} indice de joueurs : \\\".format(x)))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi un indice valide.\\\")\\n sl(2)\\n continue\\n if joueur > 0 and joueur <= len(liste_joueurs_tournois):\\n if joueur not in joueurs:\\n joueurs.append(joueur)\\n else:\\n print(\\\"Vous avez deja saisi ce joueur.\\\")\\n x += 1\\n else:\\n x += 1\\n x -= 1\\n\\n y = 1\\n nom_joueurs = []\\n for arg in liste_joueurs_tournois:\\n arg = arg[:-15]\\n nom_joueurs.append(str(arg).replace(\\\"Indice joueur : {}\\\\n \\\".format(y), \\\"\\\").replace(\\\"\\\\n \\\", \\\"\\\"))\\n y += 1\\n joueurs = Joueur.get_joueurs_tournoi(joueurs, nom_joueurs)\\n\\n print(\\\"\\\\n---------------------------\\\")\\n temps_choix = 0\\n while temps_choix != 1 or temps_choix != 2 or temps_choix != 3:\\n try:\\n temps_choix = int(input(\\\"\\\\nContrôle de temps\\\\n1 - Bullet\\\\\\n \\\\n2 - Blitz\\\\n3 - Coup rapide\\\\n\\\\nVotre choix : \\\"))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi une valeur valide.\\\")\\n sl(2)\\n continue\\n if temps_choix == 1:\\n temps = \\\"Bullet\\\"\\n break\\n if temps_choix == 2:\\n temps = \\\"Blitz\\\"\\n break\\n if temps_choix == 3:\\n temps = \\\"Coup rapide\\\"\\n break\\n\\n print(\\\"\\\\n---------------------------\\\")\\n while len(note) == 0:\\n try:\\n note = str(input(\\\"\\\\nDescription : \\\"))\\n except ValueError:\\n print(\\\"\\\\nVous n'avez pas saisi une valeur valide.\\\")\\n sl(2)\\n continue\\n if len(note) == 0:\\n break\\n return nom, lieu, date, nb_tours, joueurs, temps, note\",\n \"def lines_move(plateau, sens):\\n if sens != 0 and sens != 1:\\n return \\\"Erreur !\\\"\\n if sens == 1:\\n for j in range(0, 4): # ligne de 0 a 4\\n line_move(plateau, j ,sens)\\n else:\\n for j in range(0, 4): # ligne de 0 a 4\\n line_move(plateau, j ,sens)\",\n \"def SetMoneda(num, simbolo=\\\"$\\\", n_decimales=2):\\n #con abs, nos aseguramos que los dec. sea un positivo.\\n n_decimales = abs(n_decimales)\\n\\n #se redondea a los decimales idicados.\\n num = round(num, n_decimales)\\n\\n #se divide el entero del decimal y obtenemos los string\\n num, dec = str(num).split(\\\".\\\")\\n\\n #si el num tiene menos decimales que los que se quieren mostrar,\\n #se completan los faltantes con ceros.\\n dec += \\\"0\\\" * (n_decimales - len(dec))\\n\\n #se invierte el num, para facilitar la adicion de comas.\\n num = num[::-1]\\n\\n #se crea una lista con las cifras de miles como elementos.\\n l = [num[pos:pos+3][::-1] for pos in range(0,50,3) if (num[pos:pos+3])]\\n l.reverse()\\n\\n #se pasa la lista a string, uniendo sus elementos con comas.\\n num = str.join(\\\",\\\", l)\\n\\n #si el numero es negativo, se quita una coma sobrante.\\n try:\\n if num[0:2] == \\\"-,\\\":\\n num = \\\"-%s\\\" % num[2:]\\n except IndexError:\\n pass\\n\\n #si no se especifican decimales, se retorna un numero entero.\\n if not n_decimales:\\n return \\\"%s %s\\\" % (simbolo, num)\\n\\n return \\\"%s %s.%s\\\" % (simbolo, num, dec)\",\n \"def __init__(self, lista_enlazada): \\n\\t\\tself.lista = lista_enlazada\\n\\t\\tself.anterior = None\\n\\t\\tself.actual = lista_enlazada.prim\\n\\t\\tself.pila_anteriores = Pila()\\n\\t\\tself.posicion = 0\",\n \"def solution(self):\\n return [(\\\"the\\\", 1561900)] * 100\",\n \"def preberi_pot(ukazi):\\r\\n x_k = 0\\r\\n y_k = 0\\r\\n\\r\\n p = 1\\r\\n pot = []\\r\\n pot += (0, 0),\\r\\n\\r\\n ukazi = ukazi.split('\\\\n')\\r\\n\\r\\n for m in ukazi:\\r\\n\\r\\n if m == \\\"DESNO\\\":\\r\\n if p == 1:\\r\\n p = 4\\r\\n else:\\r\\n p -= 1\\r\\n elif m == \\\"LEVO\\\":\\r\\n if p == 4:\\r\\n p = 1\\r\\n else:\\r\\n p += 1\\r\\n elif m.isalnum():\\r\\n if p == 3:\\r\\n y_k += int(m)\\r\\n elif p == 4:\\r\\n x_k += int(m)\\r\\n elif p == 1:\\r\\n y_k -= int(m)\\r\\n elif p == 2:\\r\\n x_k -= int(m)\\r\\n pot += (x_k, y_k),\\r\\n\\r\\n return pot\",\n \"def escolher_posicao_auto(tab, jog, str1):\\r\\n if not eh_tabuleiro(tab) or not (jog in [-1,1] and type(jog)==int) or not (str1 in ['basico','normal','perfeito'] and type(str1)==str):\\r\\n raise ValueError('escolher_posicao_auto: algum dos argumentos e invalido') \\r\\n else:\\r\\n \\r\\n #vitoria_1: tabuleiro X inteiro -> posicao\\r\\n \\r\\n def vitoria_1(tab,jog):\\r\\n \\\"\\\"\\\"\\r\\n vitoria_1 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o jogador tiver duas\\r\\n das suas pecas em linha e uma posicao livre entao retorna essa posicao livre.\\r\\n \\\"\\\"\\\"\\r\\n for i in range(1,4):\\r\\n win = [(0,jog,jog), (jog,0,jog), (jog,jog,0)]\\r\\n coluna = obter_coluna(tab, i)\\r\\n linha = obter_linha(tab, i) \\r\\n if coluna in win:\\r\\n return i+3*win.index(coluna)\\r\\n elif linha in win:\\r\\n return 3*i-2+win.index(linha) \\r\\n if i!=3:\\r\\n diagonal = obter_diagonal(tab, i)\\r\\n if diagonal in win:\\r\\n if i==1:\\r\\n return i+4*win.index(diagonal)\\r\\n\\r\\n else:\\r\\n return 7-2*win.index(diagonal)\\r\\n \\r\\n #bloqueio_2: tabuleiro X inteiro -> posicao \\r\\n \\r\\n def bloqueio_2(tab,jog):\\r\\n \\\"\\\"\\\"\\r\\n bloqueio_2 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o adversario tiver duas\\r\\n das suas pecas em linha e uma posicao livre entao retorna essa posicao livre.\\r\\n \\\"\\\"\\\"\\r\\n jog*=-1\\r\\n return vitoria_1(tab,jog) \\r\\n \\r\\n #bifurcacao_3: tabuleiro X inteiro -> lista de posicoes\\r\\n \\r\\n def bifurcacao_3(tab, jog):\\r\\n \\\"\\\"\\\"\\r\\n bifurcacao_3 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o jogador tiver duas\\r\\n linhas/colunas/diagonais que se intersectam, onde cada uma contem uma das\\r\\n suas pecas entao retorna uma lista com todas as posicoes de intersecao \\r\\n (criando duas formas de vencer na jogada seguinte).\\r\\n \\\"\\\"\\\"\\r\\n pos = []\\r\\n for i in range(1,4):\\r\\n for j in range(1,4):\\r\\n if obter_coluna(tab,i).count(jog)==1 and obter_linha(tab,j).count(jog)==1 and eh_posicao_livre(tab, i+3*j-3):\\r\\n pos+=[i+3*j-3]\\r\\n for k in range(1,3):\\r\\n if k==1:\\r\\n if obter_coluna(tab,i).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 1+4*(i-1)):\\r\\n pos+=[1+4*(i-1)]\\r\\n if obter_linha(tab,j).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 1+4*(i-1)):\\r\\n pos+=[1+4*(i-1)]\\r\\n if obter_diagonal(tab,1).count(jog)==1 and obter_diagonal(tab,2).count(jog)==1 and eh_posicao_livre(tab, 5):\\r\\n pos+=[5]\\r\\n if k==2:\\r\\n if obter_coluna(tab,i).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 7-2*(i-1)):\\r\\n pos+=[7-2*(i-1)]\\r\\n if obter_linha(tab,j).count(jog)==1 and obter_diagonal(tab,1).count(jog)==1 and eh_posicao_livre(tab, 3+2*(i-1)):\\r\\n pos+=[3+2*(i-1)] \\r\\n return pos\\r\\n \\r\\n #bloqueio_de_bifurcacao_4: tabuleiro X inteiro -> posicao\\r\\n \\r\\n def bloqueio_de_bifurcacao_4(tab,jog): \\r\\n \\\"\\\"\\\"\\r\\n bloqueio_de_bifurcacao_4 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o adversario tiver apenas uma bifurcacao\\r\\n entao retorna a posicao de bloqueio dessa bifurcacao, caso contrario, retorna a posicao\\r\\n em que se cria um dois em linha para forcar o oponente a defender, desde que a defesa nao\\r\\n resulte na criacao de uma bifurcacao para o oponente.\\r\\n \\\"\\\"\\\" \\r\\n if len(bifurcacao_3(tab,-1*jog)) == 1 :\\r\\n return bifurcacao_3(tab,-1*jog)[0]\\r\\n else:\\r\\n for i in range(1,4):\\r\\n if obter_coluna(tab,i).count(jog)==1:\\r\\n col = obter_coluna(tab,i)\\r\\n for j in range(3):\\r\\n if col[j]==0:\\r\\n pos1=3*j+i\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n \\r\\n if obter_linha(tab,i).count(jog)==1:\\r\\n linha = obter_linha(tab,i)\\r\\n for j in range(3):\\r\\n if linha[j]==0:\\r\\n pos1=j+1+3*(i-1)\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n \\r\\n if i < 3 and obter_diagonal(tab,i).count(jog)==1:\\r\\n diagonal = obter_diagonal(tab,i)\\r\\n for j in range(3):\\r\\n if i==1:\\r\\n if diagonal[j]==0:\\r\\n pos1=4*j+i\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1\\r\\n else:\\r\\n if diagonal[j]==0:\\r\\n pos1=7-2*j\\r\\n newtab = marcar_posicao(tab, jog, pos1)\\r\\n if len(bifurcacao_3(newtab,-1*jog)) == 0:\\r\\n return pos1 \\r\\n \\r\\n #centro_5: tabuleiro X inteiro -> posicao\\r\\n \\r\\n def centro_5(tab, jog):\\r\\n \\\"\\\"\\\"\\r\\n centro_5 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e devolve a posicao\\r\\n central (5) no caso da mesma estar livre.\\r\\n \\\"\\\"\\\"\\r\\n if eh_posicao_livre(tab, 5):\\r\\n return 5\\r\\n \\r\\n #canto_oposto_6: tabuleiro X inteiro -> posicao\\r\\n \\r\\n def canto_oposto_6(tab, jog):\\r\\n \\\"\\\"\\\"\\r\\n canto_oposto_6 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e se o adversario estiver num\\r\\n canto e se o canto diagonalmente oposto for uma posicao livre entao\\r\\n retorna a posicao desse canto oposto.\\r\\n \\\"\\\"\\\"\\r\\n jog*=-1\\r\\n if obter_linha(tab,1)[0]==jog and eh_posicao_livre(tab,9):\\r\\n return 9\\r\\n if obter_linha(tab,1)[2]==jog and eh_posicao_livre(tab,7):\\r\\n return 7\\r\\n if obter_linha(tab,3)[0]==jog and eh_posicao_livre(tab,3):\\r\\n return 3\\r\\n if obter_linha(tab,3)[2]==jog and eh_posicao_livre(tab,1):\\r\\n return 1 \\r\\n \\r\\n #canto_vazio_7: tabuleiro X inteiro -> posicao\\r\\n \\r\\n def canto_vazio_7(tab, jog):\\r\\n \\\"\\\"\\\"\\r\\n canto_vazio_7 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e se um canto for uma posicao\\r\\n livre entao devolve a posicao correspondente a esse canto.\\r\\n \\\"\\\"\\\"\\r\\n for x in [1,3,7,9]:\\r\\n if eh_posicao_livre(tab,x):\\r\\n return x \\r\\n \\r\\n #lateral_vazio_8: tabuleiro X inteiro -> posicao\\r\\n \\r\\n def lateral_vazio_8(tab, jog):\\r\\n \\\"\\\"\\\"\\r\\n lateral_vazio_8 recebe um tabuleiro e um inteiro correspondente ao jogador \\r\\n (1 para o jogador 'X' e -1 para o jogador 'O') e se uma posicao lateral\\r\\n (que nem e o centro, nem um canto) for livre, entao retorna a posicao\\r\\n correspondente a essa posicao lateral.\\r\\n \\\"\\\"\\\"\\r\\n for x in [2,4,6,8]:\\r\\n if eh_posicao_livre(tab,x):\\r\\n return x \\r\\n \\r\\n if str1=='basico':\\r\\n for i in range(2):\\r\\n if i==0: res = centro_5(tab, jog)\\r\\n if i==1: res = canto_vazio_7(tab, jog)\\r\\n if res!=None:\\r\\n return res\\r\\n return lateral_vazio_8(tab, jog) \\r\\n \\r\\n \\r\\n elif str1=='normal':\\r\\n for i in range(5):\\r\\n if i==0: res = vitoria_1(tab,jog)\\r\\n if i==1: res = bloqueio_2(tab,jog)\\r\\n if i==2: res = centro_5(tab, jog)\\r\\n if i==3: res = canto_oposto_6(tab, jog)\\r\\n if i==4: res = canto_vazio_7(tab, jog)\\r\\n if res!=None:\\r\\n return res\\r\\n return lateral_vazio_8(tab, jog)\\r\\n \\r\\n \\r\\n elif str1=='perfeito':\\r\\n for i in range(7):\\r\\n if i==0: res = vitoria_1(tab,jog)\\r\\n if i==1: res = bloqueio_2(tab,jog)\\r\\n if i==2: \\r\\n res = bifurcacao_3(tab, jog)\\r\\n if res!=[]:\\r\\n res = bifurcacao_3(tab, jog)[0]\\r\\n else:\\r\\n res=None\\r\\n if i==3: \\r\\n res = bloqueio_de_bifurcacao_4(tab,jog)\\r\\n if res!=[]:\\r\\n res = bloqueio_de_bifurcacao_4(tab,jog)\\r\\n else:\\r\\n res=None \\r\\n if i==4: res = centro_5(tab, jog)\\r\\n if i==5: res = canto_oposto_6(tab, jog)\\r\\n if i==6: res = canto_vazio_7(tab, jog)\\r\\n if res!=None:\\r\\n return res\\r\\n return lateral_vazio_8(tab, jog)\",\n \"async def tamere(self):\\n tamere = [\\n \\\"Ta mère est tellement grosse que pour la voir entièrement, on doit reculer de trois pas.\\\",\\n \\\"Ta mère est tellement grosse qu'il faut deux pokéflutes pour la réveiller.\\\",\\n \\\"Ta mère est tellement grosse qu'il y a un décalage horaire entre ses deux fesses.\\\",\\n \\\"Ta mère est tellement radine que, quand elle vomit, elle sert les dents pour garder les morceaux.\\\",\\n \\\"Ta mère est tellement moche que ton père est capable de l'emmener au travail pour éviter de lui dire au revoir en l'embrassant.\\\",\\n \\\"Ta mère est tellement vieille que quand elle pète, elle fait de la poussière.\\\",\\n \\\"Ta mère est tellement desséchée que ses morpions ne se baladent jamais sans leur gourde perso.\\\",\\n \\\"Ta mère est tellement grosse qu'elle a décroché le rôle de la grosse pierre roulante au casting d'Indiana Jones.\\\",\\n \\\"Ta mère est tellement grosse qu'elle a été baptisée en mer.\\\",\\n \\\"Ta mère est tellement pauvre que ce sont les pigeons qui lui jettent du pain.\\\",\\n \\\"Ta mère est tellement moche que quand elle va à la banque ils coupent les caméras.\\\",\\n \\\"Ta mère est tellement grosse que quand elle met des talons aiguilles, elle trouve du pétrole !\\\",\\n \\\"Ta mère est tellement petite que sa tête pue des pieds.\\\",\\n \\\"Ta mère est tellement vieille qu'elle fait du lait en poudre.\\\",\\n \\\"Ta mère a tellement mauvaise haleine qu'on a l'impression qu'elle a l'anus derrière les dents.\\\",\\n \\\"Si tu vois un bateau qui flotte sur l'eau c'est que ta mère n'est pas à bord.\\\",\\n \\\"Ta mère est tellement grosse que lorsqu'elle tombe du lit elle tombe des deux bords.\\\",\\n \\\"Ta mère est tellement grosse que pour la photographier il faut un satellite.\\\",\\n \\\"Ta mère est tellement grosse que quand elle mange des cacahuètes, elle chie des Snickers.\\\",\\n \\\"Ta mère est tellement grosse que lorsqu'elle se pèse, c'est son numéro de téléphone qui s'affiche !\\\",\\n \\\"Si les femmes sont des fleurs, il faudrait changer l'eau de ta mère.\\\",\\n \\\"Ta mère est tellement bête que quand ton père l'a demandée en mariage elle a dit oui\\\"\\n ]\\n print('Blague sur les daronnes')\\n await self.bot.say(random.choice(tamere))\",\n \"def joueCoup(position,coup):\\n nouvelle_pos = clonePosition(position) # on duplique pour ne pas modifier l'original\\n n = nouvelle_pos['taille']\\n trait = nouvelle_pos['trait']\\n # on transforme coup en indice\\n if trait == 'SUD':\\n indice_depart = coup-1\\n else:\\n indice_depart = 2*n-coup\\n # retrait des graines de la case de depart\\n nbGraines = nouvelle_pos['tablier'][indice_depart]\\n nouvelle_pos['tablier'][indice_depart] = 0\\n # on seme les graines dans les cases a partir de celle de depart\\n indice_courant = indice_depart\\n while nbGraines > 0:\\n indice_courant = (indice_courant + 1) % (2*n)\\n if (indice_courant != indice_depart): # si ce n'est pas la case de depart\\n nouvelle_pos['tablier'][indice_courant] += 1 # on seme une graine\\n nbGraines -= 1\\n # la case d'arrivee est dans le camp ennemi ?\\n if (trait == 'NORD'):\\n estChezEnnemi = (indice_courant < n)\\n else:\\n estChezEnnemi = (indice_courant >= n)\\n # realisation des prises eventuelles\\n while estChezEnnemi and (nouvelle_pos['tablier'][indice_courant] in range(2,4)):\\n nouvelle_pos['graines'][trait] += nouvelle_pos['tablier'][indice_courant]\\n nouvelle_pos['tablier'][indice_courant] = 0\\n indice_courant = (indice_courant - 1) % (2*n)\\n if (trait == 'NORD'):\\n estChezEnnemi = (indice_courant < n)\\n else:\\n estChezEnnemi = (indice_courant >= n)\\n # mise a jour du camp au trait\\n if trait == 'SUD':\\n nouvelle_pos['trait'] = 'NORD'\\n else:\\n nouvelle_pos['trait'] = 'SUD'\\n return nouvelle_pos\",\n \"def criaColuns():\\n\\n #Preencher Colunas\\n numColunsVaz = 5\\n numColuns = 2\\n coluns = \\\"\\\"\\n\\n while(numColuns > 0): #preenchendo colunas de linha\\n while(numColunsVaz > 0): #preenchendo espacos vazios das colunas de cada linha\\n coluns += \\\" \\\"\\n numColunsVaz -= 1\\n\\n coluns += \\\"|\\\"\\n numColunsVaz = 5\\n numColuns -= 1\\n\\n coluns += \\\" \\\"\\n print(espacamento ,coluns ,espacamento)\",\n \"def ubicar_submarino(): #esta clase de barcos no tiene orientacion\\n tamano = Submarinos.tamano #se importa el tamano del barco desde su clase\\n cantidad = Submarinos.cantidad #se importa la cantidad de barcos desde su clase\\n while cantidad > 0:\\n mal_ubicado = \\\"no\\\"\\n coor_fila = randint(1,numero_filas)\\n coor_columna = randint(1,numero_columnas)\\n ubicacion = (coor_fila, coor_columna)\\n for x in lista_ubicacion_barco:\\n if x == ubicacion:\\n mal_ubicado = \\\"si\\\"\\n #validacion para que los barcos no queden contiguos entre otros ya posicionados\\n elif (ubicacion[0] == x[0] or (ubicacion[0]+1) == x[0] or (ubicacion[0]-1) == x[0]) and ((ubicacion[1]) == x[1] or (ubicacion[1]+1) == x[1] or (ubicacion[1]- 1) == x[1]): \\n mal_ubicado = \\\"si\\\"\\n if mal_ubicado == \\\"no\\\":\\n cantidad -= 1 #se resta uno a la cantidad de los barcos porque ya este se posiciono correctamente\\n lista_ubicacion_barco.append(ubicacion) #si el barco no es contiguo con ningun otro barco se agrega a la lista de los barcos ya posicionados\\n elif mal_ubicado == \\\"si\\\":\\n cantidad = cantidad #la cantidad de barcos se mantiene igual porque el barco quedo contiguo a otro, se repite el proceso d eubicacion para este barco\",\n \"def __init__(self, mot):\\n premiere_cellule = None\\n self.taille = 0\\n for lettre in reversed(mot):\\n premiere_cellule = Cellule(lettre, premiere_cellule)\\n self.taille += 1\\n self.tete = premiere_cellule\",\n \"def solution(self):\\n return [(\\\"the\\\", 1579644)] * 100\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6889607","0.648981","0.61234885","0.6100312","0.59595793","0.5941458","0.5847579","0.5844933","0.58387846","0.58319885","0.5828353","0.5821314","0.5816315","0.5805892","0.5794173","0.5782808","0.5778222","0.57483304","0.57463837","0.57396597","0.57307076","0.57280296","0.5726919","0.5690755","0.5684239","0.5680042","0.5677151","0.567517","0.56702316","0.56642133","0.5664152","0.5662104","0.56618947","0.5654676","0.56482863","0.56379884","0.5618113","0.5600046","0.5594618","0.559203","0.5589892","0.55885786","0.5530691","0.551807","0.5516843","0.551568","0.5505712","0.5503671","0.5503671","0.5503671","0.5503671","0.5503671","0.548983","0.5477257","0.54772073","0.54754907","0.5468955","0.54676163","0.54676163","0.54676163","0.5461232","0.5460271","0.5459637","0.544377","0.54390985","0.5438201","0.54332626","0.5420889","0.5408525","0.5408067","0.5407696","0.5405329","0.5403372","0.5398553","0.53963816","0.53831965","0.5381849","0.53791696","0.5377705","0.53773695","0.53734595","0.53732115","0.5372276","0.5370578","0.535998","0.5355318","0.53522664","0.53513926","0.5344411","0.53404415","0.5338954","0.53346735","0.5334011","0.5331904","0.5329967","0.5329822","0.532883","0.5328136","0.53272206","0.5323651","0.53231454"],"string":"[\n \"0.6889607\",\n \"0.648981\",\n \"0.61234885\",\n \"0.6100312\",\n \"0.59595793\",\n \"0.5941458\",\n \"0.5847579\",\n \"0.5844933\",\n \"0.58387846\",\n \"0.58319885\",\n \"0.5828353\",\n \"0.5821314\",\n \"0.5816315\",\n \"0.5805892\",\n \"0.5794173\",\n \"0.5782808\",\n \"0.5778222\",\n \"0.57483304\",\n \"0.57463837\",\n \"0.57396597\",\n \"0.57307076\",\n \"0.57280296\",\n \"0.5726919\",\n \"0.5690755\",\n \"0.5684239\",\n \"0.5680042\",\n \"0.5677151\",\n \"0.567517\",\n \"0.56702316\",\n \"0.56642133\",\n \"0.5664152\",\n \"0.5662104\",\n \"0.56618947\",\n \"0.5654676\",\n \"0.56482863\",\n \"0.56379884\",\n \"0.5618113\",\n \"0.5600046\",\n \"0.5594618\",\n \"0.559203\",\n \"0.5589892\",\n \"0.55885786\",\n \"0.5530691\",\n \"0.551807\",\n \"0.5516843\",\n \"0.551568\",\n \"0.5505712\",\n \"0.5503671\",\n \"0.5503671\",\n \"0.5503671\",\n \"0.5503671\",\n \"0.5503671\",\n \"0.548983\",\n \"0.5477257\",\n \"0.54772073\",\n \"0.54754907\",\n \"0.5468955\",\n \"0.54676163\",\n \"0.54676163\",\n \"0.54676163\",\n \"0.5461232\",\n \"0.5460271\",\n \"0.5459637\",\n \"0.544377\",\n \"0.54390985\",\n \"0.5438201\",\n \"0.54332626\",\n \"0.5420889\",\n \"0.5408525\",\n \"0.5408067\",\n \"0.5407696\",\n \"0.5405329\",\n \"0.5403372\",\n \"0.5398553\",\n \"0.53963816\",\n \"0.53831965\",\n \"0.5381849\",\n \"0.53791696\",\n \"0.5377705\",\n \"0.53773695\",\n \"0.53734595\",\n \"0.53732115\",\n \"0.5372276\",\n \"0.5370578\",\n \"0.535998\",\n \"0.5355318\",\n \"0.53522664\",\n \"0.53513926\",\n \"0.5344411\",\n \"0.53404415\",\n \"0.5338954\",\n \"0.53346735\",\n \"0.5334011\",\n \"0.5331904\",\n \"0.5329967\",\n \"0.5329822\",\n \"0.532883\",\n \"0.5328136\",\n \"0.53272206\",\n \"0.5323651\",\n \"0.53231454\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13280,"cells":{"query":{"kind":"string","value":"1 spleen, 2 right kidney, 3 left kidney, 4 gall bladder, 5 esophagus 6 liver, 7 stomach, 8 aorta, 9 inferior vena cava, 10 portal and splenic vein, 11 pancreas, 12 left adrenal gland, 13 right adrenal gland."},"document":{"kind":"string","value":"def load_learn2reg(self, patient):\n start = time.time()\n \n ct_path = self.folder + 'img/' + patient + end\n \n array = load_sitk(ct_path)[np.newaxis, ...].astype(float)# Add 1 dimension\n array = array[:, ::-1, ::-1, :]\n \n if self.load_mask:\n\n if self.pseudo_labels:\n mask_path = self.folder + 'pseudo_seg/' + patient + '-seg' + end\n else:\n mask_path = self.folder + 'label/label' + patient[3:] + end\n mask = load_sitk(mask_path).astype(int)\n \n if self.pseudo_labels:\n label = 12*[1]\n else:\n mask, label = convert_L2R_labels(mask, self.keep_all_label)\n\n mask = mask[::-1, ::-1, :]\n\n num_label = len(label)\n mask = np.rollaxis(np.eye(num_label, dtype=np.uint8)[mask], -1, 0)\n else:\n\n mask = np.zeros(array.shape[1:], dtype=np.int16)\n mask = np.rollaxis(np.eye(2)[mask], -1, 0) # Put to one hot encoder\n label = 14*[0]\n \n stop = time.time()\n\n return array, mask, np.array(label), stop - start"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def hangman_figure(attempt_left):\n if attempt_left == N_TURNS:\n print('___________')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 1:\n print('___________')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 2:\n print('___________')\n print('| |')\n print('| O')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 3:\n print('___________')\n print('| |')\n print('| O')\n print('| |')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 4:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 5:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 6:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| /')\n print('| |')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 7:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 8:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| |')\n print('|_____')\n if attempt_left == N_TURNS - 9:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| | |')\n print('|_____')\n if attempt_left == N_TURNS - 10:\n print('___________')\n print('| |')\n print('| -O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| | |')\n print('|_____')\n if attempt_left == N_TURNS - 11:\n print('___________')\n print('| |')\n print('| -O-')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| | |')\n print('|_____')","def generate_horror_title():\n d666 = random.randint(1, 666)\n if d666 <= 111:\n #the adj noun\n return \"The \" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \" \" + horror_noun[random.randint(0, len(horror_noun) - 1)]\n elif d666 > 111 and d666 <= 222: \n #noun of noun\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \" of \" + horror_noun[random.randint(0, len(horror_noun) - 1)]\n elif d666 > 222 and d666 < 444: \n #the adj noun of verb \n return \"The \" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \" \" + horror_noun[random.randint(0, len(horror_noun) - 1)] + \" of \" + horror_verb[random.randint(0, len(horror_verb) - 1)]\n elif d666 >= 444 and d666 < 555: \n #noun of noun\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \" of \" + horror_noun[random.randint(0, len(horror_noun) - 1)]\n elif d666 >= 555:\n #verb of the adj noun\n return horror_verb[random.randint(0, len(horror_verb) - 1)] + \" of the \" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \" \" + horror_noun[random.randint(0, len(horror_noun) - 1)]","def pirate():\n \n from random import choice\n d = {\n \"sir\": \"matey\", \"hotel\": \"fleabag inn\", \"student\": \"swabbie\",\n \"boy\": \"matey\", \"girl\": \"wench\", \"professor\": \"foul blaggart\",\n \"restaurant\": \"galley\", \"your\": \"ye\", \"excuse\": \"arr\", \"you\": \"ye\",\n \"students\": \"swabbies\", \"are\": \"be\", \"lawyer\": \"foul blaggart\",\n \"the\": \"th'\", \"restroom\": \"head\", \"my\": \"me\", \"hello\": \"avast\",\n \"is\": \"be\", \"man\": \"scurvy dog\", \"hey\": \"avast\", \"pirate\": \"scurvy pirate\",\n \"idiot\": \"flunder\", \"young\": \"ye\", \"the\": \"t'\", \"suck\": \"blow down\",\n \"fall\": \"hade\", \"happens\": \"be happening\", \"death\": \"Davy Jones' treasure chest\",\n \"always\": \"ever\", \"you're\": \"ye're\", \"girlfriend\": \"Lassie-Lucy\",\n \"with\": \"wit'\", \"everyone\": \"evr'un\"\n }\n #~ sentence = raw_input(\"What be yer sentence, ye old landlubber? \")\n sentences = [\"If the world didn't suck we'd all fall off\",\n \"What happens if you get scared half to death twice?\",\n \"Save water and shower with your girlfriend\",\n \"Always remember you're unique, just like everyone else\"]\n \n start = [\"Yarr, \", \"Yarr! \", \"Yarr-ha-harr! \", \"Skuttle me Skippers! \",\n \"Shiver me timbers! \", \"Ahoy, me hearties! \", \"Dogs ahoy! \",\n \"Hoist the mizzen!!! \", \"Hoist the colors!! \" ]\n end = [\". ARRRGHHHH!\", \". Avast ye varmint!\", \". Yarr?\",\n \". Savvyy?\", \". Yarr!\", \". Aye!\",\n \", ye bilge rat!\", \", ye mangy dog!\", \", ye scallywag!\"]\n\n s = choice(sentences)\n print s\n print choice(start) +\\\n ' '.join([d[i] if i in d else i for i in s.lower().split()]).capitalize()\\\n + choice(end)","def test_splitting_on_feature(num = 0):\n left = [0,0]\n right = [0,0]\n for i, side in enumerate(train_matrix_df[num]):\n if int(side) == 0: \n if train_labels_df.ix[i]['candy_id'] == 0:\n left[0] += 1\n else:\n left[1] += 1\n else:\n if train_labels_df.ix[i]['candy_id'] == 0:\n right[0] += 1\n else:\n right[1] += 1\n\n #print \" %s goes to the %i side\" %(train_labels_df.ix[i]['candy'], side)\n\n print str(left) + \"<--left -- + -- right-->\" + str(right)","def display_words(word_list,specifier):\n \n if specifier.lower() == 'score':\n print(\"{:>6s} - {:s}\".format(\"Score\", \"Word\"))\n if len(word_list) < 5:\n for tup in word_list:\n print(\"{:>6d} - {:s}\".format(tup[1], tup[0]))\n else:\n \n for tup in word_list[:5]:\n print(\"{:>6d} - {:s}\".format(tup[1], tup[0]))\n \n \n elif specifier.lower() == 'length':\n print(\"{:>6s} - {:s}\".format(\"Length\", \"Word\"))\n if len(word_list) < 5:\n for tup in word_list:\n print(\"{:>6d} - {:s}\".format(tup[2], tup[0]))\n else:\n \n for tup in word_list[:5]:\n print(\"{:>6d} - {:s}\".format(tup[2], tup[0]))","def pre_flop_strength(hand):\n highs = {}\n highs[4] = [\n \"AA\", \"AKs\", \"AQs\", \"AJs\", \"ATs\", \"AKo\", \"KK\", \"KQs\", \"KJs\", \"AQo\",\n \"QQ\", \"QJs\", \"JJ\", \"TT\"\n ]\n highs[3] = [\n \"A5s\", \"A4s\", \"A3s\", \"KTs\", \"KQo\", \"QTs\", \"AJo\", \"JTs\", \"T9s\", \"99\",\n \"98s\", \"88\", \"87s\", \"77\", \"66\"\n ]\n highs[2] = [\n \"A9s\", \"A8s\", \"A7s\", \"A6s\", \"A2s\", \"K9s\", \"K8s\", \"Q9s\", \"KJo\", \"QJo\",\n \"J9s\", \"ATo\", \"KTo\", \"QTo\", \"JTo\", \"T8s\", \"A9o\", \"J9o\", \"T9o\", \"97s\",\n \"98o\", \"86s\", \"76s\", \"75s\", \"65s\", \"55\", \"44\", \"33\", \"22\"\n ]\n highs[1] = [\n \"K7s\", \"K6s\", \"K5s\", \"K4s\", \"K3s\", \"Q8s\", \"Q7s\", \"Q6s\", \"Q5s\", \"Q4s\",\n \"J8s\", \"J7s\", \"J6s\", \"J5s\", \"T7s\", \"T6s\", \"K9o\", \"Q9o\", \"96s\", \"A8o\",\n \"K8o\", \"Q8o\", \"J8o\", \"T8o\", \"85s\", \"A7o\", \"K7o\", \"Q7o\", \"T7o\", \"97o\",\n \"87o\", \"74s\", \"A6o\", \"K6o\", \"86o\", \"76o\", \"64s\", \"63s\", \"A5o\", \"75o\",\n \"65o\", \"54s\", \"53s\", \"A4o\", \"43s\", \"A3o\"\n ]\n card0, card1 = hand\n if card0[0] == card1[0]:\n pair = \"\".join([card0[0], card1[0]])\n elif card0[1] == card1[1]:\n pair = \"\".join([card0[0], card1[0], \"s\"])\n else:\n pair = \"\".join([card0[0], card1[0], \"o\"])\n for strenght in highs:\n if pair in highs[strenght]:\n return strenght\n return 0","def heads_legs(heads, legs):\n for i in range(0, heads + 1):\n cows = heads - i\n if 4 * cows + 2 * i == legs:\n chickens = i\n return chickens, cows\n return \"No solutions.\"","def way_to_prewin(self, one):\r\n\t\tkind = [0, 0, 0, 0] \r\n\t\tuseful = []\r\n\t\tscore = 0\r\n\t\tfor part in one.split(\"\\t\"):\r\n\t\t\t#print \"part: {0}\".format(part)\r\n\t\t\ttmp = part.split()\r\n\t\t\tlength = len(tmp)\r\n\t\t\tif (length == 3):\t\t# triple\r\n\t\t\t\tkind[0] += 1\r\n\t\t\t\tscore += 3\r\n\t\t\telif (length == 1):\t\t# single\r\n\t\t\t\tkind[3] += 1\r\n\t\t\telif (tmp[0] == tmp[1]):# pair\r\n\t\t\t\tkind[1] += 1\r\n\t\t\t\tuseful.append(\"{0}\".format(tmp[0]))\r\n\t\t\t\tscore += 2\r\n\t\t\telse:\r\n\t\t\t\tkind[2] += 1\r\n\t\t\t\tn = GameBoard.NextCard(tmp[0])\r\n\t\t\t\tp = GameBoard.PrevCard(tmp[0])\r\n\t\t\t\tnn = GameBoard.NextCard(tmp[1])\r\n\t\t\t\tif (n == tmp[1]):\t# consecutive neighbor\r\n\t\t\t\t\tscore += 2\r\n\t\t\t\t\tif (p != None): useful.append(p)\r\n\t\t\t\t\tif (nn != None): useful.append(nn)\r\n\t\t\t\telse:\r\n\t\t\t\t\tuseful.append(n)\r\n\t\t\t\t\tscore += 1\r\n\r\n\t\t#print \"kind: {0}\".format(kind)\r\n\t\t\"\"\" how many cards can we probably get \"\"\"\r\n\t\tuseful_amount = 0\r\n\t\tfor card in set(useful):\r\n\t\t\tctype = GameBoard.CardType(card)\r\n\t\t\tif (ctype == 1): a = self.wang_list.count(card)\r\n\t\t\telif (ctype == 2): a = self.tube_list.count(card)\r\n\t\t\telif (ctype == 3): a = self.bamb_list.count(card)\r\n\t\t\telif (ctype == 4): a = self.word_list.count(card)\r\n\t\t\telse: a = self.wind_list.count(card)\r\n\t\t\tb = self.gb.drop_list.count(card)\r\n\t\t\tuseful_amount += (4 - a - b)\r\n\r\n\t\t\"\"\"\r\n\t\t1. enumerate, because goal state not too much\r\n\t\t2. counting pong_list so that we can focus on 16 cards\r\n\t\t3. check prewin first\t\r\n\t\t\"\"\"\r\n\t\tgoals = [[4, 1, 1, 0], [5, 0, 0, 1], [4, 2, 0, 0]]\r\n\t\tgpattern = [[\"***\", \"***\", \"***\", \"***\", \"##\", \"$$\"],[\"***\", \"***\", \"***\", \"***\", \"***\", \"/\"],\r\n\t\t\t\t\t[\"***\", \"***\", \"***\", \"***\", \"##\", \"##\"]]\r\n\t\tresult = [0, 0, 0]\r\n\t\tsize = len(self.pong_list) / 3\r\n\t\tif ((size + kind[0]) > 4): return [0, useful_amount, score]\r\n\t\tfor i in range(size): \r\n\t\t\tgpattern[0].remove(\"***\")\r\n\t\t\tgpattern[1].remove(\"***\")\r\n\t\t\tgpattern[2].remove(\"***\")\r\n\t\tfor number in range(3):\r\n\t\t\tk0 = kind[0]\r\n\t\t\tk1 = kind[1]\r\n\t\t\tk2 = kind[2]\r\n\t\t\tk3 = kind[3]\r\n\t\t\tp1 = gpattern[number]\r\n\t\t\tfor i in range(k0): p1.remove(\"***\")\r\n\t\t\tfor i in range(min(k1, goals[number][1])): \r\n\t\t\t\tk1 -= 1\r\n\t\t\t\tp1.remove(\"##\")\r\n\t\t\tfor i in range(min(k2, goals[number][2])):\r\n\t\t\t\tk2 -= 1\r\n\t\t\t\tp1.remove(\"$$\")\r\n\t\t\t#print \"p1: {0}, size: {1}\".format(p1, (k1+k2)*2+k3)\r\n\t\t\tstep = 0\r\n\t\t\ttwo = k1 + k2\r\n\t\t\tfor i in range(len(p1)):\r\n\t\t\t\tlength = len(p1[i])\r\n\t\t\t\tif (length == 3):\r\n\t\t\t\t\tif two:\r\n\t\t\t\t\t\ttwo -= 1\r\n\t\t\t\t\t\tstep += 1\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tstep += 2\r\n\t\t\t\telif (length == 2):\r\n\t\t\t\t\tstep += 1\r\n\t\t\tresult[number] = step\r\n\t\t#print \"steps to goal: {0}, useful: {1}\".format(result, len(useful))\r\n\t\t\r\n\t\treturn [min(result), useful_amount, score]","def viz(analogies):\n print(\"Index\".ljust(12) + \"Analogy\".center(45) + \"Gender score\".rjust(12))\n print(\"-\" * 69)\n print(\n \"\\n\".join(\n str(i).rjust(4) + a[0].rjust(29) + \" | \" + a[1].ljust(29) + (str(a[2]))[:4]\n for i, a in enumerate(analogies)\n )\n )","def one_v_all(description):\n label = [0, 0, 0]\n for raw in description.split(\"|\")[4:]:\n line = raw.strip()\n if \"midbrain\" in line:\n label[0] = 1\n if \"forebrain\" in line:\n label[1] = 1\n if \"hindbrain\" in line:\n label[2] = 1\n return label","def chargen (level0number, level0die, level1number, level1die, level2number, level2die, level3number, level3die, level4number, level4die): #input dice numbers and types for all four potential character levels\r\n\tfilename=stellagama.savefile(\"txt\")\r\n\twith open (filename, \"w\") as output:\r\n\t\tfor i in range (0, stellagama.dice(level0number, level0die)):\r\n\t\t\tcharacter1=character(0)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level1number, level1die)):\r\n\t\t\tcharacter1=character(1)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level2number, level2die)):\r\n\t\t\tcharacter1=character(2)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level3number, level3die)):\r\n\t\t\tcharacter1=character(3)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level4number, level4die)):\r\n\t\t\tcharacter1=character(4)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')","def rules():\n help = textwrap.dedent(\"\"\"\n THIS IS THE GAME OF \"REVERSE\". TO WIN, ALL YOU HAVE\n TO DO IS ARRANGE A LIST OF NUMBERS (1 THROUGH {})\n IN NUMERICAL ORDER FROM LEFT TO RIGHT. TO MOVE, YOU\n TELL ME HOW MANY NUMBERS (COUNTING FROM THE LEFT) TO\n REVERSE. FOR EXAMPLE, IF THE CURRENT LIST IS:\n\n 2 3 4 5 1 6 7 8 9\n\n AND YOU REVERSE 4, THE RESULT WILL BE:\n\n 5 4 3 2 1 6 7 8 9\n\n NOW IF YOU REVERSE 5, YOU WIN!\n\n 1 2 3 4 5 6 7 8 9\n\n NO DOUBT YOU WILL LIKE THIS GAME, BUT\n IF YOU WANT TO QUIT, REVERSE 0 (ZERO).\n \"\"\".format(NUMCNT))\n print(help)\n print()","def rarity():\n rarities = find_rarities()\n longest = 0\n for rarity in rarities:\n if (len(rarity) > longest): \n longest = len(rarity)\n spacer = \"\".join(map(lambda x: x*longest, \"-\"))\n click.echo(\"\\nRarities\")\n click.echo(spacer)\n for rarity in rarities:\n click.echo(rarity)\n click.echo(\"\\n\")","def __str__(self) -> str:\n side = self.side_length\n\n hori_lst = self.hori_lst\n hori_result = self.hori_result\n left_lst = self.left_lst\n left_result = self.left_result\n right_lst = self.right_lst\n right_result = self.right_result\n\n total_line=''\n for i in range(2 * side + 5):\n # empty line string\n line = ''\n if i % 2 == 0:\n lineindex = int(i / 2)\n if lineindex <= side:\n # get the first 2 left result\n if lineindex == 0:\n # print('first line')\n for ia in range(3*(side+1)):\n line += ' '\n line += left_result[0]\n line += ' '\n line += left_result[1]\n # general case of combing the results and list together\n else:\n if lineindex == side:\n line += ' '\n for ib in range(side - lineindex):\n line += ' '\n line += hori_result[lineindex - 1]\n for ic in range(len(hori_lst[lineindex - 1])):\n line += ' - '\n line += hori_lst[lineindex - 1][ic]\n if lineindex != side:\n line += ' '\n line += left_result[lineindex + 1]\n else:\n if lineindex == side + 1:\n # for id in range():\n line += ' '\n line += hori_result[side]\n for ie in range(side):\n line += ' - '\n line += hori_lst[side][ie]\n line += ' '\n line += right_result[side]\n else:\n # print the last row for all other right resutls\n # print('right results')\n for ig in range(9):\n line += ' '\n for ih in range(side):\n line += right_result[ih]\n line += ' '\n total_line += line + '\\n'\n else:\n # print stuff for the '/'\n lineindex2 = int(i / 2)\n if lineindex2 == 0:\n for iA in range(3*side+1):\n line += ' '\n line += ' / '\n line += ' '\n line += \" / \"\n elif lineindex2 < side:\n for iA in range(3 * (1 + side - lineindex2)):\n line += ' '\n # print('lineindex2: '+str(lineindex2)+' '+str(3*(1+side-lineindex2)))\n for iB in range(lineindex2 + 1):\n line += '/ \\\\ '\n line += '/'\n elif lineindex2 == side:\n #for iC in range(side+1):\n line += ' '\n for iD in range(side):\n line += '\\\\ / '\n line += '\\\\'\n elif lineindex2 == side + 1:\n for iE in range(8):\n line += ' '\n for iG in range(side):\n line += '\\\\ '\n total_line += line + '\\n'\n return total_line","def spell_triade(triade):\n spelled_triade = ''\n\n if triade[1] == 1:\n\n spelled_triade += numerals_dictionary[triade[1] * 10 + triade[2]]\n\n elif triade[1] == 0:\n\n spelled_triade += numerals_dictionary[triade[2]]\n\n else:\n\n if triade[2] == 0:\n\n spelled_triade = numerals_dictionary[triade[1] * 10]\n\n else:\n\n spelled_triade = '-'.join((numerals_dictionary[triade[1] * 10], numerals_dictionary[triade[2]]))\n\n if triade[0] in range(1, 10):\n\n hundreds = ' '.join((numerals_dictionary[triade[0]], 'hundred'))\n\n if spelled_triade != 'zero':\n\n spelled_triade = ' and '.join((hundreds, spelled_triade))\n\n else:\n\n spelled_triade = hundreds\n\n return spelled_triade","def get_ability_scores(self):\n s = ''\n for i in range(6):\n s += ' ' + str(self.dna[i])\n return s","def won(s,n):","def rangoli(n):\r\n alphabet = string.ascii_lowercase\r\n pad = 4*n-3\r\n filler = '-'\r\n initial = [alphabet[n-1]]\r\n top = [alphabet[n-1].center(pad, filler)]\r\n\r\n for i in range(n-2, -1, -1):\r\n initial.append(alphabet[i])\r\n sub_list = initial[:-1]+[alphabet[i]]+list(reversed(initial[:-1]))\r\n sub_seq = filler.join(sub_list).center(pad, filler)\r\n top.append(sub_seq)\r\n\r\n bot = list(reversed(top[:-1]))\r\n result = '\\n'.join(top + bot)\r\n print(result)\r\n return","def __init__(self, is_p1_turn: bool, side_length: int) -> None:\n super().__init__(is_p1_turn)\n self.side_length = side_length\n # ISSUE: what if node is more than 26 --> no need to handle side more than 5\n # construct a list of uppercase and lower case letters\n alph_lst_upper = list(string.ascii_uppercase)\n alph_lst_lower = list(string.ascii_lowercase)\n # alph_lst has a length of 52\n alph_lst = alph_lst_upper + alph_lst_lower\n\n # assign original value for each ley-line\n hori_result = []\n for i in range(side_length + 1):\n hori_result.append(\"@\")\n left_result = []\n for i in range(side_length + 1):\n left_result.append(\"@\")\n right_result = []\n for i in range(side_length + 1):\n right_result.append(\"@\")\n self.hori_result = hori_result\n self.left_result = left_result\n self.right_result = right_result\n\n self.hori_lst = []\n self.left_lst = []\n self.right_lst = []\n\n # construct horizontal ley-lines\n n = 2\n start_index = 0\n end_index = 0\n while n <= side_length + 1:\n end_index = start_index + n\n self.hori_lst.append(alph_lst[start_index:end_index])\n start_index = end_index\n n += 1\n end_index = start_index + side_length\n self.hori_lst.append(alph_lst[start_index:end_index])\n\n # copy hori_lst\n hori_copy = []\n for item in self.hori_lst:\n hori_copy.append(item)\n\n # construct left ley-lines\n for i in range(side_length + 1):\n temp = []\n for lst in hori_copy[:len(hori_copy) - 1]:\n if len(lst) > i:\n temp.append(lst[i])\n self.left_lst.append(temp)\n for i in range(1, side_length + 1):\n self.left_lst[i].append(hori_copy[-1][i - 1])\n\n # construct right ley-lines\n for i in range(-1, side_length * (-1) - 2, -1):\n temp = []\n for lst in hori_copy[:len(hori_copy) - 1]:\n if len(lst) >= i * (-1):\n temp.append(lst[i])\n self.right_lst.append(temp)\n self.right_lst = self.right_lst[::-1]\n for i in range(side_length):\n self.right_lst[i].append(hori_copy[-1][i])","def leerUltrasonido() -> int:\n pass","def print_hangman(n, wrong_times):\n # the width of the print, must > 4\n width = 13\n height = n\n s = \"\"\n # let s be a width * height string then we can replace every hangman part each wrong time\n for i in range(height):\n for j in range(width-1):\n s += \" \"\n # every (width-1) spaces plus a \\n to change row\n s += '\\n'\n # ceiling\n for i in range(len(s)):\n if i < width-1:\n s = s[:i] + '-' + s[i+1:]\n # pillar and rope\n for i in range(width, len(s), width):\n s = s[:i] + '|' + s[i+1:]\n s = s[:int(width + width/2)] + '|' + s[int(width + width/2 + 1):]\n # head\n if wrong_times >= 1:\n s = s[:int(width*2 + width/2)] + 'O' + s[int(width*2 + width/2 + 1):]\n # body\n if wrong_times >= 2:\n s = s[:int(width*3 + width/2)] + '|' + s[int(width*3 + width/2 + 1):]\n # left hand\n if wrong_times >= 3:\n s = s[:int(width*3 + width/2 - 1)] + '/' + s[int(width*3 + width/2):]\n # right hand\n if wrong_times >= 4:\n s = s[:int(width*3 + width/2 + 1)] + '\\\\' + s[int(width*3 + width/2 + 2):]\n # if n > 6 continue adding body part until left 2 chances to try\n if (wrong_times >= 5) & (n - wrong_times <= n-5):\n if n - wrong_times > 1:\n # 4 means head, body, left hand and right hand\n for i in range(wrong_times - 4):\n s = s[:int(width * (3+i+1) + width/2)] + '|' + s[int(width * (3+i+1) + width/2 + 1):]\n if n - wrong_times <= 1:\n # 6 means head, body, left hand, right hand, left leg and right leg\n for i in range(n - 6):\n s = s[:int(width * (3+i+1) + width/2)] + '|' + s[int(width * (3+i+1) + width/2 + 1):]\n # left leg\n if n - wrong_times <= 1:\n s = s[:int(width * (height-2) + width/2 - 1)] + '/' + s[int(width * (height-2) + width/2):]\n # right leg\n if n - wrong_times <= 0:\n s = s[:int(width * (height-2) + width/2 + 1)] + '\\\\' + s[int(width * (height-2) + width/2 + 2):]\n print(s)","def pentakis(self):\n return self.nlegomena(5)","def parse_streetdir(self):\n \n first = self.words[self.index]['word']\n if self.index + 1 < self.length:\n second = self.words[self.index+1]['word']\n else:\n second = None\n \n if first in ['northwest', 'northeast', 'southwest', 'southeast']:\n return first, 1 \n elif first == 'nw':\n return \"northwest\", 1\n elif first == 'ne':\n return \"northeast\", 1\n elif first == 'sw':\n return \"southwest\", 1\n elif first == 'se':\n return \"southeast\", 1\n \n if first in ['n', 'north']:\n if second in ['w', 'west']:\n return \"northwest\", 2\n elif second in ['e', 'east']:\n return \"northeast\", 2\n else:\n return \"north\", 1\n elif first in ['s', 'south']:\n if second in ['w', 'west']:\n return \"southwest\", 2\n elif second in ['e', 'east']:\n return \"southeast\", 2\n else:\n return \"south\", 1\n elif first in ['e', 'east']:\n return \"east\", 1\n elif first in ['w', 'west']:\n return \"west\", 1\n \n return None,0","def test():\n sf = \"6C 7C 8C 9C TC\".split() # Straight Flush\n sf1 = \"6C 7C 8C 9C TC\".split() # Straight Flush\n sf2 = \"6D 7D 8D 9D TD\".split() # Straight Flush\n fk = \"9D 9H 9S 9C 7D\".split() # Four of a Kind\n fk3 = \"TC TS TH 2C TD\".split() # Four of a Kind\n fh = \"TD TC TH 7C 7D\".split() # Full House\n fl = \"AH KH JH 6H TH\".split() # Flush\n st = \"AH KC QD JD TS\".split() # Straight\n tk = \"2H 2C 2D AC TD\".split() # Three of kind\n tp = \"TD 9H TH 7C 9S\".split() # Two Pair\n op = \"TD TC AD KD QD\".split() # One Pair\n hq = \"2D 3D 4C 5H 7H\".split() # High card\n al = \"AC 2D 4H 3D 5S\".split() # Ace-Low Straight\n tp1 = \"7H 7D 9C 3C 9S\".split() #Two Pair\n fkranks = card_ranks(fk)\n tpranks = card_ranks(tp)\n op1 = \"KH 7C 5S KS 2S\".split() # One pair\n tp2 = \"TH 3S 2H 3D TC\".split() # Two pair\n tk1 = \"TH JD JH 8C JC\".split() # Three of kind\n hq1 = \"TH 9D 5C 3H 2C\".split() # High card\n f3 = \"2C 4C 6C 7C TC\".split() # Flush\n s3 = \"3C 4D 5H 6D 7H\".split() # Straight\n assert poker([fk3, f3, s3]) == fk3 #gilje start\n assert poker([sf, 20*fk]) == sf\n assert poker([fk3, 5*f3]) == fk3\n assert card_ranks(fk3) == [10, 10, 10, 10, 2]\n assert card_ranks(f3) == [10, 7, 6, 4, 2]\n assert hand_rank(fk3) == (7, 10, 2)\n assert hand_rank(f3) == (5, [10, 7, 6, 4, 2])\n assert flush(f3) == True\n assert straight(card_ranks(s3)) == True\n assert straight(card_ranks(f3)) == False #gilje slutt\n assert poker([fh, tk, hq]) == fh #oistein start\n assert poker([fl, sf1, tk]) == sf1\n assert poker([op, al, fh]) == fh\n assert poker([st, fk, tp]) == fk\n assert poker([tk, tp, op]) == tk\n assert poker([hq, op, hq]) == op\n assert card_ranks(op1) == [13, 13, 7, 5, 2]\n assert card_ranks(tp2) == [10, 10, 3, 3, 2]\n assert card_ranks(tk1) == [11, 11, 11, 10, 8]\n assert card_ranks(hq1) == [10, 9, 5, 3, 2] #oistein slutt\n assert poker([hq, tp, op]) == tp#steffen start\n assert poker([al, st]) == st\n assert poker([al, st, fl]) == fl\n assert card_ranks(hq) == [7, 5, 4, 3, 2]\n assert card_ranks(fk) == [9, 9, 9, 9, 7]\n assert card_ranks(fh) == [10, 10, 10, 7, 7]#steffen slutt\n assert poker([sf2, tk, al]) == sf2#arild start\n assert poker([hq, st]) == st\n assert poker([al, st, fk]) == fk\n assert flush(fl) == True\n assert straight(card_ranks(tp)) == False\n assert card_ranks(fk) == [9, 9, 9, 9, 7]\n assert card_ranks(hq) == [7, 5, 4, 3, 2]\n assert hand_rank(tk) == (3, 2, [14, 10, 2, 2, 2])\n assert hand_rank(st) == (4, 14)\n assert kind(5, tpranks) == None#arild slutt\n assert poker([tp, op]) == tp #Even start\n assert poker([hq, tk]) == tk\n assert poker([sf1] + 50*[fl]) == sf1\n assert card_ranks(sf1) == [10, 9, 8, 7, 6]\n assert card_ranks(tk) == [14, 10, 2, 2, 2]\n assert card_ranks(st) == [14, 13, 12, 11, 10]\n assert kind(4, fkranks) == 9\n assert kind(3, fkranks) == None\n assert kind(2, tpranks) == 10\n assert kind(1, fkranks) == 7 #Even slutt\n assert poker([sf1, fk, fh]) == sf1\n assert poker([fk, fh]) == fk\n assert poker([fh, fh]) == [fh, fh]\n assert poker([sf1]) == sf1\n assert poker([sf1] + 99*[fh]) == sf1\n assert hand_rank(sf1) == (8, 10)\n assert hand_rank(fk) == (7, 9, 7)\n assert hand_rank(fh) == (6, 10, 7)\n assert straight(card_ranks(al)) == True\n assert poker([sf1, sf2, fk, fh]) == [sf1, sf2]\n assert kind(4, fkranks) == 9\n assert kind(3, fkranks) == None\n assert kind(2, fkranks) == None\n assert kind(1, fkranks) == 7\n return 'You did good, and you should feel good about yourself :)'","def solution(self):\n return [(\"the\", 1579644)] * 100","def lyft_labels():\n\n return {\n 0: 'None',\n 7: 'Roads',\n 10: 'Vehicles'\n }","def alphabet_war(fight):","def stickers_for(phrase):\n\n stic_dict = {}\n for ltr in 'instagram':\n if ltr not in stic_dict:\n stic_dict[ltr] = 1\n else:\n stic_dict[ltr] += 1\n print(ltr)\n\n phr_dict = {}\n for ltr in phrase:\n if ltr not in phr_dict:\n phr_dict[ltr] = 1\n else:\n phr_dict[ltr] += 1\n print(ltr)\n\n ratios = []\n for ltr in stic_dict:\n if ltr in phr_dict:\n ratio = phr_dict[ltr] / stic_dict[ltr]\n ratios.append(ratio)\n\n if len(ratios) > 0:\n num_sticks = max(ratios)\n num_sticks = int(round(num_sticks, 0))\n return stic_dict, phr_dict, ratios, num_sticks\n\n else: \n return 0","def adjust_left_right_positions():\n # bp_* is synonym for 'Best Position Left/Right' and are adjusted \n # to optimize bmv_*\n p_l, bp_l = [pos] * 2\n p_r, bp_r = [pos + qlen] * 2\n\n # bmv_* are declared here in case they are untouched in optimization\n bmv_l = match_values[p_l / step]\n bmv_r = match_values[p_l / step]\n\n for f in range(flex):\n ll = _match(query, corpus[p_l - f: p_r])\n if ll > bmv_l:\n bmv_l = ll\n bp_l = p_l - f\n\n lr = _match(query, corpus[p_l + f: p_r])\n if lr > bmv_l:\n bmv_l = lr\n bp_l = p_l + f\n\n rl = _match(query, corpus[p_l: p_r - f])\n if rl > bmv_r:\n bmv_r = rl\n bp_r = p_r - f\n\n rr = _match(query, corpus[p_l: p_r + f])\n if rr > bmv_r:\n bmv_r = rr\n bp_r = p_r + f\n\n if verbose:\n print(\"\\n\" + str(f))\n print(\"ll: -- value: %f -- snippet: %s\" % (ll, corpus[p_l - f: p_r]))\n print(\"lr: -- value: %f -- snippet: %s\" % (lr, corpus[p_l + f: p_r]))\n print(\"rl: -- value: %f -- snippet: %s\" % (rl, corpus[p_l: p_r - f]))\n print(\"rr: -- value: %f -- snippet: %s\" % (rl, corpus[p_l: p_r + f]))\n\n return bp_l, bp_r, _match(query, corpus[bp_l : bp_r])","def substantiate():","def celex_pron_loc(language, lemma):\n pron = 5\n if language == \"german\" or language== \"dutch\": pron = pron -2 #german one less\n if lemma == \"wordform\": pron += 1\n return pron","def logAscent():\r\n global hardest\r\n \r\n #v-grade running total\r\n running = eFive.get()\r\n eFive.delete(0, END)\r\n r = int(running)\r\n grade = eTwo.get()\r\n eFive.insert(0, r + int(grade) )\r\n\r\n #hardest boulder tracker\r\n latest = eTwo.get()\r\n if int(latest) >= int(hardest):\r\n hardest = latest\r\n \r\n #attempts running total\r\n attRunning = eSix.get()\r\n eSix.delete(0, END)\r\n aR = int(attRunning)\r\n tries = eThree.get()\r\n eSix.insert(0, aR + int(tries) )\r\n \r\n #moves running total\r\n movesRunning = eSeven.get()\r\n eSeven.delete(0, END)\r\n mR = int(movesRunning)\r\n moves = eFour.get()\r\n eSeven.insert(0, mR + int(moves) )\r\n\r\n #logs the names of all boulders\r\n name = eOne.get()\r\n eEight.insert(0, str(name) + \" || \")","def fo_shizzle_my_nizzle(n): \n if n < 0:\n n = \"fo\"\n elif n >= 1 and n < 50: \n n = \"shizzle\"\n elif n >= 50 and n <= 100:\n n = \"my\"\n elif n % 2 == 0 and n % 3 == 0 and n > 100:\n n = \"nizzle\"\n else:\n n = \"\"\n return n","def count_words_and_dublicates(novel):","def solution(self):\n return [(\"the\", 1561900)] * 100","def dis(self):\n return self.nlegomena(2)","def verse_2():\n print(\"Old MacDonald had a farm\")\n print(\"E-I-E-I-O\")","def __init__(self, n, sents):\n assert n > 0\n self._n = n\n print(\"Counting...\")\n count = defaultdict(int)\n while n >= 0:\n for sent in sents:\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n print(\"Computing vocabulary...\")\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc) # vocabulary size\n print(\"Done\")","def apex(side):\n return side % 3","def step4(self):\n\t\tif self.b[self.k - 1] == 'a':\n\t\t\tif self.ends(\"al\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'c':\n\t\t\tif self.ends(\"ance\"): pass\n\t\t\telif self.ends(\"ence\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'e':\n\t\t\tif self.ends(\"er\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'i':\n\t\t\tif self.ends(\"ic\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'l':\n\t\t\tif self.ends(\"able\"): pass\n\t\t\telif self.ends(\"ible\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'n':\n\t\t\tif self.ends(\"ant\"): pass\n\t\t\telif self.ends(\"ement\"): pass\n\t\t\telif self.ends(\"ment\"): pass\n\t\t\telif self.ends(\"ent\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'o':\n\t\t\tif self.ends(\"ion\") and (self.b[self.j] == 's' or self.b[self.j] == 't'): pass\n\t\t\telif self.ends(\"ou\"): pass\n\t\t\t# takes care of -ous\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 's':\n\t\t\tif self.ends(\"ism\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 't':\n\t\t\tif self.ends(\"ate\"): pass\n\t\t\telif self.ends(\"iti\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'u':\n\t\t\tif self.ends(\"ous\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'v':\n\t\t\tif self.ends(\"ive\"): pass\n\t\t\telse: return\n\t\telif self.b[self.k - 1] == 'z':\n\t\t\tif self.ends(\"ize\"): pass\n\t\t\telse: return\n\t\telse:\n\t\t\treturn\n\t\tif self.m() > 1:\n\t\t\tself.k = self.j","def get_entailment_judgements():\n results = defaultdict(lambda: [0,0,0])\n mapping = dict(zip(('CONTRADICTION','ENTAILMENT','NEUTRAL'), range(3)))\n\n firstline = True\n for line in open('working/sick.run'):\n if firstline:\n firstline = False\n else:\n words = line.split()\n sick_id = str(words[0])\n result = words[1]\n\n # Set the index correspoinding to the judgement to 1\n results[sick_id][mapping[result]] = 1\n return results","def REC_L_STRAIGHT():\n return 11","def watch_pyramid_from_the_side(characters):\n if characters:\n space_count = 0\n count = len(characters)\n out_string = \"\"\n for char in characters:\n out_string += \" \" * space_count + char * (2 * count - 1) +\\\n \" \" * space_count + \"\\n\"\n count -= 1\n space_count += 1\n return out_string[-2::-1]\n else:\n return characters","def ROOM_DESCRIPTIONS(adventurer):\n rooms = (\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside a wine cellar, most of it is filled with cracked, empty bottles.\\n\"\n \"Perhaps it is better to not go looking for an intact bottle.\\n\"\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} suspects it will be very detrimental to their health to fight monsters while drunk.\",\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside a gaol, the cells are mostly filled with the skeletons of prisoners long dead.\\n\"\n \"Most of the cell doors are open with the exception of one in the far corner.\\n\"\n \"There seems to be a person in there but they are crouched in the corner muttering to themself.\\n\"\n \"The cleaver they are holding looks very dangerous so perhaps it is best to leave them alone.\\n\",\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR}is inside a dusty old library, piles and piles of books are scattered amongst the dirty floor.\\n\"\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} remembers the last time they perused books inside of that nast vampire\\'s castle.\\n\"\n f\"The tentacles that came out of the pages almost strangled {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR}.\\n\"\n f\"Perhaps it is better to finish what {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} came here to do instead of doing some light reading.\",\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside what appears to be a ritual room.\\n\"\n \"The only things inside a room are black candles mounted on the walls and a pentagram in the middle of the floor.\\n\"\n f\"The pentagram appears to be made from dried blood, {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} would rather not think of who or what provided that blood.\\n\"\n \"On each corner of the star there appears to be a random assortment of objects.\\n\"\n \"For some reason one of them looks like a phallic object.\\n\"\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} decides they don\\'t want to stay here any longer than they have to.\",\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside their childhood bedroom.\\n\"\n f\"The bed and drawer is just like how they remember it.\\n\"\n f\"There's even that empty aquarium {adventurer} left inside their room even though the fish all died within a day.\\n\"\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} would rather not think too hard about why their room is inside of a dungeon.\\n\",\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside of a sewer, the smell feels like its burning away their nostril hairs.\\n\"\n f\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} wonders how there could even be a sewer when the doors connecting it lead into different rooms.\\n\"\n f\"As {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} stands there they see a figure in their peripheral vision.\\n\"\n \"What looks like a large bipedal rat is standing there 4 smaller bipedal turtles.\\n\"\n f\"Before {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} can say anything a large cloud of smoke appears and when it disappears they are gone.\\n\"\n )\n return random.choice(rooms)","def Lobulation(self):\n s = self.lobulation\n assert s in range(1,6), \"Lobulation score out of bounds.\"\n return _char_to_word_[ s-1 ] + ' Lobulation'","def how_many(self):\n\tprint \"We have {0} robots !!!\".format(self.population)","def solution(self):\n return [(\"simple 1\", 1.),\n (\"simple 2\", 1.),\n (\"simple 3\", 1.),\n (\"simple 4\", 1.),\n (\"simple 5\", 1.),\n (\"simple 10\", 1.),\n (\"simple 15\", 1.),\n (\"thai 1\", 1.),\n (\"thai 2\", 1.),\n (\"thai 3\", 1.),\n (\"thai 4\", 1.),\n (\"thai 5\", 1.),\n (\"thai 10\", 1.),\n (\"thai 15\", 1.),\n ]","def strategiaa(stan_gry):\n ruch = min(random.randint(1,3), stan_gry)\n return ruch","def exemple():\r\n\r\n case_1 = \"\\u25CC\"\r\n case_1 = u\"{}\".format(case_1)\r\n fourmi_1_1 = \"\\u22C0\"\r\n fourmi_1_1 = u\"{}\".format(fourmi_1_1)\r\n fourmi_2_1 = \"\\u21CA\"\r\n fourmi_2_1 = u\"{}\".format(fourmi_2_1)\r\n fourmi_3_1 = \"\\u25BC\"\r\n fourmi_3_1 = u\"{}\".format(fourmi_3_1)\r\n fourmi_1_2 = \"\\u22C0\"\r\n fourmi_1_2 = u\"{}\".format(fourmi_1_2)\r\n fourmi_2_2 = \"\\u21C8\"\r\n fourmi_2_2 = u\"{}\".format(fourmi_2_2)\r\n fourmi_3_2 = \"\\u25B2\"\r\n fourmi_3_2 = u\"{}\".format(fourmi_3_2)\r\n clods_1 = \"\\u2726\"\r\n clods_1 = u\"{}\".format(clods_1)\r\n clods_2 = \"\\u2737\"\r\n clods_2 = u\"{}\".format(clods_2)\r\n clods_3 = \"\\u2739\"\r\n clods_3 = u\"{}\".format(clods_3)\r\n \r\n print(term.move_xy(82,3) + term.white + 'DEPOT : ' + (case_1))\r\n print(term.move_xy(82,5) + term.white + 'Clods de niveau 1 : ' + (clods_1))\r\n print(term.move_xy(82,6) + term.white + 'Clods de niveau 2 : ' + (clods_2))\r\n print(term.move_xy(82,7) + term.white + 'Clods de niveau 3 : ' + (clods_3))\r\n print(term.move_xy(82,8) + term.white + 'Fourmis de niveau 1 : ' + (fourmi_1_1) + ' ' + (fourmi_1_2))\r\n print(term.move_xy(82,9) + term.white + 'Fourmis de niveau 2 : ' + (fourmi_2_1) + ' ' + (fourmi_2_2))\r\n print(term.move_xy(82,10) + term.white + 'Fourmis de niveau 3 : ' + (fourmi_3_1) + ' ' + (fourmi_3_2))\r\n print(term.move_xy(82,12) + term.white + 'Joueur 1 vous jouez en rouge.')\r\n print(term.move_xy(82,13) + term.white + 'Joueur 2 vous jouez en jaune.')","def one_v_all(d):\n label = [0, 0, 0, 0]\n for raw in d.split(\"|\")[4:]:\n line = raw.strip()\n if \"brain\" in line:\n label[0] = 1\n if \"limb\" in line:\n label[1] = 1\n if \"heart\" in line:\n label[2] = 1\n if \"neural\" in line:\n label[3] = 1\n return label","def generate_romance_title():\n d69 = random.randint(1, 69)\n if d69 <= 35:\n #the adj noun\n return \"The \" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \" \" + romance_noun[random.randint(0, len(romance_noun) - 1)]\n elif d69 > 35:\n #noun of the adj noun\n return romance_noun[random.randint(0, len(romance_noun) - 1)] + \" of the \" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \" \" + romance_noun[random.randint(0, len(romance_noun) - 1)]","def apartment_number():\r\n\r\n type = _random.choice(['Apt.', 'Apartment', 'Suite', 'Ste.'])\r\n letter = _random.choice(string.ascii_letters).capitalize()\r\n directions = ['E', 'W', 'N', 'S']\r\n short = '{} {}'.format(type, _random.randint(1, 999))\r\n long = '{} {}{}'.format(type, _random.randint(1, 999), letter)\r\n alt = '{} {}-{}{}'.format(type, _random.choice(directions),\r\n _random.randint(1, 999), letter)\r\n return _random.choice([short, long, alt])","def enough_lords(self):\n real_numbers = {\n Title.count: len(self.get_lords_of_title(Title.count)),\n Title.baron: len(self.get_lords_of_title(Title.baron)),\n Title.baronet: len(self.get_lords_of_title(Title.baronet)),\n Title.chevalier: len(self.get_lords_of_title(Title.chevalier)),\n Title.client: len(self.get_lords_of_title(Title.client)),\n }\n\n counter = {Title.baron: 0, Title.baronet: 0, Title.chevalier: 0,\n Title.client: 0}\n\n for title, vassals in LORDS_VASSALS.items():\n for i in range(real_numbers[title]):\n for lower_title, value in vassals.items():\n counter[lower_title] += value\n\n for title, count in counter.items():\n if count > real_numbers[title]:\n print(f'Not enough lords of title: {title.value}, '\n f'required: {count}, actual: {real_numbers[title]}')\n return False\n return True","def verse_1():\n print(\"Old MACDONALD had a farm\")\n print(\"E-I-E-I-O\")","def bolinish_alomatlari(son):\n for n in range(1,11):\n if not son % (n):\n print(f\"{son} {n} ga qoldiqsiz bo'linadi \")","def left(i):\r\n return 2 * i + 1","def display_pokemon(pokemon_party):\n \n for count, i in enumerate(pokemon_party, start=0):\n print(f\"{count+1}){pokemon_party[count]}\")","def get_number_of_atmos_levels(description):\n if description == \"none\":\n return \"0\", \"0\"\n elif re.search(\"levels\", description):\n match = re.search(\"(?P<nl>\\d+)\\s?(levels|vertical levels)\", description)\n nlevs = match.groupdict()[\"nl\"]\n if int(nlevs) > 49: nlas = \"20\"\n else: nlas = \"10\"\n return nlevs, nlas\n else:\n return \"40\", \"20\"","def organise(times, words):\r\n length_lst = \"\"\r\n comm_lst = \"\"\r\n for item in times:\r\n length_lst += str(item[0]) + \" - \" + str(item[1]) + \"\\n\"\r\n for item in words:\r\n comm_lst += str(item[0]) + \" - \" + str(item[1]) + \"\\n\"\r\n\r\n return length_lst, comm_lst","def main():\r\n\thead()\r\n\tbelt()\r\n\tupper()\r\n\tlower()\r\n\tbelt()\r\n\thead()","def main():\r\n\thead()\r\n\tbelt()\r\n\tupper()\r\n\tlower()\r\n\tbelt()\r\n\thead()","def give_names(x): \n if x == 0:\n return 'Lost'\n else:\n return 'Won/Broke Even'","def wcount(lines, topn):\n word = ''\n for i in lines:\n if 65<=ord(i) and ord(i)<=90:\n word = word + i \n elif 97<=ord(i) and ord(i)<=122:\n word = word + i\n else:\n word = word + ' ' \n word = word.split()\n #提取不重复的单词\n alreadyknown = []\n for m in word:\n if m not in alreadyknown:\n alreadyknown.append(m)\n #分别数数，排序，建构字典\n empty = []\n final = {}\n final2 = {}\n for j in alreadyknown:\n number = icount(word,j)\n final[j]=number\n final2[str(number)]=j\n empty.append(number)\n empty.sort()\n empty.reverse()\n last_step = empty[:10]\n #通过数字找到对应word\n last_str = ''\n for y in last_step:\n z = final2[str(y)]\n last_str += z + \"\\t\" + str(y) + \"\\n\"\n return last_str","def CARD_SUITS() -> tuple:\n return \"Diamonds\", \"Hearts\", \"Clubs\", \"Spades\"","def treatment_plugs(data_plugs):\r\n\r\n no_plugs = []\r\n little = []\r\n means = []\r\n great = []\r\n large_enough = []\r\n super_large = []\r\n\r\n\r\n for i in data_plugs:\r\n print(i[0])\r\n if i[1] in ('None', None)\\\r\n or i[0] in ('None', None):\r\n pass\r\n elif i[0] == 'non':\r\n no_plugs.append(int(i[1]))\r\n elif i[0] == 'petit':\r\n little.append(int(i[1]))\r\n elif i[0] == 'moyen':\r\n means.append(int(i[1]))\r\n elif i[0] == 'grand':\r\n great.append(int(i[1]))\r\n elif i[0] == 'assez grand':\r\n large_enough.append(int(i[1]))\r\n elif i[0] == 'tres grand':\r\n super_large.append(int(i[1]))\r\n\r\n\r\n data = len(no_plugs) + len(little) +\\\r\n len(means) + len(great)+\\\r\n len(large_enough)+\\\r\n len(super_large)\r\n\r\n print(data)\r\n\r\n data_no = moyenne(no_plugs)\r\n data_little = moyenne(little)\r\n data_means = moyenne(means)\r\n data_great = moyenne(great)\r\n data_large_enough = moyenne(large_enough)\r\n data_super_large = moyenne(super_large)\r\n\r\n return data_no[0],\\\r\n data_little[0],\\\r\n data_means[0],\\\r\n data_great[0],\\\r\n data_large_enough[0],\\\r\n data_super_large[0],\\\r\n data_no[1],\\\r\n data_little[1],\\\r\n data_means[1],\\\r\n data_great[1],\\\r\n data_large_enough[1],\\\r\n data_super_large[1],\\\r\n data","def make_althws(entries):\n althws = []\n nentries = len(entries)\n for ientry,entry in enumerate(entries):\n m = re.search(r'<althws>{#(.*?)#}</althws>',entry.datalines[0])\n if m == None:\n continue\n hws = re.split(r', *',m.group(1))\n L0 = entry.metad['L']\n pc0 = entry.metad['pc']\n k10 = entry.metad['k1']\n k20 = entry.metad['k2']\n # Get L for next entry, or None if this is last entry\n ientry1 = ientry+1\n if ientry1 < nentries:\n entry1 = entries[ientry1]\n L1 = entry1.metad['L']\n else:\n L1 = None\n nhws = len(hws)\n Lhws = generate_Ls(L0,L1,nhws) # this is the tricky part\n if 10 <= nhws:\n print('%s,%s,%s has %s alternate headwords' %(L0,pc0,k10,nhws))\n # generate a line for each hw\n for ihw,hw in enumerate(hws):\n L = Lhws[ihw]\n pc = pc0\n k1 = hw\n k2 = hw\n t = 'alt' #type\n lp = L0\n k1p = k10\n out = '<L>%s<pc>%s<k1>%s<k2>%s<type>%s<LP>%s<k1P>%s' %(\n L,pc,k1,k2,t,lp,k1p)\n althws.append(out)\n return althws","def rules():\r\n print(\"\\n\\\r\n \\tMmmmm... Si vous etes ici, j'imagine que votre décision est prise !\\n\\\r\n Je ne veux pas vous inciter à arreter mais vous etes conscient des risques ?\\n\\\r\n Vous participez quand meme au plus grand combat de tous les temps...\\n\\n\\\r\n \\tBon je vous explique les règles : Vous allez affronter un autre titan en duel\\n\\\r\n Vous avez chacun des tentatives d'infliger une attaque. Si elles réussissent,\\n\\\r\n Vous aurez le choix d'infliger entre 0 et 100 dégats. Enfin non puisque tout\\n\\\r\n sera tiré au sort :)\\n\\\r\n La partie s'arrete quand l'un des deux titans est mort\\n\\\r\n \\tBonne chance a vous!\\n\")","def pix(length, legs):\n pos_m = 0\n pos_p = 0\n for i in range(1, legs+1):\n print(i, '. leg')\n pos_m, pos_p = one_leg(length, pos_m, pos_p)\n if pos_m == length:\n print('Mat wins')\n return 1\n elif pos_p == length:\n print('Pat wins')\n return -1\n return 0","def vanilaScore(self,attended,state,W):","def prob4():\n#pass\n n_men = 0\n n_women = 0\n db = sql.connect('sql2')\n cur = db.cursor()\n cur.execute(\"SELECT Gender FROM ICD WHERE Age>=25 AND Age<=35\")\n for gen in cur :\n if gen[0] == 'M' :\n n_men += 1\n else :\n n_women += 1\n db.close()\n return n_men,n_women","def abstract(res):\n o = r'\\begin{center}'\n #o += r'\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\n #o += r'\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\n o += r'\\begin{tikzpicture}' + '\\n'\n o += r'\\draw[blue!40!white] (0,0) rectangle (6,4); \\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\n'\n for i in range(res[7]):\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\n o += r'\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\n'\n o += r'\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\n'\n o += r'\\end{tikzpicture}\\end{center}' + '\\n'\n\n o += r'\\begin{tabular}{|l|l|}' + '\\n' + r'\\hline' + '\\n'\n o += r'Election name& \\texttt{\"%s\"}\\\\'%res[1]\n o += r'Box number& \\texttt{%s}\\\\'%res[2]\n o += r'State& \\texttt{%s}\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\n o += r'Registration end& \\textit{%s}\\\\'%res[3]\n o += r'Vote closing& \\textit{%s}\\\\'%res[4]\n o += r'Casted/registered& $%s/%s$\\\\'%(res[7],res[6]) +'\\n'\n o += r'\\hline\\end{tabular}' + '\\n'\n o += r'\\quad' + '\\n'\n o += r'\\begin{tabular}{|l|l|}\\hline'\n l = res[8].items()\n l.sort(key = operator.itemgetter(1),reverse=True)\n n = 0\n for x in l:\n o += r'%s & %s\\\\'%(r'\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\texttt{%s}'%x[0],x[1]) \n if n == 0:\n o += r'\\hline' + '\\n'\n n += 1\n o += r'\\hline\\end{tabular}' + '\\n'\n\n\n #o += r'\\item The designer\\textquoteright s digital signature of this document (the source file \\texttt{oeu.py}) is: \\tiny $$\\verb!%s!$$ \\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\n'\n\n return r'\\begin{abstract}' + abstract.__doc__ + r'\\end{abstract}' + o","def part1(input_string):\n twos, threes = 0, 0\n for line in input_string:\n letters_seen = {}\n for char in line:\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\n if 2 in letters_seen.values():\n twos += 1\n if 3 in letters_seen.values():\n threes += 1\n return threes * twos","def the_counting_game(number_of_players=10, total=100):\n # a b c d e f g h i j\n # 1 2 3 4 5 6 7\n # 13 12 11 10 9 8\n # 14\n # 15 16 17 18 19 20 21\n # 27 26 25 24 23 22\n # 28\n # 29\n # print \"total\", total\n player_number = 1 # first player will say the number 1\n dir = 'right' # we start off counting to the right\n num_said = 1 # the number said by the first player\n while num_said < total:\n if dir == 'right':\n print dir\n # if we're at the last player, go back to the first player\n # which is last player minus total number of players minus 1\n if player_number == number_of_players:\n player_number = number_of_players - 1\n print \"p\", player_number, \"said: \", num_said\n else:\n print \"p\", player_number, \"said: \", num_said\n player_number += 1\n # if the next number will be a multiple of 7, time to switch directions\n if (num_said + 1) % 7 == 0:\n print \"this should switch\", dir\n dir = switch_direction(dir)\n print \"this should switch\", dir\n elif dir == 'left':\n print dir\n # if this is the first player, going left means going to the last player\n # which is total number of players\n if player_number == 1:\n player_number += (number_of_players - 1)\n else:\n print \"p\", player_number, \"said: \", num_said\n player_number -= 1\n # if the next number will be a multiple of 7, time to switch directions\n if (num_said + 1) % 7 == 0:\n print \"this should switch\", dir\n dir = switch_direction(dir)\n print \"this should switch\", dir\n num_said += 1\n return \"Player to say the total: \" + str(player_number)","def step2(self):\n\t\tif self.b[self.k - 1] == 'a':\n\t\t\tif self.ends(\"ational\"): self.r(\"ate\")\n\t\t\telif self.ends(\"tional\"): self.r(\"tion\")\n\t\telif self.b[self.k - 1] == 'c':\n\t\t\tif self.ends(\"enci\"):\t self.r(\"ence\")\n\t\t\telif self.ends(\"anci\"): self.r(\"ance\")\n\t\telif self.b[self.k - 1] == 'e':\n\t\t\tif self.ends(\"izer\"):\t self.r(\"ize\")\n\t\telif self.b[self.k - 1] == 'l':\n\t\t\tif self.ends(\"bli\"):\t self.r(\"ble\") # --DEPARTURE--\n\t\t\t# To match the published algorithm, replace this phrase with\n\t\t\t#\tif self.ends(\"abli\"):\t self.r(\"able\")\n\t\t\telif self.ends(\"alli\"): self.r(\"al\")\n\t\t\telif self.ends(\"entli\"): self.r(\"ent\")\n\t\t\telif self.ends(\"eli\"):\t self.r(\"e\")\n\t\t\telif self.ends(\"ousli\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 'o':\n\t\t\tif self.ends(\"ization\"): self.r(\"ize\")\n\t\t\telif self.ends(\"ation\"): self.r(\"ate\")\n\t\t\telif self.ends(\"ator\"): self.r(\"ate\")\n\t\telif self.b[self.k - 1] == 's':\n\t\t\tif self.ends(\"alism\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iveness\"): self.r(\"ive\")\n\t\t\telif self.ends(\"fulness\"): self.r(\"ful\")\n\t\t\telif self.ends(\"ousness\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 't':\n\t\t\tif self.ends(\"aliti\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iviti\"): self.r(\"ive\")\n\t\t\telif self.ends(\"biliti\"): self.r(\"ble\")\n\t\telif self.b[self.k - 1] == 'g': # --DEPARTURE--\n\t\t\tif self.ends(\"logi\"):\t self.r(\"log\")\n\t\t# To match the published algorithm, delete this phrase","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2):\n #moves shorter sequence along longer, counting number of matches in\n #each position\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\"\n score = score + 1\n else:\n matched = matched + \"-\"\n\n # gives an output for each startpoint showing the number of matches where\n # * is a match and - is no match, position of the two sequences relative to\n # each other, and the number of matches for that startpoint.\n print(\".\" * startpoint + matched) \n print(\".\" * startpoint + s2)\n print(s1)\n print(score) \n print(\" \")\n\n return score","def estimate_planks(self, length):\n number_of_planks = length // self.plank_length\n return f\"You need {number_of_planks} plank(s) of wood to build this wall\"","def main():\n args = get_args()\n guess = args.guess.upper()\n choice = args.choice\n \n dict = {1: 'Arcosanti', 2: 'Intercept', 3: 'Positions', 4: 'Collected', 5: 'Gemstones', 6: 'Cellulose', 7: 'Mastodons', 8: 'Meteorite', 9: 'Phoenixes', 10: 'Fireflies'} \n \n if choice > 10 or choice < 1: \n die('The choice number must be between 1 and 10') \n base = dict[choice].upper()\n if len(guess) < len(base) or len(guess) > len(base):\n die('The guess must be the same length as the word: {}'.format(len(base)))\n \n for i,j in zip(guess, base): \n if i == j:\n print('{}'.format(i),end='') \n else:\n print('_', end='')\n print('\\n')","def generate_fantasy_title():\n d20 = random.randint(1, 20)\n if d20 <= 4:\n #genetive noun\n return fantasy_genetive[random.randint(0, len(fantasy_genetive) - 1)] + \" \" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\n elif d20 > 4 and d20 < 13: \n #The adj noun\n return \"The \" + fantasy_adj[random.randint(0, len(fantasy_adj) - 1)] + \" \" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\n elif d20 >= 13:\n #something of something\n return fantasy_noun[random.randint(0, len(fantasy_noun) - 1)] + \" of \" + fantasy_what_is_this[random.randint(0, len(fantasy_what_is_this) - 1)]","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2): \n if (i + startpoint) < (l1 + l2 - 1): \n if l2 - i > startpoint + 1:\n matched = matched + \".\" #dots before they start overlapping\n elif s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" #matched bases\n score = score + 1 #adds one to score\n else:\n matched = matched + \"-\" #not matched bases\n shift, end_shift = startpoint * \".\", (l2 + l1 - startpoint - 2) * \".\"\n # dots at end, but only up until end of dots tailing l1\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\n # this formula. the below check stops it from getting less than l2.\n if startpoint < l1 - 1:\n print(shift + matched + end_shift)\n else:\n print(shift + matched + (l2 - 1) * \".\")\n print(shift + s2 + end_shift)\n print(s1)\n print(str(score) + \"\\n\")\n return score, matched, shift, end_shift","def build_leftpart():\n # build kelly.\n build_kelly()\n # copy kelly to 3.\n copy(0, 3)\n\n # build june in slots 0,1,2\n build_june()\n # copy kelly to slot 1\n copy(3, 1)\n\n # smash together to get (june kelly) in 0\n smash()\n # copy (june kelly) to 1\n copy(0, 1)\n # build horace in 0\n build_horace(0)\n # smash together to get (horace (june kelly)) in 0\n smash()\n # wrap with an S for the whole left part.\n apply_card(\"S\", 0)","def find_gender_adj(novel, female):\n output = {}\n text = novel.get_tokenized_text()\n\n if female:\n distances = female_instance_dist(novel)\n pronouns1 = [\"her\", \"hers\", \"she\", \"herself\"]\n pronouns2 = [\"his\", \"him\", \"he\", \"himself\"]\n else:\n distances = male_instance_dist(novel)\n pronouns1 = [\"his\", \"him\", \"he\", \"himself\"]\n pronouns2 = [\"her\", \"hers\", \"she\", \"herself\"]\n if len(distances) == 0:\n return {}\n elif len(distances) <= 3:\n lower_window_bound = 5\n else:\n lower_window_bound = median(sorted(distances)[:int(len(distances) / 2)])\n\n if not lower_window_bound >= 5:\n return \"lower window bound less than 5\"\n for l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11 in windowed(text, 11):\n l6 = l6.lower()\n if not l6 in pronouns1:\n continue\n words = [l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11]\n if bool(set(words) & set(pronouns2)):\n continue\n for index, word in enumerate(words):\n words[index] = word.lower()\n tags = nltk.pos_tag(words)\n for tag_index, tag in enumerate(tags):\n if tags[tag_index][1] == \"JJ\" or tags[tag_index][1] == \"JJR\" or tags[tag_index][1] == \"JJS\":\n word = words[tag_index]\n if word in output.keys():\n output[word] += 1\n else:\n output[word] = 1\n return output","def get_true_propositions(self):\n current_loc = self.objects.get((self.agent.i,self.agent.j), \"\")\n if current_loc: # taxi at location\n loc_i = \"abcd\".index(current_loc.lower())\n if self.passenger == current_loc: # passenger at location\n return Traces.letters[loc_i+4]\n else: # passenger in taxi or elsewere\n return Traces.letters[loc_i]\n else: # taxi in transit\n return \"\"\n\n # ret = self.objects.get((self.agent.i,self.agent.j), \"\").lower()\n # ret += \"efgh\"[\"abcd\".index(self.destination.lower())]\n # if self.passenger is not None: # at location\n # ret += \"ijkl\"[\"abcd\".index(self.passenger.lower())]\n # else: # in taxi\n # ret += \"m\"\n # return ret","def walk_through_floors(instructions):\n floor = 0\n position = 0\n enter_basement_at = 0\n for instruction in instructions:\n position += 1\n if instruction == '(':\n floor += 1\n else:\n floor -= 1\n if floor == -1 and enter_basement_at == 0:\n enter_basement_at = position\n return floor, enter_basement_at","def test_longest_streak_all_habits():\n habits_trackings_table = analytics.habits_trackings_table()\n habit_info_longest_streak = analytics.habit_info_longest_streak(habits_trackings_table)\n assert analytics.name_habit_longest_streak(habit_info_longest_streak) == [('Yoga', 9)]","def get_direction_letters(d):\n d_letters = ('N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW')\n x = int((d + 11.25) / 22.5) % 16\n return d_letters[x]","def possible_directions(valid_positions):\n if valid_positions == \"n\":\n print(\"You can travel: (N)orth.\")\n elif valid_positions == \"nes\":\n print(\"You can travel: (N)orth or (E)ast or (S)outh.\")\n elif valid_positions == \"es\":\n print(\"You can travel: (E)ast or (S)outh.\")\n elif valid_positions == \"sw\":\n print(\"You can travel: (S)outh or (W)est.\")\n elif valid_positions == \"ew\":\n print(\"You can travel: (E)ast or (W)est.\")\n elif valid_positions == \"ns\":\n print(\"You can travel: (N)orth or (S)outh.\")","def evaulate_monster(generikmon):\r\n score = generikmon['headA']\r\n #score = generikmon['chinA']\r\n return score","def action_to_id(a):\n if a == [-1.0, 0.0, 0.0]: return LEFT # LEFT: 1\n elif a == [1.0, 0.0, 0.0]: return RIGHT # RIGHT: 2\n elif a == [0.0, 1.0, 0.0]: return ACCELERATE # ACCELERATE: 3\n elif a == [0.0, 0.0, 0.2]: return BRAKE # BRAKE: 4\n else: \n return STRAIGHT # STRAIGHT = 0","def one_leg(length, pos_m, pos_p):\n pos_m, mat_moves = one_player_leg(length, pos_m)\n if pos_p == pos_m:\n pos_p = 0\n pos_p, pat_moves = one_player_leg(length, pos_p)\n print('Mat:', end=' ')\n for move in mat_moves:\n print(move, end=' ')\n print('Pat:', end=' ')\n for move in pat_moves:\n print(move, end=' ')\n if pos_m == pos_p:\n pos_m = 0\n print('\\n')\n one_line_print(length, 'M', pos_m)\n one_line_print(length, 'P', pos_p)\n print('\\n')\n return pos_m, pos_p","def find_boundaries(s, w):\n ind = w.i\n # handling height\n if ind + 2 < len(s) and s[ind + 1].text == \"'\" and s[ind + 2].like_num:\n return ind, ind + 3\n if ind - 2 >= 0 and s[ind - 1].text == \"'\" and s[ind - 2].like_num:\n return ind - 2, ind + 1\n\n # forward\n if s[ind].ent_iob == 2:\n return ind, ind + 1\n if ind != len(s) - 1:\n i = ind + 1\n while s[i].ent_iob == 1 and (s[i].pos_ == 'NUM' or s[i].like_num or\n (i+1 < len(s) and (s[i+1].pos_ == 'NUM' or s[i+1].like_num))):\n i += 1\n if i == len(s):\n break\n if s[i - 1].pos_ == 'NUM' or s[i - 1].like_num or s[i - 1].lemma_ in ['one']:\n end = i\n else:\n end = i - 1\n else:\n end = ind + 1\n\n # backward\n if s[ind].ent_iob == 3:\n return ind, end\n i = ind - 1\n while s[i].ent_iob != 2 and (s[i].pos_ == 'NUM' or s[i].like_num or s[i-1].pos_ == 'NUM' or s[i-1].like_num):\n i -= 1\n if i == -1:\n break\n i += 1\n if s[i].pos_ != 'NUM' and not s[i].like_num:\n i += 1\n return i, end","def display_game(game: List[int]) -> None:\n print()\n row = 0\n while(row < len(game)):\n print(row+1, end=\"- \")\n m = game[row]\n while m > 0:\n print(\"| \", end='')\n m -= 1\n row += 1\n print()\n print()","def _make_limb_dict():\n\n return {'left_arm_y': 10, 'right_arm_y': 13,\n 'left_arm_z': 11, 'right_arm_z': 14,\n 'left_leg_y': 4, 'right_leg_y': 7,\n 'left_leg_z': 5, 'right_leg_z': 8,\n 'hip_y': 2, 'hip_x': 1}","def predictSideFromFEN(fen):\n\n # remove spaces values (numbers) from fen\n fen = re.sub('\\d','',fen)\n \n #split fen to top half and bottom half (top half first)\n parts = fen.split('/')\n top = list(''.join(parts[:4]))\n bottom = list(''.join(parts[4:]))\n \n # If screenshot is aligned from POV of white to play, we'd expect\n # top to be mostly black pieces (lowercase)\n # and bottom to be mostly white pieces (uppercase), so lets count\n top_count_white = sum(list(map(lambda x: ord(x) <= ord('Z'), top)))\n bottom_count_white = sum(list(map(lambda x: ord(x) <= ord('Z'), bottom)))\n\n top_count_black = sum(list(map(lambda x: ord(x) >= ord('a'), top)))\n bottom_count_black = sum(list(map(lambda x: ord(x) >= ord('a'), bottom)))\n\n # If more white pieces on top side, or more black pieces on bottom side, black to play\n if (top_count_white > bottom_count_white or top_count_black < bottom_count_black):\n return 'b'\n\n # Otherwise white\n return 'w'","def check_hand_rank(hand):\n card_rank = ['--23456789TJQKA'.index(n) for n,h in hand]\n card_rank.sort()\n card_rank.reverse()\n #for royal straight flush\n card_rank_rsf = ['HDSC'.index(h) for n,h in hand]\n card_rank_rsf.sort()\n card_rank_rsf.reverse()\n if card_rank == [14,5,4,3,2]:\n card_rank = [5,4,3,2,1]\n if royal_straight_flush(hand):\n return 9,card_rank_rsf[0]\n elif straight_flush(hand):\n return 8,max(card_rank)\n elif four_of_a_kind(hand):\n return 7,max(card_rank)\n elif full_house(hand):\n tong = 0\n kuu = 0\n s = [n for n,h in hand]\n for i in xrange(len(s)):\n if(s.count(s[i])==3):\n tong = s[i]\n else:\n kuu = s[i]\n return 6,int(tong),int(kuu)\n elif flush(hand):\n return 5,max(card_rank)\n elif straight(hand):\n return 4,max(card_rank)\n elif three_of_a_kind(hand):\n ld = 0\n a = 0\n for i in xrange(0,3):\n if card_rank.count(card_rank[i]) > 1 :\n ld = (card_rank[i])\n else:\n a = card_rank[i]\n return 3,ld,a\n elif two_pair(hand):\n ld = []\n a = 0\n for i in xrange(0,3):\n if card_rank.count(card_rank[i]) >=2:\n ld.append(card_rank[i])\n card_rank.pop(i)\n else:\n a = card_rank[i]\n ld.sort(reverse=True)\n return 2,ld[0],ld[1],a\n elif one_pair(hand):\n ld = 0\n a = []\n for i in xrange(len(card_rank)):\n if card_rank.count(card_rank[i]) > 1 :\n ld = (card_rank[i])\n else:\n a.append(card_rank[i])\n a.sort(reverse = True)\n return 1,ld,a[0],a[1],a[2]\n else:\n return 0,max(card_rank)","def desimal_til_bokstav(snitt):\r\n if snitt >= 4.5:\r\n return 'A'\r\n elif 3.5 <= snitt < 4.5:\r\n return 'B'\r\n elif 2.5 <= snitt < 3.5:\r\n return 'C'\r\n elif 1.5 <= snitt < 2.5:\r\n return 'D'\r\n elif 0.5 <= snitt < 1.5:\r\n return 'E'\r\n else:\r\n return 'F'","def threes_points(dice_list):\n return dice_list.count(3) * 3","def level(score):\n user_level = \"\"\n if score < 20:\n user_level = \"elementary\"\n elif score < 30:\n user_level = \"intermediate\"\n elif score < 35:\n user_level = \"upper intermediate\"\n else:\n user_level = \"advanced\"\n return user_level","def threes(dice):\n for i, j, k in combinations(dice, 3):\n if i == j == k:\n return 3 * i\n\n return 0","def find_ladders_pretty(left_word: str, right_word: str, exact_depth: Optional[int] = None, max_depth: int = 10, use_heuristic: bool = True):\n # Find all ladders and sort by length\n pretty_ladders = find_ladders_unique(left_word, right_word, exact_depth, max_depth, use_heuristic)\n if len(pretty_ladders) == 0:\n return\n\n pretty_ladders.sort(key=len)\n for pretty_ladder in pretty_ladders:\n print(pretty_ladder)","def solution(self):\n return [((\"communes of the bouches-du-rh\\u00f4ne department\", \"france\"), 0.024170164983320565)] * 100","def tetrakis(self):\n return self.nlegomena(4)"],"string":"[\n \"def hangman_figure(attempt_left):\\n if attempt_left == N_TURNS:\\n print('___________')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 1:\\n print('___________')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 2:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 3:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| |')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 4:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 5:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 6:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| /')\\n print('| |')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 7:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 8:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| |')\\n print('|_____')\\n if attempt_left == N_TURNS - 9:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| | |')\\n print('|_____')\\n if attempt_left == N_TURNS - 10:\\n print('___________')\\n print('| |')\\n print('| -O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| | |')\\n print('|_____')\\n if attempt_left == N_TURNS - 11:\\n print('___________')\\n print('| |')\\n print('| -O-')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| | |')\\n print('|_____')\",\n \"def generate_horror_title():\\n d666 = random.randint(1, 666)\\n if d666 <= 111:\\n #the adj noun\\n return \\\"The \\\" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \\\" \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\\n elif d666 > 111 and d666 <= 222: \\n #noun of noun\\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \\\" of \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\\n elif d666 > 222 and d666 < 444: \\n #the adj noun of verb \\n return \\\"The \\\" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \\\" \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)] + \\\" of \\\" + horror_verb[random.randint(0, len(horror_verb) - 1)]\\n elif d666 >= 444 and d666 < 555: \\n #noun of noun\\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \\\" of \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\\n elif d666 >= 555:\\n #verb of the adj noun\\n return horror_verb[random.randint(0, len(horror_verb) - 1)] + \\\" of the \\\" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \\\" \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\",\n \"def pirate():\\n \\n from random import choice\\n d = {\\n \\\"sir\\\": \\\"matey\\\", \\\"hotel\\\": \\\"fleabag inn\\\", \\\"student\\\": \\\"swabbie\\\",\\n \\\"boy\\\": \\\"matey\\\", \\\"girl\\\": \\\"wench\\\", \\\"professor\\\": \\\"foul blaggart\\\",\\n \\\"restaurant\\\": \\\"galley\\\", \\\"your\\\": \\\"ye\\\", \\\"excuse\\\": \\\"arr\\\", \\\"you\\\": \\\"ye\\\",\\n \\\"students\\\": \\\"swabbies\\\", \\\"are\\\": \\\"be\\\", \\\"lawyer\\\": \\\"foul blaggart\\\",\\n \\\"the\\\": \\\"th'\\\", \\\"restroom\\\": \\\"head\\\", \\\"my\\\": \\\"me\\\", \\\"hello\\\": \\\"avast\\\",\\n \\\"is\\\": \\\"be\\\", \\\"man\\\": \\\"scurvy dog\\\", \\\"hey\\\": \\\"avast\\\", \\\"pirate\\\": \\\"scurvy pirate\\\",\\n \\\"idiot\\\": \\\"flunder\\\", \\\"young\\\": \\\"ye\\\", \\\"the\\\": \\\"t'\\\", \\\"suck\\\": \\\"blow down\\\",\\n \\\"fall\\\": \\\"hade\\\", \\\"happens\\\": \\\"be happening\\\", \\\"death\\\": \\\"Davy Jones' treasure chest\\\",\\n \\\"always\\\": \\\"ever\\\", \\\"you're\\\": \\\"ye're\\\", \\\"girlfriend\\\": \\\"Lassie-Lucy\\\",\\n \\\"with\\\": \\\"wit'\\\", \\\"everyone\\\": \\\"evr'un\\\"\\n }\\n #~ sentence = raw_input(\\\"What be yer sentence, ye old landlubber? \\\")\\n sentences = [\\\"If the world didn't suck we'd all fall off\\\",\\n \\\"What happens if you get scared half to death twice?\\\",\\n \\\"Save water and shower with your girlfriend\\\",\\n \\\"Always remember you're unique, just like everyone else\\\"]\\n \\n start = [\\\"Yarr, \\\", \\\"Yarr! \\\", \\\"Yarr-ha-harr! \\\", \\\"Skuttle me Skippers! \\\",\\n \\\"Shiver me timbers! \\\", \\\"Ahoy, me hearties! \\\", \\\"Dogs ahoy! \\\",\\n \\\"Hoist the mizzen!!! \\\", \\\"Hoist the colors!! \\\" ]\\n end = [\\\". ARRRGHHHH!\\\", \\\". Avast ye varmint!\\\", \\\". Yarr?\\\",\\n \\\". Savvyy?\\\", \\\". Yarr!\\\", \\\". Aye!\\\",\\n \\\", ye bilge rat!\\\", \\\", ye mangy dog!\\\", \\\", ye scallywag!\\\"]\\n\\n s = choice(sentences)\\n print s\\n print choice(start) +\\\\\\n ' '.join([d[i] if i in d else i for i in s.lower().split()]).capitalize()\\\\\\n + choice(end)\",\n \"def test_splitting_on_feature(num = 0):\\n left = [0,0]\\n right = [0,0]\\n for i, side in enumerate(train_matrix_df[num]):\\n if int(side) == 0: \\n if train_labels_df.ix[i]['candy_id'] == 0:\\n left[0] += 1\\n else:\\n left[1] += 1\\n else:\\n if train_labels_df.ix[i]['candy_id'] == 0:\\n right[0] += 1\\n else:\\n right[1] += 1\\n\\n #print \\\" %s goes to the %i side\\\" %(train_labels_df.ix[i]['candy'], side)\\n\\n print str(left) + \\\"<--left -- + -- right-->\\\" + str(right)\",\n \"def display_words(word_list,specifier):\\n \\n if specifier.lower() == 'score':\\n print(\\\"{:>6s} - {:s}\\\".format(\\\"Score\\\", \\\"Word\\\"))\\n if len(word_list) < 5:\\n for tup in word_list:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[1], tup[0]))\\n else:\\n \\n for tup in word_list[:5]:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[1], tup[0]))\\n \\n \\n elif specifier.lower() == 'length':\\n print(\\\"{:>6s} - {:s}\\\".format(\\\"Length\\\", \\\"Word\\\"))\\n if len(word_list) < 5:\\n for tup in word_list:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[2], tup[0]))\\n else:\\n \\n for tup in word_list[:5]:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[2], tup[0]))\",\n \"def pre_flop_strength(hand):\\n highs = {}\\n highs[4] = [\\n \\\"AA\\\", \\\"AKs\\\", \\\"AQs\\\", \\\"AJs\\\", \\\"ATs\\\", \\\"AKo\\\", \\\"KK\\\", \\\"KQs\\\", \\\"KJs\\\", \\\"AQo\\\",\\n \\\"QQ\\\", \\\"QJs\\\", \\\"JJ\\\", \\\"TT\\\"\\n ]\\n highs[3] = [\\n \\\"A5s\\\", \\\"A4s\\\", \\\"A3s\\\", \\\"KTs\\\", \\\"KQo\\\", \\\"QTs\\\", \\\"AJo\\\", \\\"JTs\\\", \\\"T9s\\\", \\\"99\\\",\\n \\\"98s\\\", \\\"88\\\", \\\"87s\\\", \\\"77\\\", \\\"66\\\"\\n ]\\n highs[2] = [\\n \\\"A9s\\\", \\\"A8s\\\", \\\"A7s\\\", \\\"A6s\\\", \\\"A2s\\\", \\\"K9s\\\", \\\"K8s\\\", \\\"Q9s\\\", \\\"KJo\\\", \\\"QJo\\\",\\n \\\"J9s\\\", \\\"ATo\\\", \\\"KTo\\\", \\\"QTo\\\", \\\"JTo\\\", \\\"T8s\\\", \\\"A9o\\\", \\\"J9o\\\", \\\"T9o\\\", \\\"97s\\\",\\n \\\"98o\\\", \\\"86s\\\", \\\"76s\\\", \\\"75s\\\", \\\"65s\\\", \\\"55\\\", \\\"44\\\", \\\"33\\\", \\\"22\\\"\\n ]\\n highs[1] = [\\n \\\"K7s\\\", \\\"K6s\\\", \\\"K5s\\\", \\\"K4s\\\", \\\"K3s\\\", \\\"Q8s\\\", \\\"Q7s\\\", \\\"Q6s\\\", \\\"Q5s\\\", \\\"Q4s\\\",\\n \\\"J8s\\\", \\\"J7s\\\", \\\"J6s\\\", \\\"J5s\\\", \\\"T7s\\\", \\\"T6s\\\", \\\"K9o\\\", \\\"Q9o\\\", \\\"96s\\\", \\\"A8o\\\",\\n \\\"K8o\\\", \\\"Q8o\\\", \\\"J8o\\\", \\\"T8o\\\", \\\"85s\\\", \\\"A7o\\\", \\\"K7o\\\", \\\"Q7o\\\", \\\"T7o\\\", \\\"97o\\\",\\n \\\"87o\\\", \\\"74s\\\", \\\"A6o\\\", \\\"K6o\\\", \\\"86o\\\", \\\"76o\\\", \\\"64s\\\", \\\"63s\\\", \\\"A5o\\\", \\\"75o\\\",\\n \\\"65o\\\", \\\"54s\\\", \\\"53s\\\", \\\"A4o\\\", \\\"43s\\\", \\\"A3o\\\"\\n ]\\n card0, card1 = hand\\n if card0[0] == card1[0]:\\n pair = \\\"\\\".join([card0[0], card1[0]])\\n elif card0[1] == card1[1]:\\n pair = \\\"\\\".join([card0[0], card1[0], \\\"s\\\"])\\n else:\\n pair = \\\"\\\".join([card0[0], card1[0], \\\"o\\\"])\\n for strenght in highs:\\n if pair in highs[strenght]:\\n return strenght\\n return 0\",\n \"def heads_legs(heads, legs):\\n for i in range(0, heads + 1):\\n cows = heads - i\\n if 4 * cows + 2 * i == legs:\\n chickens = i\\n return chickens, cows\\n return \\\"No solutions.\\\"\",\n \"def way_to_prewin(self, one):\\r\\n\\t\\tkind = [0, 0, 0, 0] \\r\\n\\t\\tuseful = []\\r\\n\\t\\tscore = 0\\r\\n\\t\\tfor part in one.split(\\\"\\\\t\\\"):\\r\\n\\t\\t\\t#print \\\"part: {0}\\\".format(part)\\r\\n\\t\\t\\ttmp = part.split()\\r\\n\\t\\t\\tlength = len(tmp)\\r\\n\\t\\t\\tif (length == 3):\\t\\t# triple\\r\\n\\t\\t\\t\\tkind[0] += 1\\r\\n\\t\\t\\t\\tscore += 3\\r\\n\\t\\t\\telif (length == 1):\\t\\t# single\\r\\n\\t\\t\\t\\tkind[3] += 1\\r\\n\\t\\t\\telif (tmp[0] == tmp[1]):# pair\\r\\n\\t\\t\\t\\tkind[1] += 1\\r\\n\\t\\t\\t\\tuseful.append(\\\"{0}\\\".format(tmp[0]))\\r\\n\\t\\t\\t\\tscore += 2\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tkind[2] += 1\\r\\n\\t\\t\\t\\tn = GameBoard.NextCard(tmp[0])\\r\\n\\t\\t\\t\\tp = GameBoard.PrevCard(tmp[0])\\r\\n\\t\\t\\t\\tnn = GameBoard.NextCard(tmp[1])\\r\\n\\t\\t\\t\\tif (n == tmp[1]):\\t# consecutive neighbor\\r\\n\\t\\t\\t\\t\\tscore += 2\\r\\n\\t\\t\\t\\t\\tif (p != None): useful.append(p)\\r\\n\\t\\t\\t\\t\\tif (nn != None): useful.append(nn)\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tuseful.append(n)\\r\\n\\t\\t\\t\\t\\tscore += 1\\r\\n\\r\\n\\t\\t#print \\\"kind: {0}\\\".format(kind)\\r\\n\\t\\t\\\"\\\"\\\" how many cards can we probably get \\\"\\\"\\\"\\r\\n\\t\\tuseful_amount = 0\\r\\n\\t\\tfor card in set(useful):\\r\\n\\t\\t\\tctype = GameBoard.CardType(card)\\r\\n\\t\\t\\tif (ctype == 1): a = self.wang_list.count(card)\\r\\n\\t\\t\\telif (ctype == 2): a = self.tube_list.count(card)\\r\\n\\t\\t\\telif (ctype == 3): a = self.bamb_list.count(card)\\r\\n\\t\\t\\telif (ctype == 4): a = self.word_list.count(card)\\r\\n\\t\\t\\telse: a = self.wind_list.count(card)\\r\\n\\t\\t\\tb = self.gb.drop_list.count(card)\\r\\n\\t\\t\\tuseful_amount += (4 - a - b)\\r\\n\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\t\\t1. enumerate, because goal state not too much\\r\\n\\t\\t2. counting pong_list so that we can focus on 16 cards\\r\\n\\t\\t3. check prewin first\\t\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\t\\tgoals = [[4, 1, 1, 0], [5, 0, 0, 1], [4, 2, 0, 0]]\\r\\n\\t\\tgpattern = [[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"##\\\", \\\"$$\\\"],[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"/\\\"],\\r\\n\\t\\t\\t\\t\\t[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"##\\\", \\\"##\\\"]]\\r\\n\\t\\tresult = [0, 0, 0]\\r\\n\\t\\tsize = len(self.pong_list) / 3\\r\\n\\t\\tif ((size + kind[0]) > 4): return [0, useful_amount, score]\\r\\n\\t\\tfor i in range(size): \\r\\n\\t\\t\\tgpattern[0].remove(\\\"***\\\")\\r\\n\\t\\t\\tgpattern[1].remove(\\\"***\\\")\\r\\n\\t\\t\\tgpattern[2].remove(\\\"***\\\")\\r\\n\\t\\tfor number in range(3):\\r\\n\\t\\t\\tk0 = kind[0]\\r\\n\\t\\t\\tk1 = kind[1]\\r\\n\\t\\t\\tk2 = kind[2]\\r\\n\\t\\t\\tk3 = kind[3]\\r\\n\\t\\t\\tp1 = gpattern[number]\\r\\n\\t\\t\\tfor i in range(k0): p1.remove(\\\"***\\\")\\r\\n\\t\\t\\tfor i in range(min(k1, goals[number][1])): \\r\\n\\t\\t\\t\\tk1 -= 1\\r\\n\\t\\t\\t\\tp1.remove(\\\"##\\\")\\r\\n\\t\\t\\tfor i in range(min(k2, goals[number][2])):\\r\\n\\t\\t\\t\\tk2 -= 1\\r\\n\\t\\t\\t\\tp1.remove(\\\"$$\\\")\\r\\n\\t\\t\\t#print \\\"p1: {0}, size: {1}\\\".format(p1, (k1+k2)*2+k3)\\r\\n\\t\\t\\tstep = 0\\r\\n\\t\\t\\ttwo = k1 + k2\\r\\n\\t\\t\\tfor i in range(len(p1)):\\r\\n\\t\\t\\t\\tlength = len(p1[i])\\r\\n\\t\\t\\t\\tif (length == 3):\\r\\n\\t\\t\\t\\t\\tif two:\\r\\n\\t\\t\\t\\t\\t\\ttwo -= 1\\r\\n\\t\\t\\t\\t\\t\\tstep += 1\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tstep += 2\\r\\n\\t\\t\\t\\telif (length == 2):\\r\\n\\t\\t\\t\\t\\tstep += 1\\r\\n\\t\\t\\tresult[number] = step\\r\\n\\t\\t#print \\\"steps to goal: {0}, useful: {1}\\\".format(result, len(useful))\\r\\n\\t\\t\\r\\n\\t\\treturn [min(result), useful_amount, score]\",\n \"def viz(analogies):\\n print(\\\"Index\\\".ljust(12) + \\\"Analogy\\\".center(45) + \\\"Gender score\\\".rjust(12))\\n print(\\\"-\\\" * 69)\\n print(\\n \\\"\\\\n\\\".join(\\n str(i).rjust(4) + a[0].rjust(29) + \\\" | \\\" + a[1].ljust(29) + (str(a[2]))[:4]\\n for i, a in enumerate(analogies)\\n )\\n )\",\n \"def one_v_all(description):\\n label = [0, 0, 0]\\n for raw in description.split(\\\"|\\\")[4:]:\\n line = raw.strip()\\n if \\\"midbrain\\\" in line:\\n label[0] = 1\\n if \\\"forebrain\\\" in line:\\n label[1] = 1\\n if \\\"hindbrain\\\" in line:\\n label[2] = 1\\n return label\",\n \"def chargen (level0number, level0die, level1number, level1die, level2number, level2die, level3number, level3die, level4number, level4die): #input dice numbers and types for all four potential character levels\\r\\n\\tfilename=stellagama.savefile(\\\"txt\\\")\\r\\n\\twith open (filename, \\\"w\\\") as output:\\r\\n\\t\\tfor i in range (0, stellagama.dice(level0number, level0die)):\\r\\n\\t\\t\\tcharacter1=character(0)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level1number, level1die)):\\r\\n\\t\\t\\tcharacter1=character(1)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level2number, level2die)):\\r\\n\\t\\t\\tcharacter1=character(2)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level3number, level3die)):\\r\\n\\t\\t\\tcharacter1=character(3)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level4number, level4die)):\\r\\n\\t\\t\\tcharacter1=character(4)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\",\n \"def rules():\\n help = textwrap.dedent(\\\"\\\"\\\"\\n THIS IS THE GAME OF \\\"REVERSE\\\". TO WIN, ALL YOU HAVE\\n TO DO IS ARRANGE A LIST OF NUMBERS (1 THROUGH {})\\n IN NUMERICAL ORDER FROM LEFT TO RIGHT. TO MOVE, YOU\\n TELL ME HOW MANY NUMBERS (COUNTING FROM THE LEFT) TO\\n REVERSE. FOR EXAMPLE, IF THE CURRENT LIST IS:\\n\\n 2 3 4 5 1 6 7 8 9\\n\\n AND YOU REVERSE 4, THE RESULT WILL BE:\\n\\n 5 4 3 2 1 6 7 8 9\\n\\n NOW IF YOU REVERSE 5, YOU WIN!\\n\\n 1 2 3 4 5 6 7 8 9\\n\\n NO DOUBT YOU WILL LIKE THIS GAME, BUT\\n IF YOU WANT TO QUIT, REVERSE 0 (ZERO).\\n \\\"\\\"\\\".format(NUMCNT))\\n print(help)\\n print()\",\n \"def rarity():\\n rarities = find_rarities()\\n longest = 0\\n for rarity in rarities:\\n if (len(rarity) > longest): \\n longest = len(rarity)\\n spacer = \\\"\\\".join(map(lambda x: x*longest, \\\"-\\\"))\\n click.echo(\\\"\\\\nRarities\\\")\\n click.echo(spacer)\\n for rarity in rarities:\\n click.echo(rarity)\\n click.echo(\\\"\\\\n\\\")\",\n \"def __str__(self) -> str:\\n side = self.side_length\\n\\n hori_lst = self.hori_lst\\n hori_result = self.hori_result\\n left_lst = self.left_lst\\n left_result = self.left_result\\n right_lst = self.right_lst\\n right_result = self.right_result\\n\\n total_line=''\\n for i in range(2 * side + 5):\\n # empty line string\\n line = ''\\n if i % 2 == 0:\\n lineindex = int(i / 2)\\n if lineindex <= side:\\n # get the first 2 left result\\n if lineindex == 0:\\n # print('first line')\\n for ia in range(3*(side+1)):\\n line += ' '\\n line += left_result[0]\\n line += ' '\\n line += left_result[1]\\n # general case of combing the results and list together\\n else:\\n if lineindex == side:\\n line += ' '\\n for ib in range(side - lineindex):\\n line += ' '\\n line += hori_result[lineindex - 1]\\n for ic in range(len(hori_lst[lineindex - 1])):\\n line += ' - '\\n line += hori_lst[lineindex - 1][ic]\\n if lineindex != side:\\n line += ' '\\n line += left_result[lineindex + 1]\\n else:\\n if lineindex == side + 1:\\n # for id in range():\\n line += ' '\\n line += hori_result[side]\\n for ie in range(side):\\n line += ' - '\\n line += hori_lst[side][ie]\\n line += ' '\\n line += right_result[side]\\n else:\\n # print the last row for all other right resutls\\n # print('right results')\\n for ig in range(9):\\n line += ' '\\n for ih in range(side):\\n line += right_result[ih]\\n line += ' '\\n total_line += line + '\\\\n'\\n else:\\n # print stuff for the '/'\\n lineindex2 = int(i / 2)\\n if lineindex2 == 0:\\n for iA in range(3*side+1):\\n line += ' '\\n line += ' / '\\n line += ' '\\n line += \\\" / \\\"\\n elif lineindex2 < side:\\n for iA in range(3 * (1 + side - lineindex2)):\\n line += ' '\\n # print('lineindex2: '+str(lineindex2)+' '+str(3*(1+side-lineindex2)))\\n for iB in range(lineindex2 + 1):\\n line += '/ \\\\\\\\ '\\n line += '/'\\n elif lineindex2 == side:\\n #for iC in range(side+1):\\n line += ' '\\n for iD in range(side):\\n line += '\\\\\\\\ / '\\n line += '\\\\\\\\'\\n elif lineindex2 == side + 1:\\n for iE in range(8):\\n line += ' '\\n for iG in range(side):\\n line += '\\\\\\\\ '\\n total_line += line + '\\\\n'\\n return total_line\",\n \"def spell_triade(triade):\\n spelled_triade = ''\\n\\n if triade[1] == 1:\\n\\n spelled_triade += numerals_dictionary[triade[1] * 10 + triade[2]]\\n\\n elif triade[1] == 0:\\n\\n spelled_triade += numerals_dictionary[triade[2]]\\n\\n else:\\n\\n if triade[2] == 0:\\n\\n spelled_triade = numerals_dictionary[triade[1] * 10]\\n\\n else:\\n\\n spelled_triade = '-'.join((numerals_dictionary[triade[1] * 10], numerals_dictionary[triade[2]]))\\n\\n if triade[0] in range(1, 10):\\n\\n hundreds = ' '.join((numerals_dictionary[triade[0]], 'hundred'))\\n\\n if spelled_triade != 'zero':\\n\\n spelled_triade = ' and '.join((hundreds, spelled_triade))\\n\\n else:\\n\\n spelled_triade = hundreds\\n\\n return spelled_triade\",\n \"def get_ability_scores(self):\\n s = ''\\n for i in range(6):\\n s += ' ' + str(self.dna[i])\\n return s\",\n \"def won(s,n):\",\n \"def rangoli(n):\\r\\n alphabet = string.ascii_lowercase\\r\\n pad = 4*n-3\\r\\n filler = '-'\\r\\n initial = [alphabet[n-1]]\\r\\n top = [alphabet[n-1].center(pad, filler)]\\r\\n\\r\\n for i in range(n-2, -1, -1):\\r\\n initial.append(alphabet[i])\\r\\n sub_list = initial[:-1]+[alphabet[i]]+list(reversed(initial[:-1]))\\r\\n sub_seq = filler.join(sub_list).center(pad, filler)\\r\\n top.append(sub_seq)\\r\\n\\r\\n bot = list(reversed(top[:-1]))\\r\\n result = '\\\\n'.join(top + bot)\\r\\n print(result)\\r\\n return\",\n \"def __init__(self, is_p1_turn: bool, side_length: int) -> None:\\n super().__init__(is_p1_turn)\\n self.side_length = side_length\\n # ISSUE: what if node is more than 26 --> no need to handle side more than 5\\n # construct a list of uppercase and lower case letters\\n alph_lst_upper = list(string.ascii_uppercase)\\n alph_lst_lower = list(string.ascii_lowercase)\\n # alph_lst has a length of 52\\n alph_lst = alph_lst_upper + alph_lst_lower\\n\\n # assign original value for each ley-line\\n hori_result = []\\n for i in range(side_length + 1):\\n hori_result.append(\\\"@\\\")\\n left_result = []\\n for i in range(side_length + 1):\\n left_result.append(\\\"@\\\")\\n right_result = []\\n for i in range(side_length + 1):\\n right_result.append(\\\"@\\\")\\n self.hori_result = hori_result\\n self.left_result = left_result\\n self.right_result = right_result\\n\\n self.hori_lst = []\\n self.left_lst = []\\n self.right_lst = []\\n\\n # construct horizontal ley-lines\\n n = 2\\n start_index = 0\\n end_index = 0\\n while n <= side_length + 1:\\n end_index = start_index + n\\n self.hori_lst.append(alph_lst[start_index:end_index])\\n start_index = end_index\\n n += 1\\n end_index = start_index + side_length\\n self.hori_lst.append(alph_lst[start_index:end_index])\\n\\n # copy hori_lst\\n hori_copy = []\\n for item in self.hori_lst:\\n hori_copy.append(item)\\n\\n # construct left ley-lines\\n for i in range(side_length + 1):\\n temp = []\\n for lst in hori_copy[:len(hori_copy) - 1]:\\n if len(lst) > i:\\n temp.append(lst[i])\\n self.left_lst.append(temp)\\n for i in range(1, side_length + 1):\\n self.left_lst[i].append(hori_copy[-1][i - 1])\\n\\n # construct right ley-lines\\n for i in range(-1, side_length * (-1) - 2, -1):\\n temp = []\\n for lst in hori_copy[:len(hori_copy) - 1]:\\n if len(lst) >= i * (-1):\\n temp.append(lst[i])\\n self.right_lst.append(temp)\\n self.right_lst = self.right_lst[::-1]\\n for i in range(side_length):\\n self.right_lst[i].append(hori_copy[-1][i])\",\n \"def leerUltrasonido() -> int:\\n pass\",\n \"def print_hangman(n, wrong_times):\\n # the width of the print, must > 4\\n width = 13\\n height = n\\n s = \\\"\\\"\\n # let s be a width * height string then we can replace every hangman part each wrong time\\n for i in range(height):\\n for j in range(width-1):\\n s += \\\" \\\"\\n # every (width-1) spaces plus a \\\\n to change row\\n s += '\\\\n'\\n # ceiling\\n for i in range(len(s)):\\n if i < width-1:\\n s = s[:i] + '-' + s[i+1:]\\n # pillar and rope\\n for i in range(width, len(s), width):\\n s = s[:i] + '|' + s[i+1:]\\n s = s[:int(width + width/2)] + '|' + s[int(width + width/2 + 1):]\\n # head\\n if wrong_times >= 1:\\n s = s[:int(width*2 + width/2)] + 'O' + s[int(width*2 + width/2 + 1):]\\n # body\\n if wrong_times >= 2:\\n s = s[:int(width*3 + width/2)] + '|' + s[int(width*3 + width/2 + 1):]\\n # left hand\\n if wrong_times >= 3:\\n s = s[:int(width*3 + width/2 - 1)] + '/' + s[int(width*3 + width/2):]\\n # right hand\\n if wrong_times >= 4:\\n s = s[:int(width*3 + width/2 + 1)] + '\\\\\\\\' + s[int(width*3 + width/2 + 2):]\\n # if n > 6 continue adding body part until left 2 chances to try\\n if (wrong_times >= 5) & (n - wrong_times <= n-5):\\n if n - wrong_times > 1:\\n # 4 means head, body, left hand and right hand\\n for i in range(wrong_times - 4):\\n s = s[:int(width * (3+i+1) + width/2)] + '|' + s[int(width * (3+i+1) + width/2 + 1):]\\n if n - wrong_times <= 1:\\n # 6 means head, body, left hand, right hand, left leg and right leg\\n for i in range(n - 6):\\n s = s[:int(width * (3+i+1) + width/2)] + '|' + s[int(width * (3+i+1) + width/2 + 1):]\\n # left leg\\n if n - wrong_times <= 1:\\n s = s[:int(width * (height-2) + width/2 - 1)] + '/' + s[int(width * (height-2) + width/2):]\\n # right leg\\n if n - wrong_times <= 0:\\n s = s[:int(width * (height-2) + width/2 + 1)] + '\\\\\\\\' + s[int(width * (height-2) + width/2 + 2):]\\n print(s)\",\n \"def pentakis(self):\\n return self.nlegomena(5)\",\n \"def parse_streetdir(self):\\n \\n first = self.words[self.index]['word']\\n if self.index + 1 < self.length:\\n second = self.words[self.index+1]['word']\\n else:\\n second = None\\n \\n if first in ['northwest', 'northeast', 'southwest', 'southeast']:\\n return first, 1 \\n elif first == 'nw':\\n return \\\"northwest\\\", 1\\n elif first == 'ne':\\n return \\\"northeast\\\", 1\\n elif first == 'sw':\\n return \\\"southwest\\\", 1\\n elif first == 'se':\\n return \\\"southeast\\\", 1\\n \\n if first in ['n', 'north']:\\n if second in ['w', 'west']:\\n return \\\"northwest\\\", 2\\n elif second in ['e', 'east']:\\n return \\\"northeast\\\", 2\\n else:\\n return \\\"north\\\", 1\\n elif first in ['s', 'south']:\\n if second in ['w', 'west']:\\n return \\\"southwest\\\", 2\\n elif second in ['e', 'east']:\\n return \\\"southeast\\\", 2\\n else:\\n return \\\"south\\\", 1\\n elif first in ['e', 'east']:\\n return \\\"east\\\", 1\\n elif first in ['w', 'west']:\\n return \\\"west\\\", 1\\n \\n return None,0\",\n \"def test():\\n sf = \\\"6C 7C 8C 9C TC\\\".split() # Straight Flush\\n sf1 = \\\"6C 7C 8C 9C TC\\\".split() # Straight Flush\\n sf2 = \\\"6D 7D 8D 9D TD\\\".split() # Straight Flush\\n fk = \\\"9D 9H 9S 9C 7D\\\".split() # Four of a Kind\\n fk3 = \\\"TC TS TH 2C TD\\\".split() # Four of a Kind\\n fh = \\\"TD TC TH 7C 7D\\\".split() # Full House\\n fl = \\\"AH KH JH 6H TH\\\".split() # Flush\\n st = \\\"AH KC QD JD TS\\\".split() # Straight\\n tk = \\\"2H 2C 2D AC TD\\\".split() # Three of kind\\n tp = \\\"TD 9H TH 7C 9S\\\".split() # Two Pair\\n op = \\\"TD TC AD KD QD\\\".split() # One Pair\\n hq = \\\"2D 3D 4C 5H 7H\\\".split() # High card\\n al = \\\"AC 2D 4H 3D 5S\\\".split() # Ace-Low Straight\\n tp1 = \\\"7H 7D 9C 3C 9S\\\".split() #Two Pair\\n fkranks = card_ranks(fk)\\n tpranks = card_ranks(tp)\\n op1 = \\\"KH 7C 5S KS 2S\\\".split() # One pair\\n tp2 = \\\"TH 3S 2H 3D TC\\\".split() # Two pair\\n tk1 = \\\"TH JD JH 8C JC\\\".split() # Three of kind\\n hq1 = \\\"TH 9D 5C 3H 2C\\\".split() # High card\\n f3 = \\\"2C 4C 6C 7C TC\\\".split() # Flush\\n s3 = \\\"3C 4D 5H 6D 7H\\\".split() # Straight\\n assert poker([fk3, f3, s3]) == fk3 #gilje start\\n assert poker([sf, 20*fk]) == sf\\n assert poker([fk3, 5*f3]) == fk3\\n assert card_ranks(fk3) == [10, 10, 10, 10, 2]\\n assert card_ranks(f3) == [10, 7, 6, 4, 2]\\n assert hand_rank(fk3) == (7, 10, 2)\\n assert hand_rank(f3) == (5, [10, 7, 6, 4, 2])\\n assert flush(f3) == True\\n assert straight(card_ranks(s3)) == True\\n assert straight(card_ranks(f3)) == False #gilje slutt\\n assert poker([fh, tk, hq]) == fh #oistein start\\n assert poker([fl, sf1, tk]) == sf1\\n assert poker([op, al, fh]) == fh\\n assert poker([st, fk, tp]) == fk\\n assert poker([tk, tp, op]) == tk\\n assert poker([hq, op, hq]) == op\\n assert card_ranks(op1) == [13, 13, 7, 5, 2]\\n assert card_ranks(tp2) == [10, 10, 3, 3, 2]\\n assert card_ranks(tk1) == [11, 11, 11, 10, 8]\\n assert card_ranks(hq1) == [10, 9, 5, 3, 2] #oistein slutt\\n assert poker([hq, tp, op]) == tp#steffen start\\n assert poker([al, st]) == st\\n assert poker([al, st, fl]) == fl\\n assert card_ranks(hq) == [7, 5, 4, 3, 2]\\n assert card_ranks(fk) == [9, 9, 9, 9, 7]\\n assert card_ranks(fh) == [10, 10, 10, 7, 7]#steffen slutt\\n assert poker([sf2, tk, al]) == sf2#arild start\\n assert poker([hq, st]) == st\\n assert poker([al, st, fk]) == fk\\n assert flush(fl) == True\\n assert straight(card_ranks(tp)) == False\\n assert card_ranks(fk) == [9, 9, 9, 9, 7]\\n assert card_ranks(hq) == [7, 5, 4, 3, 2]\\n assert hand_rank(tk) == (3, 2, [14, 10, 2, 2, 2])\\n assert hand_rank(st) == (4, 14)\\n assert kind(5, tpranks) == None#arild slutt\\n assert poker([tp, op]) == tp #Even start\\n assert poker([hq, tk]) == tk\\n assert poker([sf1] + 50*[fl]) == sf1\\n assert card_ranks(sf1) == [10, 9, 8, 7, 6]\\n assert card_ranks(tk) == [14, 10, 2, 2, 2]\\n assert card_ranks(st) == [14, 13, 12, 11, 10]\\n assert kind(4, fkranks) == 9\\n assert kind(3, fkranks) == None\\n assert kind(2, tpranks) == 10\\n assert kind(1, fkranks) == 7 #Even slutt\\n assert poker([sf1, fk, fh]) == sf1\\n assert poker([fk, fh]) == fk\\n assert poker([fh, fh]) == [fh, fh]\\n assert poker([sf1]) == sf1\\n assert poker([sf1] + 99*[fh]) == sf1\\n assert hand_rank(sf1) == (8, 10)\\n assert hand_rank(fk) == (7, 9, 7)\\n assert hand_rank(fh) == (6, 10, 7)\\n assert straight(card_ranks(al)) == True\\n assert poker([sf1, sf2, fk, fh]) == [sf1, sf2]\\n assert kind(4, fkranks) == 9\\n assert kind(3, fkranks) == None\\n assert kind(2, fkranks) == None\\n assert kind(1, fkranks) == 7\\n return 'You did good, and you should feel good about yourself :)'\",\n \"def solution(self):\\n return [(\\\"the\\\", 1579644)] * 100\",\n \"def lyft_labels():\\n\\n return {\\n 0: 'None',\\n 7: 'Roads',\\n 10: 'Vehicles'\\n }\",\n \"def alphabet_war(fight):\",\n \"def stickers_for(phrase):\\n\\n stic_dict = {}\\n for ltr in 'instagram':\\n if ltr not in stic_dict:\\n stic_dict[ltr] = 1\\n else:\\n stic_dict[ltr] += 1\\n print(ltr)\\n\\n phr_dict = {}\\n for ltr in phrase:\\n if ltr not in phr_dict:\\n phr_dict[ltr] = 1\\n else:\\n phr_dict[ltr] += 1\\n print(ltr)\\n\\n ratios = []\\n for ltr in stic_dict:\\n if ltr in phr_dict:\\n ratio = phr_dict[ltr] / stic_dict[ltr]\\n ratios.append(ratio)\\n\\n if len(ratios) > 0:\\n num_sticks = max(ratios)\\n num_sticks = int(round(num_sticks, 0))\\n return stic_dict, phr_dict, ratios, num_sticks\\n\\n else: \\n return 0\",\n \"def adjust_left_right_positions():\\n # bp_* is synonym for 'Best Position Left/Right' and are adjusted \\n # to optimize bmv_*\\n p_l, bp_l = [pos] * 2\\n p_r, bp_r = [pos + qlen] * 2\\n\\n # bmv_* are declared here in case they are untouched in optimization\\n bmv_l = match_values[p_l / step]\\n bmv_r = match_values[p_l / step]\\n\\n for f in range(flex):\\n ll = _match(query, corpus[p_l - f: p_r])\\n if ll > bmv_l:\\n bmv_l = ll\\n bp_l = p_l - f\\n\\n lr = _match(query, corpus[p_l + f: p_r])\\n if lr > bmv_l:\\n bmv_l = lr\\n bp_l = p_l + f\\n\\n rl = _match(query, corpus[p_l: p_r - f])\\n if rl > bmv_r:\\n bmv_r = rl\\n bp_r = p_r - f\\n\\n rr = _match(query, corpus[p_l: p_r + f])\\n if rr > bmv_r:\\n bmv_r = rr\\n bp_r = p_r + f\\n\\n if verbose:\\n print(\\\"\\\\n\\\" + str(f))\\n print(\\\"ll: -- value: %f -- snippet: %s\\\" % (ll, corpus[p_l - f: p_r]))\\n print(\\\"lr: -- value: %f -- snippet: %s\\\" % (lr, corpus[p_l + f: p_r]))\\n print(\\\"rl: -- value: %f -- snippet: %s\\\" % (rl, corpus[p_l: p_r - f]))\\n print(\\\"rr: -- value: %f -- snippet: %s\\\" % (rl, corpus[p_l: p_r + f]))\\n\\n return bp_l, bp_r, _match(query, corpus[bp_l : bp_r])\",\n \"def substantiate():\",\n \"def celex_pron_loc(language, lemma):\\n pron = 5\\n if language == \\\"german\\\" or language== \\\"dutch\\\": pron = pron -2 #german one less\\n if lemma == \\\"wordform\\\": pron += 1\\n return pron\",\n \"def logAscent():\\r\\n global hardest\\r\\n \\r\\n #v-grade running total\\r\\n running = eFive.get()\\r\\n eFive.delete(0, END)\\r\\n r = int(running)\\r\\n grade = eTwo.get()\\r\\n eFive.insert(0, r + int(grade) )\\r\\n\\r\\n #hardest boulder tracker\\r\\n latest = eTwo.get()\\r\\n if int(latest) >= int(hardest):\\r\\n hardest = latest\\r\\n \\r\\n #attempts running total\\r\\n attRunning = eSix.get()\\r\\n eSix.delete(0, END)\\r\\n aR = int(attRunning)\\r\\n tries = eThree.get()\\r\\n eSix.insert(0, aR + int(tries) )\\r\\n \\r\\n #moves running total\\r\\n movesRunning = eSeven.get()\\r\\n eSeven.delete(0, END)\\r\\n mR = int(movesRunning)\\r\\n moves = eFour.get()\\r\\n eSeven.insert(0, mR + int(moves) )\\r\\n\\r\\n #logs the names of all boulders\\r\\n name = eOne.get()\\r\\n eEight.insert(0, str(name) + \\\" || \\\")\",\n \"def fo_shizzle_my_nizzle(n): \\n if n < 0:\\n n = \\\"fo\\\"\\n elif n >= 1 and n < 50: \\n n = \\\"shizzle\\\"\\n elif n >= 50 and n <= 100:\\n n = \\\"my\\\"\\n elif n % 2 == 0 and n % 3 == 0 and n > 100:\\n n = \\\"nizzle\\\"\\n else:\\n n = \\\"\\\"\\n return n\",\n \"def count_words_and_dublicates(novel):\",\n \"def solution(self):\\n return [(\\\"the\\\", 1561900)] * 100\",\n \"def dis(self):\\n return self.nlegomena(2)\",\n \"def verse_2():\\n print(\\\"Old MacDonald had a farm\\\")\\n print(\\\"E-I-E-I-O\\\")\",\n \"def __init__(self, n, sents):\\n assert n > 0\\n self._n = n\\n print(\\\"Counting...\\\")\\n count = defaultdict(int)\\n while n >= 0:\\n for sent in sents:\\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n print(\\\"Computing vocabulary...\\\")\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc) # vocabulary size\\n print(\\\"Done\\\")\",\n \"def apex(side):\\n return side % 3\",\n \"def step4(self):\\n\\t\\tif self.b[self.k - 1] == 'a':\\n\\t\\t\\tif self.ends(\\\"al\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'c':\\n\\t\\t\\tif self.ends(\\\"ance\\\"): pass\\n\\t\\t\\telif self.ends(\\\"ence\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'e':\\n\\t\\t\\tif self.ends(\\\"er\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'i':\\n\\t\\t\\tif self.ends(\\\"ic\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'l':\\n\\t\\t\\tif self.ends(\\\"able\\\"): pass\\n\\t\\t\\telif self.ends(\\\"ible\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'n':\\n\\t\\t\\tif self.ends(\\\"ant\\\"): pass\\n\\t\\t\\telif self.ends(\\\"ement\\\"): pass\\n\\t\\t\\telif self.ends(\\\"ment\\\"): pass\\n\\t\\t\\telif self.ends(\\\"ent\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'o':\\n\\t\\t\\tif self.ends(\\\"ion\\\") and (self.b[self.j] == 's' or self.b[self.j] == 't'): pass\\n\\t\\t\\telif self.ends(\\\"ou\\\"): pass\\n\\t\\t\\t# takes care of -ous\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 's':\\n\\t\\t\\tif self.ends(\\\"ism\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 't':\\n\\t\\t\\tif self.ends(\\\"ate\\\"): pass\\n\\t\\t\\telif self.ends(\\\"iti\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'u':\\n\\t\\t\\tif self.ends(\\\"ous\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'v':\\n\\t\\t\\tif self.ends(\\\"ive\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telif self.b[self.k - 1] == 'z':\\n\\t\\t\\tif self.ends(\\\"ize\\\"): pass\\n\\t\\t\\telse: return\\n\\t\\telse:\\n\\t\\t\\treturn\\n\\t\\tif self.m() > 1:\\n\\t\\t\\tself.k = self.j\",\n \"def get_entailment_judgements():\\n results = defaultdict(lambda: [0,0,0])\\n mapping = dict(zip(('CONTRADICTION','ENTAILMENT','NEUTRAL'), range(3)))\\n\\n firstline = True\\n for line in open('working/sick.run'):\\n if firstline:\\n firstline = False\\n else:\\n words = line.split()\\n sick_id = str(words[0])\\n result = words[1]\\n\\n # Set the index correspoinding to the judgement to 1\\n results[sick_id][mapping[result]] = 1\\n return results\",\n \"def REC_L_STRAIGHT():\\n return 11\",\n \"def watch_pyramid_from_the_side(characters):\\n if characters:\\n space_count = 0\\n count = len(characters)\\n out_string = \\\"\\\"\\n for char in characters:\\n out_string += \\\" \\\" * space_count + char * (2 * count - 1) +\\\\\\n \\\" \\\" * space_count + \\\"\\\\n\\\"\\n count -= 1\\n space_count += 1\\n return out_string[-2::-1]\\n else:\\n return characters\",\n \"def ROOM_DESCRIPTIONS(adventurer):\\n rooms = (\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside a wine cellar, most of it is filled with cracked, empty bottles.\\\\n\\\"\\n \\\"Perhaps it is better to not go looking for an intact bottle.\\\\n\\\"\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} suspects it will be very detrimental to their health to fight monsters while drunk.\\\",\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside a gaol, the cells are mostly filled with the skeletons of prisoners long dead.\\\\n\\\"\\n \\\"Most of the cell doors are open with the exception of one in the far corner.\\\\n\\\"\\n \\\"There seems to be a person in there but they are crouched in the corner muttering to themself.\\\\n\\\"\\n \\\"The cleaver they are holding looks very dangerous so perhaps it is best to leave them alone.\\\\n\\\",\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR}is inside a dusty old library, piles and piles of books are scattered amongst the dirty floor.\\\\n\\\"\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} remembers the last time they perused books inside of that nast vampire\\\\'s castle.\\\\n\\\"\\n f\\\"The tentacles that came out of the pages almost strangled {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR}.\\\\n\\\"\\n f\\\"Perhaps it is better to finish what {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} came here to do instead of doing some light reading.\\\",\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside what appears to be a ritual room.\\\\n\\\"\\n \\\"The only things inside a room are black candles mounted on the walls and a pentagram in the middle of the floor.\\\\n\\\"\\n f\\\"The pentagram appears to be made from dried blood, {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} would rather not think of who or what provided that blood.\\\\n\\\"\\n \\\"On each corner of the star there appears to be a random assortment of objects.\\\\n\\\"\\n \\\"For some reason one of them looks like a phallic object.\\\\n\\\"\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} decides they don\\\\'t want to stay here any longer than they have to.\\\",\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside their childhood bedroom.\\\\n\\\"\\n f\\\"The bed and drawer is just like how they remember it.\\\\n\\\"\\n f\\\"There's even that empty aquarium {adventurer} left inside their room even though the fish all died within a day.\\\\n\\\"\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} would rather not think too hard about why their room is inside of a dungeon.\\\\n\\\",\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} is inside of a sewer, the smell feels like its burning away their nostril hairs.\\\\n\\\"\\n f\\\"{text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} wonders how there could even be a sewer when the doors connecting it lead into different rooms.\\\\n\\\"\\n f\\\"As {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} stands there they see a figure in their peripheral vision.\\\\n\\\"\\n \\\"What looks like a large bipedal rat is standing there 4 smaller bipedal turtles.\\\\n\\\"\\n f\\\"Before {text_color.MAGENTA_TEXT}{adventurer}{text_color.FINISH_COLOR} can say anything a large cloud of smoke appears and when it disappears they are gone.\\\\n\\\"\\n )\\n return random.choice(rooms)\",\n \"def Lobulation(self):\\n s = self.lobulation\\n assert s in range(1,6), \\\"Lobulation score out of bounds.\\\"\\n return _char_to_word_[ s-1 ] + ' Lobulation'\",\n \"def how_many(self):\\n\\tprint \\\"We have {0} robots !!!\\\".format(self.population)\",\n \"def solution(self):\\n return [(\\\"simple 1\\\", 1.),\\n (\\\"simple 2\\\", 1.),\\n (\\\"simple 3\\\", 1.),\\n (\\\"simple 4\\\", 1.),\\n (\\\"simple 5\\\", 1.),\\n (\\\"simple 10\\\", 1.),\\n (\\\"simple 15\\\", 1.),\\n (\\\"thai 1\\\", 1.),\\n (\\\"thai 2\\\", 1.),\\n (\\\"thai 3\\\", 1.),\\n (\\\"thai 4\\\", 1.),\\n (\\\"thai 5\\\", 1.),\\n (\\\"thai 10\\\", 1.),\\n (\\\"thai 15\\\", 1.),\\n ]\",\n \"def strategiaa(stan_gry):\\n ruch = min(random.randint(1,3), stan_gry)\\n return ruch\",\n \"def exemple():\\r\\n\\r\\n case_1 = \\\"\\\\u25CC\\\"\\r\\n case_1 = u\\\"{}\\\".format(case_1)\\r\\n fourmi_1_1 = \\\"\\\\u22C0\\\"\\r\\n fourmi_1_1 = u\\\"{}\\\".format(fourmi_1_1)\\r\\n fourmi_2_1 = \\\"\\\\u21CA\\\"\\r\\n fourmi_2_1 = u\\\"{}\\\".format(fourmi_2_1)\\r\\n fourmi_3_1 = \\\"\\\\u25BC\\\"\\r\\n fourmi_3_1 = u\\\"{}\\\".format(fourmi_3_1)\\r\\n fourmi_1_2 = \\\"\\\\u22C0\\\"\\r\\n fourmi_1_2 = u\\\"{}\\\".format(fourmi_1_2)\\r\\n fourmi_2_2 = \\\"\\\\u21C8\\\"\\r\\n fourmi_2_2 = u\\\"{}\\\".format(fourmi_2_2)\\r\\n fourmi_3_2 = \\\"\\\\u25B2\\\"\\r\\n fourmi_3_2 = u\\\"{}\\\".format(fourmi_3_2)\\r\\n clods_1 = \\\"\\\\u2726\\\"\\r\\n clods_1 = u\\\"{}\\\".format(clods_1)\\r\\n clods_2 = \\\"\\\\u2737\\\"\\r\\n clods_2 = u\\\"{}\\\".format(clods_2)\\r\\n clods_3 = \\\"\\\\u2739\\\"\\r\\n clods_3 = u\\\"{}\\\".format(clods_3)\\r\\n \\r\\n print(term.move_xy(82,3) + term.white + 'DEPOT : ' + (case_1))\\r\\n print(term.move_xy(82,5) + term.white + 'Clods de niveau 1 : ' + (clods_1))\\r\\n print(term.move_xy(82,6) + term.white + 'Clods de niveau 2 : ' + (clods_2))\\r\\n print(term.move_xy(82,7) + term.white + 'Clods de niveau 3 : ' + (clods_3))\\r\\n print(term.move_xy(82,8) + term.white + 'Fourmis de niveau 1 : ' + (fourmi_1_1) + ' ' + (fourmi_1_2))\\r\\n print(term.move_xy(82,9) + term.white + 'Fourmis de niveau 2 : ' + (fourmi_2_1) + ' ' + (fourmi_2_2))\\r\\n print(term.move_xy(82,10) + term.white + 'Fourmis de niveau 3 : ' + (fourmi_3_1) + ' ' + (fourmi_3_2))\\r\\n print(term.move_xy(82,12) + term.white + 'Joueur 1 vous jouez en rouge.')\\r\\n print(term.move_xy(82,13) + term.white + 'Joueur 2 vous jouez en jaune.')\",\n \"def one_v_all(d):\\n label = [0, 0, 0, 0]\\n for raw in d.split(\\\"|\\\")[4:]:\\n line = raw.strip()\\n if \\\"brain\\\" in line:\\n label[0] = 1\\n if \\\"limb\\\" in line:\\n label[1] = 1\\n if \\\"heart\\\" in line:\\n label[2] = 1\\n if \\\"neural\\\" in line:\\n label[3] = 1\\n return label\",\n \"def generate_romance_title():\\n d69 = random.randint(1, 69)\\n if d69 <= 35:\\n #the adj noun\\n return \\\"The \\\" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \\\" \\\" + romance_noun[random.randint(0, len(romance_noun) - 1)]\\n elif d69 > 35:\\n #noun of the adj noun\\n return romance_noun[random.randint(0, len(romance_noun) - 1)] + \\\" of the \\\" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \\\" \\\" + romance_noun[random.randint(0, len(romance_noun) - 1)]\",\n \"def apartment_number():\\r\\n\\r\\n type = _random.choice(['Apt.', 'Apartment', 'Suite', 'Ste.'])\\r\\n letter = _random.choice(string.ascii_letters).capitalize()\\r\\n directions = ['E', 'W', 'N', 'S']\\r\\n short = '{} {}'.format(type, _random.randint(1, 999))\\r\\n long = '{} {}{}'.format(type, _random.randint(1, 999), letter)\\r\\n alt = '{} {}-{}{}'.format(type, _random.choice(directions),\\r\\n _random.randint(1, 999), letter)\\r\\n return _random.choice([short, long, alt])\",\n \"def enough_lords(self):\\n real_numbers = {\\n Title.count: len(self.get_lords_of_title(Title.count)),\\n Title.baron: len(self.get_lords_of_title(Title.baron)),\\n Title.baronet: len(self.get_lords_of_title(Title.baronet)),\\n Title.chevalier: len(self.get_lords_of_title(Title.chevalier)),\\n Title.client: len(self.get_lords_of_title(Title.client)),\\n }\\n\\n counter = {Title.baron: 0, Title.baronet: 0, Title.chevalier: 0,\\n Title.client: 0}\\n\\n for title, vassals in LORDS_VASSALS.items():\\n for i in range(real_numbers[title]):\\n for lower_title, value in vassals.items():\\n counter[lower_title] += value\\n\\n for title, count in counter.items():\\n if count > real_numbers[title]:\\n print(f'Not enough lords of title: {title.value}, '\\n f'required: {count}, actual: {real_numbers[title]}')\\n return False\\n return True\",\n \"def verse_1():\\n print(\\\"Old MACDONALD had a farm\\\")\\n print(\\\"E-I-E-I-O\\\")\",\n \"def bolinish_alomatlari(son):\\n for n in range(1,11):\\n if not son % (n):\\n print(f\\\"{son} {n} ga qoldiqsiz bo'linadi \\\")\",\n \"def left(i):\\r\\n return 2 * i + 1\",\n \"def display_pokemon(pokemon_party):\\n \\n for count, i in enumerate(pokemon_party, start=0):\\n print(f\\\"{count+1}){pokemon_party[count]}\\\")\",\n \"def get_number_of_atmos_levels(description):\\n if description == \\\"none\\\":\\n return \\\"0\\\", \\\"0\\\"\\n elif re.search(\\\"levels\\\", description):\\n match = re.search(\\\"(?P<nl>\\\\d+)\\\\s?(levels|vertical levels)\\\", description)\\n nlevs = match.groupdict()[\\\"nl\\\"]\\n if int(nlevs) > 49: nlas = \\\"20\\\"\\n else: nlas = \\\"10\\\"\\n return nlevs, nlas\\n else:\\n return \\\"40\\\", \\\"20\\\"\",\n \"def organise(times, words):\\r\\n length_lst = \\\"\\\"\\r\\n comm_lst = \\\"\\\"\\r\\n for item in times:\\r\\n length_lst += str(item[0]) + \\\" - \\\" + str(item[1]) + \\\"\\\\n\\\"\\r\\n for item in words:\\r\\n comm_lst += str(item[0]) + \\\" - \\\" + str(item[1]) + \\\"\\\\n\\\"\\r\\n\\r\\n return length_lst, comm_lst\",\n \"def main():\\r\\n\\thead()\\r\\n\\tbelt()\\r\\n\\tupper()\\r\\n\\tlower()\\r\\n\\tbelt()\\r\\n\\thead()\",\n \"def main():\\r\\n\\thead()\\r\\n\\tbelt()\\r\\n\\tupper()\\r\\n\\tlower()\\r\\n\\tbelt()\\r\\n\\thead()\",\n \"def give_names(x): \\n if x == 0:\\n return 'Lost'\\n else:\\n return 'Won/Broke Even'\",\n \"def wcount(lines, topn):\\n word = ''\\n for i in lines:\\n if 65<=ord(i) and ord(i)<=90:\\n word = word + i \\n elif 97<=ord(i) and ord(i)<=122:\\n word = word + i\\n else:\\n word = word + ' ' \\n word = word.split()\\n #提取不重复的单词\\n alreadyknown = []\\n for m in word:\\n if m not in alreadyknown:\\n alreadyknown.append(m)\\n #分别数数，排序，建构字典\\n empty = []\\n final = {}\\n final2 = {}\\n for j in alreadyknown:\\n number = icount(word,j)\\n final[j]=number\\n final2[str(number)]=j\\n empty.append(number)\\n empty.sort()\\n empty.reverse()\\n last_step = empty[:10]\\n #通过数字找到对应word\\n last_str = ''\\n for y in last_step:\\n z = final2[str(y)]\\n last_str += z + \\\"\\\\t\\\" + str(y) + \\\"\\\\n\\\"\\n return last_str\",\n \"def CARD_SUITS() -> tuple:\\n return \\\"Diamonds\\\", \\\"Hearts\\\", \\\"Clubs\\\", \\\"Spades\\\"\",\n \"def treatment_plugs(data_plugs):\\r\\n\\r\\n no_plugs = []\\r\\n little = []\\r\\n means = []\\r\\n great = []\\r\\n large_enough = []\\r\\n super_large = []\\r\\n\\r\\n\\r\\n for i in data_plugs:\\r\\n print(i[0])\\r\\n if i[1] in ('None', None)\\\\\\r\\n or i[0] in ('None', None):\\r\\n pass\\r\\n elif i[0] == 'non':\\r\\n no_plugs.append(int(i[1]))\\r\\n elif i[0] == 'petit':\\r\\n little.append(int(i[1]))\\r\\n elif i[0] == 'moyen':\\r\\n means.append(int(i[1]))\\r\\n elif i[0] == 'grand':\\r\\n great.append(int(i[1]))\\r\\n elif i[0] == 'assez grand':\\r\\n large_enough.append(int(i[1]))\\r\\n elif i[0] == 'tres grand':\\r\\n super_large.append(int(i[1]))\\r\\n\\r\\n\\r\\n data = len(no_plugs) + len(little) +\\\\\\r\\n len(means) + len(great)+\\\\\\r\\n len(large_enough)+\\\\\\r\\n len(super_large)\\r\\n\\r\\n print(data)\\r\\n\\r\\n data_no = moyenne(no_plugs)\\r\\n data_little = moyenne(little)\\r\\n data_means = moyenne(means)\\r\\n data_great = moyenne(great)\\r\\n data_large_enough = moyenne(large_enough)\\r\\n data_super_large = moyenne(super_large)\\r\\n\\r\\n return data_no[0],\\\\\\r\\n data_little[0],\\\\\\r\\n data_means[0],\\\\\\r\\n data_great[0],\\\\\\r\\n data_large_enough[0],\\\\\\r\\n data_super_large[0],\\\\\\r\\n data_no[1],\\\\\\r\\n data_little[1],\\\\\\r\\n data_means[1],\\\\\\r\\n data_great[1],\\\\\\r\\n data_large_enough[1],\\\\\\r\\n data_super_large[1],\\\\\\r\\n data\",\n \"def make_althws(entries):\\n althws = []\\n nentries = len(entries)\\n for ientry,entry in enumerate(entries):\\n m = re.search(r'<althws>{#(.*?)#}</althws>',entry.datalines[0])\\n if m == None:\\n continue\\n hws = re.split(r', *',m.group(1))\\n L0 = entry.metad['L']\\n pc0 = entry.metad['pc']\\n k10 = entry.metad['k1']\\n k20 = entry.metad['k2']\\n # Get L for next entry, or None if this is last entry\\n ientry1 = ientry+1\\n if ientry1 < nentries:\\n entry1 = entries[ientry1]\\n L1 = entry1.metad['L']\\n else:\\n L1 = None\\n nhws = len(hws)\\n Lhws = generate_Ls(L0,L1,nhws) # this is the tricky part\\n if 10 <= nhws:\\n print('%s,%s,%s has %s alternate headwords' %(L0,pc0,k10,nhws))\\n # generate a line for each hw\\n for ihw,hw in enumerate(hws):\\n L = Lhws[ihw]\\n pc = pc0\\n k1 = hw\\n k2 = hw\\n t = 'alt' #type\\n lp = L0\\n k1p = k10\\n out = '<L>%s<pc>%s<k1>%s<k2>%s<type>%s<LP>%s<k1P>%s' %(\\n L,pc,k1,k2,t,lp,k1p)\\n althws.append(out)\\n return althws\",\n \"def rules():\\r\\n print(\\\"\\\\n\\\\\\r\\n \\\\tMmmmm... Si vous etes ici, j'imagine que votre décision est prise !\\\\n\\\\\\r\\n Je ne veux pas vous inciter à arreter mais vous etes conscient des risques ?\\\\n\\\\\\r\\n Vous participez quand meme au plus grand combat de tous les temps...\\\\n\\\\n\\\\\\r\\n \\\\tBon je vous explique les règles : Vous allez affronter un autre titan en duel\\\\n\\\\\\r\\n Vous avez chacun des tentatives d'infliger une attaque. Si elles réussissent,\\\\n\\\\\\r\\n Vous aurez le choix d'infliger entre 0 et 100 dégats. Enfin non puisque tout\\\\n\\\\\\r\\n sera tiré au sort :)\\\\n\\\\\\r\\n La partie s'arrete quand l'un des deux titans est mort\\\\n\\\\\\r\\n \\\\tBonne chance a vous!\\\\n\\\")\",\n \"def pix(length, legs):\\n pos_m = 0\\n pos_p = 0\\n for i in range(1, legs+1):\\n print(i, '. leg')\\n pos_m, pos_p = one_leg(length, pos_m, pos_p)\\n if pos_m == length:\\n print('Mat wins')\\n return 1\\n elif pos_p == length:\\n print('Pat wins')\\n return -1\\n return 0\",\n \"def vanilaScore(self,attended,state,W):\",\n \"def prob4():\\n#pass\\n n_men = 0\\n n_women = 0\\n db = sql.connect('sql2')\\n cur = db.cursor()\\n cur.execute(\\\"SELECT Gender FROM ICD WHERE Age>=25 AND Age<=35\\\")\\n for gen in cur :\\n if gen[0] == 'M' :\\n n_men += 1\\n else :\\n n_women += 1\\n db.close()\\n return n_men,n_women\",\n \"def abstract(res):\\n o = r'\\\\begin{center}'\\n #o += r'\\\\begin{tikzpicture}[x={(-0.5cm,-0.5cm)}, y={(0.966cm,-0.2588cm)}, z={(0cm,1cm)}, scale=0.6, color={lightgray},opacity=.5]'\\n #o += r'\\\\tikzset{facestyle/.style={fill=lightgray,draw=black,very thin,line join=round}}'\\n o += r'\\\\begin{tikzpicture}' + '\\\\n'\\n o += r'\\\\draw[blue!40!white] (0,0) rectangle (6,4); \\\\fill[blue!10!white] (2.4,4) rectangle (3.6,4.15);' + '\\\\n'\\n for i in range(res[7]):\\n x,y = random.randrange(2,538)/100.0,random.randrange(2,300)/100.0\\n o += r'\\\\filldraw[fill=green!30!white,draw=white] (%s,%s) rectangle (%s,%s);'%(x,y,(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%((x+0.29),(y+0.19),(x+0.58),(y+0.38)) + '\\\\n'\\n o += r'\\\\filldraw[white] (%s,%s) -- (%s,%s);'%(x,(y+0.38),(x+0.29),(y+0.19)) + '\\\\n'\\n o += r'\\\\end{tikzpicture}\\\\end{center}' + '\\\\n'\\n\\n o += r'\\\\begin{tabular}{|l|l|}' + '\\\\n' + r'\\\\hline' + '\\\\n'\\n o += r'Election name& \\\\texttt{\\\"%s\\\"}\\\\\\\\'%res[1]\\n o += r'Box number& \\\\texttt{%s}\\\\\\\\'%res[2]\\n o += r'State& \\\\texttt{%s}\\\\\\\\'%('closed' if res[5] == cloSt else ('vote' if res[5] == votSt else 'register'))\\n o += r'Registration end& \\\\textit{%s}\\\\\\\\'%res[3]\\n o += r'Vote closing& \\\\textit{%s}\\\\\\\\'%res[4]\\n o += r'Casted/registered& $%s/%s$\\\\\\\\'%(res[7],res[6]) +'\\\\n'\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n o += r'\\\\quad' + '\\\\n'\\n o += r'\\\\begin{tabular}{|l|l|}\\\\hline'\\n l = res[8].items()\\n l.sort(key = operator.itemgetter(1),reverse=True)\\n n = 0\\n for x in l:\\n o += r'%s & %s\\\\\\\\'%(r'\\\\textit{%s}'%x[0] if x[0] == 'White Ballot' else r'\\\\texttt{%s}'%x[0],x[1]) \\n if n == 0:\\n o += r'\\\\hline' + '\\\\n'\\n n += 1\\n o += r'\\\\hline\\\\end{tabular}' + '\\\\n'\\n\\n\\n #o += r'\\\\item The designer\\\\textquoteright s digital signature of this document (the source file \\\\texttt{oeu.py}) is: \\\\tiny $$\\\\verb!%s!$$ \\\\normalsize'%rsa(IKey).sign(open(__file__).read()) + '\\\\n'\\n\\n return r'\\\\begin{abstract}' + abstract.__doc__ + r'\\\\end{abstract}' + o\",\n \"def part1(input_string):\\n twos, threes = 0, 0\\n for line in input_string:\\n letters_seen = {}\\n for char in line:\\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\\n if 2 in letters_seen.values():\\n twos += 1\\n if 3 in letters_seen.values():\\n threes += 1\\n return threes * twos\",\n \"def the_counting_game(number_of_players=10, total=100):\\n # a b c d e f g h i j\\n # 1 2 3 4 5 6 7\\n # 13 12 11 10 9 8\\n # 14\\n # 15 16 17 18 19 20 21\\n # 27 26 25 24 23 22\\n # 28\\n # 29\\n # print \\\"total\\\", total\\n player_number = 1 # first player will say the number 1\\n dir = 'right' # we start off counting to the right\\n num_said = 1 # the number said by the first player\\n while num_said < total:\\n if dir == 'right':\\n print dir\\n # if we're at the last player, go back to the first player\\n # which is last player minus total number of players minus 1\\n if player_number == number_of_players:\\n player_number = number_of_players - 1\\n print \\\"p\\\", player_number, \\\"said: \\\", num_said\\n else:\\n print \\\"p\\\", player_number, \\\"said: \\\", num_said\\n player_number += 1\\n # if the next number will be a multiple of 7, time to switch directions\\n if (num_said + 1) % 7 == 0:\\n print \\\"this should switch\\\", dir\\n dir = switch_direction(dir)\\n print \\\"this should switch\\\", dir\\n elif dir == 'left':\\n print dir\\n # if this is the first player, going left means going to the last player\\n # which is total number of players\\n if player_number == 1:\\n player_number += (number_of_players - 1)\\n else:\\n print \\\"p\\\", player_number, \\\"said: \\\", num_said\\n player_number -= 1\\n # if the next number will be a multiple of 7, time to switch directions\\n if (num_said + 1) % 7 == 0:\\n print \\\"this should switch\\\", dir\\n dir = switch_direction(dir)\\n print \\\"this should switch\\\", dir\\n num_said += 1\\n return \\\"Player to say the total: \\\" + str(player_number)\",\n \"def step2(self):\\n\\t\\tif self.b[self.k - 1] == 'a':\\n\\t\\t\\tif self.ends(\\\"ational\\\"): self.r(\\\"ate\\\")\\n\\t\\t\\telif self.ends(\\\"tional\\\"): self.r(\\\"tion\\\")\\n\\t\\telif self.b[self.k - 1] == 'c':\\n\\t\\t\\tif self.ends(\\\"enci\\\"):\\t self.r(\\\"ence\\\")\\n\\t\\t\\telif self.ends(\\\"anci\\\"): self.r(\\\"ance\\\")\\n\\t\\telif self.b[self.k - 1] == 'e':\\n\\t\\t\\tif self.ends(\\\"izer\\\"):\\t self.r(\\\"ize\\\")\\n\\t\\telif self.b[self.k - 1] == 'l':\\n\\t\\t\\tif self.ends(\\\"bli\\\"):\\t self.r(\\\"ble\\\") # --DEPARTURE--\\n\\t\\t\\t# To match the published algorithm, replace this phrase with\\n\\t\\t\\t#\\tif self.ends(\\\"abli\\\"):\\t self.r(\\\"able\\\")\\n\\t\\t\\telif self.ends(\\\"alli\\\"): self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"entli\\\"): self.r(\\\"ent\\\")\\n\\t\\t\\telif self.ends(\\\"eli\\\"):\\t self.r(\\\"e\\\")\\n\\t\\t\\telif self.ends(\\\"ousli\\\"): self.r(\\\"ous\\\")\\n\\t\\telif self.b[self.k - 1] == 'o':\\n\\t\\t\\tif self.ends(\\\"ization\\\"): self.r(\\\"ize\\\")\\n\\t\\t\\telif self.ends(\\\"ation\\\"): self.r(\\\"ate\\\")\\n\\t\\t\\telif self.ends(\\\"ator\\\"): self.r(\\\"ate\\\")\\n\\t\\telif self.b[self.k - 1] == 's':\\n\\t\\t\\tif self.ends(\\\"alism\\\"):\\t self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"iveness\\\"): self.r(\\\"ive\\\")\\n\\t\\t\\telif self.ends(\\\"fulness\\\"): self.r(\\\"ful\\\")\\n\\t\\t\\telif self.ends(\\\"ousness\\\"): self.r(\\\"ous\\\")\\n\\t\\telif self.b[self.k - 1] == 't':\\n\\t\\t\\tif self.ends(\\\"aliti\\\"):\\t self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"iviti\\\"): self.r(\\\"ive\\\")\\n\\t\\t\\telif self.ends(\\\"biliti\\\"): self.r(\\\"ble\\\")\\n\\t\\telif self.b[self.k - 1] == 'g': # --DEPARTURE--\\n\\t\\t\\tif self.ends(\\\"logi\\\"):\\t self.r(\\\"log\\\")\\n\\t\\t# To match the published algorithm, delete this phrase\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2):\\n #moves shorter sequence along longer, counting number of matches in\\n #each position\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\"\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\"\\n\\n # gives an output for each startpoint showing the number of matches where\\n # * is a match and - is no match, position of the two sequences relative to\\n # each other, and the number of matches for that startpoint.\\n print(\\\".\\\" * startpoint + matched) \\n print(\\\".\\\" * startpoint + s2)\\n print(s1)\\n print(score) \\n print(\\\" \\\")\\n\\n return score\",\n \"def estimate_planks(self, length):\\n number_of_planks = length // self.plank_length\\n return f\\\"You need {number_of_planks} plank(s) of wood to build this wall\\\"\",\n \"def main():\\n args = get_args()\\n guess = args.guess.upper()\\n choice = args.choice\\n \\n dict = {1: 'Arcosanti', 2: 'Intercept', 3: 'Positions', 4: 'Collected', 5: 'Gemstones', 6: 'Cellulose', 7: 'Mastodons', 8: 'Meteorite', 9: 'Phoenixes', 10: 'Fireflies'} \\n \\n if choice > 10 or choice < 1: \\n die('The choice number must be between 1 and 10') \\n base = dict[choice].upper()\\n if len(guess) < len(base) or len(guess) > len(base):\\n die('The guess must be the same length as the word: {}'.format(len(base)))\\n \\n for i,j in zip(guess, base): \\n if i == j:\\n print('{}'.format(i),end='') \\n else:\\n print('_', end='')\\n print('\\\\n')\",\n \"def generate_fantasy_title():\\n d20 = random.randint(1, 20)\\n if d20 <= 4:\\n #genetive noun\\n return fantasy_genetive[random.randint(0, len(fantasy_genetive) - 1)] + \\\" \\\" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\\n elif d20 > 4 and d20 < 13: \\n #The adj noun\\n return \\\"The \\\" + fantasy_adj[random.randint(0, len(fantasy_adj) - 1)] + \\\" \\\" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\\n elif d20 >= 13:\\n #something of something\\n return fantasy_noun[random.randint(0, len(fantasy_noun) - 1)] + \\\" of \\\" + fantasy_what_is_this[random.randint(0, len(fantasy_what_is_this) - 1)]\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2): \\n if (i + startpoint) < (l1 + l2 - 1): \\n if l2 - i > startpoint + 1:\\n matched = matched + \\\".\\\" #dots before they start overlapping\\n elif s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" #matched bases\\n score = score + 1 #adds one to score\\n else:\\n matched = matched + \\\"-\\\" #not matched bases\\n shift, end_shift = startpoint * \\\".\\\", (l2 + l1 - startpoint - 2) * \\\".\\\"\\n # dots at end, but only up until end of dots tailing l1\\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\\n # this formula. the below check stops it from getting less than l2.\\n if startpoint < l1 - 1:\\n print(shift + matched + end_shift)\\n else:\\n print(shift + matched + (l2 - 1) * \\\".\\\")\\n print(shift + s2 + end_shift)\\n print(s1)\\n print(str(score) + \\\"\\\\n\\\")\\n return score, matched, shift, end_shift\",\n \"def build_leftpart():\\n # build kelly.\\n build_kelly()\\n # copy kelly to 3.\\n copy(0, 3)\\n\\n # build june in slots 0,1,2\\n build_june()\\n # copy kelly to slot 1\\n copy(3, 1)\\n\\n # smash together to get (june kelly) in 0\\n smash()\\n # copy (june kelly) to 1\\n copy(0, 1)\\n # build horace in 0\\n build_horace(0)\\n # smash together to get (horace (june kelly)) in 0\\n smash()\\n # wrap with an S for the whole left part.\\n apply_card(\\\"S\\\", 0)\",\n \"def find_gender_adj(novel, female):\\n output = {}\\n text = novel.get_tokenized_text()\\n\\n if female:\\n distances = female_instance_dist(novel)\\n pronouns1 = [\\\"her\\\", \\\"hers\\\", \\\"she\\\", \\\"herself\\\"]\\n pronouns2 = [\\\"his\\\", \\\"him\\\", \\\"he\\\", \\\"himself\\\"]\\n else:\\n distances = male_instance_dist(novel)\\n pronouns1 = [\\\"his\\\", \\\"him\\\", \\\"he\\\", \\\"himself\\\"]\\n pronouns2 = [\\\"her\\\", \\\"hers\\\", \\\"she\\\", \\\"herself\\\"]\\n if len(distances) == 0:\\n return {}\\n elif len(distances) <= 3:\\n lower_window_bound = 5\\n else:\\n lower_window_bound = median(sorted(distances)[:int(len(distances) / 2)])\\n\\n if not lower_window_bound >= 5:\\n return \\\"lower window bound less than 5\\\"\\n for l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11 in windowed(text, 11):\\n l6 = l6.lower()\\n if not l6 in pronouns1:\\n continue\\n words = [l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11]\\n if bool(set(words) & set(pronouns2)):\\n continue\\n for index, word in enumerate(words):\\n words[index] = word.lower()\\n tags = nltk.pos_tag(words)\\n for tag_index, tag in enumerate(tags):\\n if tags[tag_index][1] == \\\"JJ\\\" or tags[tag_index][1] == \\\"JJR\\\" or tags[tag_index][1] == \\\"JJS\\\":\\n word = words[tag_index]\\n if word in output.keys():\\n output[word] += 1\\n else:\\n output[word] = 1\\n return output\",\n \"def get_true_propositions(self):\\n current_loc = self.objects.get((self.agent.i,self.agent.j), \\\"\\\")\\n if current_loc: # taxi at location\\n loc_i = \\\"abcd\\\".index(current_loc.lower())\\n if self.passenger == current_loc: # passenger at location\\n return Traces.letters[loc_i+4]\\n else: # passenger in taxi or elsewere\\n return Traces.letters[loc_i]\\n else: # taxi in transit\\n return \\\"\\\"\\n\\n # ret = self.objects.get((self.agent.i,self.agent.j), \\\"\\\").lower()\\n # ret += \\\"efgh\\\"[\\\"abcd\\\".index(self.destination.lower())]\\n # if self.passenger is not None: # at location\\n # ret += \\\"ijkl\\\"[\\\"abcd\\\".index(self.passenger.lower())]\\n # else: # in taxi\\n # ret += \\\"m\\\"\\n # return ret\",\n \"def walk_through_floors(instructions):\\n floor = 0\\n position = 0\\n enter_basement_at = 0\\n for instruction in instructions:\\n position += 1\\n if instruction == '(':\\n floor += 1\\n else:\\n floor -= 1\\n if floor == -1 and enter_basement_at == 0:\\n enter_basement_at = position\\n return floor, enter_basement_at\",\n \"def test_longest_streak_all_habits():\\n habits_trackings_table = analytics.habits_trackings_table()\\n habit_info_longest_streak = analytics.habit_info_longest_streak(habits_trackings_table)\\n assert analytics.name_habit_longest_streak(habit_info_longest_streak) == [('Yoga', 9)]\",\n \"def get_direction_letters(d):\\n d_letters = ('N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW')\\n x = int((d + 11.25) / 22.5) % 16\\n return d_letters[x]\",\n \"def possible_directions(valid_positions):\\n if valid_positions == \\\"n\\\":\\n print(\\\"You can travel: (N)orth.\\\")\\n elif valid_positions == \\\"nes\\\":\\n print(\\\"You can travel: (N)orth or (E)ast or (S)outh.\\\")\\n elif valid_positions == \\\"es\\\":\\n print(\\\"You can travel: (E)ast or (S)outh.\\\")\\n elif valid_positions == \\\"sw\\\":\\n print(\\\"You can travel: (S)outh or (W)est.\\\")\\n elif valid_positions == \\\"ew\\\":\\n print(\\\"You can travel: (E)ast or (W)est.\\\")\\n elif valid_positions == \\\"ns\\\":\\n print(\\\"You can travel: (N)orth or (S)outh.\\\")\",\n \"def evaulate_monster(generikmon):\\r\\n score = generikmon['headA']\\r\\n #score = generikmon['chinA']\\r\\n return score\",\n \"def action_to_id(a):\\n if a == [-1.0, 0.0, 0.0]: return LEFT # LEFT: 1\\n elif a == [1.0, 0.0, 0.0]: return RIGHT # RIGHT: 2\\n elif a == [0.0, 1.0, 0.0]: return ACCELERATE # ACCELERATE: 3\\n elif a == [0.0, 0.0, 0.2]: return BRAKE # BRAKE: 4\\n else: \\n return STRAIGHT # STRAIGHT = 0\",\n \"def one_leg(length, pos_m, pos_p):\\n pos_m, mat_moves = one_player_leg(length, pos_m)\\n if pos_p == pos_m:\\n pos_p = 0\\n pos_p, pat_moves = one_player_leg(length, pos_p)\\n print('Mat:', end=' ')\\n for move in mat_moves:\\n print(move, end=' ')\\n print('Pat:', end=' ')\\n for move in pat_moves:\\n print(move, end=' ')\\n if pos_m == pos_p:\\n pos_m = 0\\n print('\\\\n')\\n one_line_print(length, 'M', pos_m)\\n one_line_print(length, 'P', pos_p)\\n print('\\\\n')\\n return pos_m, pos_p\",\n \"def find_boundaries(s, w):\\n ind = w.i\\n # handling height\\n if ind + 2 < len(s) and s[ind + 1].text == \\\"'\\\" and s[ind + 2].like_num:\\n return ind, ind + 3\\n if ind - 2 >= 0 and s[ind - 1].text == \\\"'\\\" and s[ind - 2].like_num:\\n return ind - 2, ind + 1\\n\\n # forward\\n if s[ind].ent_iob == 2:\\n return ind, ind + 1\\n if ind != len(s) - 1:\\n i = ind + 1\\n while s[i].ent_iob == 1 and (s[i].pos_ == 'NUM' or s[i].like_num or\\n (i+1 < len(s) and (s[i+1].pos_ == 'NUM' or s[i+1].like_num))):\\n i += 1\\n if i == len(s):\\n break\\n if s[i - 1].pos_ == 'NUM' or s[i - 1].like_num or s[i - 1].lemma_ in ['one']:\\n end = i\\n else:\\n end = i - 1\\n else:\\n end = ind + 1\\n\\n # backward\\n if s[ind].ent_iob == 3:\\n return ind, end\\n i = ind - 1\\n while s[i].ent_iob != 2 and (s[i].pos_ == 'NUM' or s[i].like_num or s[i-1].pos_ == 'NUM' or s[i-1].like_num):\\n i -= 1\\n if i == -1:\\n break\\n i += 1\\n if s[i].pos_ != 'NUM' and not s[i].like_num:\\n i += 1\\n return i, end\",\n \"def display_game(game: List[int]) -> None:\\n print()\\n row = 0\\n while(row < len(game)):\\n print(row+1, end=\\\"- \\\")\\n m = game[row]\\n while m > 0:\\n print(\\\"| \\\", end='')\\n m -= 1\\n row += 1\\n print()\\n print()\",\n \"def _make_limb_dict():\\n\\n return {'left_arm_y': 10, 'right_arm_y': 13,\\n 'left_arm_z': 11, 'right_arm_z': 14,\\n 'left_leg_y': 4, 'right_leg_y': 7,\\n 'left_leg_z': 5, 'right_leg_z': 8,\\n 'hip_y': 2, 'hip_x': 1}\",\n \"def predictSideFromFEN(fen):\\n\\n # remove spaces values (numbers) from fen\\n fen = re.sub('\\\\d','',fen)\\n \\n #split fen to top half and bottom half (top half first)\\n parts = fen.split('/')\\n top = list(''.join(parts[:4]))\\n bottom = list(''.join(parts[4:]))\\n \\n # If screenshot is aligned from POV of white to play, we'd expect\\n # top to be mostly black pieces (lowercase)\\n # and bottom to be mostly white pieces (uppercase), so lets count\\n top_count_white = sum(list(map(lambda x: ord(x) <= ord('Z'), top)))\\n bottom_count_white = sum(list(map(lambda x: ord(x) <= ord('Z'), bottom)))\\n\\n top_count_black = sum(list(map(lambda x: ord(x) >= ord('a'), top)))\\n bottom_count_black = sum(list(map(lambda x: ord(x) >= ord('a'), bottom)))\\n\\n # If more white pieces on top side, or more black pieces on bottom side, black to play\\n if (top_count_white > bottom_count_white or top_count_black < bottom_count_black):\\n return 'b'\\n\\n # Otherwise white\\n return 'w'\",\n \"def check_hand_rank(hand):\\n card_rank = ['--23456789TJQKA'.index(n) for n,h in hand]\\n card_rank.sort()\\n card_rank.reverse()\\n #for royal straight flush\\n card_rank_rsf = ['HDSC'.index(h) for n,h in hand]\\n card_rank_rsf.sort()\\n card_rank_rsf.reverse()\\n if card_rank == [14,5,4,3,2]:\\n card_rank = [5,4,3,2,1]\\n if royal_straight_flush(hand):\\n return 9,card_rank_rsf[0]\\n elif straight_flush(hand):\\n return 8,max(card_rank)\\n elif four_of_a_kind(hand):\\n return 7,max(card_rank)\\n elif full_house(hand):\\n tong = 0\\n kuu = 0\\n s = [n for n,h in hand]\\n for i in xrange(len(s)):\\n if(s.count(s[i])==3):\\n tong = s[i]\\n else:\\n kuu = s[i]\\n return 6,int(tong),int(kuu)\\n elif flush(hand):\\n return 5,max(card_rank)\\n elif straight(hand):\\n return 4,max(card_rank)\\n elif three_of_a_kind(hand):\\n ld = 0\\n a = 0\\n for i in xrange(0,3):\\n if card_rank.count(card_rank[i]) > 1 :\\n ld = (card_rank[i])\\n else:\\n a = card_rank[i]\\n return 3,ld,a\\n elif two_pair(hand):\\n ld = []\\n a = 0\\n for i in xrange(0,3):\\n if card_rank.count(card_rank[i]) >=2:\\n ld.append(card_rank[i])\\n card_rank.pop(i)\\n else:\\n a = card_rank[i]\\n ld.sort(reverse=True)\\n return 2,ld[0],ld[1],a\\n elif one_pair(hand):\\n ld = 0\\n a = []\\n for i in xrange(len(card_rank)):\\n if card_rank.count(card_rank[i]) > 1 :\\n ld = (card_rank[i])\\n else:\\n a.append(card_rank[i])\\n a.sort(reverse = True)\\n return 1,ld,a[0],a[1],a[2]\\n else:\\n return 0,max(card_rank)\",\n \"def desimal_til_bokstav(snitt):\\r\\n if snitt >= 4.5:\\r\\n return 'A'\\r\\n elif 3.5 <= snitt < 4.5:\\r\\n return 'B'\\r\\n elif 2.5 <= snitt < 3.5:\\r\\n return 'C'\\r\\n elif 1.5 <= snitt < 2.5:\\r\\n return 'D'\\r\\n elif 0.5 <= snitt < 1.5:\\r\\n return 'E'\\r\\n else:\\r\\n return 'F'\",\n \"def threes_points(dice_list):\\n return dice_list.count(3) * 3\",\n \"def level(score):\\n user_level = \\\"\\\"\\n if score < 20:\\n user_level = \\\"elementary\\\"\\n elif score < 30:\\n user_level = \\\"intermediate\\\"\\n elif score < 35:\\n user_level = \\\"upper intermediate\\\"\\n else:\\n user_level = \\\"advanced\\\"\\n return user_level\",\n \"def threes(dice):\\n for i, j, k in combinations(dice, 3):\\n if i == j == k:\\n return 3 * i\\n\\n return 0\",\n \"def find_ladders_pretty(left_word: str, right_word: str, exact_depth: Optional[int] = None, max_depth: int = 10, use_heuristic: bool = True):\\n # Find all ladders and sort by length\\n pretty_ladders = find_ladders_unique(left_word, right_word, exact_depth, max_depth, use_heuristic)\\n if len(pretty_ladders) == 0:\\n return\\n\\n pretty_ladders.sort(key=len)\\n for pretty_ladder in pretty_ladders:\\n print(pretty_ladder)\",\n \"def solution(self):\\n return [((\\\"communes of the bouches-du-rh\\\\u00f4ne department\\\", \\\"france\\\"), 0.024170164983320565)] * 100\",\n \"def tetrakis(self):\\n return self.nlegomena(4)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.53578615","0.53493005","0.5348243","0.5291687","0.528967","0.5280485","0.52631533","0.52626497","0.52135915","0.52076775","0.5184838","0.51696646","0.5135104","0.51240534","0.5113022","0.51092434","0.5107674","0.5095507","0.50915027","0.50757784","0.50535756","0.50522333","0.50485003","0.50396705","0.5028297","0.50135463","0.50113815","0.4998529","0.49974275","0.49931204","0.49881783","0.49819046","0.49815294","0.49815166","0.4961207","0.49592242","0.49495006","0.49463907","0.49435452","0.49427408","0.49412942","0.4940968","0.49142173","0.49095497","0.49092945","0.4905989","0.48955786","0.48922923","0.48902047","0.48900416","0.48845395","0.48749968","0.48727512","0.48689368","0.48666355","0.48592263","0.485454","0.4852326","0.4841152","0.48350316","0.48350316","0.48326623","0.48243847","0.4822386","0.48142225","0.48084062","0.4806136","0.48034003","0.48013538","0.48006892","0.4799281","0.47962373","0.4796104","0.4793566","0.47824436","0.47805452","0.47703943","0.47701228","0.47630954","0.4761506","0.47541162","0.47536236","0.4750218","0.4747503","0.47470698","0.4743919","0.4743915","0.47435778","0.4740238","0.4740096","0.4740071","0.47380567","0.47331506","0.47301787","0.4729946","0.47277144","0.4727669","0.47274658","0.47270688","0.47270498","0.47250938"],"string":"[\n \"0.53578615\",\n \"0.53493005\",\n \"0.5348243\",\n \"0.5291687\",\n \"0.528967\",\n \"0.5280485\",\n \"0.52631533\",\n \"0.52626497\",\n \"0.52135915\",\n \"0.52076775\",\n \"0.5184838\",\n \"0.51696646\",\n \"0.5135104\",\n \"0.51240534\",\n \"0.5113022\",\n \"0.51092434\",\n \"0.5107674\",\n \"0.5095507\",\n \"0.50915027\",\n \"0.50757784\",\n \"0.50535756\",\n \"0.50522333\",\n \"0.50485003\",\n \"0.50396705\",\n \"0.5028297\",\n \"0.50135463\",\n \"0.50113815\",\n \"0.4998529\",\n \"0.49974275\",\n \"0.49931204\",\n \"0.49881783\",\n \"0.49819046\",\n \"0.49815294\",\n \"0.49815166\",\n \"0.4961207\",\n \"0.49592242\",\n \"0.49495006\",\n \"0.49463907\",\n \"0.49435452\",\n \"0.49427408\",\n \"0.49412942\",\n \"0.4940968\",\n \"0.49142173\",\n \"0.49095497\",\n \"0.49092945\",\n \"0.4905989\",\n \"0.48955786\",\n \"0.48922923\",\n \"0.48902047\",\n \"0.48900416\",\n \"0.48845395\",\n \"0.48749968\",\n \"0.48727512\",\n \"0.48689368\",\n \"0.48666355\",\n \"0.48592263\",\n \"0.485454\",\n \"0.4852326\",\n \"0.4841152\",\n \"0.48350316\",\n \"0.48350316\",\n \"0.48326623\",\n \"0.48243847\",\n \"0.4822386\",\n \"0.48142225\",\n \"0.48084062\",\n \"0.4806136\",\n \"0.48034003\",\n \"0.48013538\",\n \"0.48006892\",\n \"0.4799281\",\n \"0.47962373\",\n \"0.4796104\",\n \"0.4793566\",\n \"0.47824436\",\n \"0.47805452\",\n \"0.47703943\",\n \"0.47701228\",\n \"0.47630954\",\n \"0.4761506\",\n \"0.47541162\",\n \"0.47536236\",\n \"0.4750218\",\n \"0.4747503\",\n \"0.47470698\",\n \"0.4743919\",\n \"0.4743915\",\n \"0.47435778\",\n \"0.4740238\",\n \"0.4740096\",\n \"0.4740071\",\n \"0.47380567\",\n \"0.47331506\",\n \"0.47301787\",\n \"0.4729946\",\n \"0.47277144\",\n \"0.4727669\",\n \"0.47274658\",\n \"0.47270688\",\n \"0.47270498\",\n \"0.47250938\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13281,"cells":{"query":{"kind":"string","value":"1 > spleen, 3 > left kidney, 4 > gallbladder, 5 > esophagus 6 > liver, 7 > stomach, 11 > pancreas, 14 > duodenum"},"document":{"kind":"string","value":"def load_tcia_pancreas(self, patient):\n start = time.time()\n \n ct_path = self.folder + 'nifti/' + patient + end\n array = load_sitk(ct_path)[np.newaxis, ...].astype(float)# Add 1 dimension\n \n # Correction of the orientation\n array = array[:, ::-1, ::-1, ::-1]\n \n if self.pseudo_labels:\n mask_path = self.folder + 'pseudo_seg/' + patient + '-seg' + end\n else:\n mask_path = self.folder + 'labels/' + patient + '-seg' + end\n\n if self.load_mask and os.path.isfile(mask_path):\n \n mask = load_sitk(mask_path).astype(int)\n mask = mask[::-1, ::-1, ::-1]\n\n if self.pseudo_labels:\n label = 12*[1]\n else:\n mask, label = convert_tcia_labels(mask, self.keep_all_label)\n \n num_label = len(label)\n mask = np.rollaxis(np.eye(num_label, dtype=np.uint8)[mask], -1, 0)\n else:\n print(mask_path)\n mask = np.zeros(array.shape[1:], dtype=np.int16)\n mask = np.rollaxis(np.eye(2)[mask], -1, 0) # Put to one hot encoder\n label = 14*[0]\n \n stop = time.time()\n \n\n return array, mask, np.array(label), stop - start"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def fo_shizzle_my_nizzle(n): \n if n < 0:\n n = \"fo\"\n elif n >= 1 and n < 50: \n n = \"shizzle\"\n elif n >= 50 and n <= 100:\n n = \"my\"\n elif n % 2 == 0 and n % 3 == 0 and n > 100:\n n = \"nizzle\"\n else:\n n = \"\"\n return n","def solution(self):\n return [(\"the\", 1579644)] * 100","def generate_horror_title():\n d666 = random.randint(1, 666)\n if d666 <= 111:\n #the adj noun\n return \"The \" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \" \" + horror_noun[random.randint(0, len(horror_noun) - 1)]\n elif d666 > 111 and d666 <= 222: \n #noun of noun\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \" of \" + horror_noun[random.randint(0, len(horror_noun) - 1)]\n elif d666 > 222 and d666 < 444: \n #the adj noun of verb \n return \"The \" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \" \" + horror_noun[random.randint(0, len(horror_noun) - 1)] + \" of \" + horror_verb[random.randint(0, len(horror_verb) - 1)]\n elif d666 >= 444 and d666 < 555: \n #noun of noun\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \" of \" + horror_noun[random.randint(0, len(horror_noun) - 1)]\n elif d666 >= 555:\n #verb of the adj noun\n return horror_verb[random.randint(0, len(horror_verb) - 1)] + \" of the \" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \" \" + horror_noun[random.randint(0, len(horror_noun) - 1)]","def CARD_SUITS() -> tuple:\n return \"Diamonds\", \"Hearts\", \"Clubs\", \"Spades\"","def solution(self):\n return [(\"the\", 1561900)] * 100","def strategiaa(stan_gry):\n ruch = min(random.randint(1,3), stan_gry)\n return ruch","def find_gender_adj(novel, female):\n output = {}\n text = novel.get_tokenized_text()\n\n if female:\n distances = female_instance_dist(novel)\n pronouns1 = [\"her\", \"hers\", \"she\", \"herself\"]\n pronouns2 = [\"his\", \"him\", \"he\", \"himself\"]\n else:\n distances = male_instance_dist(novel)\n pronouns1 = [\"his\", \"him\", \"he\", \"himself\"]\n pronouns2 = [\"her\", \"hers\", \"she\", \"herself\"]\n if len(distances) == 0:\n return {}\n elif len(distances) <= 3:\n lower_window_bound = 5\n else:\n lower_window_bound = median(sorted(distances)[:int(len(distances) / 2)])\n\n if not lower_window_bound >= 5:\n return \"lower window bound less than 5\"\n for l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11 in windowed(text, 11):\n l6 = l6.lower()\n if not l6 in pronouns1:\n continue\n words = [l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11]\n if bool(set(words) & set(pronouns2)):\n continue\n for index, word in enumerate(words):\n words[index] = word.lower()\n tags = nltk.pos_tag(words)\n for tag_index, tag in enumerate(tags):\n if tags[tag_index][1] == \"JJ\" or tags[tag_index][1] == \"JJR\" or tags[tag_index][1] == \"JJS\":\n word = words[tag_index]\n if word in output.keys():\n output[word] += 1\n else:\n output[word] = 1\n return output","def solution(self):\n return [(\"simple 1\", 1.),\n (\"simple 2\", 1.),\n (\"simple 3\", 1.),\n (\"simple 4\", 1.),\n (\"simple 5\", 1.),\n (\"simple 10\", 1.),\n (\"simple 15\", 1.),\n (\"thai 1\", 1.),\n (\"thai 2\", 1.),\n (\"thai 3\", 1.),\n (\"thai 4\", 1.),\n (\"thai 5\", 1.),\n (\"thai 10\", 1.),\n (\"thai 15\", 1.),\n ]","def part1(input_string):\n twos, threes = 0, 0\n for line in input_string:\n letters_seen = {}\n for char in line:\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\n if 2 in letters_seen.values():\n twos += 1\n if 3 in letters_seen.values():\n threes += 1\n return threes * twos","def won(s,n):","def count_words_and_dublicates(novel):","def substantiate():","def solution(self):\n return [((\"communes of the bouches-du-rh\\u00f4ne department\", \"france\"), 0.024170164983320565)] * 100","def __init__(self, n, sents):\n assert n > 0\n self._n = n\n print(\"Counting...\")\n count = defaultdict(int)\n while n >= 0:\n for sent in sents:\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n print(\"Computing vocabulary...\")\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc) # vocabulary size\n print(\"Done\")","def count_sheep(n):\t\n\treturn ''.join([str(x) + ' sheep...' for x in range(1, n + 1)])","def pirate():\n \n from random import choice\n d = {\n \"sir\": \"matey\", \"hotel\": \"fleabag inn\", \"student\": \"swabbie\",\n \"boy\": \"matey\", \"girl\": \"wench\", \"professor\": \"foul blaggart\",\n \"restaurant\": \"galley\", \"your\": \"ye\", \"excuse\": \"arr\", \"you\": \"ye\",\n \"students\": \"swabbies\", \"are\": \"be\", \"lawyer\": \"foul blaggart\",\n \"the\": \"th'\", \"restroom\": \"head\", \"my\": \"me\", \"hello\": \"avast\",\n \"is\": \"be\", \"man\": \"scurvy dog\", \"hey\": \"avast\", \"pirate\": \"scurvy pirate\",\n \"idiot\": \"flunder\", \"young\": \"ye\", \"the\": \"t'\", \"suck\": \"blow down\",\n \"fall\": \"hade\", \"happens\": \"be happening\", \"death\": \"Davy Jones' treasure chest\",\n \"always\": \"ever\", \"you're\": \"ye're\", \"girlfriend\": \"Lassie-Lucy\",\n \"with\": \"wit'\", \"everyone\": \"evr'un\"\n }\n #~ sentence = raw_input(\"What be yer sentence, ye old landlubber? \")\n sentences = [\"If the world didn't suck we'd all fall off\",\n \"What happens if you get scared half to death twice?\",\n \"Save water and shower with your girlfriend\",\n \"Always remember you're unique, just like everyone else\"]\n \n start = [\"Yarr, \", \"Yarr! \", \"Yarr-ha-harr! \", \"Skuttle me Skippers! \",\n \"Shiver me timbers! \", \"Ahoy, me hearties! \", \"Dogs ahoy! \",\n \"Hoist the mizzen!!! \", \"Hoist the colors!! \" ]\n end = [\". ARRRGHHHH!\", \". Avast ye varmint!\", \". Yarr?\",\n \". Savvyy?\", \". Yarr!\", \". Aye!\",\n \", ye bilge rat!\", \", ye mangy dog!\", \", ye scallywag!\"]\n\n s = choice(sentences)\n print s\n print choice(start) +\\\n ' '.join([d[i] if i in d else i for i in s.lower().split()]).capitalize()\\\n + choice(end)","def order_ideal(self, gens):","def spell_triade(triade):\n spelled_triade = ''\n\n if triade[1] == 1:\n\n spelled_triade += numerals_dictionary[triade[1] * 10 + triade[2]]\n\n elif triade[1] == 0:\n\n spelled_triade += numerals_dictionary[triade[2]]\n\n else:\n\n if triade[2] == 0:\n\n spelled_triade = numerals_dictionary[triade[1] * 10]\n\n else:\n\n spelled_triade = '-'.join((numerals_dictionary[triade[1] * 10], numerals_dictionary[triade[2]]))\n\n if triade[0] in range(1, 10):\n\n hundreds = ' '.join((numerals_dictionary[triade[0]], 'hundred'))\n\n if spelled_triade != 'zero':\n\n spelled_triade = ' and '.join((hundreds, spelled_triade))\n\n else:\n\n spelled_triade = hundreds\n\n return spelled_triade","def generate_fantasy_title():\n d20 = random.randint(1, 20)\n if d20 <= 4:\n #genetive noun\n return fantasy_genetive[random.randint(0, len(fantasy_genetive) - 1)] + \" \" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\n elif d20 > 4 and d20 < 13: \n #The adj noun\n return \"The \" + fantasy_adj[random.randint(0, len(fantasy_adj) - 1)] + \" \" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\n elif d20 >= 13:\n #something of something\n return fantasy_noun[random.randint(0, len(fantasy_noun) - 1)] + \" of \" + fantasy_what_is_this[random.randint(0, len(fantasy_what_is_this) - 1)]","def _precook(s, n=4, out=False):\n if isinstance(s,str):\n words = s.split()\n # print(words)\n elif isinstance(s,list) or isinstance(s,tuple):\n words = s\n else:\n raise NotImplementedError(type(s))\n counts = defaultdict(int)\n for k in range(1, n + 1):\n for i in range(len(words) - k + 1):\n ngram = tuple(words[i:i + k])\n counts[ngram] += 1\n return (len(words), counts)","def get_stopwords(choice = 0):\n low_acc_words = [u'orange', u'game', u'wafe', u'gold', u'gas pump', u'dock', u'magnetic disk', u'beard', u'splash', u'stethoscope', u'clock', u'modem', u'spring', u'dribble', u'scale', u'thing', u'parachute', u'screw', u'haired', u'hair spray', u'stick', u'projectile', u'surface', u'scarf', u'boat', u'lantern', u'weapon', u'fire screen', u'maypole', u'Old World buffalo', u'backpack', u'velvet', u'pistol', u'duplicator', u'tissue', u'holding', u'eel', u'iron', u'zoo', u'toilet seat', u'eye', u'telephone', u'drum', u'pepper', u'church', u'pillow', u'body', u'mink', u'prison', u'color', u'jewelry', u'elephant', u'mug', u'cargo ship', u'football', u'llama', u'wombat', u'ax', u'giant panda', u'bison', u'climber', u'tractor', u'hamster', u'beetle', u'sidewalk', u'oilseed', u'shore', u'feet', u'vending machine', u'nail', u'lock', u'licking', u'crowded', u'pudding', u'library', u'sliding', u'steel drum', u'cutter', u'trench coat', u'plate rack', u'fancy', u'barbershop', u'switch', u'hip', u'petting', u'keyboard', u'drilling platform', u'denim', u'old', u'sewing machine', u'dancing', u'lawn mower', u'jaguar', u'cauliflower', u'bubble', u'tray', u'printer', u'hillside', u'heater', u'store', u'stove', u'hook', u'bed', u'book jacket', u'rain barrel', u'dinosaur', u'rowing', u'surf', u'worm', u'garbage truck', u'laptop', u'mouth', u'flute', u'tape player', u'gym', u'large', u'birdhouse', u'covered', u'groom', u'swan', u'lampshade', u'snowplow', u'ramp', u'bathing cap', u'strainer', u'hard', u'mortarboard', u'penguin', u'wooden spoon', u'loaf of bread', u'window', u\"potter's wheel\", u'branch', u'fly', u'greyhound', u'walk', u'starfish', u'kitchen', u'parking meter', u'cassette', u'work', u'cash machine', u'custard apple', u'play', u'ice cream', u'mosque', u'market', u'swing', u'hay', u'fan', u'surfer', u'number', u'climb', u'golfcart', u'burrito', u'feather boa', u'resting', u'neck brace', u'glove', u'remote control', u'lotion', u'lamp', u'perched', u'jeep', u'necklace', u'shopping basket', u'sea urchin', u'pajama', u'pinwheel', u'foot', u'maze', u'squash', u'dishrag', u'bib', u'ant', u'dumbbell', u'dragonfly', u'bakery', u'lighter', u'salamander', u'sandglass', u'apron', u'cannon', u'palm', u'tent', u'spacecraft', u'oil filter', u'beer bottle', u'throne', u'stretcher', u'bedroom', u'pan', u'camera', u'kiddie', u'mashed potato', u'railing', u'tongue', u'sky', u'event', u'bright', u'curb', u'sundial', u'screwdriver', u'hand blower', u'joystick', u'flower', u'tv', u'back', u'smile', u'mortar', u'bee', u'bath', u'spatula', u'lawn', u'object', u'barrier', u'mailbox', u'fallen', u'crayfish', u'kid', u'metal', u'shot', u'quill', u'snowboarding', u'mud', u'vacuum', u'water tower', u'sleeping bag', u'altar', u'bassoon', u'family', u'shovel', u'leather', u'maillot', u'soap dispenser', u'blurry', u'racetrack', u'dish', u'gondola', u'chewing', u'badger', u'spindle', u'door', u'shaker', u'purse', u'apiary', u'bus', u'wreck', u'cell', u'balance beam', u'lip', u'animal', u'baby', u'toilet', u'armor plate', u'jigsaw puzzle', u'piggy bank', u'leafhopper', u'torch', u'ashcan', u'talking', u'traveling', u'handrail', u'area', u'raft', u'can opener', u'missile', u'syringe', u'pen', u'beacon', u'croquet ball', u'trail', u'snowboard', u'light', u'owl', u'lift', u'acorn', u'pencil box', u'hermit crab', u'binder', u'ladle', u'fire engine', u'tan', u'volcano', u'chocolate sauce', u'crossword puzzle', u'whistle', u'floating', u'forklift', u'hotdog', u'monotreme', u'eggnog', u'traffic', u'envelope', u'surfboard', u'face', u'polecat', u'tiled', u'camel', u'refrigerator', u'carousel', u'parking', u'spider web', u'stream', u'train', u'square', u'candle', u'thimble', u'jellyfish', u'teddy', u'leash', u'wild', u'shopping cart', u'jackfruit', u'office', u'alligator', u'ready', u'end', u'power drill', u'lens cap', u'looking', u'hand', u'fountain', u'radiator', u'French horn', u'graze', u'female', u'koala', u'paper towel', u'artichoke', u'passenger', u'airship', u'cow', u'slug', u'home', u'tug', u'weasel', u'including', u'crutch', u'submarine', u'chime', u'pretty', u'phone', u'barrow', u'purple', u'pulling', u'wing', u'mongoose', u'washer', u'slide', u'Band Aid', u'splashing', u'obstacle', u'flying', u'restaurant', u'pencil sharpener', u'control', u'something', u'tricycle', u'motor', u'watching', u'grey', u'balcony', u'surrounded', u'statue', u'rotisserie', u'puck', u'assorted', u'umbrella', u'measuring cup', u'hanging', u'ride', u'scuba', u'perform', u'tusker', u'desk', u'puddle', u'sea slug', u'team', u'beaker', u'held', u'safe', u'shower curtain', u'isopod', u'tire', u'beaver', u'tower', u'stump', u'dinner', u'conch', u'playground', u'marmot', u'fruit', u'golf ball', u'read', u'tile', u'watch', u'mosquito net', u'goggle', u'swab', u'cricket', u'wheelie', u'guacamole', u'bush', u'cockroach', u'intersection', u'letter opener', u'station', u'plow', u'course', u'aeroplane', u'view', u'racing', u'broom', u'sunny', u'corn', u'matchstick', u'variety', u'messy', u'playpen', u'ambulance', u'perfume', u'brush', u'go', u'shelf', u'look', u'blowing', u'lobster', u'lettuce', u'busy', u'digging', u'trampoline', u'track', u'glass', u'ox', u'handstand', u'assortment', u'vase', u'aircraft carrier', u'microwave', u'high', u'mousetrap', u'bathroom', u'shower cap', u'counter', u'Christmas stocking', u'safety pin', u'plastic', u'garden', u'transit', u'knife', u'docked', u'cluttered', u'serving', u'toddler', u'ledge', u'formation', u'snorkel', u'lying', u'lemon', u'ladybug', u'carry', u'solar dish', u'hammer', u'sleeping', u'saltshaker', u'cowboy', u'unicycle', u'single', u'rule', u'shoji', u'business', u'cup', u'antique', u'catch', u'open', u'carnival', u'cooking', u'rural', u'small', u'wine', u'top', u'flat', u'yurt', u'grasshopper', u'hoop', u'wallet', u'hold', u'someone', u'necked', u'salad', u'leafe', u'paddlewheel', u'porcupine', u'radio telescope', u'preparing', u'canopy', u'pointing', u'honeycomb', u'older', u'hair slide', u'plunger', u'mirror', u'landscape', u'bow', u'cart', u'skateboard', u'device', u'urban', u'sunset', u'attached', u'toward', u'right', u'town', u'four', u'beach wagon', u'close', u'lone', u'chew', u'pile', u'working', u'bottlecap', u'corner', u'swinging', u'behind', u'slot machine', u'food', u'mushroom', u'around', u'tall', u'oxygen mask', u'together', u'veggy', u'skating', u'concrete', u'subway', u'seen', u'head', u'armadillo', u'ly', u'kitten', u'cap', u'painted', u'mustache', u'moving', u'lit', u'sliced', u'sticking', u'milk can', u'roller', u'stainless', u'teeth', u'seated', u'serve', u'lady', u'carriage', u'stand', u'apple', u'paper', u'apartment', u'video', u'eating', u'stadium', u'turn', u'racket', u'stunt', u'plate', u'drinking', u'slice', u'warplane', u'cheese', u'onion', u'backyard', u'coffee', u'peach', u'staring', u'outfit', u'engine', u'coaster', u'striped', u'stacked', u'decorated', u'throwing', u'dirty', u'hula', u'mid', u'catching', u'closed', u'item', u'otter', u'rail', u'tenni', u'sink', u'toaster', u'meal', u'skate', u'fridge', u'pitch', u'kite', u'desktop', u'meat', u'military', u'fireplace', u'show', u'rider', u'rodeo', u'graffiti', u'bunch', u'coming', u'reading', u'walkway', u'another', u'mouse', u'soup', u'hole', u'steel', u'container', u'past', u'carrying', u'equipment', u'farm', u'dressed', u'scooter', u'cellphone', u'stuffed', u'commercial', u'platform', u'full', u'one', u'electronic', u'sprinkler', u'stop', u'along', u'blanket', u'residential', u'kneeling', u'blender', u'oven', u'cattle', u'skateboarder', u'produce', u'book', u'cement', u'bag', u'carrot', u'board', u'round', u'many', u'giant', u'shower', u'asian', u'picnic', u'dining', u'wedding', u'desert', u'huge', u'narrow', u'outside', u'deck', u'three', u'display', u'filled', u'cutting', u'colored', u'ear', u'feeding', u'across', u'eat', u'skateboarding', u'fighter', u'sun', u'darkened', u'brushing', u'ty', u'party', u'pedestrian', u'wet', u'structure', u'different', u'crossbone', u'jet', u'public', u'cooked', u'airplane', u'bread', u'clothe', u'tunnel', u'fishing', u'drife', u'gear', u'birthday', u'frisbee', u'piece', u'row', u'hydrant', u'drawn', u'meter', u'vegetable', u'broccoli', u'country', u'half', u'sandwich', u'doorway', u'lot', u'pair', u'luggage', u'long', u'christma', u'wii', u'guy', u'side', u'leap', u'plane', u'silver', u'post', u'bar', u'reaching', u'drink', u'reflection', u'wand', u'airport', u'photograph', u'type', u'lay', u'lap', u'waterfall', u'banana', u'next', u'baseball', u'hot', u'making', u'gray', u'using', u'batter', u'empty', u'bat', u'clear', u'hospital', u'scissor', u'neck', u'cake', u'alone', u'rope', u'winter', u'runway', u'broken', u'fire', u'getting', u'variou', u'distance', u'beer', u'outstretched', u'chocolate', u'match', u'stopped', u'vintage', u'clean', u'fork', u'cut', u'eaten', u'waiting', u'going', u'onto', u'nintendo', u'time', u'several', u'lined', u'railroad', u'case', u'mother', u'suitcase', u'taking', u'doughnut', u'smoke', u'controller', u'crossing', u'friend', u'closeup', u'couple', u'showing', u'made', u'big', u'trying', u'putting', u'hit', u'male', u'', u'pickelhaube', u'suburban', u'costume', u'enjoy', u'new', u'studio', u'mantis', u'pastum', u'gymnast', u'rafting', u'golden', u'waffle iron', u'watering', u'overhead', u'shoot', u'feature', u'machine', u'attempt', u'third', u'tulip', u'jungle', u'wind', u'fig', u'band', u'bone', u'free', u'cucumber', u'bouncing', u'boarding', u'tackled', u'__background__', u'gymnastic apparatus', u'pineapple', u'folded', u'rice', u'sunglasses', u'cushion', u'net', u'covering', u'pretzel', u'steam', u'santum', u'fair', u'sail', u'score', u'toothbrush', u'loaded', u'fry', u'life', u'glider', u'bounce', u'balance', u'cone', u'containing', u'beside', u'wheel', u'rain', u'spaghetti squash', u'thi', u'left', u'photographer', u'forested', u'vanity', u'shoulder', u'pavement', u'officer', u'creek', u'dead', u'ice', u'slide rule', u'dunking', u'horizon', u'raised', u'fabric', u'fight', u'way', u'war', u'landing', u'umpire', u'fashioned', u'dimly', u'topped', u'setting', u'sling', u'potato', u'painting', u'bottom', u'dance', u'crocodile', u'string', u'dig', u'gun', u'chicken', u'tarmac', u'falling', u'french', u'wait', u'pony', u'decker', u'plaza', u'earphone', u'chip', u'get', u'staircase', u'wakeboarder', u'wheelchair', u'pulled', u'polouse', u'still', u'curly', u'scaling', u'lunch', u'base', u'pizza', u'meat loaf', u'shown', u'opened', u'space', u'mess', u'headband', u'place', u'pelican', u'ring', u'sheet', u'bite', u'frame', u'hug', u'wide', u'lick', u'pastry', u'breakfast', u'take', u'topping', u'multiple', u'knee', u'tackling', u'sale', u'professional', u'german', u'crane', u'snack', u'stair', u'ping-pong ball', u'snowsuit', u'sport', u'bicyclist', u'skyscraper', u'checkered', u'restroom', u'tour', u'nearby', u'foggy', u'bmx', u'newspaper', u'mound', u'foam', u'driven', u'mohawk', u'rest', u'instrument', u'chainsaw', u'towel', u'facing', u'audience', u'served', u'clau', u'go-kart', u'tube', u'throw', u'muddy', u'harness', u'strip', u'racquet', u'prepare', u'low', u'pitcher', u'cardoon', u'gymnasium', u'pull', u'arranged', u'strawberry', u'deep', u'cream', u'rubber', u'trash', u'midair', u'peak', u'remote', u'disc', u'follow', u'potpie', u'enjoying', u'stool', u'leaping', u'action', u'taken', u'chopstick', u'flag', u'mounted', u'grill', u'wrestler', u'marble', u'backpacking', u'breaking', u'fungus', u'shade', u'egg', u'muzzled', u'style', u'carpeted', u'sauce', u'snowball', u'abacus', u'foreground', u'circuit', u'leading', u'airborne', u'hotel', u'leotard', u'kind', u'double', u'scabbard', u'bride', u'stall', u'blond', u'cave', u'electric', u'cigarette', u'sponsored', u'shepherd', u'dandelion', u'catcher', u'movie', u'recently', u'floaty', u'chambered nautilus', u'hitting', u'racer', u'passing', u'leaning', u'kissing', u'chase', u'funny', u'used', u'snail', u'pomegranate', u'stack', u'center', u'grind', u'bin', u'formal', u'shaped', u'signal', u'zucchini', u'parade', u'limb', u'laughing', u'step', u'range', u'slouse', u'block', u'downhill', u'jockey', u'retrieving', u'atop', u'cloth', u'skull', u'diving', u'rainy', u'tarp', u'black-footed ferret', u'nice', u'prepared', u'hot pot', u'land', u'fresh', u'hello', u'wrestle', u'kitty', u'spoon', u'rack', u'smaller', u'hose', u'giving', u'attire', u'leaving', u'chiton', u'singing', u'frog', u'crab', u'porch', u'saddle', u'donut', u'crossed', u'tied', u'tomato', u'chasing', u'scenic', u'beneath', u'boarder', u'hippopotamus', u'wading', u'sea_anemone', u'wrapped', u'shallow', u'steep', u'bagel', u'gather', u'pipe', u'hi', u'ha', u'jar', u'bug', u'finger', u'handle', u'beam', u'bean', u'whilst', u'contain', u'shake', u'attempting', u'merry', u'yawning', u'sniff', u'swimmer', u'commuter', u'bull', u'smoking', u'plain', u'cross', u'member', u'binoculars', u'underneath', u'well', u'fighting', u'bandanna', u'rocket', u'pay-phone', u'five', u'puppy', u'like', u'campfire', u'shaking', u'construction', u'bun', u'partially', u'flip', u'placed', u'bearing', u'pinatum', u'pie', u'boardwalk', u'pit', u'star', u'baked']\n\n STOPWORDS = ['none','inside', 'near', 'one', 'two', 'three', 'day', 'front', u'i', u'me', u'my', u'myself', u'we', u'our', u'ours', u'ourselves', u'you', u'your', u'yours', u'yourself', u'yourselves', u'he', u'him', u'his', u'himself', u'she', u'her', u'hers', u'herself', u'it', u'its', u'itself', u'they', u'them', u'their', u'theirs', u'themselves', u'what', u'which', u'who', u'whom', u'this', u'that', u'these', u'those', u'am', u'is', u'are', u'was', u'were', u'be', u'been', u'being', u'have', u'has', u'had', u'having', u'do', u'does', u'did', u'doing', u'a', u'an', u'the', u'and', u'but', u'if', u'or', u'because', u'as', u'until', u'while', u'of', u'at', u'by', u'for', u'with', u'about', u'against', u'between', u'into', u'through', u'during', u'before', u'after', u'above', u'below', u'to', u'from', u'up', u'down', u'in', u'out', u'on', u'off', u'over', u'under', u'again', u'further', u'then', u'once', u'here', u'there', u'when', u'where', u'why', u'how', u'all', u'any', u'both', u'each', u'few', u'more', u'most', u'other', u'some', u'such', u'no', u'nor', u'not', u'only', u'own', u'same', u'so', u'than', u'too', u'very', u's', u't', u'can', u'will', u'just', u'don', u'should', u'now', 'background', '__background__', '']\n \n\n unselected_words = [u'', u'pickelhaube', u'enjoy', u'new', u'studio', u'kissing', u'mantis', u'pastum', u'rafting', u'golden', u'waffle iron', u'watering', u'overhead', u'shoot', u'feature', u'machine', u'pizza', u'attempt', u'third', u'tulip', u'jungle', u'wind', u'fig', u'band', u'bone', u'free', u'bouncing', u'boarding', u'tackled', u'__background__', u'gymnasium', u'gymnastic apparatus', u'pineapple', u'folded', u'rice', u'sunglasses', u'cushion', u'net', u'covering', u'pretzel', u'steam', u'santum', u'fair', u'sail', u'score', u'toothbrush', u'loaded', u'fry', u'life', u'glider', u'balance', u'cone', u'containing', u'beside', u'wheel', u'rain', u'spaghetti squash', u'thi', u'left', u'photographer', u'forested', u'vanity', u'shoulder', u'pavement', u'officer', u'creek', u'dead', u'slide rule', u'dunking', u'horizon', u'raised', u'fabric', u'fight', u'way', u'war', u'landing', u'umpire', u'fashioned', u'dimly', u'topped', u'setting', u'sling', u'potato', u'bottom', u'dance', u'crocodile', u'ice', u'string', u'dig', u'gun', u'tarmac', u'falling', u'french', u'wait', u'decker', u'earphone', u'chip', u'get', u'staircase', u'wakeboarder', u'wheelchair', u'pulled', u'polouse', u'still', u'curly', u'scaling', u'lunch', u'meat loaf', u'shown', u'opened', u'space', u'mess', u'headband', u'place', u'pelican', u'ring', u'sheet', u'bite', u'hug', u'wide', u'lick', u'pastry', u'breakfast', u'take', u'topping', u'multiple', u'knee', u'bicyclist', u'sale', u'professional', u'german', u'snack', u'stair', u'ping-pong ball', u'snowsuit', u'sport', u'tackling', u'skyscraper', u'checkered', u'restroom', u'tour', u'nearby', u'foggy', u'bmx', u'newspaper', u'mound', u'chopstick', u'foam', u'driven', u'passing', u'mohawk', u'rest', u'instrument', u'chainsaw', u'towel', u'facing', u'audience', u'laughing', u'served', u'clau', u'diving', u'go-kart', u'tube', u'throw', u'harness', u'strip', u'racquet', u'prepare', u'low', u'pitcher', u'cardoon', u'pull', u'arranged', u'strawberry', u'deep', u'cream', u'rubber', u'trash', u'midair', u'peak', u'remote', u'suburban', u'disc', u'follow', u'potpie', u'gymnast', u'enjoying', u'stool', u'leaping', u'action', u'taken', u'flag', u'mounted', u'grill', u'wrestler', u'marble', u'pony', u'backpacking', u'breaking', u'fungus', u'shade', u'egg', u'style', u'carpeted', u'sauce', u'snowball', u'abacus', u'foreground', u'base', u'circuit', u'leading', u'airborne', u'hotel', u'leotard', u'kind', u'double', u'scabbard', u'bride', u'stall', u'blond', u'cave', u'zucchini', u'electric', u'cigarette', u'sponsored', u'shepherd', u'dandelion', u'catcher', u'movie', u'recently', u'floaty', u'chambered nautilus', u'hitting', u'racer', u'leaning', u'chase', u'funny', u'used', u'snail', u'pomegranate', u'cucumber', u'stack', u'center', u'grind', u'bin', u'formal', u'shaped', u'signal', u'parade', u'bounce', u'step', u'plaza', u'range', u'slouse', u'block', u'downhill', u'jockey', u'retrieving', u'atop', u'cloth', u'crane', u'skull', u'rainy', u'tarp', u'black-footed ferret', u'nice', u'prepared', u'hot pot', u'land', u'fresh', u'hello', u'wrestle', u'kitty', u'spoon', u'muzzled', u'rack', u'smaller', u'hose', u'giving', u'attire', u'leaving', u'chiton', u'limb', u'singing', u'frog', u'crab', u'porch', u'donut', u'crossed', u'tied', u'tomato', u'chasing', u'scenic', u'beneath', u'shaking', u'boarder', u'hippopotamus', u'wading', u'sea_anemone', u'wrapped', u'shallow', u'steep', u'bagel', u'gather', u'pipe', u'construction', u'painting', u'chicken', u'jar', u'bug', u'finger', u'handle', u'beam', u'bean', u'whilst', u'contain', u'costume', u'frame', u'shake', u'attempting', u'merry', u'yawning', u'sniff', u'swimmer', u'muddy', u'commuter', u'bull', u'smoking', u'plain', u'cross', u'member', u'binoculars', u'underneath', u'well', u'fighting', u'bandanna', u'rocket', u'pay-phone', u'five', u'puppy', u'like', u'campfire', u'saddle', u'hi', u'bun', u'ha', u'partially', u'flip', u'placed', u'bearing', u'pinatum', u'pie', u'boardwalk', u'pit', u'star', u'baked', u'smoke', u'hospital', u'type', u'hole', u'wand', u'chocolate sauce', u'haired', u'onto', u'drawn', u'wear', u'loaf of bread', u'beer', u'mushroom', u'lift', u'make', u'mother', u'cowboy', u'fork', u'otter', u'playpen', u'alone', u'hamburger', u'bottlecap', u'soup', u'cutter', u'square', u'friend', u'scuba', u'hockey', u'wheelie', u'picnic', u'tug', u'squash', u'case', u'inflatable', u'railroad', u'competition', u'slice', u'broken', u'jeep', u'trying', u'apartment', u'chewing', u'grasshopper', u'guacamole', u'splash', u'male', u'dishrag', u'kayaking', u'acorn', u'snowbank', u'clean', u'hit', u'batter', u'kick', u'jewelry', u'fighter', u'cooked', u'putting', u'try', u'wallet', u'mustache', u'artichoke', u'spaghetti sauce', u'crossing', u'retriever', u'veggy', u'produce', u'darkened', u'kiddie', u'mashed potato', u'closed', u'canopy', u'runway', u'vintage', u'fishing', u'doughnut', u'onion', u'leap', u'rodeo', u'cricket', u'made', u'closeup', u'chew', u'sliced', u'hot', u'deck', u'French horn', u'clothe', u'goggle', u'rowing', u'milk can', u'post', u'outstretched', u'chocolate', u'making', u'course', u'hula', u'carry', u'upside', u'desktop', u'lobster', u'suitcase', u'crossbone', u'ty', u'sea slug', u'polecat', u'sandwich', u'racetrack', u'lettuce', u'cockroach', u'toward', u'eaten', u'blender', u'giant', u'atv', u'big', u'holster', u'splashing', u'commercial', u'tunnel', u'bend', u'meter', u'including', u'badger', u'beach wagon', u'beard', u'beak', u'controller', u'match', u'buckle', u'hiker', u'barometer', u'bread', u'serve', u'object', u'stadium', u'tank', u'waterfall', u'stream', u'neck', u'serving', u'manhole cover', u'pitch', u'pistol', u'dribble', u'isopod', u'transit', u'dragonfly', u'huge', u'backyard', u'foot', u'jet', u'dancing', u'custard apple', u'porcupine', u'assorted', u'rope', u'cut', u'showing', u'lemon', u'armadillo', u'salad', u'carrot', u'biting', u'bee', u'hammer', u'lens cap', u'cauliflower', u'kicking', u'denim', u'marmot', u'nintendo', u'fireplace', u'landscape', u'turn', u'hoop', u'wedding', u'eggnog', u'antique', u'bow', u'winter', u'stacked', u'purse', u'beaver', u'kneeling', u'island', u'slot machine', u'Christmas stocking', u'public', u'narrow', u'ladybug', u'stopped', u'burrito', u'necked', u'cheese', u'crayfish', u'single', u'getting', u'tan', u'lined', u'handstand', u'letter opener', u'pencil box', u'doorway', u'leafhopper', u'residential', u'slug', u'eat', u'carriage', u'end', u'lap', u'distance', u'mink', u'sleeping bag', u'time', u'container', u'stunt', u'drife', u'broccoli', u'docked', u'structure', u'cooker', u'go', u'aircraft carrier', u'pudding', u'tape player', u'outfit', u'coaster', u'reaching', u'meat', u'splashed', u'hair slide', u'roller', u'submarine', u'toaster', u'dining', u'rotisserie', u'football', u'spindle', u'christma', u'thimble', u'giant panda', u'pedestrian', u'compass', u'squirrel', u'sea urchin', u'hotdog', u'peach', u'warplane', u'oil filter', u'waiting', u'hip', u'jaguar', u'mortar', u'gear', u'sprinkler', u'beer bottle', u'gondola', u'half', u'stainless', u'military', u'electronic', u'bat', u'handrail', u'perform', u'coffee maker', u'flat', u'round', u'meal', u'telephone', u'pool table', u'seagull', u'hermit crab', u'fancy', u'obstacle', u'honeycomb', u'gravel', u'ladle', u'farm', u'crossword puzzle', u'steel', u'drink', u'pepper', u'tongue', u'owl', u'rule', u'gym', u'seated', u'monotreme', u'cattle', u'water tower', u'vegetable', u'eel', u'variou', u'messy', u'raft', u'castle', u'fire', u'bib', u'skunk', u'gray', u\"carpenter's kit\", u'wombat', u'carnival', u'equipment', u'mousetrap', u'joystick', u'golf ball', u'shoji', u'banana', u'clear', u'sloth', u'glove', u'reel', u'desert', u'necklace', u'ear', u'digging', u'rural', u'asian', u'school', u'wreck', u'coffee', u'hydrant', u'mouse', u'mid', u'row', u'puddle', u'engine', u'mongoose', u'stopwatch', u'walkway', u'past', u'beacon', u'koala', u'lip', u'gold', u'scooter', u'puck', u\"potter's wheel\", u'ly', u'oilseed', u'tire', u'drum', u'party', u'radio telescope', u'worm', u'lay', u'magnetic disk', u'bar', u'butterfly', u'dinner', u'birthday', u'power drill', u'saltshaker', u'thing', u'ant', u'lantern', u'hard', u'weasel', u'ridden', u'paddlewheel', u'drilling platform', u'climber', u'safe', u'shower', u'airship', u'cassette player', u'printer', u'wooden spoon', u'bassoon', u'reflection', u'scissor', u'apiary', u'ice cream', u'rider', u'boathouse', u'mud', u'corn', u'guinea pig', u'snow leopard', u'mailbox', u'cement', u'bakery', u'taking', u'variety', u'swan', u'velvet', u'couple', u'fridge', u'strainer', u'dirty', u'screwdriver', u'jigsaw puzzle', u'device', u'alligator', u'oven', u'silver', u'urban', u'country', u'opener', u'leather', u'barrel', u'duck', u'drumstick', u'cake', u'ambulance', u'pencil sharpener', u'barrier', u'safety pin', u'right', u'baseball', u'beetle', u'ax', u'cassette', u'assortment', u'entree', u'armor plate', u'going', u'cart', u'can opener', u'curve', u'pointing', u'dribbling', u'sock', u'home', u'catching', u'church', u'mosque', u'measuring cup', u'striped', u'throne', u'skating', u'sundial', u'CD player', u'grille', u'brushing', u'jersey', u'plunger', u'conch', u'several', u'shaker', u'tile', u'stretcher', u'tower', u'plane', u'salamander', u'lock', u'platform', u'airport', u'hamster', u'graffiti', u'jackfruit', u'cabbage', u'blowing', u'kitten', u'yurt', u'cannon', u'powder', u'sea cucumber', u'sea cow', u'dinosaur', u'racing', u'primate', u'wii', u'skateboarding', u'blanket', u'mug', u'cap', u'challenging', u'throwing', u'library', u'quill', u'trench coat', u'microwave', u'tusker', u'cluttered', u'apple', u'duplicator', u'broom', u'wet', u'altar', u'show', u'heater', u'radiator', u'cargo ship', u'spatula', u'screw', u'neck brace', u'flute', u'peacock', u'sewing machine', u'reading', u'dough', u'rifle', u'long', u'penguin', u'playground', u'photograph', u'luggage', u'plow', u'item', u'factory', u'starfish', u'fire engine', u'locomotive', u'piggy bank', u'empty', u'scale', u'plate rack', u'graze', u'cutting', u'feeding', u'cooking', u'rapid', u'ledge', u'business', u'colored', u'forklift', u'boot', u'wing', u'remote control', u'trampoline', u'gas pump', u'space bar', u'snorkel', u'book', u'microscope', u'rain barrel', u'pair', u'Old World buffalo', u'airplane', u'creature', u'knee pad', u'whale', u'birdhouse', u'oxygen mask', u'bag', u'sailboat', u'mat', u'town', u'using', u'rugby ball', u'staring', u'shopping basket', u'binder', u'team', u'sailing vessel', u'ox', u'leopard', u'shield', u'full', u'Band Aid', u'mountaintop', u'crate', u'modem', u'family', u'tennis ball', u'barn', u'work', u'formation', u'barrow', u'goose', u'syringe', u'soap dispenser', u'kite', u'appliance', u'solar dish', u'lizard', u'paddling', u'cardigan', u'sink', u'control', u'toddler', u'mortarboard']\n\n useless_words = ['holding','hold' ,'wearing', 'wear' , 'standing','sitting', 'stand', 'sit' , 'smiling', 'smile', 'clothing', 'shirt', \"next\", 'posing', 'playing']\n abstract_words = ['beautiful', 'young']\n color_words = ['black', 'white', 'red', 'blue', 'brown']\n\n if choice == 1:\n return STOPWORDS\n\n STOPWORDS += unselected_words\n STOPWORDS += useless_words\n STOPWORDS += low_acc_words\n #STOPWORDS += color_words\n #STOPWORDS += abstract_words\n return STOPWORDS","def how_many(number):\n if int(number) == 1:\n return \"guess\"\n return \"guesses\"","def give_names(x): \n if x == 0:\n return 'Lost'\n else:\n return 'Won/Broke Even'","def generate_romance_title():\n d69 = random.randint(1, 69)\n if d69 <= 35:\n #the adj noun\n return \"The \" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \" \" + romance_noun[random.randint(0, len(romance_noun) - 1)]\n elif d69 > 35:\n #noun of the adj noun\n return romance_noun[random.randint(0, len(romance_noun) - 1)] + \" of the \" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \" \" + romance_noun[random.randint(0, len(romance_noun) - 1)]","def stickers_for(phrase):\n\n stic_dict = {}\n for ltr in 'instagram':\n if ltr not in stic_dict:\n stic_dict[ltr] = 1\n else:\n stic_dict[ltr] += 1\n print(ltr)\n\n phr_dict = {}\n for ltr in phrase:\n if ltr not in phr_dict:\n phr_dict[ltr] = 1\n else:\n phr_dict[ltr] += 1\n print(ltr)\n\n ratios = []\n for ltr in stic_dict:\n if ltr in phr_dict:\n ratio = phr_dict[ltr] / stic_dict[ltr]\n ratios.append(ratio)\n\n if len(ratios) > 0:\n num_sticks = max(ratios)\n num_sticks = int(round(num_sticks, 0))\n return stic_dict, phr_dict, ratios, num_sticks\n\n else: \n return 0","def get_number_of_soil_levels(description):\n if description == \"none\":\n return \"0\"\n else:\n return \"5\"","def precook(s, n=4, out=False):\n words = s.split()\n counts = defaultdict(int)\n for k in xrange(1,n+1):\n for i in xrange(len(words)-k+1):\n ngram = tuple(words[i:i+k])\n counts[ngram] += 1\n return counts","def lab10_q1():\n return \"\"\"\n Since there has to be at least two, len(self.fruits) >=2 and at least one cup, self.cups (number == True)\n\tDecrease cups by 1 because we use one to create mixed juice.\n\tfirst pop gives the 0 index fruit, second pop gives the next 0 index which is originally at 1 index.\n\t\n\tlen(item) to show number of letters then -1 because of hyphen.\n \"\"\"","def s_words(words):\n\t\n\treturn words // 100 / 10","def make_chains(text_string):\n\n chains = {}\n n = 2\n # n = int(raw_input(\"Enter the number of ngrams you want? >\"))\n # your code goes here\n words = text_string.split()\n for i in range(len(words) - 1):\n ngram = tuple(words[i: i + n])\n if i >= len(words) - n:\n chains[ngram] = None\n else:\n nth_word = words[i + n]\n if ngram not in chains:\n chains[ngram] = [nth_word]\n else:\n chains[ngram].append(nth_word)\n return (chains, n)","def wcount(lines, topn):\n word = ''\n for i in lines:\n if 65<=ord(i) and ord(i)<=90:\n word = word + i \n elif 97<=ord(i) and ord(i)<=122:\n word = word + i\n else:\n word = word + ' ' \n word = word.split()\n #提取不重复的单词\n alreadyknown = []\n for m in word:\n if m not in alreadyknown:\n alreadyknown.append(m)\n #分别数数，排序，建构字典\n empty = []\n final = {}\n final2 = {}\n for j in alreadyknown:\n number = icount(word,j)\n final[j]=number\n final2[str(number)]=j\n empty.append(number)\n empty.sort()\n empty.reverse()\n last_step = empty[:10]\n #通过数字找到对应word\n last_str = ''\n for y in last_step:\n z = final2[str(y)]\n last_str += z + \"\\t\" + str(y) + \"\\n\"\n return last_str","def spell(number):\n if number > 1000:\n raise # This doesn't handle numbers greater than 1000\n\n if number == 1000:\n return ['one', 'thousand']\n\n if number >= 100:\n if number % 100 == 0:\n return spell(number // 100) + ['hundred']\n else:\n return spell(number // 100 * 100) + ['and'] + spell(number % 100)\n\n if number >= 20:\n names = {\n 20: 'twenty',\n 30: 'thirty',\n 40: 'forty',\n 50: 'fifty',\n 60: 'sixty',\n 70: 'seventy',\n 80: 'eighty',\n 90: 'ninety',\n }\n if number % 10 == 0:\n return [names[number]]\n else:\n return spell(number // 10 * 10) + spell(number % 10)\n\n names = [\n 'zero', 'one', 'two', 'three', 'four',\n 'five', 'six', 'seven', 'eight', 'nine',\n 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen',\n 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen',\n ]\n return [names[number]]","def leerUltrasonido() -> int:\n pass","def celex_pron_loc(language, lemma):\n pron = 5\n if language == \"german\" or language== \"dutch\": pron = pron -2 #german one less\n if lemma == \"wordform\": pron += 1\n return pron","def ordinal(n):\n if 11 <= n <= 19:\n return str(n) + \"th\"\n s = str(n)\n last = int(s[-1])\n if 1 <= last <= 3:\n return s + (\"st\", \"nd\", \"rd\")[last-1]\n return s + \"th\"","def get_number_of_atmos_levels(description):\n if description == \"none\":\n return \"0\", \"0\"\n elif re.search(\"levels\", description):\n match = re.search(\"(?P<nl>\\d+)\\s?(levels|vertical levels)\", description)\n nlevs = match.groupdict()[\"nl\"]\n if int(nlevs) > 49: nlas = \"20\"\n else: nlas = \"10\"\n return nlevs, nlas\n else:\n return \"40\", \"20\"","def pre_flop_strength(hand):\n highs = {}\n highs[4] = [\n \"AA\", \"AKs\", \"AQs\", \"AJs\", \"ATs\", \"AKo\", \"KK\", \"KQs\", \"KJs\", \"AQo\",\n \"QQ\", \"QJs\", \"JJ\", \"TT\"\n ]\n highs[3] = [\n \"A5s\", \"A4s\", \"A3s\", \"KTs\", \"KQo\", \"QTs\", \"AJo\", \"JTs\", \"T9s\", \"99\",\n \"98s\", \"88\", \"87s\", \"77\", \"66\"\n ]\n highs[2] = [\n \"A9s\", \"A8s\", \"A7s\", \"A6s\", \"A2s\", \"K9s\", \"K8s\", \"Q9s\", \"KJo\", \"QJo\",\n \"J9s\", \"ATo\", \"KTo\", \"QTo\", \"JTo\", \"T8s\", \"A9o\", \"J9o\", \"T9o\", \"97s\",\n \"98o\", \"86s\", \"76s\", \"75s\", \"65s\", \"55\", \"44\", \"33\", \"22\"\n ]\n highs[1] = [\n \"K7s\", \"K6s\", \"K5s\", \"K4s\", \"K3s\", \"Q8s\", \"Q7s\", \"Q6s\", \"Q5s\", \"Q4s\",\n \"J8s\", \"J7s\", \"J6s\", \"J5s\", \"T7s\", \"T6s\", \"K9o\", \"Q9o\", \"96s\", \"A8o\",\n \"K8o\", \"Q8o\", \"J8o\", \"T8o\", \"85s\", \"A7o\", \"K7o\", \"Q7o\", \"T7o\", \"97o\",\n \"87o\", \"74s\", \"A6o\", \"K6o\", \"86o\", \"76o\", \"64s\", \"63s\", \"A5o\", \"75o\",\n \"65o\", \"54s\", \"53s\", \"A4o\", \"43s\", \"A3o\"\n ]\n card0, card1 = hand\n if card0[0] == card1[0]:\n pair = \"\".join([card0[0], card1[0]])\n elif card0[1] == card1[1]:\n pair = \"\".join([card0[0], card1[0], \"s\"])\n else:\n pair = \"\".join([card0[0], card1[0], \"o\"])\n for strenght in highs:\n if pair in highs[strenght]:\n return strenght\n return 0","def one_v_all(description):\n label = [0, 0, 0]\n for raw in description.split(\"|\")[4:]:\n line = raw.strip()\n if \"midbrain\" in line:\n label[0] = 1\n if \"forebrain\" in line:\n label[1] = 1\n if \"hindbrain\" in line:\n label[2] = 1\n return label","def lexical_diversity(text):\n return len(set(text)) / len(text)","def base_number(number, count, dict_cardinal_num):\n special_numeral = [\"trăm\", \"mười\", \"mươi\", \"linh\", \"lăm\", \"mốt\"]\n list_cardinal_numeral = []\n # Divide number (abc) and follow place's number\n a = number // 100 # hundreds\n b = (number % 100) // 10 # Tens\n c = number % 10 # Ones\n # check a\n if a > 0:\n list_cardinal_numeral.append(dict_cardinal_num[a])\n list_cardinal_numeral.append(special_numeral[0])\n elif a == 0:\n if count > 1 and (b > 0 or c > 0):\n list_cardinal_numeral.append(dict_cardinal_num[a])\n list_cardinal_numeral.append(special_numeral[0])\n # check b\n if b == 0:\n if c > 0:\n if a > 0 or count > 1:\n list_cardinal_numeral.append(special_numeral[3])\n elif b > 0:\n if b == 1:\n list_cardinal_numeral.append(special_numeral[1])\n elif b > 1:\n list_cardinal_numeral.append(dict_cardinal_num[b])\n list_cardinal_numeral.append(special_numeral[2])\n # check c\n if c == 0:\n if count == 1 and a == 0 and b == 0:\n list_cardinal_numeral.append(dict_cardinal_num[c])\n elif c > 0:\n if b >= 1 and c == 5:\n list_cardinal_numeral.append(special_numeral[4])\n elif b >= 2 and c == 1:\n list_cardinal_numeral.append(special_numeral[5])\n else:\n list_cardinal_numeral.append(dict_cardinal_num[c])\n\n return \" \".join(list_cardinal_numeral)","def heads_legs(heads, legs):\n for i in range(0, heads + 1):\n cows = heads - i\n if 4 * cows + 2 * i == legs:\n chickens = i\n return chickens, cows\n return \"No solutions.\"","def desimal_til_bokstav(snitt):\r\n if snitt >= 4.5:\r\n return 'A'\r\n elif 3.5 <= snitt < 4.5:\r\n return 'B'\r\n elif 2.5 <= snitt < 3.5:\r\n return 'C'\r\n elif 1.5 <= snitt < 2.5:\r\n return 'D'\r\n elif 0.5 <= snitt < 1.5:\r\n return 'E'\r\n else:\r\n return 'F'","def pentakis(self):\n return self.nlegomena(5)","def gale_shapley(preferences):\n men = [None for _ in range(len(preferences[0]))]\n women = men[:]\n while None in men:\n m_index = men.index(None)\n w_index = preferences[0][m_index].pop(0)\n if women[w_index] is None:\n men[m_index] = w_index\n women[w_index] = m_index\n else:\n if preferences[1][w_index].index(m_index) < preferences[1][w_index].index(women[w_index]):\n men[women[w_index]] = None\n men[m_index] = w_index\n women[w_index] = m_index\n return list(enumerate(men))","def check1800(s):\n num_translation = str.maketrans(\n 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', '22233344455566677778889999')\n nums_dict = defaultdict(list)\n for word in WORDS:\n nums_dict[word.translate(num_translation)].append(word)\n\n number = s[6:].replace('-', '').translate(num_translation)\n\n # we take the cartesian product of all the options for the first word and all the options for the second.\n\n # case 1, first word is 3 letter & second is 4 letter\n possibilities1 = {'1-800-{}-{}'.format(*poss) for poss in it.product(\n nums_dict[number[:3]], nums_dict[number[3:]])}\n\n # case 2, first word is 4 letter & second is 3 letter\n possibilities2 = {'1-800-{}-{}'.format(*poss) for poss in it.product(\n nums_dict[number[:4]], nums_dict[number[4:]])}\n\n return possibilities1.union(possibilities2)","def dis(self):\n return self.nlegomena(2)","def classify_message(message: str) -> int:\n normalized_message = take_away_punctuation(normalize_string(message))\n associated_words = {\n STORY_WEATHER_FORECAST_REQUEST: {'погода', 'какая', 'что', 'прогноз'},\n STORY_SUBSCRIPTION_MANAGEMENT: {'подписка', 'подписаться', 'рассылка', 'присылать',\n 'ежедневно', 'каждый', 'рассказывать', 'подпиши', 'отпиши', 'отписка',\n 'перестань'},\n STORY_WARDROBE_MANAGEMENT: {'гардероб', 'добавить', 'удалить', *get_clothing_items_names(),\n 'купить', 'потерять', 'порваться'},\n STORY_CLOTHES_SET_REQUEST: {'что', 'надеть', 'одеть', 'одеться', 'облачиться', 'напялить', 'бы',\n 'одежда', 'одежду', 'сгенерировать', 'сгенерируем'},\n STORY_FEEDBACK: {'тепло', 'холодно', 'холодный', 'замерзнуть', 'зажариться', 'вспотеть',\n 'продуть', 'было', 'хотеть', 'хорошо',\n *[str(i) for i in range(-5, 6)]}\n }\n multipliers = {\n STORY_WEATHER_FORECAST_REQUEST: 1,\n STORY_SUBSCRIPTION_MANAGEMENT: 10,\n STORY_WARDROBE_MANAGEMENT: 10,\n STORY_CLOTHES_SET_REQUEST: 1,\n STORY_FEEDBACK: 1\n }\n words = {*message.split(), *normalized_message.split()}\n scores = {\n STORY_WEATHER_FORECAST_REQUEST: 0.5,\n STORY_SUBSCRIPTION_MANAGEMENT: 0,\n STORY_WARDROBE_MANAGEMENT: 0,\n STORY_CLOTHES_SET_REQUEST: 0,\n STORY_FEEDBACK: 0\n }\n for story in associated_words:\n scores[story] += len(associated_words[story] & words)\n scores[story] *= multipliers[story]\n max_score = max(scores.values())\n for story in scores:\n if scores[story] == max_score:\n return story","def qscore(seq):\n return [ord(i)-33 for i in seq.upper()]","def life_sentence(x): \n if x == 'Life':\n return 1\n else:\n return 0","def display_words(word_list,specifier):\n \n if specifier.lower() == 'score':\n print(\"{:>6s} - {:s}\".format(\"Score\", \"Word\"))\n if len(word_list) < 5:\n for tup in word_list:\n print(\"{:>6d} - {:s}\".format(tup[1], tup[0]))\n else:\n \n for tup in word_list[:5]:\n print(\"{:>6d} - {:s}\".format(tup[1], tup[0]))\n \n \n elif specifier.lower() == 'length':\n print(\"{:>6s} - {:s}\".format(\"Length\", \"Word\"))\n if len(word_list) < 5:\n for tup in word_list:\n print(\"{:>6d} - {:s}\".format(tup[2], tup[0]))\n else:\n \n for tup in word_list[:5]:\n print(\"{:>6d} - {:s}\".format(tup[2], tup[0]))","async def character_popularity(\n position: P('number', 'Please select a number between 1 and 20', min_value = 1, max_value = 20)\n):\n return MOST_POPULAR_TOUHOU_CHARACTERS[position - 1]","def retagger(tags):\n if tags == 'Positive':\n return 'pos'\n else:\n return 'neg'","def level(score):\n user_level = \"\"\n if score < 20:\n user_level = \"elementary\"\n elif score < 30:\n user_level = \"intermediate\"\n elif score < 35:\n user_level = \"upper intermediate\"\n else:\n user_level = \"advanced\"\n return user_level","def get_ability_scores(self):\n s = ''\n for i in range(6):\n s += ' ' + str(self.dna[i])\n return s","def _pettifor_numbers():\n return { \"Li\": 0.45,\n \"Be\": 1.5,\n \"B\": 2.0,\n \"C\": 2.5,\n \"N\": 3.0, \n \"O\": 3.5,\n \"F\": 4.0,\n \n \"Na\": 0.4,\n \"Mg\": 1.28,\n \"Al\": 1.66,\n \"Si\": 1.92,\n \"P\": 2.18,\n \"S\": 2.44,\n \"Cl\": 2.70,\n \n \"K\": 0.35,\n \"Ca\": 0.60,\n \"Sc\": 0.74,\n \"Ti\": 0.79,\n \"V\": 0.84,\n \"Cr\": 0.89,\n \"Mn\": 0.94,\n \"Fe\": 0.99,\n \"Co\": 1.04,\n \"Ni\": 1.09,\n \"Cu\": 1.20,\n \"Zn\": 1.44,\n \"Ga\": 1.68,\n \"Ge\": 1.92,\n \"As\": 2.16,\n \"Se\": 2.40,\n \"Br\": 2.64,\n\n \"Rb\": 0.30,\n \"Sr\": 0.55,\n \"Y\": 0.70,\n \"Zr\": 0.76,\n \"Nb\": 0.82,\n \"Mo\": 0.88,\n \"Tc\": 0.94,\n \"Ru\": 1.00,\n \"Rh\": 1.06,\n \"Pd\": 1.12,\n \"Ag\": 1.18,\n \"Cd\": 1.36,\n \"In\": 1.60,\n \"Sn\": 1.84,\n \"Sb\": 2.08,\n \"Te\": 2.32,\n \"I\": 2.56,\n \n \"Cs\": 0.25,\n \"Ba\": 0.50,\n \"La\": 0.748,\n \"Hf\": 0.775,\n \"Ta\": 0.83,\n \"W\": 0.885,\n \"Re\": 0.94,\n \"Os\": 0.995,\n \"Ir\": 1.05,\n \"Pt\": 1.105,\n \"Au\": 1.16,\n \"Hg\": 1.32,\n \"Tl\": 1.56,\n \"Pb\": 1.80,\n \"Bi\": 2.04,\n \"Po\": 2.28, \n \"At\": 2.52 }","def ordinal(n):\n ord_dict = {1: \"st\", 2: \"nd\", 3: \"rd\"}\n return str(n + 1) + ord_dict.get((n + 1) if (n + 1) < 20 else (n + 1) % 10, \"th\")","def rarity():\n rarities = find_rarities()\n longest = 0\n for rarity in rarities:\n if (len(rarity) > longest): \n longest = len(rarity)\n spacer = \"\".join(map(lambda x: x*longest, \"-\"))\n click.echo(\"\\nRarities\")\n click.echo(spacer)\n for rarity in rarities:\n click.echo(rarity)\n click.echo(\"\\n\")","def lyft_labels():\n\n return {\n 0: 'None',\n 7: 'Roads',\n 10: 'Vehicles'\n }","def goals():\n rand_nmr = random.random()\n if rand_nmr < 0.5:\n return 1\n elif rand_nmr < 0.8:\n return 2\n elif rand_nmr < 0.97:\n return 3\n else:\n return 4","def get_lexicon(seg_sents:List[List[str]]) -> Dict[str, int]:\n\tlexicon = {}\n\n\tfor sent in seg_sents:\n\t\tfor word in sent:\n\t\t\tlexicon[word] = lexicon.get(word, 0) + 1\n\t# print(lexicon)\n\treturn lexicon","def chargen (level0number, level0die, level1number, level1die, level2number, level2die, level3number, level3die, level4number, level4die): #input dice numbers and types for all four potential character levels\r\n\tfilename=stellagama.savefile(\"txt\")\r\n\twith open (filename, \"w\") as output:\r\n\t\tfor i in range (0, stellagama.dice(level0number, level0die)):\r\n\t\t\tcharacter1=character(0)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level1number, level1die)):\r\n\t\t\tcharacter1=character(1)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level2number, level2die)):\r\n\t\t\tcharacter1=character(2)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level3number, level3die)):\r\n\t\t\tcharacter1=character(3)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')\r\n\t\tfor i in range (0, stellagama.dice(level4number, level4die)):\r\n\t\t\tcharacter1=character(4)\r\n\t\t\toutput.write (\"%s, level %s %s %s %s, %s hit points\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\r\\n')\r\n\t\t\toutput.write (\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\r\\n')\r\n\t\t\tproflist=\", \".join(character1.proficiencies)\r\n\t\t\toutput.write (\"Proficiencies: %s\" %(proflist)+'\\r\\n')\r\n\t\t\toutput.write (character1.quirk+'\\r\\n')\r\n\t\t\toutput.write (\"%s, %s, %s\" %(character1.weapon, character1.armor, character1.trinket)+'\\r\\n')\r\n\t\t\toutput.write('\\r\\n')","def score(state, first_n):\n\n return sum([(i + first_n) for i, letter in enumerate(state) if letter == \"#\"])","def __init__(self, n, sents, gamma=None, addone=True):\n assert n > 0\n self._n = n\n\n if gamma is not None:\n # everything is training data\n train_sents = sents\n else:\n # 90% training, 10% held-out\n m = int(0.45 * len(sents))\n l = int(0.65 * len(sents))\n train_sents = sents[:m] + sents[l:]\n held_out_sents = sents[m:l]\n\n print('Computing counts...')\n count = defaultdict(int)\n while (n >= 0):\n for sent in train_sents:\n s = sent[:] ## En una oracion auxiliar agrego el item de start y end para contarlos\n s.insert(0, \"<s>\")\n s.append(\"</s>\")\n for i in range(len(s) - n + 1):\n count[tuple(s[i:i + n])] += 1\n n -= 1\n count[()] = count[()] - count[('<s>',)] - count[\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\n self._count = count\n # WORKed HERE!!\n # COMPUTE COUNTS FOR ALL K-GRAMS WITH K <= N\n\n # compute vocabulary size for add-one in the last step\n self._addone = addone\n if addone:\n print('Computing vocabulary...')\n self._voc = voc = set()\n for sent in sents:\n voc = voc.union(set(sent))\n voc.add('</s>')\n self._voc = voc\n self._V = len(voc)\n\n # compute gamma if not given\n if gamma is not None:\n self._gamma = gamma\n else:\n print('Computing gamma...')\n self._gamma = gamma = 1\n p = self.log_prob(held_out_sents)\n new_gamma = 2\n streak = 1\n growing = True\n turns = 0\n while (turns < 15):\n self._gamma = new_gamma\n np = self.log_prob(held_out_sents)\n gamma = new_gamma\n if (np > p):\n if growing:\n streak += 1\n else:\n turns += 1\n streak = 0\n growing = True\n new_gamma = new_gamma + 2 ** streak\n else:\n if growing:\n turns += 1\n streak = 0\n growing = False\n else:\n streak += 1\n new_gamma = new_gamma - 2 ** streak\n p = np\n self._gamma = new_gamma\n print(self._gamma)","def produced_by(entry):\n if \"ArtsEntRec\" in entry:\n return \"Arts Entertainment Recreation\"\n if \"DurableWholesaleTrucking\" in entry:\n return \"Durable Wholesale Trucking\"\n if \"Education\" in entry:\n return \"Education\"\n if \"ElectronicEquipment\" in entry:\n return \"Electronic Equipment\"\n if \"FoodBeverageStores\" in entry:\n return \"Food Beverage Stores\"\n if \"FoodNondurableWholesale\" in entry:\n return \"Food Nondurable Wholesale\"\n if \"HotelLodging\" in entry:\n return \"Hotel Lodging\"\n if \"MedicalHealth\" in entry:\n return \"Medical Health\"\n if \"Multifamily\" in entry:\n return \"Multifamily\"\n if \"NotElsewhereClassified\" in entry:\n return \"Not Elsewhere Classified\"\n if \"OtherManufacturing\" in entry:\n return \"Other Manufacturing\"\n if \"OtherRetailTrade\" in entry:\n return \"Other Retail Trade\"\n if \"PublicAdministration\" in entry:\n return \"Public Administration\"\n if \"Restaurants\" in entry:\n return \"Restaurants\"\n if \"ServicesManagementAdminSupportSocial\" in entry:\n return \"Services Management Administration Support Social\"\n if \"ServicesProfessionalTechFinancial\" in entry:\n return \"Services Professional Technical Financial\"\n if \"ServicesRepairPersonal\" in entry:\n return \"Services Repair Personal\"","def get_ordinal(n):\n n = int(n)\n # Zeroeth, First, Second, Third, Fourth+\n ordinal = ['th', 'st', 'nd', 'rd', 'th'][min((n % 10), 4)]\n # all the teenths that don't match the above pattern\n if (n % 100) in [11, 12, 13]:\n ordinal = 'th'\n return f\"{n}{ordinal}\"","def all_manslaughter(x): \n for elem in x:\n if elem == 'Manslaughter' or elem == 'Voluntary Manslaughter':\n return 1\n return 0","def makeGerund(self):\r\n clean_s = self.cleanString(self.text)\r\n LoW = clean_s.split()\r\n for x in LoW: \r\n if 'ing' in x and x not in self.gerund: \r\n self.gerund[x] = 1\r\n elif 'ing' in x and x in self.gerund: \r\n self.gerund[x] += 1\r\n return self.gerund","def setDif(dificultad):\n if(dificultad=='Easy'):\n return ['NN', 'JJ', 'VB']\n elif(dificultad=='Medium'):\n return ['NN', 'VB']\n elif(dificultad=='Hard'):\n i=randint(0,2)\n dif=['NN', 'JJ', 'VB']\n return dif[i]","def prob4():\n#pass\n n_men = 0\n n_women = 0\n db = sql.connect('sql2')\n cur = db.cursor()\n cur.execute(\"SELECT Gender FROM ICD WHERE Age>=25 AND Age<=35\")\n for gen in cur :\n if gen[0] == 'M' :\n n_men += 1\n else :\n n_women += 1\n db.close()\n return n_men,n_women","def possessif(nom):\n\n CA = nom[1]\n\n\n rand = randint(0,5)\n\n if CA == \"-1\" or CA == \"-3\" or CA == \"-5\" or CA == \"-7\" or CA == \"-8\" or CA == \"-4\" or Premiere_lettre_voyelle(nom[0]):\n if rand == 0:\n return \"mon \"\n elif rand == 1:\n return \"ton \"\n elif rand == 2:\n return \"son \"\n elif rand == 3:\n return \"notre \"\n elif rand == 4:\n return \"votre \"\n elif rand == 5:\n return \"leur \"\n \n elif (CA == \"-2\" or CA == \"-6\" or CA == \"-9\"):\n if rand == 0:\n return \"ma \"\n elif rand == 1:\n return \"ta \"\n elif rand == 2:\n return \"sa \"\n elif rand == 3:\n return \"notre \"\n elif rand == 4:\n return \"votre \"\n elif rand == 5:\n return \"leur \"\n else:\n return False","def letter_name(lst, letter):\n arr = [0 for i in range(100)]\n counter = 0\n for name in lst:\n letter = name[0][0].lower()\n order = ord(letter) - 1072\n arr[order] += 1\n maximum = 0\n letter = \"\"\n for i in range(len(arr)):\n if arr[i] > maximum:\n maximum = arr[i]\n letter = chr(i + 1072)\n arr_of_names = []\n sum_of_children = 0\n for name in lst:\n if name[0][0].lower() == letter:\n arr_of_names.append(name[0])\n sum_of_children += name[1]\n return letter, maximum, arr_of_names, sum_of_children","def think(s):","def say_chunk(num):\n output_string_list = []\n num_string = str(num)\n\n units = ['zero', 'one', 'two', 'three', 'four', 'five',\n 'six', 'seven', 'eight', 'nine']\n teens = ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen',\n 'sixteen', 'seventeen', 'eighteen', 'nineteen']\n tens = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']\n\n # singles\n if num < 10:\n output_string_list.append(units[num])\n\n # teens\n elif 10 <= num <= 19:\n output_string_list.append(teens[int(num) % 10])\n\n # tens\n elif 20 <= num <= 99:\n num_str = str(num)\n modifier = int(num_str[0])\n if int(num_str[1]):\n output_string_list.append(\"{}-{}\".format(tens[modifier - 2], units[int(num) % 10]))\n else:\n output_string_list.append(tens[modifier - 2])\n\n # hundreds\n elif 100 <= num <= 999:\n output_string_list.append(units[int(num_string[0])])\n output_string_list.append('hundred')\n\n num = int(num_string[1:])\n if num:\n output_string_list.append('and')\n num_string = str(num)\n modifier = int(num_string[0])\n\n if int(num_string[1]):\n output_string_list.append(\"{}-{}\".format(tens[modifier - 2], units[int(num_string[1:]) % 10]))\n else:\n output_string_list.append(tens[modifier - 2])\n\n return ' '.join(output_string_list)","def cardinal(n, friendly=True):\n if friendly:\n n_abs = abs(n)\n\n if n_abs < 20:\n return cardinal(n, friendly=False)\n\n if n_abs < 100 and n_abs % 10 == 0:\n return cardinal(n, friendly=False)\n\n if n_abs < 1000 and n_abs % 100 == 0:\n return cardinal(n, friendly=False)\n\n if n_abs < 12000 and n_abs % 1000 == 0:\n return cardinal(n, friendly=False)\n\n prefix = \"min \" if n < 0 else \"\"\n\n if n_abs < MILLION:\n q, r = divmod(n_abs, 1000)\n if r == 0:\n return prefix + \"%d duizend\" % q\n\n if n_abs < BILLION:\n q, r = divmod(n_abs, MILLION)\n if r == 0:\n return prefix + \"%d miljoen\" % q\n\n # No friendly variant, just return the numerical representation.\n return unicode(n)\n\n # Code below completely spells out each number.\n\n if n < 0:\n return \"min \" + cardinal(abs(n))\n\n if n < 20:\n return UNITS[n]\n\n if n < 100:\n q, r = divmod(n, 10)\n a = TENS[q]\n if r == 0:\n return a\n b = cardinal(r)\n joiner = \"en\" if not b.endswith(\"e\") else \"ën\"\n return b + joiner + a\n\n if n < 1000:\n q, r = divmod(n, 100)\n a = cardinal(q, friendly=False) if q > 1 else \"\"\n b = cardinal(r, friendly=False) if r > 0 else \"\"\n return a + \"honderd\" + b\n\n if 1000 < n < 10000 and n % 1000:\n # Special case for numbers that are exactly divisble by 100, but\n # not by 1000, e.g. \"tweeëntwintighonderd\"\n q, r = divmod(n, 100)\n if r == 0:\n a = cardinal(q, friendly=False) if q > 1 else \"\"\n return a + \"honderd\"\n\n if n < MILLION:\n q, r = divmod(n, 1000)\n a = cardinal(q, friendly=False) if q > 1 else \"\"\n b = \" \" + cardinal(r, friendly=False) if r > 0 else \"\"\n return a + \"duizend\" + b\n\n if n < BILLION:\n q, r = divmod(n, MILLION)\n a = cardinal(q, friendly=False)\n b = \" \" + cardinal(r, friendly=False) if r > 0 else \"\"\n return a + \" miljoen\" + b\n\n if n < TRILLION:\n q, r = divmod(n, BILLION)\n a = cardinal(q, friendly=False)\n b = \" \" + cardinal(r, friendly=False) if r > 0 else \"\"\n return a + \" miljard\" + b\n\n if n < QUADRILLION:\n q, r = divmod(n, TRILLION)\n a = cardinal(q, friendly=False)\n b = \" \" + cardinal(r, friendly=False) if r > 0 else \"\"\n return a + \" biljoen\" + b\n\n # Fallback to numerical representation\n return unicode(n)","def get_final_score(scores):\n \n print(\"get_final_score\")\n \n print(\"scores:\", scores)\n \n max_score = max(scores.values())\n print(\"max_score:\", max_score)\n sieger = [x for x in scores.keys() if scores[x] == max_score]\n \n print(\"sieger:\", sieger)\n\n if len(scores) == 1:\n print(\"if1\")\n text = \"<s>Spiel beendet. </s>Du hast {0} von {1} Fragen richtig beantwortet.\"\\\n .format(scores[\"1\"], TOTAL_ROUNDS)\n elif len(sieger) == 1:\n sieger = sieger[0]\n text = \"<s>Spiel beendet.</s> Der Sieger ist Spieler {0} mit {1} von {2} Punkten.\"\\\n .format(sieger, scores[sieger], TOTAL_ROUNDS)\n\n elif len(sieger) == len(scores):\n text = \"<s>Spiel beendet.</s> <s>Es gab keinen Sieger;</s> alle Spieler haben\\\n {0} von {1} Fragen richtig beantwortet.\".format(max_score, TOTAL_ROUNDS)\n else:\n scores_text = \"\"\n for e in sieger[:-1]:\n scores_text += \"<break/> Spieler {0}\".format(e)\n scores_text += \" und Spieler {0} mit {1} von {2} Fragen richtig beantwortet.\"\\\n .format(sieger[-1], max_score, TOTAL_ROUNDS)\n text = \"<s>Spiel beendet.</s> Das beste Ergebnis hatten\" + scores_text\n\n text += \"<s> Danke fürs Mitspielen!</s>\"\n\n return text","def REC_L_STRAIGHT():\n return 11","def get_entailment_judgements():\n results = defaultdict(lambda: [0,0,0])\n mapping = dict(zip(('CONTRADICTION','ENTAILMENT','NEUTRAL'), range(3)))\n\n firstline = True\n for line in open('working/sick.run'):\n if firstline:\n firstline = False\n else:\n words = line.split()\n sick_id = str(words[0])\n result = words[1]\n\n # Set the index correspoinding to the judgement to 1\n results[sick_id][mapping[result]] = 1\n return results","def fix_teen(n):\n x = 0\n\n while(x < len(n)):\n if(n[x] in(13, 14, 17,18,19)):\n n[x] = 0\n x = x + 1\n \n return n","def bolinish_alomatlari(son):\n for n in range(1,11):\n if not son % (n):\n print(f\"{son} {n} ga qoldiqsiz bo'linadi \")","def get_movie_most_nominations(movies: list) -> str:\n pass","def rules():\n help = textwrap.dedent(\"\"\"\n THIS IS THE GAME OF \"REVERSE\". TO WIN, ALL YOU HAVE\n TO DO IS ARRANGE A LIST OF NUMBERS (1 THROUGH {})\n IN NUMERICAL ORDER FROM LEFT TO RIGHT. TO MOVE, YOU\n TELL ME HOW MANY NUMBERS (COUNTING FROM THE LEFT) TO\n REVERSE. FOR EXAMPLE, IF THE CURRENT LIST IS:\n\n 2 3 4 5 1 6 7 8 9\n\n AND YOU REVERSE 4, THE RESULT WILL BE:\n\n 5 4 3 2 1 6 7 8 9\n\n NOW IF YOU REVERSE 5, YOU WIN!\n\n 1 2 3 4 5 6 7 8 9\n\n NO DOUBT YOU WILL LIKE THIS GAME, BUT\n IF YOU WANT TO QUIT, REVERSE 0 (ZERO).\n \"\"\".format(NUMCNT))\n print(help)\n print()","def alphabet_war(fight):","def n_hellos(n:int) -> None:\n for x in range(1, n+1):\n if 10 < x <=20:\n print(f'{x}th hello')\n elif x % 10 == 1:\n print(f'{x}st hello')\n elif x % 10 == 2:\n print(f'{x}nd hello')\n elif x % 10 == 3:\n print(f'{x}rd hello')\n else:\n print(f'{x}th hello')","def zapisi_pot(pot):\r\n u = ()\r\n p = 1\r\n for c in range(1, len(pot)):\r\n if pot[c][1] > pot[c - 1][1]:\r\n if p == 2:\r\n p = 3\r\n u += 'LEVO',\r\n elif p == 4:\r\n p = 3\r\n u += 'DESNO',\r\n elif p == 1:\r\n p = 3\r\n u += 'DESNO', 'DESNO'\r\n u += str(pot[c][1] - pot[c - 1][1]),\r\n elif pot[c][1] < pot[c - 1][1]:\r\n if p == 2:\r\n p = 1\r\n u += 'DESNO',\r\n elif p == 4:\r\n p = 1\r\n u += 'LEVO',\r\n elif p == 3:\r\n p = 1\r\n u += 'DESNO', 'DESNO'\r\n u += str(pot[c - 1][1] - pot[c][1]),\r\n elif pot[c][0] > pot[c - 1][0]:\r\n if p == 1:\r\n p = 4\r\n u += 'DESNO',\r\n elif p == 3:\r\n p = 4\r\n u += 'LEVO',\r\n elif p == 2:\r\n p = 4\r\n u += 'DESNO', 'DESNO'\r\n u += str(pot[c][0] - pot[c - 1][0]),\r\n elif pot[c][0] < pot[c - 1][0]:\r\n if p == 1:\r\n p = 2\r\n u += 'LEVO',\r\n elif p == 3:\r\n p = 2\r\n u += 'DESNO',\r\n elif p == 4:\r\n p = 2\r\n u += 'DESNO', 'DESNO'\r\n u += str(pot[c - 1][0] - pot[c][0]),\r\n c += 1\r\n\r\n return '\\n'.join(u)","def get_color(tense, seq=0):\n if tense in ['Perfekt', 'present perfect', 'pretérito perfecto compuesto', 'passé composé', 'vtt',\n 'passato prossimo', 'PresPerf']:\n return '#1f77b4'\n elif tense in ['Präsens', 'simple present', 'presente', 'présent', 'ott', 'Present', 'present imperfective', 'present']:\n return '#ff7f0e'\n elif tense in ['Präteritum', 'simple past', 'pretérito perfecto simple', 'indefinido', 'passé simple', 'ovt', 'Past', 'past perfective', 'past']:\n return '#2ca02c'\n elif tense in ['Plusquamperfekt', 'past perfect', 'pretérito pluscuamperfecto', 'plus-que-parfait', 'vvt',\n 'trapassato prossimo', 'PastPerf', 'past+infinitive']:\n return '#d62728'\n elif tense in ['Futur I', 'simple future', 'futur', 'futuro', 'ottt', 'future']:\n return '#9467bd'\n elif tense in ['Futur II', 'future perfect', 'futur antérieur', 'futuro perfecto', 'ovtt', 'future past']:\n return '#8c564b'\n elif tense in ['present perfect continuous', 'Cont', 'present/adjective']:\n return '#e377c2'\n elif tense in ['pasado reciente', 'passé récent', 'RecentPast', 'copular']:\n return '#7f7f7f'\n elif tense in ['pretérito imperfecto', 'imparfait', 'Imperfecto', 'past imperfective', 'past+present']:\n return '#bcbd22'\n elif tense in ['present participle', 'participio', 'Gerund', 'gerund', 'gerund perfective']:\n return '#17becf'\n elif tense in ['Infinitiv', 'infinitief', 'infinitif', 'infinitivo', 'infinitive']:\n return '#aec7e8'\n elif tense in ['present continuous', 'PresGer', 'existential']:\n return '#ffbb78'\n elif tense in ['condicional', 'conditionnel', 'Rep']:\n return '#98df8a'\n elif tense in ['past continuous']:\n return '#ff9896'\n elif tense in ['past perfect continuous']:\n return '#c5b0d5'\n elif tense in ['future continuous']:\n return '#c49c94'\n elif tense in ['future in the past', 'futuro perfecto']:\n return '#f7b6d2'\n elif tense in ['future in the past continuous']:\n return '#c7c7c7'\n elif tense in ['infinitivo perfecto']:\n return '#dbdb8d'\n elif tense in ['futur proche', 'futuro próximo']:\n return '#9edae5'\n elif tense in ['futur proche du passé', 'futuro próximo en imperfecto']:\n return '#393b79'\n elif tense in ['conditionnel passé']:\n return '#5254a3'\n elif tense in ['subjuntivo presente']:\n return '#e7cb94'\n elif tense in ['subjuntivo pretérito imperfecto']:\n return '#8c6d31'\n elif tense in ['participle past perfective active']:\n return '#843c39'\n elif tense in ['gerund imperfective']:\n return '#393b79'\n\n # Mandarin\n elif tense in ['unmarked']:\n return '#1f77b4'\n elif tense in ['rvc']:\n return '#ff7f0e'\n elif tense in ['le1', 'le']:\n return '#2ca02c'\n elif tense in ['le12']:\n return '#d62728'\n elif tense in ['guo']:\n return '#9467bd'\n elif tense in ['zhe']:\n return '#8c564b'\n elif tense in ['zai']:\n return '#e377c2'\n elif tense in ['unmarked duplication']:\n return '#7f7f7f'\n elif tense in ['adv']:\n return '#bcbd22'\n elif tense in ['adj']:\n return '#17becf'\n elif tense in ['conj']:\n return '#aec7e8'\n elif tense in ['mood']:\n return '#ffbb78'\n elif tense in ['noun']:\n return '#98df8a'\n elif tense in ['non-verb', 'other']:\n return '#ff9896'\n\n # ViB\n elif tense in ['adjectif']:\n return '#e6194b'\n elif tense in ['adverbe']:\n return '#3cb44b'\n elif tense in ['article défini']:\n return '#ff0000'\n elif tense in ['article défini pluriel']:\n return '#bf0000'\n elif tense in ['article défini singulier']:\n return '#ff0051'\n elif tense in ['article indéfini']:\n return '#ff8400'\n elif tense in ['article indéfini pluriel']:\n return '#8c4800'\n elif tense in ['article indéfini singulier']:\n return '#4c2800'\n elif tense in ['déterminant défini pluriel']:\n return '#adb300'\n elif tense in ['déterminant démonstratif']:\n return '#56bf00'\n elif tense in ['déterminant indéfini']:\n return '#285900'\n elif tense in ['déterminant possessif']:\n return '#00e686'\n elif tense in ['expression']:\n return '#e377c2'\n elif tense in ['nom commun']:\n return '#7f7f7f'\n elif tense in ['nom propre']:\n return '#bcbd22'\n elif tense in ['nom propre gén']:\n return '#dbdb8d'\n elif tense in ['numéral']:\n return '#17becf'\n elif tense in ['pronom démonstratif']:\n return '#5b008c'\n elif tense in ['pronom indéfini']:\n return '#2200ff'\n elif tense in ['pronom interrogatif']:\n return '#0058e6'\n elif tense in ['pronom personnel']:\n return '#006773'\n elif tense in ['pronom personnel adverbial']:\n return '#00331e'\n elif tense in ['pronom relatif']:\n return '#285900'\n elif tense in ['pronom réfléchi']:\n return '#00e686'\n\n # Contraction\n elif tense in ['contracted', 'bare noun']:\n return '#2f5597'\n elif tense in ['uncontracted', 'demonstrative']:\n return '#fd8f8e'\n\n else:\n return COLOR_LIST[seq % len(COLOR_LIST)]","def way_to_prewin(self, one):\r\n\t\tkind = [0, 0, 0, 0] \r\n\t\tuseful = []\r\n\t\tscore = 0\r\n\t\tfor part in one.split(\"\\t\"):\r\n\t\t\t#print \"part: {0}\".format(part)\r\n\t\t\ttmp = part.split()\r\n\t\t\tlength = len(tmp)\r\n\t\t\tif (length == 3):\t\t# triple\r\n\t\t\t\tkind[0] += 1\r\n\t\t\t\tscore += 3\r\n\t\t\telif (length == 1):\t\t# single\r\n\t\t\t\tkind[3] += 1\r\n\t\t\telif (tmp[0] == tmp[1]):# pair\r\n\t\t\t\tkind[1] += 1\r\n\t\t\t\tuseful.append(\"{0}\".format(tmp[0]))\r\n\t\t\t\tscore += 2\r\n\t\t\telse:\r\n\t\t\t\tkind[2] += 1\r\n\t\t\t\tn = GameBoard.NextCard(tmp[0])\r\n\t\t\t\tp = GameBoard.PrevCard(tmp[0])\r\n\t\t\t\tnn = GameBoard.NextCard(tmp[1])\r\n\t\t\t\tif (n == tmp[1]):\t# consecutive neighbor\r\n\t\t\t\t\tscore += 2\r\n\t\t\t\t\tif (p != None): useful.append(p)\r\n\t\t\t\t\tif (nn != None): useful.append(nn)\r\n\t\t\t\telse:\r\n\t\t\t\t\tuseful.append(n)\r\n\t\t\t\t\tscore += 1\r\n\r\n\t\t#print \"kind: {0}\".format(kind)\r\n\t\t\"\"\" how many cards can we probably get \"\"\"\r\n\t\tuseful_amount = 0\r\n\t\tfor card in set(useful):\r\n\t\t\tctype = GameBoard.CardType(card)\r\n\t\t\tif (ctype == 1): a = self.wang_list.count(card)\r\n\t\t\telif (ctype == 2): a = self.tube_list.count(card)\r\n\t\t\telif (ctype == 3): a = self.bamb_list.count(card)\r\n\t\t\telif (ctype == 4): a = self.word_list.count(card)\r\n\t\t\telse: a = self.wind_list.count(card)\r\n\t\t\tb = self.gb.drop_list.count(card)\r\n\t\t\tuseful_amount += (4 - a - b)\r\n\r\n\t\t\"\"\"\r\n\t\t1. enumerate, because goal state not too much\r\n\t\t2. counting pong_list so that we can focus on 16 cards\r\n\t\t3. check prewin first\t\r\n\t\t\"\"\"\r\n\t\tgoals = [[4, 1, 1, 0], [5, 0, 0, 1], [4, 2, 0, 0]]\r\n\t\tgpattern = [[\"***\", \"***\", \"***\", \"***\", \"##\", \"$$\"],[\"***\", \"***\", \"***\", \"***\", \"***\", \"/\"],\r\n\t\t\t\t\t[\"***\", \"***\", \"***\", \"***\", \"##\", \"##\"]]\r\n\t\tresult = [0, 0, 0]\r\n\t\tsize = len(self.pong_list) / 3\r\n\t\tif ((size + kind[0]) > 4): return [0, useful_amount, score]\r\n\t\tfor i in range(size): \r\n\t\t\tgpattern[0].remove(\"***\")\r\n\t\t\tgpattern[1].remove(\"***\")\r\n\t\t\tgpattern[2].remove(\"***\")\r\n\t\tfor number in range(3):\r\n\t\t\tk0 = kind[0]\r\n\t\t\tk1 = kind[1]\r\n\t\t\tk2 = kind[2]\r\n\t\t\tk3 = kind[3]\r\n\t\t\tp1 = gpattern[number]\r\n\t\t\tfor i in range(k0): p1.remove(\"***\")\r\n\t\t\tfor i in range(min(k1, goals[number][1])): \r\n\t\t\t\tk1 -= 1\r\n\t\t\t\tp1.remove(\"##\")\r\n\t\t\tfor i in range(min(k2, goals[number][2])):\r\n\t\t\t\tk2 -= 1\r\n\t\t\t\tp1.remove(\"$$\")\r\n\t\t\t#print \"p1: {0}, size: {1}\".format(p1, (k1+k2)*2+k3)\r\n\t\t\tstep = 0\r\n\t\t\ttwo = k1 + k2\r\n\t\t\tfor i in range(len(p1)):\r\n\t\t\t\tlength = len(p1[i])\r\n\t\t\t\tif (length == 3):\r\n\t\t\t\t\tif two:\r\n\t\t\t\t\t\ttwo -= 1\r\n\t\t\t\t\t\tstep += 1\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tstep += 2\r\n\t\t\t\telif (length == 2):\r\n\t\t\t\t\tstep += 1\r\n\t\t\tresult[number] = step\r\n\t\t#print \"steps to goal: {0}, useful: {1}\".format(result, len(useful))\r\n\t\t\r\n\t\treturn [min(result), useful_amount, score]","def compute(data):\n spoken = collections.defaultdict(lambda: collections.deque(maxlen=2))\n\n starting = map(int, data.split(\",\"))\n last_number = None\n i = 0\n\n for i, last_number in enumerate(starting, start=i + 1):\n spoken[last_number].append(i)\n\n for i in range(i + 1, 30000001):\n if len(spoken[last_number]) <= 1:\n last_number = 0\n else:\n last_number = spoken[last_number][1] - spoken[last_number][0]\n\n spoken[last_number].append(i)\n\n return last_number","def tetrakis(self):\n return self.nlegomena(4)","def generation(state, first_n, rules):\n\n state = \"....\" + state + \"....\"\n first_n -= 2 # adding 4 dots, but only add 2 to the first_n because we start at 2 below\n\n new_state = \"\".join([rules.get(state[i:i+5],\".\") for i in range(len(state))])\n\n first_pot = new_state.find(\"#\")\n first_n += first_pot\n\n last_pot = new_state.rfind(\"#\")\n \n# print(f\"first pot {first_pot} in {new_state}\")\n return new_state[first_pot:last_pot+1], first_n","def frequency_quran_level():\n\n # * A list of sura level frequencies.\n # * Each element is a list of ayat el-sura frequencies.\n quranWordsFrequences = []\n\n for suraNumber in range(1, 114 +1):\n suraWordsFrequeces = frequency_sura_level(suraNumber)\n quranWordsFrequences.append(suraWordsFrequeces)\n\n return quranWordsFrequences","def pluralize(word, num):\n word = word.lower().lstrip()\n string = \"\"\n numList = [\"zero\", \"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\",\n \"eight\", \"nine\", \"ten\", \"eleven\", \"twelve\", \"thirteen\",\n \"fourteen\", \"fifteen\", \"sixteen\", \"seventeen\", \"eighteen\",\n \"nineteen\", \"twenty\", \"thirty\", \"forty\", \"fifty\", \"sixty\",\n \"seventy\", \"eighty\", \"ninety\"]\n vowels = [\"a\", \"e\", \"i\", \"o\", \"u\", \"y\"]\n multi_exception = {\"is\": \"es\", \"us\": \"i\", \"ix\": \"ices\", \"eau\": \"eaux\", \"ouse\": \"ice\",\n \"ch\": \"es\", \"sh\": \"es\"}\n o_exception = [\"hero\", \"potato\", \"volcano\"]\n special = {\"goose\": \"geese\", \"man\": \"men\", \"mouse\": \"mice\",\n \"tooth\": \"teeth\", \"child\": \"children\",\n \"woman\": \"women\", \"ox\": \"oxen\", \"wolf\" : \"wolves\"}\n unchanging = [\"deer\", \"fish\", \"sheep\", \"species\", \"aircraft\", \"bison\"]\n if num <= 20:\n string = numList[num] \n else:\n temp1 = int(num / 10)\n temp2 = int(num % 10)\n string = numList[temp1 + 18] + \"-\" + numList[temp2]\n string += \" \"\n if num != 1 and word not in unchanging:\n if word in special:\n word = special[word]\n elif multiCheck(word, multi_exception)[0]:\n b = multiCheck(word, multi_exception)[1]\n word = word[0 : -len(b)] + multi_exception[b]\n elif word[-1] == \"y\":\n if word[-2] in vowels:\n word += \"s\"\n else:\n word = word[0 : -1] + \"ies\"\n elif word[-1] in [\"s\", \"x\", \"z\"] or word in o_exception:\n word += \"es\"\n else:\n word += \"s\"\n return string + word","def get_word_score(word, n=7):\n score = 0\n\n for i in word:\n score += SCRABBLE_LETTER_VALUES[i]\n\n if len(word) == n:\n score += 50\n\n return score","def treatment_plugs(data_plugs):\r\n\r\n no_plugs = []\r\n little = []\r\n means = []\r\n great = []\r\n large_enough = []\r\n super_large = []\r\n\r\n\r\n for i in data_plugs:\r\n print(i[0])\r\n if i[1] in ('None', None)\\\r\n or i[0] in ('None', None):\r\n pass\r\n elif i[0] == 'non':\r\n no_plugs.append(int(i[1]))\r\n elif i[0] == 'petit':\r\n little.append(int(i[1]))\r\n elif i[0] == 'moyen':\r\n means.append(int(i[1]))\r\n elif i[0] == 'grand':\r\n great.append(int(i[1]))\r\n elif i[0] == 'assez grand':\r\n large_enough.append(int(i[1]))\r\n elif i[0] == 'tres grand':\r\n super_large.append(int(i[1]))\r\n\r\n\r\n data = len(no_plugs) + len(little) +\\\r\n len(means) + len(great)+\\\r\n len(large_enough)+\\\r\n len(super_large)\r\n\r\n print(data)\r\n\r\n data_no = moyenne(no_plugs)\r\n data_little = moyenne(little)\r\n data_means = moyenne(means)\r\n data_great = moyenne(great)\r\n data_large_enough = moyenne(large_enough)\r\n data_super_large = moyenne(super_large)\r\n\r\n return data_no[0],\\\r\n data_little[0],\\\r\n data_means[0],\\\r\n data_great[0],\\\r\n data_large_enough[0],\\\r\n data_super_large[0],\\\r\n data_no[1],\\\r\n data_little[1],\\\r\n data_means[1],\\\r\n data_great[1],\\\r\n data_large_enough[1],\\\r\n data_super_large[1],\\\r\n data","def organize(select, strain, equals):\n scores = []\n data = list(strainer(select, strain, equals))\n while len(data) != 0:\n number = lowest_number(data)\n scores.append(number)\n data.remove(number)\n return scores","def getWordScore(word, n):\n score=0\n for i in range(len(word)):\n addition=SCRABBLE_LETTER_VALUES[word[i]]\n score+=addition*(len(word))\n if len(word)==n:\n score+=50\n return score","def ordinal_label(n):\n n = int(n)\n return \"%d%s\" % (n,\"tsnrhtdd\"[(n/10%10!=1)*(n%10<4)*n%10::4])","def main(duck, abstract, answer):\n set_duck = sorted(set(duck))\n for i in set_duck:\n if i > abstract / 2:\n break\n answer += duck.count(abstract - i) * duck.count(i)\n print(answer)","def minion_game(string):\n vowels = sum(len(string) - i for i, c in enumerate(string) if c in 'AEIOU')\n consonants = sum(len(string) - i for i, c in enumerate(string) if c not in 'AEIOU')\n\n if vowels == consonants:\n print(DRAW)\n elif vowels > consonants:\n print(f'{PLAYER_VOWELS} {vowels}')\n else:\n print(f'{PLAYER_CONSONANTS} {consonants}')","def test_get_scorable_threes_5ok():\n roll = np.array([3, 3, 3, 3, 3, 1])\n expected = {\n \"one\": 1,\n \"five\": 0,\n \"three-ones\": False,\n \"three-twos\": False,\n \"three-threes\": False,\n \"three-fours\": False,\n \"three-fives\": False,\n \"three-sixes\": False,\n \"four-of-a-kind\": False,\n \"three-and-one\": False,\n \"five-of-a-kind\": True,\n \"six-of-a-kind\": False,\n \"straight\": False,\n \"three-pairs\": False,\n \"four-and-pair\": False,\n \"triplets\": False,\n }\n actual = analyze_roll.get_scorable(roll)\n assert expected == actual","def get_keywords(self, number=10):\n # print(len(self.node_weight.items()))\n node_weight_list = [list(ele) for ele in self.node_weight.items()]\n for i in node_weight_list:\n res = len(i[0].split())\n if res==2:\n # weight for bigrams\n i[1]=4*i[1]\n if res==3:\n # weight for trigrams\n i[1]=6*i[1]\n\n node_weight = OrderedDict(sorted(node_weight_list, key=lambda t: t[1], reverse=True))\n for i, (key, value) in enumerate(node_weight.items()):\n # print(key + ' - ' + str(value))\n print(i+':'+key)\n if i > number:\n break","def word_enders():\n space = ''\n for k,v in key.items():\n if v==' ':\n space = k\n\n enders = Counter()\n for word in ciphertext.split( space ):\n last_two = word[-2]+word[-1]\n enders[last_two] += 1\n\n return enders"],"string":"[\n \"def fo_shizzle_my_nizzle(n): \\n if n < 0:\\n n = \\\"fo\\\"\\n elif n >= 1 and n < 50: \\n n = \\\"shizzle\\\"\\n elif n >= 50 and n <= 100:\\n n = \\\"my\\\"\\n elif n % 2 == 0 and n % 3 == 0 and n > 100:\\n n = \\\"nizzle\\\"\\n else:\\n n = \\\"\\\"\\n return n\",\n \"def solution(self):\\n return [(\\\"the\\\", 1579644)] * 100\",\n \"def generate_horror_title():\\n d666 = random.randint(1, 666)\\n if d666 <= 111:\\n #the adj noun\\n return \\\"The \\\" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \\\" \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\\n elif d666 > 111 and d666 <= 222: \\n #noun of noun\\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \\\" of \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\\n elif d666 > 222 and d666 < 444: \\n #the adj noun of verb \\n return \\\"The \\\" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \\\" \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)] + \\\" of \\\" + horror_verb[random.randint(0, len(horror_verb) - 1)]\\n elif d666 >= 444 and d666 < 555: \\n #noun of noun\\n return horror_noun[random.randint(0, len(horror_noun) - 1)] + \\\" of \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\\n elif d666 >= 555:\\n #verb of the adj noun\\n return horror_verb[random.randint(0, len(horror_verb) - 1)] + \\\" of the \\\" + horror_adj[random.randint(0, len(horror_adj) - 1)] + \\\" \\\" + horror_noun[random.randint(0, len(horror_noun) - 1)]\",\n \"def CARD_SUITS() -> tuple:\\n return \\\"Diamonds\\\", \\\"Hearts\\\", \\\"Clubs\\\", \\\"Spades\\\"\",\n \"def solution(self):\\n return [(\\\"the\\\", 1561900)] * 100\",\n \"def strategiaa(stan_gry):\\n ruch = min(random.randint(1,3), stan_gry)\\n return ruch\",\n \"def find_gender_adj(novel, female):\\n output = {}\\n text = novel.get_tokenized_text()\\n\\n if female:\\n distances = female_instance_dist(novel)\\n pronouns1 = [\\\"her\\\", \\\"hers\\\", \\\"she\\\", \\\"herself\\\"]\\n pronouns2 = [\\\"his\\\", \\\"him\\\", \\\"he\\\", \\\"himself\\\"]\\n else:\\n distances = male_instance_dist(novel)\\n pronouns1 = [\\\"his\\\", \\\"him\\\", \\\"he\\\", \\\"himself\\\"]\\n pronouns2 = [\\\"her\\\", \\\"hers\\\", \\\"she\\\", \\\"herself\\\"]\\n if len(distances) == 0:\\n return {}\\n elif len(distances) <= 3:\\n lower_window_bound = 5\\n else:\\n lower_window_bound = median(sorted(distances)[:int(len(distances) / 2)])\\n\\n if not lower_window_bound >= 5:\\n return \\\"lower window bound less than 5\\\"\\n for l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11 in windowed(text, 11):\\n l6 = l6.lower()\\n if not l6 in pronouns1:\\n continue\\n words = [l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11]\\n if bool(set(words) & set(pronouns2)):\\n continue\\n for index, word in enumerate(words):\\n words[index] = word.lower()\\n tags = nltk.pos_tag(words)\\n for tag_index, tag in enumerate(tags):\\n if tags[tag_index][1] == \\\"JJ\\\" or tags[tag_index][1] == \\\"JJR\\\" or tags[tag_index][1] == \\\"JJS\\\":\\n word = words[tag_index]\\n if word in output.keys():\\n output[word] += 1\\n else:\\n output[word] = 1\\n return output\",\n \"def solution(self):\\n return [(\\\"simple 1\\\", 1.),\\n (\\\"simple 2\\\", 1.),\\n (\\\"simple 3\\\", 1.),\\n (\\\"simple 4\\\", 1.),\\n (\\\"simple 5\\\", 1.),\\n (\\\"simple 10\\\", 1.),\\n (\\\"simple 15\\\", 1.),\\n (\\\"thai 1\\\", 1.),\\n (\\\"thai 2\\\", 1.),\\n (\\\"thai 3\\\", 1.),\\n (\\\"thai 4\\\", 1.),\\n (\\\"thai 5\\\", 1.),\\n (\\\"thai 10\\\", 1.),\\n (\\\"thai 15\\\", 1.),\\n ]\",\n \"def part1(input_string):\\n twos, threes = 0, 0\\n for line in input_string:\\n letters_seen = {}\\n for char in line:\\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\\n if 2 in letters_seen.values():\\n twos += 1\\n if 3 in letters_seen.values():\\n threes += 1\\n return threes * twos\",\n \"def won(s,n):\",\n \"def count_words_and_dublicates(novel):\",\n \"def substantiate():\",\n \"def solution(self):\\n return [((\\\"communes of the bouches-du-rh\\\\u00f4ne department\\\", \\\"france\\\"), 0.024170164983320565)] * 100\",\n \"def __init__(self, n, sents):\\n assert n > 0\\n self._n = n\\n print(\\\"Counting...\\\")\\n count = defaultdict(int)\\n while n >= 0:\\n for sent in sents:\\n s = sent[:] # En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n print(\\\"Computing vocabulary...\\\")\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc) # vocabulary size\\n print(\\\"Done\\\")\",\n \"def count_sheep(n):\\t\\n\\treturn ''.join([str(x) + ' sheep...' for x in range(1, n + 1)])\",\n \"def pirate():\\n \\n from random import choice\\n d = {\\n \\\"sir\\\": \\\"matey\\\", \\\"hotel\\\": \\\"fleabag inn\\\", \\\"student\\\": \\\"swabbie\\\",\\n \\\"boy\\\": \\\"matey\\\", \\\"girl\\\": \\\"wench\\\", \\\"professor\\\": \\\"foul blaggart\\\",\\n \\\"restaurant\\\": \\\"galley\\\", \\\"your\\\": \\\"ye\\\", \\\"excuse\\\": \\\"arr\\\", \\\"you\\\": \\\"ye\\\",\\n \\\"students\\\": \\\"swabbies\\\", \\\"are\\\": \\\"be\\\", \\\"lawyer\\\": \\\"foul blaggart\\\",\\n \\\"the\\\": \\\"th'\\\", \\\"restroom\\\": \\\"head\\\", \\\"my\\\": \\\"me\\\", \\\"hello\\\": \\\"avast\\\",\\n \\\"is\\\": \\\"be\\\", \\\"man\\\": \\\"scurvy dog\\\", \\\"hey\\\": \\\"avast\\\", \\\"pirate\\\": \\\"scurvy pirate\\\",\\n \\\"idiot\\\": \\\"flunder\\\", \\\"young\\\": \\\"ye\\\", \\\"the\\\": \\\"t'\\\", \\\"suck\\\": \\\"blow down\\\",\\n \\\"fall\\\": \\\"hade\\\", \\\"happens\\\": \\\"be happening\\\", \\\"death\\\": \\\"Davy Jones' treasure chest\\\",\\n \\\"always\\\": \\\"ever\\\", \\\"you're\\\": \\\"ye're\\\", \\\"girlfriend\\\": \\\"Lassie-Lucy\\\",\\n \\\"with\\\": \\\"wit'\\\", \\\"everyone\\\": \\\"evr'un\\\"\\n }\\n #~ sentence = raw_input(\\\"What be yer sentence, ye old landlubber? \\\")\\n sentences = [\\\"If the world didn't suck we'd all fall off\\\",\\n \\\"What happens if you get scared half to death twice?\\\",\\n \\\"Save water and shower with your girlfriend\\\",\\n \\\"Always remember you're unique, just like everyone else\\\"]\\n \\n start = [\\\"Yarr, \\\", \\\"Yarr! \\\", \\\"Yarr-ha-harr! \\\", \\\"Skuttle me Skippers! \\\",\\n \\\"Shiver me timbers! \\\", \\\"Ahoy, me hearties! \\\", \\\"Dogs ahoy! \\\",\\n \\\"Hoist the mizzen!!! \\\", \\\"Hoist the colors!! \\\" ]\\n end = [\\\". ARRRGHHHH!\\\", \\\". Avast ye varmint!\\\", \\\". Yarr?\\\",\\n \\\". Savvyy?\\\", \\\". Yarr!\\\", \\\". Aye!\\\",\\n \\\", ye bilge rat!\\\", \\\", ye mangy dog!\\\", \\\", ye scallywag!\\\"]\\n\\n s = choice(sentences)\\n print s\\n print choice(start) +\\\\\\n ' '.join([d[i] if i in d else i for i in s.lower().split()]).capitalize()\\\\\\n + choice(end)\",\n \"def order_ideal(self, gens):\",\n \"def spell_triade(triade):\\n spelled_triade = ''\\n\\n if triade[1] == 1:\\n\\n spelled_triade += numerals_dictionary[triade[1] * 10 + triade[2]]\\n\\n elif triade[1] == 0:\\n\\n spelled_triade += numerals_dictionary[triade[2]]\\n\\n else:\\n\\n if triade[2] == 0:\\n\\n spelled_triade = numerals_dictionary[triade[1] * 10]\\n\\n else:\\n\\n spelled_triade = '-'.join((numerals_dictionary[triade[1] * 10], numerals_dictionary[triade[2]]))\\n\\n if triade[0] in range(1, 10):\\n\\n hundreds = ' '.join((numerals_dictionary[triade[0]], 'hundred'))\\n\\n if spelled_triade != 'zero':\\n\\n spelled_triade = ' and '.join((hundreds, spelled_triade))\\n\\n else:\\n\\n spelled_triade = hundreds\\n\\n return spelled_triade\",\n \"def generate_fantasy_title():\\n d20 = random.randint(1, 20)\\n if d20 <= 4:\\n #genetive noun\\n return fantasy_genetive[random.randint(0, len(fantasy_genetive) - 1)] + \\\" \\\" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\\n elif d20 > 4 and d20 < 13: \\n #The adj noun\\n return \\\"The \\\" + fantasy_adj[random.randint(0, len(fantasy_adj) - 1)] + \\\" \\\" + fantasy_noun[random.randint(0, len(fantasy_noun) - 1)]\\n elif d20 >= 13:\\n #something of something\\n return fantasy_noun[random.randint(0, len(fantasy_noun) - 1)] + \\\" of \\\" + fantasy_what_is_this[random.randint(0, len(fantasy_what_is_this) - 1)]\",\n \"def _precook(s, n=4, out=False):\\n if isinstance(s,str):\\n words = s.split()\\n # print(words)\\n elif isinstance(s,list) or isinstance(s,tuple):\\n words = s\\n else:\\n raise NotImplementedError(type(s))\\n counts = defaultdict(int)\\n for k in range(1, n + 1):\\n for i in range(len(words) - k + 1):\\n ngram = tuple(words[i:i + k])\\n counts[ngram] += 1\\n return (len(words), counts)\",\n \"def get_stopwords(choice = 0):\\n low_acc_words = [u'orange', u'game', u'wafe', u'gold', u'gas pump', u'dock', u'magnetic disk', u'beard', u'splash', u'stethoscope', u'clock', u'modem', u'spring', u'dribble', u'scale', u'thing', u'parachute', u'screw', u'haired', u'hair spray', u'stick', u'projectile', u'surface', u'scarf', u'boat', u'lantern', u'weapon', u'fire screen', u'maypole', u'Old World buffalo', u'backpack', u'velvet', u'pistol', u'duplicator', u'tissue', u'holding', u'eel', u'iron', u'zoo', u'toilet seat', u'eye', u'telephone', u'drum', u'pepper', u'church', u'pillow', u'body', u'mink', u'prison', u'color', u'jewelry', u'elephant', u'mug', u'cargo ship', u'football', u'llama', u'wombat', u'ax', u'giant panda', u'bison', u'climber', u'tractor', u'hamster', u'beetle', u'sidewalk', u'oilseed', u'shore', u'feet', u'vending machine', u'nail', u'lock', u'licking', u'crowded', u'pudding', u'library', u'sliding', u'steel drum', u'cutter', u'trench coat', u'plate rack', u'fancy', u'barbershop', u'switch', u'hip', u'petting', u'keyboard', u'drilling platform', u'denim', u'old', u'sewing machine', u'dancing', u'lawn mower', u'jaguar', u'cauliflower', u'bubble', u'tray', u'printer', u'hillside', u'heater', u'store', u'stove', u'hook', u'bed', u'book jacket', u'rain barrel', u'dinosaur', u'rowing', u'surf', u'worm', u'garbage truck', u'laptop', u'mouth', u'flute', u'tape player', u'gym', u'large', u'birdhouse', u'covered', u'groom', u'swan', u'lampshade', u'snowplow', u'ramp', u'bathing cap', u'strainer', u'hard', u'mortarboard', u'penguin', u'wooden spoon', u'loaf of bread', u'window', u\\\"potter's wheel\\\", u'branch', u'fly', u'greyhound', u'walk', u'starfish', u'kitchen', u'parking meter', u'cassette', u'work', u'cash machine', u'custard apple', u'play', u'ice cream', u'mosque', u'market', u'swing', u'hay', u'fan', u'surfer', u'number', u'climb', u'golfcart', u'burrito', u'feather boa', u'resting', u'neck brace', u'glove', u'remote control', u'lotion', u'lamp', u'perched', u'jeep', u'necklace', u'shopping basket', u'sea urchin', u'pajama', u'pinwheel', u'foot', u'maze', u'squash', u'dishrag', u'bib', u'ant', u'dumbbell', u'dragonfly', u'bakery', u'lighter', u'salamander', u'sandglass', u'apron', u'cannon', u'palm', u'tent', u'spacecraft', u'oil filter', u'beer bottle', u'throne', u'stretcher', u'bedroom', u'pan', u'camera', u'kiddie', u'mashed potato', u'railing', u'tongue', u'sky', u'event', u'bright', u'curb', u'sundial', u'screwdriver', u'hand blower', u'joystick', u'flower', u'tv', u'back', u'smile', u'mortar', u'bee', u'bath', u'spatula', u'lawn', u'object', u'barrier', u'mailbox', u'fallen', u'crayfish', u'kid', u'metal', u'shot', u'quill', u'snowboarding', u'mud', u'vacuum', u'water tower', u'sleeping bag', u'altar', u'bassoon', u'family', u'shovel', u'leather', u'maillot', u'soap dispenser', u'blurry', u'racetrack', u'dish', u'gondola', u'chewing', u'badger', u'spindle', u'door', u'shaker', u'purse', u'apiary', u'bus', u'wreck', u'cell', u'balance beam', u'lip', u'animal', u'baby', u'toilet', u'armor plate', u'jigsaw puzzle', u'piggy bank', u'leafhopper', u'torch', u'ashcan', u'talking', u'traveling', u'handrail', u'area', u'raft', u'can opener', u'missile', u'syringe', u'pen', u'beacon', u'croquet ball', u'trail', u'snowboard', u'light', u'owl', u'lift', u'acorn', u'pencil box', u'hermit crab', u'binder', u'ladle', u'fire engine', u'tan', u'volcano', u'chocolate sauce', u'crossword puzzle', u'whistle', u'floating', u'forklift', u'hotdog', u'monotreme', u'eggnog', u'traffic', u'envelope', u'surfboard', u'face', u'polecat', u'tiled', u'camel', u'refrigerator', u'carousel', u'parking', u'spider web', u'stream', u'train', u'square', u'candle', u'thimble', u'jellyfish', u'teddy', u'leash', u'wild', u'shopping cart', u'jackfruit', u'office', u'alligator', u'ready', u'end', u'power drill', u'lens cap', u'looking', u'hand', u'fountain', u'radiator', u'French horn', u'graze', u'female', u'koala', u'paper towel', u'artichoke', u'passenger', u'airship', u'cow', u'slug', u'home', u'tug', u'weasel', u'including', u'crutch', u'submarine', u'chime', u'pretty', u'phone', u'barrow', u'purple', u'pulling', u'wing', u'mongoose', u'washer', u'slide', u'Band Aid', u'splashing', u'obstacle', u'flying', u'restaurant', u'pencil sharpener', u'control', u'something', u'tricycle', u'motor', u'watching', u'grey', u'balcony', u'surrounded', u'statue', u'rotisserie', u'puck', u'assorted', u'umbrella', u'measuring cup', u'hanging', u'ride', u'scuba', u'perform', u'tusker', u'desk', u'puddle', u'sea slug', u'team', u'beaker', u'held', u'safe', u'shower curtain', u'isopod', u'tire', u'beaver', u'tower', u'stump', u'dinner', u'conch', u'playground', u'marmot', u'fruit', u'golf ball', u'read', u'tile', u'watch', u'mosquito net', u'goggle', u'swab', u'cricket', u'wheelie', u'guacamole', u'bush', u'cockroach', u'intersection', u'letter opener', u'station', u'plow', u'course', u'aeroplane', u'view', u'racing', u'broom', u'sunny', u'corn', u'matchstick', u'variety', u'messy', u'playpen', u'ambulance', u'perfume', u'brush', u'go', u'shelf', u'look', u'blowing', u'lobster', u'lettuce', u'busy', u'digging', u'trampoline', u'track', u'glass', u'ox', u'handstand', u'assortment', u'vase', u'aircraft carrier', u'microwave', u'high', u'mousetrap', u'bathroom', u'shower cap', u'counter', u'Christmas stocking', u'safety pin', u'plastic', u'garden', u'transit', u'knife', u'docked', u'cluttered', u'serving', u'toddler', u'ledge', u'formation', u'snorkel', u'lying', u'lemon', u'ladybug', u'carry', u'solar dish', u'hammer', u'sleeping', u'saltshaker', u'cowboy', u'unicycle', u'single', u'rule', u'shoji', u'business', u'cup', u'antique', u'catch', u'open', u'carnival', u'cooking', u'rural', u'small', u'wine', u'top', u'flat', u'yurt', u'grasshopper', u'hoop', u'wallet', u'hold', u'someone', u'necked', u'salad', u'leafe', u'paddlewheel', u'porcupine', u'radio telescope', u'preparing', u'canopy', u'pointing', u'honeycomb', u'older', u'hair slide', u'plunger', u'mirror', u'landscape', u'bow', u'cart', u'skateboard', u'device', u'urban', u'sunset', u'attached', u'toward', u'right', u'town', u'four', u'beach wagon', u'close', u'lone', u'chew', u'pile', u'working', u'bottlecap', u'corner', u'swinging', u'behind', u'slot machine', u'food', u'mushroom', u'around', u'tall', u'oxygen mask', u'together', u'veggy', u'skating', u'concrete', u'subway', u'seen', u'head', u'armadillo', u'ly', u'kitten', u'cap', u'painted', u'mustache', u'moving', u'lit', u'sliced', u'sticking', u'milk can', u'roller', u'stainless', u'teeth', u'seated', u'serve', u'lady', u'carriage', u'stand', u'apple', u'paper', u'apartment', u'video', u'eating', u'stadium', u'turn', u'racket', u'stunt', u'plate', u'drinking', u'slice', u'warplane', u'cheese', u'onion', u'backyard', u'coffee', u'peach', u'staring', u'outfit', u'engine', u'coaster', u'striped', u'stacked', u'decorated', u'throwing', u'dirty', u'hula', u'mid', u'catching', u'closed', u'item', u'otter', u'rail', u'tenni', u'sink', u'toaster', u'meal', u'skate', u'fridge', u'pitch', u'kite', u'desktop', u'meat', u'military', u'fireplace', u'show', u'rider', u'rodeo', u'graffiti', u'bunch', u'coming', u'reading', u'walkway', u'another', u'mouse', u'soup', u'hole', u'steel', u'container', u'past', u'carrying', u'equipment', u'farm', u'dressed', u'scooter', u'cellphone', u'stuffed', u'commercial', u'platform', u'full', u'one', u'electronic', u'sprinkler', u'stop', u'along', u'blanket', u'residential', u'kneeling', u'blender', u'oven', u'cattle', u'skateboarder', u'produce', u'book', u'cement', u'bag', u'carrot', u'board', u'round', u'many', u'giant', u'shower', u'asian', u'picnic', u'dining', u'wedding', u'desert', u'huge', u'narrow', u'outside', u'deck', u'three', u'display', u'filled', u'cutting', u'colored', u'ear', u'feeding', u'across', u'eat', u'skateboarding', u'fighter', u'sun', u'darkened', u'brushing', u'ty', u'party', u'pedestrian', u'wet', u'structure', u'different', u'crossbone', u'jet', u'public', u'cooked', u'airplane', u'bread', u'clothe', u'tunnel', u'fishing', u'drife', u'gear', u'birthday', u'frisbee', u'piece', u'row', u'hydrant', u'drawn', u'meter', u'vegetable', u'broccoli', u'country', u'half', u'sandwich', u'doorway', u'lot', u'pair', u'luggage', u'long', u'christma', u'wii', u'guy', u'side', u'leap', u'plane', u'silver', u'post', u'bar', u'reaching', u'drink', u'reflection', u'wand', u'airport', u'photograph', u'type', u'lay', u'lap', u'waterfall', u'banana', u'next', u'baseball', u'hot', u'making', u'gray', u'using', u'batter', u'empty', u'bat', u'clear', u'hospital', u'scissor', u'neck', u'cake', u'alone', u'rope', u'winter', u'runway', u'broken', u'fire', u'getting', u'variou', u'distance', u'beer', u'outstretched', u'chocolate', u'match', u'stopped', u'vintage', u'clean', u'fork', u'cut', u'eaten', u'waiting', u'going', u'onto', u'nintendo', u'time', u'several', u'lined', u'railroad', u'case', u'mother', u'suitcase', u'taking', u'doughnut', u'smoke', u'controller', u'crossing', u'friend', u'closeup', u'couple', u'showing', u'made', u'big', u'trying', u'putting', u'hit', u'male', u'', u'pickelhaube', u'suburban', u'costume', u'enjoy', u'new', u'studio', u'mantis', u'pastum', u'gymnast', u'rafting', u'golden', u'waffle iron', u'watering', u'overhead', u'shoot', u'feature', u'machine', u'attempt', u'third', u'tulip', u'jungle', u'wind', u'fig', u'band', u'bone', u'free', u'cucumber', u'bouncing', u'boarding', u'tackled', u'__background__', u'gymnastic apparatus', u'pineapple', u'folded', u'rice', u'sunglasses', u'cushion', u'net', u'covering', u'pretzel', u'steam', u'santum', u'fair', u'sail', u'score', u'toothbrush', u'loaded', u'fry', u'life', u'glider', u'bounce', u'balance', u'cone', u'containing', u'beside', u'wheel', u'rain', u'spaghetti squash', u'thi', u'left', u'photographer', u'forested', u'vanity', u'shoulder', u'pavement', u'officer', u'creek', u'dead', u'ice', u'slide rule', u'dunking', u'horizon', u'raised', u'fabric', u'fight', u'way', u'war', u'landing', u'umpire', u'fashioned', u'dimly', u'topped', u'setting', u'sling', u'potato', u'painting', u'bottom', u'dance', u'crocodile', u'string', u'dig', u'gun', u'chicken', u'tarmac', u'falling', u'french', u'wait', u'pony', u'decker', u'plaza', u'earphone', u'chip', u'get', u'staircase', u'wakeboarder', u'wheelchair', u'pulled', u'polouse', u'still', u'curly', u'scaling', u'lunch', u'base', u'pizza', u'meat loaf', u'shown', u'opened', u'space', u'mess', u'headband', u'place', u'pelican', u'ring', u'sheet', u'bite', u'frame', u'hug', u'wide', u'lick', u'pastry', u'breakfast', u'take', u'topping', u'multiple', u'knee', u'tackling', u'sale', u'professional', u'german', u'crane', u'snack', u'stair', u'ping-pong ball', u'snowsuit', u'sport', u'bicyclist', u'skyscraper', u'checkered', u'restroom', u'tour', u'nearby', u'foggy', u'bmx', u'newspaper', u'mound', u'foam', u'driven', u'mohawk', u'rest', u'instrument', u'chainsaw', u'towel', u'facing', u'audience', u'served', u'clau', u'go-kart', u'tube', u'throw', u'muddy', u'harness', u'strip', u'racquet', u'prepare', u'low', u'pitcher', u'cardoon', u'gymnasium', u'pull', u'arranged', u'strawberry', u'deep', u'cream', u'rubber', u'trash', u'midair', u'peak', u'remote', u'disc', u'follow', u'potpie', u'enjoying', u'stool', u'leaping', u'action', u'taken', u'chopstick', u'flag', u'mounted', u'grill', u'wrestler', u'marble', u'backpacking', u'breaking', u'fungus', u'shade', u'egg', u'muzzled', u'style', u'carpeted', u'sauce', u'snowball', u'abacus', u'foreground', u'circuit', u'leading', u'airborne', u'hotel', u'leotard', u'kind', u'double', u'scabbard', u'bride', u'stall', u'blond', u'cave', u'electric', u'cigarette', u'sponsored', u'shepherd', u'dandelion', u'catcher', u'movie', u'recently', u'floaty', u'chambered nautilus', u'hitting', u'racer', u'passing', u'leaning', u'kissing', u'chase', u'funny', u'used', u'snail', u'pomegranate', u'stack', u'center', u'grind', u'bin', u'formal', u'shaped', u'signal', u'zucchini', u'parade', u'limb', u'laughing', u'step', u'range', u'slouse', u'block', u'downhill', u'jockey', u'retrieving', u'atop', u'cloth', u'skull', u'diving', u'rainy', u'tarp', u'black-footed ferret', u'nice', u'prepared', u'hot pot', u'land', u'fresh', u'hello', u'wrestle', u'kitty', u'spoon', u'rack', u'smaller', u'hose', u'giving', u'attire', u'leaving', u'chiton', u'singing', u'frog', u'crab', u'porch', u'saddle', u'donut', u'crossed', u'tied', u'tomato', u'chasing', u'scenic', u'beneath', u'boarder', u'hippopotamus', u'wading', u'sea_anemone', u'wrapped', u'shallow', u'steep', u'bagel', u'gather', u'pipe', u'hi', u'ha', u'jar', u'bug', u'finger', u'handle', u'beam', u'bean', u'whilst', u'contain', u'shake', u'attempting', u'merry', u'yawning', u'sniff', u'swimmer', u'commuter', u'bull', u'smoking', u'plain', u'cross', u'member', u'binoculars', u'underneath', u'well', u'fighting', u'bandanna', u'rocket', u'pay-phone', u'five', u'puppy', u'like', u'campfire', u'shaking', u'construction', u'bun', u'partially', u'flip', u'placed', u'bearing', u'pinatum', u'pie', u'boardwalk', u'pit', u'star', u'baked']\\n\\n STOPWORDS = ['none','inside', 'near', 'one', 'two', 'three', 'day', 'front', u'i', u'me', u'my', u'myself', u'we', u'our', u'ours', u'ourselves', u'you', u'your', u'yours', u'yourself', u'yourselves', u'he', u'him', u'his', u'himself', u'she', u'her', u'hers', u'herself', u'it', u'its', u'itself', u'they', u'them', u'their', u'theirs', u'themselves', u'what', u'which', u'who', u'whom', u'this', u'that', u'these', u'those', u'am', u'is', u'are', u'was', u'were', u'be', u'been', u'being', u'have', u'has', u'had', u'having', u'do', u'does', u'did', u'doing', u'a', u'an', u'the', u'and', u'but', u'if', u'or', u'because', u'as', u'until', u'while', u'of', u'at', u'by', u'for', u'with', u'about', u'against', u'between', u'into', u'through', u'during', u'before', u'after', u'above', u'below', u'to', u'from', u'up', u'down', u'in', u'out', u'on', u'off', u'over', u'under', u'again', u'further', u'then', u'once', u'here', u'there', u'when', u'where', u'why', u'how', u'all', u'any', u'both', u'each', u'few', u'more', u'most', u'other', u'some', u'such', u'no', u'nor', u'not', u'only', u'own', u'same', u'so', u'than', u'too', u'very', u's', u't', u'can', u'will', u'just', u'don', u'should', u'now', 'background', '__background__', '']\\n \\n\\n unselected_words = [u'', u'pickelhaube', u'enjoy', u'new', u'studio', u'kissing', u'mantis', u'pastum', u'rafting', u'golden', u'waffle iron', u'watering', u'overhead', u'shoot', u'feature', u'machine', u'pizza', u'attempt', u'third', u'tulip', u'jungle', u'wind', u'fig', u'band', u'bone', u'free', u'bouncing', u'boarding', u'tackled', u'__background__', u'gymnasium', u'gymnastic apparatus', u'pineapple', u'folded', u'rice', u'sunglasses', u'cushion', u'net', u'covering', u'pretzel', u'steam', u'santum', u'fair', u'sail', u'score', u'toothbrush', u'loaded', u'fry', u'life', u'glider', u'balance', u'cone', u'containing', u'beside', u'wheel', u'rain', u'spaghetti squash', u'thi', u'left', u'photographer', u'forested', u'vanity', u'shoulder', u'pavement', u'officer', u'creek', u'dead', u'slide rule', u'dunking', u'horizon', u'raised', u'fabric', u'fight', u'way', u'war', u'landing', u'umpire', u'fashioned', u'dimly', u'topped', u'setting', u'sling', u'potato', u'bottom', u'dance', u'crocodile', u'ice', u'string', u'dig', u'gun', u'tarmac', u'falling', u'french', u'wait', u'decker', u'earphone', u'chip', u'get', u'staircase', u'wakeboarder', u'wheelchair', u'pulled', u'polouse', u'still', u'curly', u'scaling', u'lunch', u'meat loaf', u'shown', u'opened', u'space', u'mess', u'headband', u'place', u'pelican', u'ring', u'sheet', u'bite', u'hug', u'wide', u'lick', u'pastry', u'breakfast', u'take', u'topping', u'multiple', u'knee', u'bicyclist', u'sale', u'professional', u'german', u'snack', u'stair', u'ping-pong ball', u'snowsuit', u'sport', u'tackling', u'skyscraper', u'checkered', u'restroom', u'tour', u'nearby', u'foggy', u'bmx', u'newspaper', u'mound', u'chopstick', u'foam', u'driven', u'passing', u'mohawk', u'rest', u'instrument', u'chainsaw', u'towel', u'facing', u'audience', u'laughing', u'served', u'clau', u'diving', u'go-kart', u'tube', u'throw', u'harness', u'strip', u'racquet', u'prepare', u'low', u'pitcher', u'cardoon', u'pull', u'arranged', u'strawberry', u'deep', u'cream', u'rubber', u'trash', u'midair', u'peak', u'remote', u'suburban', u'disc', u'follow', u'potpie', u'gymnast', u'enjoying', u'stool', u'leaping', u'action', u'taken', u'flag', u'mounted', u'grill', u'wrestler', u'marble', u'pony', u'backpacking', u'breaking', u'fungus', u'shade', u'egg', u'style', u'carpeted', u'sauce', u'snowball', u'abacus', u'foreground', u'base', u'circuit', u'leading', u'airborne', u'hotel', u'leotard', u'kind', u'double', u'scabbard', u'bride', u'stall', u'blond', u'cave', u'zucchini', u'electric', u'cigarette', u'sponsored', u'shepherd', u'dandelion', u'catcher', u'movie', u'recently', u'floaty', u'chambered nautilus', u'hitting', u'racer', u'leaning', u'chase', u'funny', u'used', u'snail', u'pomegranate', u'cucumber', u'stack', u'center', u'grind', u'bin', u'formal', u'shaped', u'signal', u'parade', u'bounce', u'step', u'plaza', u'range', u'slouse', u'block', u'downhill', u'jockey', u'retrieving', u'atop', u'cloth', u'crane', u'skull', u'rainy', u'tarp', u'black-footed ferret', u'nice', u'prepared', u'hot pot', u'land', u'fresh', u'hello', u'wrestle', u'kitty', u'spoon', u'muzzled', u'rack', u'smaller', u'hose', u'giving', u'attire', u'leaving', u'chiton', u'limb', u'singing', u'frog', u'crab', u'porch', u'donut', u'crossed', u'tied', u'tomato', u'chasing', u'scenic', u'beneath', u'shaking', u'boarder', u'hippopotamus', u'wading', u'sea_anemone', u'wrapped', u'shallow', u'steep', u'bagel', u'gather', u'pipe', u'construction', u'painting', u'chicken', u'jar', u'bug', u'finger', u'handle', u'beam', u'bean', u'whilst', u'contain', u'costume', u'frame', u'shake', u'attempting', u'merry', u'yawning', u'sniff', u'swimmer', u'muddy', u'commuter', u'bull', u'smoking', u'plain', u'cross', u'member', u'binoculars', u'underneath', u'well', u'fighting', u'bandanna', u'rocket', u'pay-phone', u'five', u'puppy', u'like', u'campfire', u'saddle', u'hi', u'bun', u'ha', u'partially', u'flip', u'placed', u'bearing', u'pinatum', u'pie', u'boardwalk', u'pit', u'star', u'baked', u'smoke', u'hospital', u'type', u'hole', u'wand', u'chocolate sauce', u'haired', u'onto', u'drawn', u'wear', u'loaf of bread', u'beer', u'mushroom', u'lift', u'make', u'mother', u'cowboy', u'fork', u'otter', u'playpen', u'alone', u'hamburger', u'bottlecap', u'soup', u'cutter', u'square', u'friend', u'scuba', u'hockey', u'wheelie', u'picnic', u'tug', u'squash', u'case', u'inflatable', u'railroad', u'competition', u'slice', u'broken', u'jeep', u'trying', u'apartment', u'chewing', u'grasshopper', u'guacamole', u'splash', u'male', u'dishrag', u'kayaking', u'acorn', u'snowbank', u'clean', u'hit', u'batter', u'kick', u'jewelry', u'fighter', u'cooked', u'putting', u'try', u'wallet', u'mustache', u'artichoke', u'spaghetti sauce', u'crossing', u'retriever', u'veggy', u'produce', u'darkened', u'kiddie', u'mashed potato', u'closed', u'canopy', u'runway', u'vintage', u'fishing', u'doughnut', u'onion', u'leap', u'rodeo', u'cricket', u'made', u'closeup', u'chew', u'sliced', u'hot', u'deck', u'French horn', u'clothe', u'goggle', u'rowing', u'milk can', u'post', u'outstretched', u'chocolate', u'making', u'course', u'hula', u'carry', u'upside', u'desktop', u'lobster', u'suitcase', u'crossbone', u'ty', u'sea slug', u'polecat', u'sandwich', u'racetrack', u'lettuce', u'cockroach', u'toward', u'eaten', u'blender', u'giant', u'atv', u'big', u'holster', u'splashing', u'commercial', u'tunnel', u'bend', u'meter', u'including', u'badger', u'beach wagon', u'beard', u'beak', u'controller', u'match', u'buckle', u'hiker', u'barometer', u'bread', u'serve', u'object', u'stadium', u'tank', u'waterfall', u'stream', u'neck', u'serving', u'manhole cover', u'pitch', u'pistol', u'dribble', u'isopod', u'transit', u'dragonfly', u'huge', u'backyard', u'foot', u'jet', u'dancing', u'custard apple', u'porcupine', u'assorted', u'rope', u'cut', u'showing', u'lemon', u'armadillo', u'salad', u'carrot', u'biting', u'bee', u'hammer', u'lens cap', u'cauliflower', u'kicking', u'denim', u'marmot', u'nintendo', u'fireplace', u'landscape', u'turn', u'hoop', u'wedding', u'eggnog', u'antique', u'bow', u'winter', u'stacked', u'purse', u'beaver', u'kneeling', u'island', u'slot machine', u'Christmas stocking', u'public', u'narrow', u'ladybug', u'stopped', u'burrito', u'necked', u'cheese', u'crayfish', u'single', u'getting', u'tan', u'lined', u'handstand', u'letter opener', u'pencil box', u'doorway', u'leafhopper', u'residential', u'slug', u'eat', u'carriage', u'end', u'lap', u'distance', u'mink', u'sleeping bag', u'time', u'container', u'stunt', u'drife', u'broccoli', u'docked', u'structure', u'cooker', u'go', u'aircraft carrier', u'pudding', u'tape player', u'outfit', u'coaster', u'reaching', u'meat', u'splashed', u'hair slide', u'roller', u'submarine', u'toaster', u'dining', u'rotisserie', u'football', u'spindle', u'christma', u'thimble', u'giant panda', u'pedestrian', u'compass', u'squirrel', u'sea urchin', u'hotdog', u'peach', u'warplane', u'oil filter', u'waiting', u'hip', u'jaguar', u'mortar', u'gear', u'sprinkler', u'beer bottle', u'gondola', u'half', u'stainless', u'military', u'electronic', u'bat', u'handrail', u'perform', u'coffee maker', u'flat', u'round', u'meal', u'telephone', u'pool table', u'seagull', u'hermit crab', u'fancy', u'obstacle', u'honeycomb', u'gravel', u'ladle', u'farm', u'crossword puzzle', u'steel', u'drink', u'pepper', u'tongue', u'owl', u'rule', u'gym', u'seated', u'monotreme', u'cattle', u'water tower', u'vegetable', u'eel', u'variou', u'messy', u'raft', u'castle', u'fire', u'bib', u'skunk', u'gray', u\\\"carpenter's kit\\\", u'wombat', u'carnival', u'equipment', u'mousetrap', u'joystick', u'golf ball', u'shoji', u'banana', u'clear', u'sloth', u'glove', u'reel', u'desert', u'necklace', u'ear', u'digging', u'rural', u'asian', u'school', u'wreck', u'coffee', u'hydrant', u'mouse', u'mid', u'row', u'puddle', u'engine', u'mongoose', u'stopwatch', u'walkway', u'past', u'beacon', u'koala', u'lip', u'gold', u'scooter', u'puck', u\\\"potter's wheel\\\", u'ly', u'oilseed', u'tire', u'drum', u'party', u'radio telescope', u'worm', u'lay', u'magnetic disk', u'bar', u'butterfly', u'dinner', u'birthday', u'power drill', u'saltshaker', u'thing', u'ant', u'lantern', u'hard', u'weasel', u'ridden', u'paddlewheel', u'drilling platform', u'climber', u'safe', u'shower', u'airship', u'cassette player', u'printer', u'wooden spoon', u'bassoon', u'reflection', u'scissor', u'apiary', u'ice cream', u'rider', u'boathouse', u'mud', u'corn', u'guinea pig', u'snow leopard', u'mailbox', u'cement', u'bakery', u'taking', u'variety', u'swan', u'velvet', u'couple', u'fridge', u'strainer', u'dirty', u'screwdriver', u'jigsaw puzzle', u'device', u'alligator', u'oven', u'silver', u'urban', u'country', u'opener', u'leather', u'barrel', u'duck', u'drumstick', u'cake', u'ambulance', u'pencil sharpener', u'barrier', u'safety pin', u'right', u'baseball', u'beetle', u'ax', u'cassette', u'assortment', u'entree', u'armor plate', u'going', u'cart', u'can opener', u'curve', u'pointing', u'dribbling', u'sock', u'home', u'catching', u'church', u'mosque', u'measuring cup', u'striped', u'throne', u'skating', u'sundial', u'CD player', u'grille', u'brushing', u'jersey', u'plunger', u'conch', u'several', u'shaker', u'tile', u'stretcher', u'tower', u'plane', u'salamander', u'lock', u'platform', u'airport', u'hamster', u'graffiti', u'jackfruit', u'cabbage', u'blowing', u'kitten', u'yurt', u'cannon', u'powder', u'sea cucumber', u'sea cow', u'dinosaur', u'racing', u'primate', u'wii', u'skateboarding', u'blanket', u'mug', u'cap', u'challenging', u'throwing', u'library', u'quill', u'trench coat', u'microwave', u'tusker', u'cluttered', u'apple', u'duplicator', u'broom', u'wet', u'altar', u'show', u'heater', u'radiator', u'cargo ship', u'spatula', u'screw', u'neck brace', u'flute', u'peacock', u'sewing machine', u'reading', u'dough', u'rifle', u'long', u'penguin', u'playground', u'photograph', u'luggage', u'plow', u'item', u'factory', u'starfish', u'fire engine', u'locomotive', u'piggy bank', u'empty', u'scale', u'plate rack', u'graze', u'cutting', u'feeding', u'cooking', u'rapid', u'ledge', u'business', u'colored', u'forklift', u'boot', u'wing', u'remote control', u'trampoline', u'gas pump', u'space bar', u'snorkel', u'book', u'microscope', u'rain barrel', u'pair', u'Old World buffalo', u'airplane', u'creature', u'knee pad', u'whale', u'birdhouse', u'oxygen mask', u'bag', u'sailboat', u'mat', u'town', u'using', u'rugby ball', u'staring', u'shopping basket', u'binder', u'team', u'sailing vessel', u'ox', u'leopard', u'shield', u'full', u'Band Aid', u'mountaintop', u'crate', u'modem', u'family', u'tennis ball', u'barn', u'work', u'formation', u'barrow', u'goose', u'syringe', u'soap dispenser', u'kite', u'appliance', u'solar dish', u'lizard', u'paddling', u'cardigan', u'sink', u'control', u'toddler', u'mortarboard']\\n\\n useless_words = ['holding','hold' ,'wearing', 'wear' , 'standing','sitting', 'stand', 'sit' , 'smiling', 'smile', 'clothing', 'shirt', \\\"next\\\", 'posing', 'playing']\\n abstract_words = ['beautiful', 'young']\\n color_words = ['black', 'white', 'red', 'blue', 'brown']\\n\\n if choice == 1:\\n return STOPWORDS\\n\\n STOPWORDS += unselected_words\\n STOPWORDS += useless_words\\n STOPWORDS += low_acc_words\\n #STOPWORDS += color_words\\n #STOPWORDS += abstract_words\\n return STOPWORDS\",\n \"def how_many(number):\\n if int(number) == 1:\\n return \\\"guess\\\"\\n return \\\"guesses\\\"\",\n \"def give_names(x): \\n if x == 0:\\n return 'Lost'\\n else:\\n return 'Won/Broke Even'\",\n \"def generate_romance_title():\\n d69 = random.randint(1, 69)\\n if d69 <= 35:\\n #the adj noun\\n return \\\"The \\\" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \\\" \\\" + romance_noun[random.randint(0, len(romance_noun) - 1)]\\n elif d69 > 35:\\n #noun of the adj noun\\n return romance_noun[random.randint(0, len(romance_noun) - 1)] + \\\" of the \\\" + romance_adj[random.randint(0, len(romance_adj) - 1)] + \\\" \\\" + romance_noun[random.randint(0, len(romance_noun) - 1)]\",\n \"def stickers_for(phrase):\\n\\n stic_dict = {}\\n for ltr in 'instagram':\\n if ltr not in stic_dict:\\n stic_dict[ltr] = 1\\n else:\\n stic_dict[ltr] += 1\\n print(ltr)\\n\\n phr_dict = {}\\n for ltr in phrase:\\n if ltr not in phr_dict:\\n phr_dict[ltr] = 1\\n else:\\n phr_dict[ltr] += 1\\n print(ltr)\\n\\n ratios = []\\n for ltr in stic_dict:\\n if ltr in phr_dict:\\n ratio = phr_dict[ltr] / stic_dict[ltr]\\n ratios.append(ratio)\\n\\n if len(ratios) > 0:\\n num_sticks = max(ratios)\\n num_sticks = int(round(num_sticks, 0))\\n return stic_dict, phr_dict, ratios, num_sticks\\n\\n else: \\n return 0\",\n \"def get_number_of_soil_levels(description):\\n if description == \\\"none\\\":\\n return \\\"0\\\"\\n else:\\n return \\\"5\\\"\",\n \"def precook(s, n=4, out=False):\\n words = s.split()\\n counts = defaultdict(int)\\n for k in xrange(1,n+1):\\n for i in xrange(len(words)-k+1):\\n ngram = tuple(words[i:i+k])\\n counts[ngram] += 1\\n return counts\",\n \"def lab10_q1():\\n return \\\"\\\"\\\"\\n Since there has to be at least two, len(self.fruits) >=2 and at least one cup, self.cups (number == True)\\n\\tDecrease cups by 1 because we use one to create mixed juice.\\n\\tfirst pop gives the 0 index fruit, second pop gives the next 0 index which is originally at 1 index.\\n\\t\\n\\tlen(item) to show number of letters then -1 because of hyphen.\\n \\\"\\\"\\\"\",\n \"def s_words(words):\\n\\t\\n\\treturn words // 100 / 10\",\n \"def make_chains(text_string):\\n\\n chains = {}\\n n = 2\\n # n = int(raw_input(\\\"Enter the number of ngrams you want? >\\\"))\\n # your code goes here\\n words = text_string.split()\\n for i in range(len(words) - 1):\\n ngram = tuple(words[i: i + n])\\n if i >= len(words) - n:\\n chains[ngram] = None\\n else:\\n nth_word = words[i + n]\\n if ngram not in chains:\\n chains[ngram] = [nth_word]\\n else:\\n chains[ngram].append(nth_word)\\n return (chains, n)\",\n \"def wcount(lines, topn):\\n word = ''\\n for i in lines:\\n if 65<=ord(i) and ord(i)<=90:\\n word = word + i \\n elif 97<=ord(i) and ord(i)<=122:\\n word = word + i\\n else:\\n word = word + ' ' \\n word = word.split()\\n #提取不重复的单词\\n alreadyknown = []\\n for m in word:\\n if m not in alreadyknown:\\n alreadyknown.append(m)\\n #分别数数，排序，建构字典\\n empty = []\\n final = {}\\n final2 = {}\\n for j in alreadyknown:\\n number = icount(word,j)\\n final[j]=number\\n final2[str(number)]=j\\n empty.append(number)\\n empty.sort()\\n empty.reverse()\\n last_step = empty[:10]\\n #通过数字找到对应word\\n last_str = ''\\n for y in last_step:\\n z = final2[str(y)]\\n last_str += z + \\\"\\\\t\\\" + str(y) + \\\"\\\\n\\\"\\n return last_str\",\n \"def spell(number):\\n if number > 1000:\\n raise # This doesn't handle numbers greater than 1000\\n\\n if number == 1000:\\n return ['one', 'thousand']\\n\\n if number >= 100:\\n if number % 100 == 0:\\n return spell(number // 100) + ['hundred']\\n else:\\n return spell(number // 100 * 100) + ['and'] + spell(number % 100)\\n\\n if number >= 20:\\n names = {\\n 20: 'twenty',\\n 30: 'thirty',\\n 40: 'forty',\\n 50: 'fifty',\\n 60: 'sixty',\\n 70: 'seventy',\\n 80: 'eighty',\\n 90: 'ninety',\\n }\\n if number % 10 == 0:\\n return [names[number]]\\n else:\\n return spell(number // 10 * 10) + spell(number % 10)\\n\\n names = [\\n 'zero', 'one', 'two', 'three', 'four',\\n 'five', 'six', 'seven', 'eight', 'nine',\\n 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen',\\n 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen',\\n ]\\n return [names[number]]\",\n \"def leerUltrasonido() -> int:\\n pass\",\n \"def celex_pron_loc(language, lemma):\\n pron = 5\\n if language == \\\"german\\\" or language== \\\"dutch\\\": pron = pron -2 #german one less\\n if lemma == \\\"wordform\\\": pron += 1\\n return pron\",\n \"def ordinal(n):\\n if 11 <= n <= 19:\\n return str(n) + \\\"th\\\"\\n s = str(n)\\n last = int(s[-1])\\n if 1 <= last <= 3:\\n return s + (\\\"st\\\", \\\"nd\\\", \\\"rd\\\")[last-1]\\n return s + \\\"th\\\"\",\n \"def get_number_of_atmos_levels(description):\\n if description == \\\"none\\\":\\n return \\\"0\\\", \\\"0\\\"\\n elif re.search(\\\"levels\\\", description):\\n match = re.search(\\\"(?P<nl>\\\\d+)\\\\s?(levels|vertical levels)\\\", description)\\n nlevs = match.groupdict()[\\\"nl\\\"]\\n if int(nlevs) > 49: nlas = \\\"20\\\"\\n else: nlas = \\\"10\\\"\\n return nlevs, nlas\\n else:\\n return \\\"40\\\", \\\"20\\\"\",\n \"def pre_flop_strength(hand):\\n highs = {}\\n highs[4] = [\\n \\\"AA\\\", \\\"AKs\\\", \\\"AQs\\\", \\\"AJs\\\", \\\"ATs\\\", \\\"AKo\\\", \\\"KK\\\", \\\"KQs\\\", \\\"KJs\\\", \\\"AQo\\\",\\n \\\"QQ\\\", \\\"QJs\\\", \\\"JJ\\\", \\\"TT\\\"\\n ]\\n highs[3] = [\\n \\\"A5s\\\", \\\"A4s\\\", \\\"A3s\\\", \\\"KTs\\\", \\\"KQo\\\", \\\"QTs\\\", \\\"AJo\\\", \\\"JTs\\\", \\\"T9s\\\", \\\"99\\\",\\n \\\"98s\\\", \\\"88\\\", \\\"87s\\\", \\\"77\\\", \\\"66\\\"\\n ]\\n highs[2] = [\\n \\\"A9s\\\", \\\"A8s\\\", \\\"A7s\\\", \\\"A6s\\\", \\\"A2s\\\", \\\"K9s\\\", \\\"K8s\\\", \\\"Q9s\\\", \\\"KJo\\\", \\\"QJo\\\",\\n \\\"J9s\\\", \\\"ATo\\\", \\\"KTo\\\", \\\"QTo\\\", \\\"JTo\\\", \\\"T8s\\\", \\\"A9o\\\", \\\"J9o\\\", \\\"T9o\\\", \\\"97s\\\",\\n \\\"98o\\\", \\\"86s\\\", \\\"76s\\\", \\\"75s\\\", \\\"65s\\\", \\\"55\\\", \\\"44\\\", \\\"33\\\", \\\"22\\\"\\n ]\\n highs[1] = [\\n \\\"K7s\\\", \\\"K6s\\\", \\\"K5s\\\", \\\"K4s\\\", \\\"K3s\\\", \\\"Q8s\\\", \\\"Q7s\\\", \\\"Q6s\\\", \\\"Q5s\\\", \\\"Q4s\\\",\\n \\\"J8s\\\", \\\"J7s\\\", \\\"J6s\\\", \\\"J5s\\\", \\\"T7s\\\", \\\"T6s\\\", \\\"K9o\\\", \\\"Q9o\\\", \\\"96s\\\", \\\"A8o\\\",\\n \\\"K8o\\\", \\\"Q8o\\\", \\\"J8o\\\", \\\"T8o\\\", \\\"85s\\\", \\\"A7o\\\", \\\"K7o\\\", \\\"Q7o\\\", \\\"T7o\\\", \\\"97o\\\",\\n \\\"87o\\\", \\\"74s\\\", \\\"A6o\\\", \\\"K6o\\\", \\\"86o\\\", \\\"76o\\\", \\\"64s\\\", \\\"63s\\\", \\\"A5o\\\", \\\"75o\\\",\\n \\\"65o\\\", \\\"54s\\\", \\\"53s\\\", \\\"A4o\\\", \\\"43s\\\", \\\"A3o\\\"\\n ]\\n card0, card1 = hand\\n if card0[0] == card1[0]:\\n pair = \\\"\\\".join([card0[0], card1[0]])\\n elif card0[1] == card1[1]:\\n pair = \\\"\\\".join([card0[0], card1[0], \\\"s\\\"])\\n else:\\n pair = \\\"\\\".join([card0[0], card1[0], \\\"o\\\"])\\n for strenght in highs:\\n if pair in highs[strenght]:\\n return strenght\\n return 0\",\n \"def one_v_all(description):\\n label = [0, 0, 0]\\n for raw in description.split(\\\"|\\\")[4:]:\\n line = raw.strip()\\n if \\\"midbrain\\\" in line:\\n label[0] = 1\\n if \\\"forebrain\\\" in line:\\n label[1] = 1\\n if \\\"hindbrain\\\" in line:\\n label[2] = 1\\n return label\",\n \"def lexical_diversity(text):\\n return len(set(text)) / len(text)\",\n \"def base_number(number, count, dict_cardinal_num):\\n special_numeral = [\\\"trăm\\\", \\\"mười\\\", \\\"mươi\\\", \\\"linh\\\", \\\"lăm\\\", \\\"mốt\\\"]\\n list_cardinal_numeral = []\\n # Divide number (abc) and follow place's number\\n a = number // 100 # hundreds\\n b = (number % 100) // 10 # Tens\\n c = number % 10 # Ones\\n # check a\\n if a > 0:\\n list_cardinal_numeral.append(dict_cardinal_num[a])\\n list_cardinal_numeral.append(special_numeral[0])\\n elif a == 0:\\n if count > 1 and (b > 0 or c > 0):\\n list_cardinal_numeral.append(dict_cardinal_num[a])\\n list_cardinal_numeral.append(special_numeral[0])\\n # check b\\n if b == 0:\\n if c > 0:\\n if a > 0 or count > 1:\\n list_cardinal_numeral.append(special_numeral[3])\\n elif b > 0:\\n if b == 1:\\n list_cardinal_numeral.append(special_numeral[1])\\n elif b > 1:\\n list_cardinal_numeral.append(dict_cardinal_num[b])\\n list_cardinal_numeral.append(special_numeral[2])\\n # check c\\n if c == 0:\\n if count == 1 and a == 0 and b == 0:\\n list_cardinal_numeral.append(dict_cardinal_num[c])\\n elif c > 0:\\n if b >= 1 and c == 5:\\n list_cardinal_numeral.append(special_numeral[4])\\n elif b >= 2 and c == 1:\\n list_cardinal_numeral.append(special_numeral[5])\\n else:\\n list_cardinal_numeral.append(dict_cardinal_num[c])\\n\\n return \\\" \\\".join(list_cardinal_numeral)\",\n \"def heads_legs(heads, legs):\\n for i in range(0, heads + 1):\\n cows = heads - i\\n if 4 * cows + 2 * i == legs:\\n chickens = i\\n return chickens, cows\\n return \\\"No solutions.\\\"\",\n \"def desimal_til_bokstav(snitt):\\r\\n if snitt >= 4.5:\\r\\n return 'A'\\r\\n elif 3.5 <= snitt < 4.5:\\r\\n return 'B'\\r\\n elif 2.5 <= snitt < 3.5:\\r\\n return 'C'\\r\\n elif 1.5 <= snitt < 2.5:\\r\\n return 'D'\\r\\n elif 0.5 <= snitt < 1.5:\\r\\n return 'E'\\r\\n else:\\r\\n return 'F'\",\n \"def pentakis(self):\\n return self.nlegomena(5)\",\n \"def gale_shapley(preferences):\\n men = [None for _ in range(len(preferences[0]))]\\n women = men[:]\\n while None in men:\\n m_index = men.index(None)\\n w_index = preferences[0][m_index].pop(0)\\n if women[w_index] is None:\\n men[m_index] = w_index\\n women[w_index] = m_index\\n else:\\n if preferences[1][w_index].index(m_index) < preferences[1][w_index].index(women[w_index]):\\n men[women[w_index]] = None\\n men[m_index] = w_index\\n women[w_index] = m_index\\n return list(enumerate(men))\",\n \"def check1800(s):\\n num_translation = str.maketrans(\\n 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', '22233344455566677778889999')\\n nums_dict = defaultdict(list)\\n for word in WORDS:\\n nums_dict[word.translate(num_translation)].append(word)\\n\\n number = s[6:].replace('-', '').translate(num_translation)\\n\\n # we take the cartesian product of all the options for the first word and all the options for the second.\\n\\n # case 1, first word is 3 letter & second is 4 letter\\n possibilities1 = {'1-800-{}-{}'.format(*poss) for poss in it.product(\\n nums_dict[number[:3]], nums_dict[number[3:]])}\\n\\n # case 2, first word is 4 letter & second is 3 letter\\n possibilities2 = {'1-800-{}-{}'.format(*poss) for poss in it.product(\\n nums_dict[number[:4]], nums_dict[number[4:]])}\\n\\n return possibilities1.union(possibilities2)\",\n \"def dis(self):\\n return self.nlegomena(2)\",\n \"def classify_message(message: str) -> int:\\n normalized_message = take_away_punctuation(normalize_string(message))\\n associated_words = {\\n STORY_WEATHER_FORECAST_REQUEST: {'погода', 'какая', 'что', 'прогноз'},\\n STORY_SUBSCRIPTION_MANAGEMENT: {'подписка', 'подписаться', 'рассылка', 'присылать',\\n 'ежедневно', 'каждый', 'рассказывать', 'подпиши', 'отпиши', 'отписка',\\n 'перестань'},\\n STORY_WARDROBE_MANAGEMENT: {'гардероб', 'добавить', 'удалить', *get_clothing_items_names(),\\n 'купить', 'потерять', 'порваться'},\\n STORY_CLOTHES_SET_REQUEST: {'что', 'надеть', 'одеть', 'одеться', 'облачиться', 'напялить', 'бы',\\n 'одежда', 'одежду', 'сгенерировать', 'сгенерируем'},\\n STORY_FEEDBACK: {'тепло', 'холодно', 'холодный', 'замерзнуть', 'зажариться', 'вспотеть',\\n 'продуть', 'было', 'хотеть', 'хорошо',\\n *[str(i) for i in range(-5, 6)]}\\n }\\n multipliers = {\\n STORY_WEATHER_FORECAST_REQUEST: 1,\\n STORY_SUBSCRIPTION_MANAGEMENT: 10,\\n STORY_WARDROBE_MANAGEMENT: 10,\\n STORY_CLOTHES_SET_REQUEST: 1,\\n STORY_FEEDBACK: 1\\n }\\n words = {*message.split(), *normalized_message.split()}\\n scores = {\\n STORY_WEATHER_FORECAST_REQUEST: 0.5,\\n STORY_SUBSCRIPTION_MANAGEMENT: 0,\\n STORY_WARDROBE_MANAGEMENT: 0,\\n STORY_CLOTHES_SET_REQUEST: 0,\\n STORY_FEEDBACK: 0\\n }\\n for story in associated_words:\\n scores[story] += len(associated_words[story] & words)\\n scores[story] *= multipliers[story]\\n max_score = max(scores.values())\\n for story in scores:\\n if scores[story] == max_score:\\n return story\",\n \"def qscore(seq):\\n return [ord(i)-33 for i in seq.upper()]\",\n \"def life_sentence(x): \\n if x == 'Life':\\n return 1\\n else:\\n return 0\",\n \"def display_words(word_list,specifier):\\n \\n if specifier.lower() == 'score':\\n print(\\\"{:>6s} - {:s}\\\".format(\\\"Score\\\", \\\"Word\\\"))\\n if len(word_list) < 5:\\n for tup in word_list:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[1], tup[0]))\\n else:\\n \\n for tup in word_list[:5]:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[1], tup[0]))\\n \\n \\n elif specifier.lower() == 'length':\\n print(\\\"{:>6s} - {:s}\\\".format(\\\"Length\\\", \\\"Word\\\"))\\n if len(word_list) < 5:\\n for tup in word_list:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[2], tup[0]))\\n else:\\n \\n for tup in word_list[:5]:\\n print(\\\"{:>6d} - {:s}\\\".format(tup[2], tup[0]))\",\n \"async def character_popularity(\\n position: P('number', 'Please select a number between 1 and 20', min_value = 1, max_value = 20)\\n):\\n return MOST_POPULAR_TOUHOU_CHARACTERS[position - 1]\",\n \"def retagger(tags):\\n if tags == 'Positive':\\n return 'pos'\\n else:\\n return 'neg'\",\n \"def level(score):\\n user_level = \\\"\\\"\\n if score < 20:\\n user_level = \\\"elementary\\\"\\n elif score < 30:\\n user_level = \\\"intermediate\\\"\\n elif score < 35:\\n user_level = \\\"upper intermediate\\\"\\n else:\\n user_level = \\\"advanced\\\"\\n return user_level\",\n \"def get_ability_scores(self):\\n s = ''\\n for i in range(6):\\n s += ' ' + str(self.dna[i])\\n return s\",\n \"def _pettifor_numbers():\\n return { \\\"Li\\\": 0.45,\\n \\\"Be\\\": 1.5,\\n \\\"B\\\": 2.0,\\n \\\"C\\\": 2.5,\\n \\\"N\\\": 3.0, \\n \\\"O\\\": 3.5,\\n \\\"F\\\": 4.0,\\n \\n \\\"Na\\\": 0.4,\\n \\\"Mg\\\": 1.28,\\n \\\"Al\\\": 1.66,\\n \\\"Si\\\": 1.92,\\n \\\"P\\\": 2.18,\\n \\\"S\\\": 2.44,\\n \\\"Cl\\\": 2.70,\\n \\n \\\"K\\\": 0.35,\\n \\\"Ca\\\": 0.60,\\n \\\"Sc\\\": 0.74,\\n \\\"Ti\\\": 0.79,\\n \\\"V\\\": 0.84,\\n \\\"Cr\\\": 0.89,\\n \\\"Mn\\\": 0.94,\\n \\\"Fe\\\": 0.99,\\n \\\"Co\\\": 1.04,\\n \\\"Ni\\\": 1.09,\\n \\\"Cu\\\": 1.20,\\n \\\"Zn\\\": 1.44,\\n \\\"Ga\\\": 1.68,\\n \\\"Ge\\\": 1.92,\\n \\\"As\\\": 2.16,\\n \\\"Se\\\": 2.40,\\n \\\"Br\\\": 2.64,\\n\\n \\\"Rb\\\": 0.30,\\n \\\"Sr\\\": 0.55,\\n \\\"Y\\\": 0.70,\\n \\\"Zr\\\": 0.76,\\n \\\"Nb\\\": 0.82,\\n \\\"Mo\\\": 0.88,\\n \\\"Tc\\\": 0.94,\\n \\\"Ru\\\": 1.00,\\n \\\"Rh\\\": 1.06,\\n \\\"Pd\\\": 1.12,\\n \\\"Ag\\\": 1.18,\\n \\\"Cd\\\": 1.36,\\n \\\"In\\\": 1.60,\\n \\\"Sn\\\": 1.84,\\n \\\"Sb\\\": 2.08,\\n \\\"Te\\\": 2.32,\\n \\\"I\\\": 2.56,\\n \\n \\\"Cs\\\": 0.25,\\n \\\"Ba\\\": 0.50,\\n \\\"La\\\": 0.748,\\n \\\"Hf\\\": 0.775,\\n \\\"Ta\\\": 0.83,\\n \\\"W\\\": 0.885,\\n \\\"Re\\\": 0.94,\\n \\\"Os\\\": 0.995,\\n \\\"Ir\\\": 1.05,\\n \\\"Pt\\\": 1.105,\\n \\\"Au\\\": 1.16,\\n \\\"Hg\\\": 1.32,\\n \\\"Tl\\\": 1.56,\\n \\\"Pb\\\": 1.80,\\n \\\"Bi\\\": 2.04,\\n \\\"Po\\\": 2.28, \\n \\\"At\\\": 2.52 }\",\n \"def ordinal(n):\\n ord_dict = {1: \\\"st\\\", 2: \\\"nd\\\", 3: \\\"rd\\\"}\\n return str(n + 1) + ord_dict.get((n + 1) if (n + 1) < 20 else (n + 1) % 10, \\\"th\\\")\",\n \"def rarity():\\n rarities = find_rarities()\\n longest = 0\\n for rarity in rarities:\\n if (len(rarity) > longest): \\n longest = len(rarity)\\n spacer = \\\"\\\".join(map(lambda x: x*longest, \\\"-\\\"))\\n click.echo(\\\"\\\\nRarities\\\")\\n click.echo(spacer)\\n for rarity in rarities:\\n click.echo(rarity)\\n click.echo(\\\"\\\\n\\\")\",\n \"def lyft_labels():\\n\\n return {\\n 0: 'None',\\n 7: 'Roads',\\n 10: 'Vehicles'\\n }\",\n \"def goals():\\n rand_nmr = random.random()\\n if rand_nmr < 0.5:\\n return 1\\n elif rand_nmr < 0.8:\\n return 2\\n elif rand_nmr < 0.97:\\n return 3\\n else:\\n return 4\",\n \"def get_lexicon(seg_sents:List[List[str]]) -> Dict[str, int]:\\n\\tlexicon = {}\\n\\n\\tfor sent in seg_sents:\\n\\t\\tfor word in sent:\\n\\t\\t\\tlexicon[word] = lexicon.get(word, 0) + 1\\n\\t# print(lexicon)\\n\\treturn lexicon\",\n \"def chargen (level0number, level0die, level1number, level1die, level2number, level2die, level3number, level3die, level4number, level4die): #input dice numbers and types for all four potential character levels\\r\\n\\tfilename=stellagama.savefile(\\\"txt\\\")\\r\\n\\twith open (filename, \\\"w\\\") as output:\\r\\n\\t\\tfor i in range (0, stellagama.dice(level0number, level0die)):\\r\\n\\t\\t\\tcharacter1=character(0)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level1number, level1die)):\\r\\n\\t\\t\\tcharacter1=character(1)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level2number, level2die)):\\r\\n\\t\\t\\tcharacter1=character(2)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level3number, level3die)):\\r\\n\\t\\t\\tcharacter1=character(3)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\\r\\n\\t\\tfor i in range (0, stellagama.dice(level4number, level4die)):\\r\\n\\t\\t\\tcharacter1=character(4)\\r\\n\\t\\t\\toutput.write (\\\"%s, level %s %s %s %s, %s hit points\\\" %(character1.name, character1.level, character1.sex, character1.race, character1.cclass, character1.hp)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"STR: %s DEX: %s CON: %s INT: %s WIS: %s CHA: %s\\\" %(character1.strength, character1.dexterity, character1.constitution, character1.intelligence, character1.wisdom, character1.charisma)+'\\\\r\\\\n')\\r\\n\\t\\t\\tproflist=\\\", \\\".join(character1.proficiencies)\\r\\n\\t\\t\\toutput.write (\\\"Proficiencies: %s\\\" %(proflist)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (character1.quirk+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write (\\\"%s, %s, %s\\\" %(character1.weapon, character1.armor, character1.trinket)+'\\\\r\\\\n')\\r\\n\\t\\t\\toutput.write('\\\\r\\\\n')\",\n \"def score(state, first_n):\\n\\n return sum([(i + first_n) for i, letter in enumerate(state) if letter == \\\"#\\\"])\",\n \"def __init__(self, n, sents, gamma=None, addone=True):\\n assert n > 0\\n self._n = n\\n\\n if gamma is not None:\\n # everything is training data\\n train_sents = sents\\n else:\\n # 90% training, 10% held-out\\n m = int(0.45 * len(sents))\\n l = int(0.65 * len(sents))\\n train_sents = sents[:m] + sents[l:]\\n held_out_sents = sents[m:l]\\n\\n print('Computing counts...')\\n count = defaultdict(int)\\n while (n >= 0):\\n for sent in train_sents:\\n s = sent[:] ## En una oracion auxiliar agrego el item de start y end para contarlos\\n s.insert(0, \\\"<s>\\\")\\n s.append(\\\"</s>\\\")\\n for i in range(len(s) - n + 1):\\n count[tuple(s[i:i + n])] += 1\\n n -= 1\\n count[()] = count[()] - count[('<s>',)] - count[\\n ('</s>',)] # Pero no quiero que <s> y </s> sean considerados por ()\\n self._count = count\\n # WORKed HERE!!\\n # COMPUTE COUNTS FOR ALL K-GRAMS WITH K <= N\\n\\n # compute vocabulary size for add-one in the last step\\n self._addone = addone\\n if addone:\\n print('Computing vocabulary...')\\n self._voc = voc = set()\\n for sent in sents:\\n voc = voc.union(set(sent))\\n voc.add('</s>')\\n self._voc = voc\\n self._V = len(voc)\\n\\n # compute gamma if not given\\n if gamma is not None:\\n self._gamma = gamma\\n else:\\n print('Computing gamma...')\\n self._gamma = gamma = 1\\n p = self.log_prob(held_out_sents)\\n new_gamma = 2\\n streak = 1\\n growing = True\\n turns = 0\\n while (turns < 15):\\n self._gamma = new_gamma\\n np = self.log_prob(held_out_sents)\\n gamma = new_gamma\\n if (np > p):\\n if growing:\\n streak += 1\\n else:\\n turns += 1\\n streak = 0\\n growing = True\\n new_gamma = new_gamma + 2 ** streak\\n else:\\n if growing:\\n turns += 1\\n streak = 0\\n growing = False\\n else:\\n streak += 1\\n new_gamma = new_gamma - 2 ** streak\\n p = np\\n self._gamma = new_gamma\\n print(self._gamma)\",\n \"def produced_by(entry):\\n if \\\"ArtsEntRec\\\" in entry:\\n return \\\"Arts Entertainment Recreation\\\"\\n if \\\"DurableWholesaleTrucking\\\" in entry:\\n return \\\"Durable Wholesale Trucking\\\"\\n if \\\"Education\\\" in entry:\\n return \\\"Education\\\"\\n if \\\"ElectronicEquipment\\\" in entry:\\n return \\\"Electronic Equipment\\\"\\n if \\\"FoodBeverageStores\\\" in entry:\\n return \\\"Food Beverage Stores\\\"\\n if \\\"FoodNondurableWholesale\\\" in entry:\\n return \\\"Food Nondurable Wholesale\\\"\\n if \\\"HotelLodging\\\" in entry:\\n return \\\"Hotel Lodging\\\"\\n if \\\"MedicalHealth\\\" in entry:\\n return \\\"Medical Health\\\"\\n if \\\"Multifamily\\\" in entry:\\n return \\\"Multifamily\\\"\\n if \\\"NotElsewhereClassified\\\" in entry:\\n return \\\"Not Elsewhere Classified\\\"\\n if \\\"OtherManufacturing\\\" in entry:\\n return \\\"Other Manufacturing\\\"\\n if \\\"OtherRetailTrade\\\" in entry:\\n return \\\"Other Retail Trade\\\"\\n if \\\"PublicAdministration\\\" in entry:\\n return \\\"Public Administration\\\"\\n if \\\"Restaurants\\\" in entry:\\n return \\\"Restaurants\\\"\\n if \\\"ServicesManagementAdminSupportSocial\\\" in entry:\\n return \\\"Services Management Administration Support Social\\\"\\n if \\\"ServicesProfessionalTechFinancial\\\" in entry:\\n return \\\"Services Professional Technical Financial\\\"\\n if \\\"ServicesRepairPersonal\\\" in entry:\\n return \\\"Services Repair Personal\\\"\",\n \"def get_ordinal(n):\\n n = int(n)\\n # Zeroeth, First, Second, Third, Fourth+\\n ordinal = ['th', 'st', 'nd', 'rd', 'th'][min((n % 10), 4)]\\n # all the teenths that don't match the above pattern\\n if (n % 100) in [11, 12, 13]:\\n ordinal = 'th'\\n return f\\\"{n}{ordinal}\\\"\",\n \"def all_manslaughter(x): \\n for elem in x:\\n if elem == 'Manslaughter' or elem == 'Voluntary Manslaughter':\\n return 1\\n return 0\",\n \"def makeGerund(self):\\r\\n clean_s = self.cleanString(self.text)\\r\\n LoW = clean_s.split()\\r\\n for x in LoW: \\r\\n if 'ing' in x and x not in self.gerund: \\r\\n self.gerund[x] = 1\\r\\n elif 'ing' in x and x in self.gerund: \\r\\n self.gerund[x] += 1\\r\\n return self.gerund\",\n \"def setDif(dificultad):\\n if(dificultad=='Easy'):\\n return ['NN', 'JJ', 'VB']\\n elif(dificultad=='Medium'):\\n return ['NN', 'VB']\\n elif(dificultad=='Hard'):\\n i=randint(0,2)\\n dif=['NN', 'JJ', 'VB']\\n return dif[i]\",\n \"def prob4():\\n#pass\\n n_men = 0\\n n_women = 0\\n db = sql.connect('sql2')\\n cur = db.cursor()\\n cur.execute(\\\"SELECT Gender FROM ICD WHERE Age>=25 AND Age<=35\\\")\\n for gen in cur :\\n if gen[0] == 'M' :\\n n_men += 1\\n else :\\n n_women += 1\\n db.close()\\n return n_men,n_women\",\n \"def possessif(nom):\\n\\n CA = nom[1]\\n\\n\\n rand = randint(0,5)\\n\\n if CA == \\\"-1\\\" or CA == \\\"-3\\\" or CA == \\\"-5\\\" or CA == \\\"-7\\\" or CA == \\\"-8\\\" or CA == \\\"-4\\\" or Premiere_lettre_voyelle(nom[0]):\\n if rand == 0:\\n return \\\"mon \\\"\\n elif rand == 1:\\n return \\\"ton \\\"\\n elif rand == 2:\\n return \\\"son \\\"\\n elif rand == 3:\\n return \\\"notre \\\"\\n elif rand == 4:\\n return \\\"votre \\\"\\n elif rand == 5:\\n return \\\"leur \\\"\\n \\n elif (CA == \\\"-2\\\" or CA == \\\"-6\\\" or CA == \\\"-9\\\"):\\n if rand == 0:\\n return \\\"ma \\\"\\n elif rand == 1:\\n return \\\"ta \\\"\\n elif rand == 2:\\n return \\\"sa \\\"\\n elif rand == 3:\\n return \\\"notre \\\"\\n elif rand == 4:\\n return \\\"votre \\\"\\n elif rand == 5:\\n return \\\"leur \\\"\\n else:\\n return False\",\n \"def letter_name(lst, letter):\\n arr = [0 for i in range(100)]\\n counter = 0\\n for name in lst:\\n letter = name[0][0].lower()\\n order = ord(letter) - 1072\\n arr[order] += 1\\n maximum = 0\\n letter = \\\"\\\"\\n for i in range(len(arr)):\\n if arr[i] > maximum:\\n maximum = arr[i]\\n letter = chr(i + 1072)\\n arr_of_names = []\\n sum_of_children = 0\\n for name in lst:\\n if name[0][0].lower() == letter:\\n arr_of_names.append(name[0])\\n sum_of_children += name[1]\\n return letter, maximum, arr_of_names, sum_of_children\",\n \"def think(s):\",\n \"def say_chunk(num):\\n output_string_list = []\\n num_string = str(num)\\n\\n units = ['zero', 'one', 'two', 'three', 'four', 'five',\\n 'six', 'seven', 'eight', 'nine']\\n teens = ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen',\\n 'sixteen', 'seventeen', 'eighteen', 'nineteen']\\n tens = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']\\n\\n # singles\\n if num < 10:\\n output_string_list.append(units[num])\\n\\n # teens\\n elif 10 <= num <= 19:\\n output_string_list.append(teens[int(num) % 10])\\n\\n # tens\\n elif 20 <= num <= 99:\\n num_str = str(num)\\n modifier = int(num_str[0])\\n if int(num_str[1]):\\n output_string_list.append(\\\"{}-{}\\\".format(tens[modifier - 2], units[int(num) % 10]))\\n else:\\n output_string_list.append(tens[modifier - 2])\\n\\n # hundreds\\n elif 100 <= num <= 999:\\n output_string_list.append(units[int(num_string[0])])\\n output_string_list.append('hundred')\\n\\n num = int(num_string[1:])\\n if num:\\n output_string_list.append('and')\\n num_string = str(num)\\n modifier = int(num_string[0])\\n\\n if int(num_string[1]):\\n output_string_list.append(\\\"{}-{}\\\".format(tens[modifier - 2], units[int(num_string[1:]) % 10]))\\n else:\\n output_string_list.append(tens[modifier - 2])\\n\\n return ' '.join(output_string_list)\",\n \"def cardinal(n, friendly=True):\\n if friendly:\\n n_abs = abs(n)\\n\\n if n_abs < 20:\\n return cardinal(n, friendly=False)\\n\\n if n_abs < 100 and n_abs % 10 == 0:\\n return cardinal(n, friendly=False)\\n\\n if n_abs < 1000 and n_abs % 100 == 0:\\n return cardinal(n, friendly=False)\\n\\n if n_abs < 12000 and n_abs % 1000 == 0:\\n return cardinal(n, friendly=False)\\n\\n prefix = \\\"min \\\" if n < 0 else \\\"\\\"\\n\\n if n_abs < MILLION:\\n q, r = divmod(n_abs, 1000)\\n if r == 0:\\n return prefix + \\\"%d duizend\\\" % q\\n\\n if n_abs < BILLION:\\n q, r = divmod(n_abs, MILLION)\\n if r == 0:\\n return prefix + \\\"%d miljoen\\\" % q\\n\\n # No friendly variant, just return the numerical representation.\\n return unicode(n)\\n\\n # Code below completely spells out each number.\\n\\n if n < 0:\\n return \\\"min \\\" + cardinal(abs(n))\\n\\n if n < 20:\\n return UNITS[n]\\n\\n if n < 100:\\n q, r = divmod(n, 10)\\n a = TENS[q]\\n if r == 0:\\n return a\\n b = cardinal(r)\\n joiner = \\\"en\\\" if not b.endswith(\\\"e\\\") else \\\"ën\\\"\\n return b + joiner + a\\n\\n if n < 1000:\\n q, r = divmod(n, 100)\\n a = cardinal(q, friendly=False) if q > 1 else \\\"\\\"\\n b = cardinal(r, friendly=False) if r > 0 else \\\"\\\"\\n return a + \\\"honderd\\\" + b\\n\\n if 1000 < n < 10000 and n % 1000:\\n # Special case for numbers that are exactly divisble by 100, but\\n # not by 1000, e.g. \\\"tweeëntwintighonderd\\\"\\n q, r = divmod(n, 100)\\n if r == 0:\\n a = cardinal(q, friendly=False) if q > 1 else \\\"\\\"\\n return a + \\\"honderd\\\"\\n\\n if n < MILLION:\\n q, r = divmod(n, 1000)\\n a = cardinal(q, friendly=False) if q > 1 else \\\"\\\"\\n b = \\\" \\\" + cardinal(r, friendly=False) if r > 0 else \\\"\\\"\\n return a + \\\"duizend\\\" + b\\n\\n if n < BILLION:\\n q, r = divmod(n, MILLION)\\n a = cardinal(q, friendly=False)\\n b = \\\" \\\" + cardinal(r, friendly=False) if r > 0 else \\\"\\\"\\n return a + \\\" miljoen\\\" + b\\n\\n if n < TRILLION:\\n q, r = divmod(n, BILLION)\\n a = cardinal(q, friendly=False)\\n b = \\\" \\\" + cardinal(r, friendly=False) if r > 0 else \\\"\\\"\\n return a + \\\" miljard\\\" + b\\n\\n if n < QUADRILLION:\\n q, r = divmod(n, TRILLION)\\n a = cardinal(q, friendly=False)\\n b = \\\" \\\" + cardinal(r, friendly=False) if r > 0 else \\\"\\\"\\n return a + \\\" biljoen\\\" + b\\n\\n # Fallback to numerical representation\\n return unicode(n)\",\n \"def get_final_score(scores):\\n \\n print(\\\"get_final_score\\\")\\n \\n print(\\\"scores:\\\", scores)\\n \\n max_score = max(scores.values())\\n print(\\\"max_score:\\\", max_score)\\n sieger = [x for x in scores.keys() if scores[x] == max_score]\\n \\n print(\\\"sieger:\\\", sieger)\\n\\n if len(scores) == 1:\\n print(\\\"if1\\\")\\n text = \\\"<s>Spiel beendet. </s>Du hast {0} von {1} Fragen richtig beantwortet.\\\"\\\\\\n .format(scores[\\\"1\\\"], TOTAL_ROUNDS)\\n elif len(sieger) == 1:\\n sieger = sieger[0]\\n text = \\\"<s>Spiel beendet.</s> Der Sieger ist Spieler {0} mit {1} von {2} Punkten.\\\"\\\\\\n .format(sieger, scores[sieger], TOTAL_ROUNDS)\\n\\n elif len(sieger) == len(scores):\\n text = \\\"<s>Spiel beendet.</s> <s>Es gab keinen Sieger;</s> alle Spieler haben\\\\\\n {0} von {1} Fragen richtig beantwortet.\\\".format(max_score, TOTAL_ROUNDS)\\n else:\\n scores_text = \\\"\\\"\\n for e in sieger[:-1]:\\n scores_text += \\\"<break/> Spieler {0}\\\".format(e)\\n scores_text += \\\" und Spieler {0} mit {1} von {2} Fragen richtig beantwortet.\\\"\\\\\\n .format(sieger[-1], max_score, TOTAL_ROUNDS)\\n text = \\\"<s>Spiel beendet.</s> Das beste Ergebnis hatten\\\" + scores_text\\n\\n text += \\\"<s> Danke fürs Mitspielen!</s>\\\"\\n\\n return text\",\n \"def REC_L_STRAIGHT():\\n return 11\",\n \"def get_entailment_judgements():\\n results = defaultdict(lambda: [0,0,0])\\n mapping = dict(zip(('CONTRADICTION','ENTAILMENT','NEUTRAL'), range(3)))\\n\\n firstline = True\\n for line in open('working/sick.run'):\\n if firstline:\\n firstline = False\\n else:\\n words = line.split()\\n sick_id = str(words[0])\\n result = words[1]\\n\\n # Set the index correspoinding to the judgement to 1\\n results[sick_id][mapping[result]] = 1\\n return results\",\n \"def fix_teen(n):\\n x = 0\\n\\n while(x < len(n)):\\n if(n[x] in(13, 14, 17,18,19)):\\n n[x] = 0\\n x = x + 1\\n \\n return n\",\n \"def bolinish_alomatlari(son):\\n for n in range(1,11):\\n if not son % (n):\\n print(f\\\"{son} {n} ga qoldiqsiz bo'linadi \\\")\",\n \"def get_movie_most_nominations(movies: list) -> str:\\n pass\",\n \"def rules():\\n help = textwrap.dedent(\\\"\\\"\\\"\\n THIS IS THE GAME OF \\\"REVERSE\\\". TO WIN, ALL YOU HAVE\\n TO DO IS ARRANGE A LIST OF NUMBERS (1 THROUGH {})\\n IN NUMERICAL ORDER FROM LEFT TO RIGHT. TO MOVE, YOU\\n TELL ME HOW MANY NUMBERS (COUNTING FROM THE LEFT) TO\\n REVERSE. FOR EXAMPLE, IF THE CURRENT LIST IS:\\n\\n 2 3 4 5 1 6 7 8 9\\n\\n AND YOU REVERSE 4, THE RESULT WILL BE:\\n\\n 5 4 3 2 1 6 7 8 9\\n\\n NOW IF YOU REVERSE 5, YOU WIN!\\n\\n 1 2 3 4 5 6 7 8 9\\n\\n NO DOUBT YOU WILL LIKE THIS GAME, BUT\\n IF YOU WANT TO QUIT, REVERSE 0 (ZERO).\\n \\\"\\\"\\\".format(NUMCNT))\\n print(help)\\n print()\",\n \"def alphabet_war(fight):\",\n \"def n_hellos(n:int) -> None:\\n for x in range(1, n+1):\\n if 10 < x <=20:\\n print(f'{x}th hello')\\n elif x % 10 == 1:\\n print(f'{x}st hello')\\n elif x % 10 == 2:\\n print(f'{x}nd hello')\\n elif x % 10 == 3:\\n print(f'{x}rd hello')\\n else:\\n print(f'{x}th hello')\",\n \"def zapisi_pot(pot):\\r\\n u = ()\\r\\n p = 1\\r\\n for c in range(1, len(pot)):\\r\\n if pot[c][1] > pot[c - 1][1]:\\r\\n if p == 2:\\r\\n p = 3\\r\\n u += 'LEVO',\\r\\n elif p == 4:\\r\\n p = 3\\r\\n u += 'DESNO',\\r\\n elif p == 1:\\r\\n p = 3\\r\\n u += 'DESNO', 'DESNO'\\r\\n u += str(pot[c][1] - pot[c - 1][1]),\\r\\n elif pot[c][1] < pot[c - 1][1]:\\r\\n if p == 2:\\r\\n p = 1\\r\\n u += 'DESNO',\\r\\n elif p == 4:\\r\\n p = 1\\r\\n u += 'LEVO',\\r\\n elif p == 3:\\r\\n p = 1\\r\\n u += 'DESNO', 'DESNO'\\r\\n u += str(pot[c - 1][1] - pot[c][1]),\\r\\n elif pot[c][0] > pot[c - 1][0]:\\r\\n if p == 1:\\r\\n p = 4\\r\\n u += 'DESNO',\\r\\n elif p == 3:\\r\\n p = 4\\r\\n u += 'LEVO',\\r\\n elif p == 2:\\r\\n p = 4\\r\\n u += 'DESNO', 'DESNO'\\r\\n u += str(pot[c][0] - pot[c - 1][0]),\\r\\n elif pot[c][0] < pot[c - 1][0]:\\r\\n if p == 1:\\r\\n p = 2\\r\\n u += 'LEVO',\\r\\n elif p == 3:\\r\\n p = 2\\r\\n u += 'DESNO',\\r\\n elif p == 4:\\r\\n p = 2\\r\\n u += 'DESNO', 'DESNO'\\r\\n u += str(pot[c - 1][0] - pot[c][0]),\\r\\n c += 1\\r\\n\\r\\n return '\\\\n'.join(u)\",\n \"def get_color(tense, seq=0):\\n if tense in ['Perfekt', 'present perfect', 'pretérito perfecto compuesto', 'passé composé', 'vtt',\\n 'passato prossimo', 'PresPerf']:\\n return '#1f77b4'\\n elif tense in ['Präsens', 'simple present', 'presente', 'présent', 'ott', 'Present', 'present imperfective', 'present']:\\n return '#ff7f0e'\\n elif tense in ['Präteritum', 'simple past', 'pretérito perfecto simple', 'indefinido', 'passé simple', 'ovt', 'Past', 'past perfective', 'past']:\\n return '#2ca02c'\\n elif tense in ['Plusquamperfekt', 'past perfect', 'pretérito pluscuamperfecto', 'plus-que-parfait', 'vvt',\\n 'trapassato prossimo', 'PastPerf', 'past+infinitive']:\\n return '#d62728'\\n elif tense in ['Futur I', 'simple future', 'futur', 'futuro', 'ottt', 'future']:\\n return '#9467bd'\\n elif tense in ['Futur II', 'future perfect', 'futur antérieur', 'futuro perfecto', 'ovtt', 'future past']:\\n return '#8c564b'\\n elif tense in ['present perfect continuous', 'Cont', 'present/adjective']:\\n return '#e377c2'\\n elif tense in ['pasado reciente', 'passé récent', 'RecentPast', 'copular']:\\n return '#7f7f7f'\\n elif tense in ['pretérito imperfecto', 'imparfait', 'Imperfecto', 'past imperfective', 'past+present']:\\n return '#bcbd22'\\n elif tense in ['present participle', 'participio', 'Gerund', 'gerund', 'gerund perfective']:\\n return '#17becf'\\n elif tense in ['Infinitiv', 'infinitief', 'infinitif', 'infinitivo', 'infinitive']:\\n return '#aec7e8'\\n elif tense in ['present continuous', 'PresGer', 'existential']:\\n return '#ffbb78'\\n elif tense in ['condicional', 'conditionnel', 'Rep']:\\n return '#98df8a'\\n elif tense in ['past continuous']:\\n return '#ff9896'\\n elif tense in ['past perfect continuous']:\\n return '#c5b0d5'\\n elif tense in ['future continuous']:\\n return '#c49c94'\\n elif tense in ['future in the past', 'futuro perfecto']:\\n return '#f7b6d2'\\n elif tense in ['future in the past continuous']:\\n return '#c7c7c7'\\n elif tense in ['infinitivo perfecto']:\\n return '#dbdb8d'\\n elif tense in ['futur proche', 'futuro próximo']:\\n return '#9edae5'\\n elif tense in ['futur proche du passé', 'futuro próximo en imperfecto']:\\n return '#393b79'\\n elif tense in ['conditionnel passé']:\\n return '#5254a3'\\n elif tense in ['subjuntivo presente']:\\n return '#e7cb94'\\n elif tense in ['subjuntivo pretérito imperfecto']:\\n return '#8c6d31'\\n elif tense in ['participle past perfective active']:\\n return '#843c39'\\n elif tense in ['gerund imperfective']:\\n return '#393b79'\\n\\n # Mandarin\\n elif tense in ['unmarked']:\\n return '#1f77b4'\\n elif tense in ['rvc']:\\n return '#ff7f0e'\\n elif tense in ['le1', 'le']:\\n return '#2ca02c'\\n elif tense in ['le12']:\\n return '#d62728'\\n elif tense in ['guo']:\\n return '#9467bd'\\n elif tense in ['zhe']:\\n return '#8c564b'\\n elif tense in ['zai']:\\n return '#e377c2'\\n elif tense in ['unmarked duplication']:\\n return '#7f7f7f'\\n elif tense in ['adv']:\\n return '#bcbd22'\\n elif tense in ['adj']:\\n return '#17becf'\\n elif tense in ['conj']:\\n return '#aec7e8'\\n elif tense in ['mood']:\\n return '#ffbb78'\\n elif tense in ['noun']:\\n return '#98df8a'\\n elif tense in ['non-verb', 'other']:\\n return '#ff9896'\\n\\n # ViB\\n elif tense in ['adjectif']:\\n return '#e6194b'\\n elif tense in ['adverbe']:\\n return '#3cb44b'\\n elif tense in ['article défini']:\\n return '#ff0000'\\n elif tense in ['article défini pluriel']:\\n return '#bf0000'\\n elif tense in ['article défini singulier']:\\n return '#ff0051'\\n elif tense in ['article indéfini']:\\n return '#ff8400'\\n elif tense in ['article indéfini pluriel']:\\n return '#8c4800'\\n elif tense in ['article indéfini singulier']:\\n return '#4c2800'\\n elif tense in ['déterminant défini pluriel']:\\n return '#adb300'\\n elif tense in ['déterminant démonstratif']:\\n return '#56bf00'\\n elif tense in ['déterminant indéfini']:\\n return '#285900'\\n elif tense in ['déterminant possessif']:\\n return '#00e686'\\n elif tense in ['expression']:\\n return '#e377c2'\\n elif tense in ['nom commun']:\\n return '#7f7f7f'\\n elif tense in ['nom propre']:\\n return '#bcbd22'\\n elif tense in ['nom propre gén']:\\n return '#dbdb8d'\\n elif tense in ['numéral']:\\n return '#17becf'\\n elif tense in ['pronom démonstratif']:\\n return '#5b008c'\\n elif tense in ['pronom indéfini']:\\n return '#2200ff'\\n elif tense in ['pronom interrogatif']:\\n return '#0058e6'\\n elif tense in ['pronom personnel']:\\n return '#006773'\\n elif tense in ['pronom personnel adverbial']:\\n return '#00331e'\\n elif tense in ['pronom relatif']:\\n return '#285900'\\n elif tense in ['pronom réfléchi']:\\n return '#00e686'\\n\\n # Contraction\\n elif tense in ['contracted', 'bare noun']:\\n return '#2f5597'\\n elif tense in ['uncontracted', 'demonstrative']:\\n return '#fd8f8e'\\n\\n else:\\n return COLOR_LIST[seq % len(COLOR_LIST)]\",\n \"def way_to_prewin(self, one):\\r\\n\\t\\tkind = [0, 0, 0, 0] \\r\\n\\t\\tuseful = []\\r\\n\\t\\tscore = 0\\r\\n\\t\\tfor part in one.split(\\\"\\\\t\\\"):\\r\\n\\t\\t\\t#print \\\"part: {0}\\\".format(part)\\r\\n\\t\\t\\ttmp = part.split()\\r\\n\\t\\t\\tlength = len(tmp)\\r\\n\\t\\t\\tif (length == 3):\\t\\t# triple\\r\\n\\t\\t\\t\\tkind[0] += 1\\r\\n\\t\\t\\t\\tscore += 3\\r\\n\\t\\t\\telif (length == 1):\\t\\t# single\\r\\n\\t\\t\\t\\tkind[3] += 1\\r\\n\\t\\t\\telif (tmp[0] == tmp[1]):# pair\\r\\n\\t\\t\\t\\tkind[1] += 1\\r\\n\\t\\t\\t\\tuseful.append(\\\"{0}\\\".format(tmp[0]))\\r\\n\\t\\t\\t\\tscore += 2\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tkind[2] += 1\\r\\n\\t\\t\\t\\tn = GameBoard.NextCard(tmp[0])\\r\\n\\t\\t\\t\\tp = GameBoard.PrevCard(tmp[0])\\r\\n\\t\\t\\t\\tnn = GameBoard.NextCard(tmp[1])\\r\\n\\t\\t\\t\\tif (n == tmp[1]):\\t# consecutive neighbor\\r\\n\\t\\t\\t\\t\\tscore += 2\\r\\n\\t\\t\\t\\t\\tif (p != None): useful.append(p)\\r\\n\\t\\t\\t\\t\\tif (nn != None): useful.append(nn)\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tuseful.append(n)\\r\\n\\t\\t\\t\\t\\tscore += 1\\r\\n\\r\\n\\t\\t#print \\\"kind: {0}\\\".format(kind)\\r\\n\\t\\t\\\"\\\"\\\" how many cards can we probably get \\\"\\\"\\\"\\r\\n\\t\\tuseful_amount = 0\\r\\n\\t\\tfor card in set(useful):\\r\\n\\t\\t\\tctype = GameBoard.CardType(card)\\r\\n\\t\\t\\tif (ctype == 1): a = self.wang_list.count(card)\\r\\n\\t\\t\\telif (ctype == 2): a = self.tube_list.count(card)\\r\\n\\t\\t\\telif (ctype == 3): a = self.bamb_list.count(card)\\r\\n\\t\\t\\telif (ctype == 4): a = self.word_list.count(card)\\r\\n\\t\\t\\telse: a = self.wind_list.count(card)\\r\\n\\t\\t\\tb = self.gb.drop_list.count(card)\\r\\n\\t\\t\\tuseful_amount += (4 - a - b)\\r\\n\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\t\\t1. enumerate, because goal state not too much\\r\\n\\t\\t2. counting pong_list so that we can focus on 16 cards\\r\\n\\t\\t3. check prewin first\\t\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\t\\tgoals = [[4, 1, 1, 0], [5, 0, 0, 1], [4, 2, 0, 0]]\\r\\n\\t\\tgpattern = [[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"##\\\", \\\"$$\\\"],[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"/\\\"],\\r\\n\\t\\t\\t\\t\\t[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"##\\\", \\\"##\\\"]]\\r\\n\\t\\tresult = [0, 0, 0]\\r\\n\\t\\tsize = len(self.pong_list) / 3\\r\\n\\t\\tif ((size + kind[0]) > 4): return [0, useful_amount, score]\\r\\n\\t\\tfor i in range(size): \\r\\n\\t\\t\\tgpattern[0].remove(\\\"***\\\")\\r\\n\\t\\t\\tgpattern[1].remove(\\\"***\\\")\\r\\n\\t\\t\\tgpattern[2].remove(\\\"***\\\")\\r\\n\\t\\tfor number in range(3):\\r\\n\\t\\t\\tk0 = kind[0]\\r\\n\\t\\t\\tk1 = kind[1]\\r\\n\\t\\t\\tk2 = kind[2]\\r\\n\\t\\t\\tk3 = kind[3]\\r\\n\\t\\t\\tp1 = gpattern[number]\\r\\n\\t\\t\\tfor i in range(k0): p1.remove(\\\"***\\\")\\r\\n\\t\\t\\tfor i in range(min(k1, goals[number][1])): \\r\\n\\t\\t\\t\\tk1 -= 1\\r\\n\\t\\t\\t\\tp1.remove(\\\"##\\\")\\r\\n\\t\\t\\tfor i in range(min(k2, goals[number][2])):\\r\\n\\t\\t\\t\\tk2 -= 1\\r\\n\\t\\t\\t\\tp1.remove(\\\"$$\\\")\\r\\n\\t\\t\\t#print \\\"p1: {0}, size: {1}\\\".format(p1, (k1+k2)*2+k3)\\r\\n\\t\\t\\tstep = 0\\r\\n\\t\\t\\ttwo = k1 + k2\\r\\n\\t\\t\\tfor i in range(len(p1)):\\r\\n\\t\\t\\t\\tlength = len(p1[i])\\r\\n\\t\\t\\t\\tif (length == 3):\\r\\n\\t\\t\\t\\t\\tif two:\\r\\n\\t\\t\\t\\t\\t\\ttwo -= 1\\r\\n\\t\\t\\t\\t\\t\\tstep += 1\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tstep += 2\\r\\n\\t\\t\\t\\telif (length == 2):\\r\\n\\t\\t\\t\\t\\tstep += 1\\r\\n\\t\\t\\tresult[number] = step\\r\\n\\t\\t#print \\\"steps to goal: {0}, useful: {1}\\\".format(result, len(useful))\\r\\n\\t\\t\\r\\n\\t\\treturn [min(result), useful_amount, score]\",\n \"def compute(data):\\n spoken = collections.defaultdict(lambda: collections.deque(maxlen=2))\\n\\n starting = map(int, data.split(\\\",\\\"))\\n last_number = None\\n i = 0\\n\\n for i, last_number in enumerate(starting, start=i + 1):\\n spoken[last_number].append(i)\\n\\n for i in range(i + 1, 30000001):\\n if len(spoken[last_number]) <= 1:\\n last_number = 0\\n else:\\n last_number = spoken[last_number][1] - spoken[last_number][0]\\n\\n spoken[last_number].append(i)\\n\\n return last_number\",\n \"def tetrakis(self):\\n return self.nlegomena(4)\",\n \"def generation(state, first_n, rules):\\n\\n state = \\\"....\\\" + state + \\\"....\\\"\\n first_n -= 2 # adding 4 dots, but only add 2 to the first_n because we start at 2 below\\n\\n new_state = \\\"\\\".join([rules.get(state[i:i+5],\\\".\\\") for i in range(len(state))])\\n\\n first_pot = new_state.find(\\\"#\\\")\\n first_n += first_pot\\n\\n last_pot = new_state.rfind(\\\"#\\\")\\n \\n# print(f\\\"first pot {first_pot} in {new_state}\\\")\\n return new_state[first_pot:last_pot+1], first_n\",\n \"def frequency_quran_level():\\n\\n # * A list of sura level frequencies.\\n # * Each element is a list of ayat el-sura frequencies.\\n quranWordsFrequences = []\\n\\n for suraNumber in range(1, 114 +1):\\n suraWordsFrequeces = frequency_sura_level(suraNumber)\\n quranWordsFrequences.append(suraWordsFrequeces)\\n\\n return quranWordsFrequences\",\n \"def pluralize(word, num):\\n word = word.lower().lstrip()\\n string = \\\"\\\"\\n numList = [\\\"zero\\\", \\\"one\\\", \\\"two\\\", \\\"three\\\", \\\"four\\\", \\\"five\\\", \\\"six\\\", \\\"seven\\\",\\n \\\"eight\\\", \\\"nine\\\", \\\"ten\\\", \\\"eleven\\\", \\\"twelve\\\", \\\"thirteen\\\",\\n \\\"fourteen\\\", \\\"fifteen\\\", \\\"sixteen\\\", \\\"seventeen\\\", \\\"eighteen\\\",\\n \\\"nineteen\\\", \\\"twenty\\\", \\\"thirty\\\", \\\"forty\\\", \\\"fifty\\\", \\\"sixty\\\",\\n \\\"seventy\\\", \\\"eighty\\\", \\\"ninety\\\"]\\n vowels = [\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\", \\\"y\\\"]\\n multi_exception = {\\\"is\\\": \\\"es\\\", \\\"us\\\": \\\"i\\\", \\\"ix\\\": \\\"ices\\\", \\\"eau\\\": \\\"eaux\\\", \\\"ouse\\\": \\\"ice\\\",\\n \\\"ch\\\": \\\"es\\\", \\\"sh\\\": \\\"es\\\"}\\n o_exception = [\\\"hero\\\", \\\"potato\\\", \\\"volcano\\\"]\\n special = {\\\"goose\\\": \\\"geese\\\", \\\"man\\\": \\\"men\\\", \\\"mouse\\\": \\\"mice\\\",\\n \\\"tooth\\\": \\\"teeth\\\", \\\"child\\\": \\\"children\\\",\\n \\\"woman\\\": \\\"women\\\", \\\"ox\\\": \\\"oxen\\\", \\\"wolf\\\" : \\\"wolves\\\"}\\n unchanging = [\\\"deer\\\", \\\"fish\\\", \\\"sheep\\\", \\\"species\\\", \\\"aircraft\\\", \\\"bison\\\"]\\n if num <= 20:\\n string = numList[num] \\n else:\\n temp1 = int(num / 10)\\n temp2 = int(num % 10)\\n string = numList[temp1 + 18] + \\\"-\\\" + numList[temp2]\\n string += \\\" \\\"\\n if num != 1 and word not in unchanging:\\n if word in special:\\n word = special[word]\\n elif multiCheck(word, multi_exception)[0]:\\n b = multiCheck(word, multi_exception)[1]\\n word = word[0 : -len(b)] + multi_exception[b]\\n elif word[-1] == \\\"y\\\":\\n if word[-2] in vowels:\\n word += \\\"s\\\"\\n else:\\n word = word[0 : -1] + \\\"ies\\\"\\n elif word[-1] in [\\\"s\\\", \\\"x\\\", \\\"z\\\"] or word in o_exception:\\n word += \\\"es\\\"\\n else:\\n word += \\\"s\\\"\\n return string + word\",\n \"def get_word_score(word, n=7):\\n score = 0\\n\\n for i in word:\\n score += SCRABBLE_LETTER_VALUES[i]\\n\\n if len(word) == n:\\n score += 50\\n\\n return score\",\n \"def treatment_plugs(data_plugs):\\r\\n\\r\\n no_plugs = []\\r\\n little = []\\r\\n means = []\\r\\n great = []\\r\\n large_enough = []\\r\\n super_large = []\\r\\n\\r\\n\\r\\n for i in data_plugs:\\r\\n print(i[0])\\r\\n if i[1] in ('None', None)\\\\\\r\\n or i[0] in ('None', None):\\r\\n pass\\r\\n elif i[0] == 'non':\\r\\n no_plugs.append(int(i[1]))\\r\\n elif i[0] == 'petit':\\r\\n little.append(int(i[1]))\\r\\n elif i[0] == 'moyen':\\r\\n means.append(int(i[1]))\\r\\n elif i[0] == 'grand':\\r\\n great.append(int(i[1]))\\r\\n elif i[0] == 'assez grand':\\r\\n large_enough.append(int(i[1]))\\r\\n elif i[0] == 'tres grand':\\r\\n super_large.append(int(i[1]))\\r\\n\\r\\n\\r\\n data = len(no_plugs) + len(little) +\\\\\\r\\n len(means) + len(great)+\\\\\\r\\n len(large_enough)+\\\\\\r\\n len(super_large)\\r\\n\\r\\n print(data)\\r\\n\\r\\n data_no = moyenne(no_plugs)\\r\\n data_little = moyenne(little)\\r\\n data_means = moyenne(means)\\r\\n data_great = moyenne(great)\\r\\n data_large_enough = moyenne(large_enough)\\r\\n data_super_large = moyenne(super_large)\\r\\n\\r\\n return data_no[0],\\\\\\r\\n data_little[0],\\\\\\r\\n data_means[0],\\\\\\r\\n data_great[0],\\\\\\r\\n data_large_enough[0],\\\\\\r\\n data_super_large[0],\\\\\\r\\n data_no[1],\\\\\\r\\n data_little[1],\\\\\\r\\n data_means[1],\\\\\\r\\n data_great[1],\\\\\\r\\n data_large_enough[1],\\\\\\r\\n data_super_large[1],\\\\\\r\\n data\",\n \"def organize(select, strain, equals):\\n scores = []\\n data = list(strainer(select, strain, equals))\\n while len(data) != 0:\\n number = lowest_number(data)\\n scores.append(number)\\n data.remove(number)\\n return scores\",\n \"def getWordScore(word, n):\\n score=0\\n for i in range(len(word)):\\n addition=SCRABBLE_LETTER_VALUES[word[i]]\\n score+=addition*(len(word))\\n if len(word)==n:\\n score+=50\\n return score\",\n \"def ordinal_label(n):\\n n = int(n)\\n return \\\"%d%s\\\" % (n,\\\"tsnrhtdd\\\"[(n/10%10!=1)*(n%10<4)*n%10::4])\",\n \"def main(duck, abstract, answer):\\n set_duck = sorted(set(duck))\\n for i in set_duck:\\n if i > abstract / 2:\\n break\\n answer += duck.count(abstract - i) * duck.count(i)\\n print(answer)\",\n \"def minion_game(string):\\n vowels = sum(len(string) - i for i, c in enumerate(string) if c in 'AEIOU')\\n consonants = sum(len(string) - i for i, c in enumerate(string) if c not in 'AEIOU')\\n\\n if vowels == consonants:\\n print(DRAW)\\n elif vowels > consonants:\\n print(f'{PLAYER_VOWELS} {vowels}')\\n else:\\n print(f'{PLAYER_CONSONANTS} {consonants}')\",\n \"def test_get_scorable_threes_5ok():\\n roll = np.array([3, 3, 3, 3, 3, 1])\\n expected = {\\n \\\"one\\\": 1,\\n \\\"five\\\": 0,\\n \\\"three-ones\\\": False,\\n \\\"three-twos\\\": False,\\n \\\"three-threes\\\": False,\\n \\\"three-fours\\\": False,\\n \\\"three-fives\\\": False,\\n \\\"three-sixes\\\": False,\\n \\\"four-of-a-kind\\\": False,\\n \\\"three-and-one\\\": False,\\n \\\"five-of-a-kind\\\": True,\\n \\\"six-of-a-kind\\\": False,\\n \\\"straight\\\": False,\\n \\\"three-pairs\\\": False,\\n \\\"four-and-pair\\\": False,\\n \\\"triplets\\\": False,\\n }\\n actual = analyze_roll.get_scorable(roll)\\n assert expected == actual\",\n \"def get_keywords(self, number=10):\\n # print(len(self.node_weight.items()))\\n node_weight_list = [list(ele) for ele in self.node_weight.items()]\\n for i in node_weight_list:\\n res = len(i[0].split())\\n if res==2:\\n # weight for bigrams\\n i[1]=4*i[1]\\n if res==3:\\n # weight for trigrams\\n i[1]=6*i[1]\\n\\n node_weight = OrderedDict(sorted(node_weight_list, key=lambda t: t[1], reverse=True))\\n for i, (key, value) in enumerate(node_weight.items()):\\n # print(key + ' - ' + str(value))\\n print(i+':'+key)\\n if i > number:\\n break\",\n \"def word_enders():\\n space = ''\\n for k,v in key.items():\\n if v==' ':\\n space = k\\n\\n enders = Counter()\\n for word in ciphertext.split( space ):\\n last_two = word[-2]+word[-1]\\n enders[last_two] += 1\\n\\n return enders\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.596013","0.5699823","0.56656635","0.56514853","0.56017965","0.5583126","0.55336237","0.5523108","0.55034256","0.5462615","0.54474133","0.54238445","0.5409785","0.5402162","0.5380286","0.5365057","0.5361857","0.5359248","0.5339483","0.53059673","0.5297546","0.52901965","0.52863413","0.5284755","0.52620703","0.52612156","0.5256129","0.52552634","0.5249977","0.52496165","0.52342784","0.52276075","0.52204454","0.52183694","0.5198899","0.51978266","0.51936305","0.51910174","0.51752925","0.51689374","0.51615703","0.51590174","0.51576036","0.5149802","0.5149252","0.5147686","0.5147045","0.5136119","0.5126882","0.51235586","0.51229274","0.51136124","0.5113351","0.51067895","0.5089737","0.5088056","0.50867283","0.5082689","0.506582","0.5059423","0.50524116","0.5051697","0.5046759","0.5045403","0.5042826","0.5042325","0.50421727","0.50421464","0.5041191","0.50394124","0.50328654","0.50326914","0.50319934","0.5031603","0.50275874","0.50273526","0.50252366","0.50247496","0.5023634","0.50232106","0.5020587","0.5020036","0.50111496","0.50101495","0.50056684","0.50055486","0.4999565","0.49981675","0.4997659","0.49939817","0.4992953","0.49927208","0.49921858","0.4991205","0.4991027","0.49773905","0.49754408","0.4968344","0.4968154","0.49675843","0.49634704"],"string":"[\n \"0.596013\",\n \"0.5699823\",\n \"0.56656635\",\n \"0.56514853\",\n \"0.56017965\",\n \"0.5583126\",\n \"0.55336237\",\n \"0.5523108\",\n \"0.55034256\",\n \"0.5462615\",\n \"0.54474133\",\n \"0.54238445\",\n \"0.5409785\",\n \"0.5402162\",\n \"0.5380286\",\n \"0.5365057\",\n \"0.5361857\",\n \"0.5359248\",\n \"0.5339483\",\n \"0.53059673\",\n \"0.5297546\",\n \"0.52901965\",\n \"0.52863413\",\n \"0.5284755\",\n \"0.52620703\",\n \"0.52612156\",\n \"0.5256129\",\n \"0.52552634\",\n \"0.5249977\",\n \"0.52496165\",\n \"0.52342784\",\n \"0.52276075\",\n \"0.52204454\",\n \"0.52183694\",\n \"0.5198899\",\n \"0.51978266\",\n \"0.51936305\",\n \"0.51910174\",\n \"0.51752925\",\n \"0.51689374\",\n \"0.51615703\",\n \"0.51590174\",\n \"0.51576036\",\n \"0.5149802\",\n \"0.5149252\",\n \"0.5147686\",\n \"0.5147045\",\n \"0.5136119\",\n \"0.5126882\",\n \"0.51235586\",\n \"0.51229274\",\n \"0.51136124\",\n \"0.5113351\",\n \"0.51067895\",\n \"0.5089737\",\n \"0.5088056\",\n \"0.50867283\",\n \"0.5082689\",\n \"0.506582\",\n \"0.5059423\",\n \"0.50524116\",\n \"0.5051697\",\n \"0.5046759\",\n \"0.5045403\",\n \"0.5042826\",\n \"0.5042325\",\n \"0.50421727\",\n \"0.50421464\",\n \"0.5041191\",\n \"0.50394124\",\n \"0.50328654\",\n \"0.50326914\",\n \"0.50319934\",\n \"0.5031603\",\n \"0.50275874\",\n \"0.50273526\",\n \"0.50252366\",\n \"0.50247496\",\n \"0.5023634\",\n \"0.50232106\",\n \"0.5020587\",\n \"0.5020036\",\n \"0.50111496\",\n \"0.50101495\",\n \"0.50056684\",\n \"0.50055486\",\n \"0.4999565\",\n \"0.49981675\",\n \"0.4997659\",\n \"0.49939817\",\n \"0.4992953\",\n \"0.49927208\",\n \"0.49921858\",\n \"0.4991205\",\n \"0.4991027\",\n \"0.49773905\",\n \"0.49754408\",\n \"0.4968344\",\n \"0.4968154\",\n \"0.49675843\",\n \"0.49634704\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13282,"cells":{"query":{"kind":"string","value":"1 kidney (left and right); 2 tumor"},"document":{"kind":"string","value":"def load_kits(self, patient):\n start = time.time()\n ct_path = self.folder + patient + '/imaging' + end\n array = load_sitk(ct_path)[np.newaxis, ...].astype(float)# Add 1 dimension\n \n # Corection of orientation\n array = array[:, ::-1, ::-1, ::-1]\n \n if self.pseudo_labels:\n mask_path = self.folder + patient + '/pseudo_seg-seg' + end\n else:\n mask_path = self.folder + patient + '/segmentation-seg' + end\n \n if self.load_mask and os.path.isfile(mask_path):\n \n mask = load_sitk(mask_path).astype(int)\n mask = mask[::-1, ::-1, ::-1]\n\n if self.pseudo_labels:\n label = 12*[1]\n else:\n mask, label = convert_kits(mask, self.keep_all_label)\n \n num_label = len(label)\n mask = np.rollaxis(np.eye(num_label, dtype=np.uint8)[mask], -1, 0)\n else:\n print(mask_path)\n mask = np.zeros(array.shape[1:], dtype=np.int16)\n mask = np.rollaxis(np.eye(2)[mask], -1, 0) # Put to one hot encoder\n label = 14*[0]\n\n stop = time.time()\n \n return array, mask, np.array(label), stop - start"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def right_child(self, pos): \n return (2 * pos) + 1","def boundary_op_n(v):\r\n h = list(v.dic.keys())[0]\r\n p = len(h) - 1\r\n s = P_chains([],[])\r\n if (p != 0) and (isinstance(h, str) != True) and (isinstance(h, frozenset) != True) and (isinstance(h, ImmutableMatrix) != True):\r\n if (is_int(list(v.dic.keys())) == True):\r\n for u in v.dic.keys():\r\n c = 0\r\n for i in u: \r\n w = list(u)[:]\r\n w.remove(i)\r\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**c) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n else:\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n return s\r\n else:\r\n aux = P_chains([],[])\r\n D = {}\r\n ct = 0\r\n st = []\r\n for u in v.dic.keys():\r\n for x in u:\r\n if x not in st:\r\n st.append(x)\r\n for i in st:\r\n D[tuple([ct])] = i\r\n ct = ct + 1\r\n for u in v.dic.keys():\r\n w2 = []\r\n for x in u:\r\n for y in list(D.keys()):\r\n if (x == D[y]):\r\n w2.append(y)\r\n aux = aux + P_chains([tuple(w2)],[v.dic[u]]) \r\n v = aux\r\n for u in v.dic.keys():\r\n c = 0\r\n for i in u: \r\n w = list(u)[:]\r\n w.remove(i)\r\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**c) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n else:\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n s2 = P_chains([],[])\r\n for u in s.dic.keys():\r\n w2=[]\r\n for i in u:\r\n w2.append(D[i])\r\n s2 = s2 + P_chains([tuple(w2)],[s.dic[u]])\r\n \r\n return s2\r\n else:\r\n return s","def _left(node):\n return 2 * node + 1","def _left(self, j):\n return 2 * j + 1","def _left(self, j):\n return 2 * j + 1","def middleUp(self):","def threes(dice):\n for i, j, k in combinations(dice, 3):\n if i == j == k:\n return 3 * i\n\n return 0","def needwu(A,B,S,d):\n AlignementA=\"\"\n AlignementB=\"\"\n F=matriF(A,B,S,d)\n i=len(A)-1\n j=len(B)-1\n\n while i>0 and j>0:\n score=F[i][j]\n scorediag=F[i-1][j-1]\n scoreup=F[i][j-1]\n scoreleft=F[i-1][j]\n\n if score==(scorediag+S[ind(A[i])][ind(B[j])]):\n AlignementA=A[i]+AlignementA\n AlignementB=B[j]+AlignementB\n i=i-1\n j=j-1\n\n elif score==(scoreleft+d):\n AlignementA=A[i]+AlignementA\n AlignementB=\"-\"+AlignementB\n i=i-1\n\n elif score==(scoreup+d):\n AlignementA=\"-\"+AlignementA\n AlignementB=B[j]+AlignementB\n j=j-1\n\n while i>0:\n AlignementA=A[i]+AlignementA\n AlignementB=\"-\"+AlignementB\n i=i-1\n\n while j>0:\n AlignementA=\"-\"+AlignementA\n AlignementB=B[j]+AlignementB\n j=j-1\n\n return AlignementA, AlignementB","def exchange_branches(self, straight='Down'):\n\n d_first = dict() # up branch\n d_second = dict() # down branch\n\n level = len(str(self.n_parent).split(\":\")) + 1\n n_num = int(self.n)\n if straight == 'Down':\n n_next = int(self.n) + 1\n else:\n if straight == 'Up':\n n_next = int(self.n) - 1\n else:\n print('Entered not right straingth!!!')\n return\n\n mask_cur = str(self.n_parent) + \":\" + str(n_num)\n mask_next = str(self.n_parent) + \":\" + str(n_next)\n # find elements above\n for k, v in self.d.items():\n num = int(str(k).split(\":\")[-1])\n if len(str(k).split(\":\")) >= level and str(k).startswith(mask_cur):\n l_elem = str(k).split(\":\")\n if straight == 'Down':\n num = int(l_elem[level - 1]) + 1\n else:\n num = int(l_elem[level - 1]) - 1\n # summon key\n s_first = \"\" # first part of string\n s_last = \"\" # last part of string\n for i in range(0, level - 1):\n if i == 0:\n s_first = s_first + l_elem[i]\n else:\n s_first = s_first + \":\" + l_elem[i]\n try:\n for j in range(level, len(l_elem)):\n if j == 0:\n s_last = s_last + l_elem[j]\n else:\n s_last = s_last + \":\" + l_elem[j]\n except:\n pass\n\n if s_last.startswith(\":\"):\n s = ''\n for w in range(1, len(s_last)):\n s = s + s_last[w]\n s_last = s\n # summon\n if s_last:\n s_summon = str(s_first) + \":\" + str(num) + \":\" + str(s_last)\n else:\n s_summon = str(s_first) + \":\" + str(num)\n\n # write to dictionary\n d_first[s_summon] = v\n self.d.pop(k)\n\n if len(str(k).split(\":\")) >= level and str(k).startswith(mask_next):\n l_elem = str(k).split(\":\")\n if straight == 'Down':\n num = int(l_elem[level - 1]) - 1\n else:\n num = int(l_elem[level - 1]) + 1\n\n # summon key\n s_first = \"\" # first part of string\n s_last = \"\" # last part of string\n for i in range(0, level - 1):\n if i == 0:\n s_first = s_first + l_elem[i]\n else:\n s_first = s_first + \":\" + l_elem[i]\n try:\n for j in range(level, len(l_elem)):\n if j == 0:\n s_last = s_last + l_elem[j]\n else:\n s_last = s_last + \":\" + l_elem[j]\n\n except:\n pass\n\n if s_last.startswith(\":\"):\n s = ''\n for w in range(1, len(s_last)):\n s = s + s_last[w]\n s_last = s\n\n # summon\n if s_last:\n s_summon = str(s_first) + \":\" + str(num) + \":\" + str(s_last)\n else:\n s_summon = str(s_first) + \":\" + str(num)\n\n # write to dictionary\n d_second[s_summon] = v\n self.d.pop(k)\n\n for kk, vv in d_first.items():\n self.d[kk] = vv\n\n for kkk, vvv in d_second.items():\n self.d[kkk] = vvv","def needleman_wunsch1(x,y,lodict=None,gop=-2.5, gep=-1.75, local=False):\n n,m = len(x),len(y)\n dp = np.zeros((n+1,m+1))\n pointers = np.zeros((n+1,m+1),np.int32)\n for i in range(1,n+1):\n dp[i,0] = dp[i-1,0]+(gep if i>1 else gop)\n pointers[i,0]=1\n for j in range(1,m+1):\n dp[0,j] = dp[0,j-1]+(gep if j>1 else gop)\n pointers[0,j]=2\n for i in range(1,n+1):\n for j in range(1,m+1):\n if not lodict:\n if x[i-1] == y[j-1]:\n match = dp[i-1,j-1]+1\n else:\n match = dp[i-1,j-1]-1\n else:\n match = dp[i-1,j-1]+lodict[x[i-1],y[j-1]]\n insert = dp[i-1,j]+(gep if pointers[i-1,j]==1 else gop)\n delet = dp[i,j-1]+(gep if pointers[i,j-1]==2 else gop)\n max_score = max([match,insert,delet])\n dp[i,j] = max_score\n pointers[i,j] = [match,insert,delet].index(max_score)\n alg = []\n i,j = n,m\n while(i>0 or j>0):\n pt = pointers[i,j]\n if pt==0:\n i-=1\n j-=1\n alg = [[x[i],y[j]]]+alg\n if pt==1:\n i-=1\n alg = [[x[i],'-']]+alg\n if pt==2:\n j-=1\n alg = [['-',y[j]]]+alg\n return dp[-1,-1], alg","def left(t):\r\n return t(1)","def rightUp(self):","def left_child(self, pos): \n return 2 * pos","def build_leftpart():\n # build kelly.\n build_kelly()\n # copy kelly to 3.\n copy(0, 3)\n\n # build june in slots 0,1,2\n build_june()\n # copy kelly to slot 1\n copy(3, 1)\n\n # smash together to get (june kelly) in 0\n smash()\n # copy (june kelly) to 1\n copy(0, 1)\n # build horace in 0\n build_horace(0)\n # smash together to get (horace (june kelly)) in 0\n smash()\n # wrap with an S for the whole left part.\n apply_card(\"S\", 0)","def build_rightpart():\n # build in 1: (K dec)\n apply_card(\"put\", 1)\n apply_slot(1, \"dec\")\n apply_card(\"K\", 1)\n\n # build in 0: greg\n build_greg(0)\n\n # smash together to get (greg (K dec)) in 0\n smash()\n\n # copy it to 1.\n apply_card(\"put\", 1)\n apply_slot(1, \"zero\")\n apply_card(\"get\", 1)\n\n # build horace in 0.\n build_horace(0)\n\n # smash together to get (horace (greg (K dec))) in 0.\n smash()\n\n # Wrap with an S.\n apply_card(\"S\", 0)\n\n # build ian in 1.\n build_ian(1)\n\n # smash together to get ((S (horace (greg (K dec)))) ian) in 0.\n smash()","def king2(r, n0, rc0, b0, n1, rc1, b1):\n return n0 * (1. + (r/rc0)**2)**b0 + n1 * (1. + (r/rc1)**2)**b1","def _shift(self, c, mark):\n import pdb\n #pdb.set_trace()\n debug(\"sequence shift with mark %s\", mark)\n old_marked_left = self.left.marked\n marked_left = self.left.shift(c, mark) # based on current letter\n marked_right = self.right.shift(\n c, old_marked_left or (mark and self.left.empty))\n \n return (marked_left and self.right.empty) or marked_right\n \"\"\"\n if marked_right:\n return marked_right + 1\n else:\n # TODO, empties advance the counter\n return max(marked_left, self.right.empty)\n \"\"\"","def left(i):\r\n return 2 * i + 1","def __left(self,i):\n return 1+(i<<1)","def twist(self):\n self.right()\n time.sleep(1)\n self.stop()\n self.left()\n time.sleep(1)\n self.stop()","def right(t):\r\n return t(2)","def score( canvas ):\n\n score = 0\n\n score += length_score(canvas)\n score += angle_score(canvas)\n\n # 1. Chainbreaks for all junction loops.\n\n # 2. Nucleotides should be at least 15 from ALL other nts. Don't double-count.\n for seqpos1, nt1 in canvas.nucleotides.iteritems():\n for seqpos2, nt2 in canvas.nucleotides.iteritems():\n if seqpos1 >= seqpos2: continue\n #if distance( nt1, nt2 ) < 15: score += 100\n # Don't do a square root you don't have to\n if distance_squared( nt1, nt2 ) < 225: score += 100\n\n\n # 2b. Depending on base pair width, it's possible that the 'best' orientation for two stacks is\n # for them to be overlapping...\n # nt --- nt\n # | nt |-- nt\n # nt -|- nt |\n # | nt |-- nt\n # so, penalize this ( 'between two bp'ed nts' penalized like hitting a nt )\n for seqpos, nt in canvas.nucleotides.iteritems():\n for stem in canvas.stems:\n for bp in stem.base_pairs:\n if nt == bp.nt1 or nt == bp.nt2:\n continue\n # if nt in question is 'in between' nt1 and nt2. how to judge?\n if nt.x > bp.nt1.x and nt.x < bp.nt2.x \\\n and closer_than( nt.y, bp.nt1.y, canvas.bp_offset_height*0.8 ):\n score += 100\n\n # Look at pairs of adjacent nts in stem\n for seqpos1, nt1 in stem.nucleotides.iteritems():\n if seqpos1 + 1 in stem.nucleotides.keys():\n nt2 = stem.nucleotides[ seqpos1 + 1 ]\n if nt.y > nt1.y and nt.y < nt2.y \\\n and closer_than( nt.x, nt1.x, canvas.bp_offset_width*0.8 ):\n score += 100\n\n # 3. Stems should be straight and vertical.\n ### Resolved via kinematics?\n\n # 4. Coaxial stacks, where known, should be colinear.\n for idx1, idx2 in canvas.list_of_coaxialities:\n # idx1 and idx2 are coaxial stems.\n # Any two BPs from these stems should do, but -- because I have no idea\n # how we intend to handle 'alternate-order' stacks (where the first nt in a bp\n # is stacked on the second nt in another), compare either direction.\n bp1 = canvas.stems[idx1].base_pairs[0]\n bp2 = canvas.stems[idx2].base_pairs[0]\n penalty1 = harmonic_penalty( bp1.nt1.x - bp2.nt1.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt2.x, 0, 1 )\n penalty2 = harmonic_penalty( bp1.nt1.x - bp2.nt2.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt1.x, 0, 1 )\n score += min( penalty1, penalty2 )\n\n\n # 5. Apical loops should be symmetrical and near a circular path.\n for loop in canvas.loops:\n for seqpos in loop.nucleotides.keys():\n pass\n\n return score","def left_or_right(self):\n #traversal\n left_total = 0\n left_count = 0\n right_total = 0\n right_count = 0\n self.scan()\n for ang, dist in self.scan_data.items():\n if ang < self.MIDPOINT:\n right_total += dist\n right_count += 1\n print(\"Angle: %d // dist: %d // right_count: %d\" % (ang, dist, right_count))\n else:\n left_total += dist\n left_count += 1\n left_avg = left_total / left_count\n right_avg = right_total / right_count\n if left_avg > right_avg:\n self.turn_by_deg(-45)\n else:\n self.turn_by_deg(45)\n # if robot is facing the wrong way it will turn it around\n self.exit_bias()","def leftUp(self):","def substantiate():","def right(self):\n self.counterUp(teamNumber = 2)","def rightChild(self, pos):\n return (2 * pos) + 1","def rightChild(self, pos):\n return (2 * pos) + 1","def kung(vectors):\n m = len(vectors)\n # if there is only one vector left, return it\n if m == 1:\n return vectors\n #[left,right]\n left = vectors[0: m//2]\n right = vectors[m//2: m]\n\n nleft = kung(left)\n nright = kung(right)\n\n # left garanteed undominated\n return merge(nleft, nright)","def tower_of_hanoi_stack(n, beg, aux, end):","def heads_legs(heads, legs):\n for i in range(0, heads + 1):\n cows = heads - i\n if 4 * cows + 2 * i == legs:\n chickens = i\n return chickens, cows\n return \"No solutions.\"","def test_right_order():\n assert 'right' == classify_triangle(5,3,4)","def needleman_wunsch(x, y, lodict={}, gop=-2.5, gep=-1.75, local=False, indel=''):\n n, m = len(x), len(y)\n dp = np.zeros((n + 1, m + 1))\n pointers = np.zeros((n + 1, m + 1), np.int32)\n if not local:\n for i1, c1 in enumerate(x):\n if gop is None:\n dp[i1 + 1, 0] = lodict.get((c1, indel), gep)\n else:\n dp[i1 + 1, 0] = dp[i1, 0]+(gep if i1 + 1 > 1 else gop)\n pointers[i1 + 1, 0] = 1\n for i2, c2 in enumerate(y):\n if gop is None:\n dp[0, i2 + 1] = lodict.get((indel, c2), gep)\n else:\n dp[0, i2 + 1] = dp[0, i2]+(gep if i2 + 1 > 1 else gop)\n pointers[0, i2 + 1] = 2\n for i1, c1 in enumerate(x):\n for i2, c2 in enumerate(y):\n match = dp[i1, i2] + lodict.get(\n (c1, c2),\n 1 if c1 == c2 else -1)\n insert = dp[i1, i2 + 1] + (\n lodict.get((c1, indel), gep) if gop is None else\n gep if pointers[i1, i2 + 1] == 1 else gop)\n delet = dp[i1 + 1, i2] + (\n lodict.get((indel, c2), gep) if gop is None else\n gep if pointers[i1 + 1, i2] == 2 else gop)\n pointers[i1 + 1, i2 + 1] = p = np.argmax([match, insert, delet])\n max_score = [match, insert, delet][p]\n if local and max_score < 0:\n max_score = 0\n dp[i1 + 1, i2 + 1] = max_score\n alg = []\n if local:\n i, j = np.unravel_index(dp.argmax(), dp.shape)\n else:\n i, j = n, m\n score = dp[i, j]\n while (i > 0 or j > 0):\n pt = pointers[i, j]\n if pt == 0:\n i -= 1\n j -= 1\n alg = [(x[i], y[j])] + alg\n if pt == 1:\n i -= 1\n alg = [(x[i], indel)] + alg\n if pt == 2:\n j -= 1\n alg = [(indel, y[j])] + alg\n if local and dp[i, j] == 0:\n break\n return score, alg","def _right(node):\n return 2 * node + 2","def straight(handIn):","def left(i):\n return 2*i","def ski(right, down):\n matrix = read_map_into_matrix()\n outer_selector = (i % down == 0 for i in range(len(matrix)))\n\n column = 1\n trees = 0\n\n for row in compress(matrix, outer_selector):\n inner_selector = (i == column - 1 for i in range(column))\n\n col = next(compress(row, inner_selector))\n\n if col == \"#\":\n trees += 1\n\n column += right\n\n return trees","def test_depth_one_and_two(self):\n board = Board([[2, 3], [2, 2, 2, 2]],\n workers={self.workers[i]: (1, i)\n for i in range(len(self.workers))})\n # self.assertTrue(tree.do_survive(board, 1, False, \"p1\", \"p2\", self.workers[1],\n # Direction.NORTH))\n # self.assertTrue(tree.do_survive(board, 1, False, \"p1\", \"p2\", self.workers[0],\n # Direction.NORTH, Direction.EAST))\n # self.assertTrue(tree.do_survive(board, 1, False, \"p1\", \"p2\", self.workers[0],\n # Direction.SOUTH, Direction.EAST))\n # self.assertTrue(tree.do_survive(board, 1, False, \"p1\", \"p2\",self.workers[1],\n # Direction.SOUTH, Direction.EAST))\n # self.assertFalse(tree.do_survive(board, 2, False, \"p1\", \"p2\",self.workers[1],\n # Direction.SOUTH, Direction.EAST))","def __right(self,i):\n return (1+i)<<1","def get_left_right_stoichiometries(r1):\n r1_left = [(str(c), get_coefficient(r1,c,'left')) for c in \n db[r1].slot_values('left')]\n r1_left.sort()\n r1_right = [(str(c), get_coefficient(r1,c,'right')) for c in \n db[r1].slot_values('right')]\n r1_right.sort()\n \n return tuple(r1_left), tuple(r1_right)","def test_splitting_on_feature(num = 0):\n left = [0,0]\n right = [0,0]\n for i, side in enumerate(train_matrix_df[num]):\n if int(side) == 0: \n if train_labels_df.ix[i]['candy_id'] == 0:\n left[0] += 1\n else:\n left[1] += 1\n else:\n if train_labels_df.ix[i]['candy_id'] == 0:\n right[0] += 1\n else:\n right[1] += 1\n\n #print \" %s goes to the %i side\" %(train_labels_df.ix[i]['candy'], side)\n\n print str(left) + \"<--left -- + -- right-->\" + str(right)","def simple_chained_rep_rnn_phi(t1, t2):\n return t1.leaves() + t2.leaves()","def question4(T, r, n1, n2):\n\tif len(T) == 0:\n\t\treturn T\n\telif len(T) == 1:\n\t\treturn r\n\tindex_holder = None\n\tparent1 = []\n\twhile index_holder != r:\n\t\tfor a in range(len(T)):\n\t\t\tif T[a][n1] == 1:\n\t\t\t\tindex_holder = a\n\t\t\t\tn1 = index_holder\n\t\t\t\tparent1.append(index_holder)\n\tother_index = None\n\tparent2 = []\n\twhile other_index != r:\n\t\tfor a in range(len(T)):\n\t\t\tif T[a][n2] == 1:\n\t\t\t\tother_index = a\n\t\t\t\tn2 = other_index\n\t\t\t\tparent2.append(other_index)\n\tfor a1 in parent1:\n\t\tfor a2 in parent2:\n\t\t\tif a1 == a2:\n\t\t\t\treturn a1","def get_others(map_, r, c):\n nums = 0\n # your code here\n if r == 0 and c == 0: #top left corder\n nums += 2\n if len(map_[0]) > 1:\n if map_[r][c+1] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n elif r == 0 and c == len(map_[0])-1: #top right corner\n nums += 2\n if len(map_[0]) > 1:\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n elif r == len(map_)-1 and c == 0: #bottom left corder\n nums += 2\n if len(map_[0]) > 1:\n if map_[r][c+1] == 0:\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n elif r == len(map_)-1 and c == len(map_[0])-1: #bottom right corner\n nums += 2\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n elif r == 0: # top edge, excluding corner\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r][c+1] == 0:\n nums += 1\n if len(map_) > r and map_[r+1][c] == 0:\n nums += 1\n elif r == len(map_)-1: # bottom edge, excluding corner\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r][c+1] == 0:\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n elif c == 0: # left edge, excluding corner\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n if len(map_[0]) > c and map_[r][c+1] == 0:\n nums += 1\n elif c == len(map_[0])-1: # right edge. excluding corner\n nums += 1\n if map_[r-1][c] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n else: # the rest, excluding edge and corner\n if map_[r-1][c] == 0:\n nums += 1\n if map_[r+1][c] == 0:\n nums += 1\n if map_[r][c-1] == 0:\n nums += 1\n if map_[r][c+1] == 0:\n nums += 1\n return nums","def _left(self, index):\r\n return 2*index + 1","def step2(self):\n\t\tif self.b[self.k - 1] == 'a':\n\t\t\tif self.ends(\"ational\"): self.r(\"ate\")\n\t\t\telif self.ends(\"tional\"): self.r(\"tion\")\n\t\telif self.b[self.k - 1] == 'c':\n\t\t\tif self.ends(\"enci\"):\t self.r(\"ence\")\n\t\t\telif self.ends(\"anci\"): self.r(\"ance\")\n\t\telif self.b[self.k - 1] == 'e':\n\t\t\tif self.ends(\"izer\"):\t self.r(\"ize\")\n\t\telif self.b[self.k - 1] == 'l':\n\t\t\tif self.ends(\"bli\"):\t self.r(\"ble\") # --DEPARTURE--\n\t\t\t# To match the published algorithm, replace this phrase with\n\t\t\t#\tif self.ends(\"abli\"):\t self.r(\"able\")\n\t\t\telif self.ends(\"alli\"): self.r(\"al\")\n\t\t\telif self.ends(\"entli\"): self.r(\"ent\")\n\t\t\telif self.ends(\"eli\"):\t self.r(\"e\")\n\t\t\telif self.ends(\"ousli\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 'o':\n\t\t\tif self.ends(\"ization\"): self.r(\"ize\")\n\t\t\telif self.ends(\"ation\"): self.r(\"ate\")\n\t\t\telif self.ends(\"ator\"): self.r(\"ate\")\n\t\telif self.b[self.k - 1] == 's':\n\t\t\tif self.ends(\"alism\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iveness\"): self.r(\"ive\")\n\t\t\telif self.ends(\"fulness\"): self.r(\"ful\")\n\t\t\telif self.ends(\"ousness\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 't':\n\t\t\tif self.ends(\"aliti\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iviti\"): self.r(\"ive\")\n\t\t\telif self.ends(\"biliti\"): self.r(\"ble\")\n\t\telif self.b[self.k - 1] == 'g': # --DEPARTURE--\n\t\t\tif self.ends(\"logi\"):\t self.r(\"log\")\n\t\t# To match the published algorithm, delete this phrase","def _right(self, col, row):\n ones = 0\n twos = 0\n for step in range(4):\n current = self.layout[col + (step)][row] #step and right\n if current == 1: ones+=1\n if current == 2: twos+=1\n\n return self._score_a_quartet(ones, twos)","def king(r, n0, rc, b):\n return n0 * (1. + (r/rc)**2)**b","def turn_around():\n for i in range(2):\n turn_left()","def snake(A, B, M, N, k, y):\n\n x = y - k\n while (x < M) and (y < N) and (A[x] == B[y]):\n x = x + 1\n y = y + 1\n return y","def middleDown(self):","def leftChild(self, pos):\n return 2 * pos","def leftChild(self, pos):\n return 2 * pos","def sprout_leaves(t, vals):","def right_or_left(self): \n right_sum = 0\n right_avg = 0\n left_sum = 0\n left_avg = 0\n self.scan()\n for angle in self.scan_data:\n if angle < self.MIDPOINT:\n right_sum += self.scan_data[angle]\n right_avg += 1\n else: \n left_avg += self.scan_data[angle]\n left_avg += 1\n\n left_avg = left_sum / left_avg \n right_avg = right_sum / right_avg\n\n if left_avg > right_avg: \n return 'l' \n else:\n return 'r'","def test_right_rotation_four_node_tree():\n from bbst import Bst\n tree = Bst([5, 4, 3, 2, 1])\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\n assert tuple(tree.breadth_first()) == (4, 2, 5, 1, 3)\n assert tuple(tree.pre_order()) == (4, 2, 1, 3, 5)\n assert tuple(tree.post_order()) == (1, 3, 2, 5, 4)\n assert tree.depth() == 3\n assert tree.balance() == -1","def ht(node):\n n = 0\n while node: n, node = n+1, node.left\n return n","def go_down(self):\n\n d_first = dict() # up branch\n #d_second = dict() # down branch\n\n level = len(str(self.n_parent).split(\":\")) + 1\n n_num = int(self.n)\n\n n_next = int(self.n) + 1\n\n mask_cur = str(self.n_parent) + \":\" + str(n_num)\n #mask_next = str(self.n_parent) + \":\" + str(n_next)\n # find elements above\n for k, v in self.d.items():\n num = int(str(k).split(\":\")[-1])\n if len(str(k).split(\":\")) >= level and str(k).startswith(mask_cur):\n l_elem = str(k).split(\":\")\n\n num = int(l_elem[level - 1]) + 1\n #else:\n # num = int(l_elem[level - 1]) - 1\n # summon key\n s_first = \"\" # first part of string\n s_last = \"\" # last part of string\n for i in range(0, level - 1):\n if i == 0:\n s_first = s_first + l_elem[i]\n else:\n s_first = s_first + \":\" + l_elem[i]\n try:\n for j in range(level, len(l_elem)):\n if j == 0:\n s_last = s_last + l_elem[j]\n else:\n s_last = s_last + \":\" + l_elem[j]\n except:\n pass\n\n if s_last.startswith(\":\"):\n s = ''\n for w in range(1, len(s_last)):\n s = s + s_last[w]\n s_last = s\n # summon\n if s_last:\n s_summon = str(s_first) + \":\" + str(num) + \":\" + str(s_last)\n else:\n s_summon = str(s_first) + \":\" + str(num)\n\n # write to dictionary\n d_first[s_summon] = v\n self.d.pop(k)\n\n\n\n for kk, vv in d_first.items():\n self.d[kk] = vv","def positive_left_right_requirements(\n self,\n ) -> Tuple[Tuple[GriddedPerm, ...], Tuple[GriddedPerm, ...]]:\n left, right = [], []\n for (x, y) in self._tiling.active_cells:\n if self._fuse_row and y == self._row_idx:\n left.append(GriddedPerm.single_cell((0,), (x, y)))\n right.append(GriddedPerm.single_cell((0,), (x, y + 1)))\n if not self._fuse_row and x == self._col_idx:\n left.append(GriddedPerm.single_cell((0,), (x, y)))\n right.append(GriddedPerm.single_cell((0,), (x + 1, y)))\n return tuple(sorted(left)), tuple(sorted(right))","def roll(state, d):\n (p, me, you, pending) = state\n if d == 1:\n return (other[p], you, me+1, 0) # pig out; other player's turn\n else:\n return (p, me, you, pending+d) # accumulate die roll in pending","def is_oriented(word1: str, word2: str):\n tree1, tree2, label_to_vertex = construct_trees(word1, word2)\n OUT = \"OUT\"\n pairs = set()\n\n index = {OUT: 0}\n\n verts_1 = (v for v in tree1.in_order_vertices() if not v.is_leaf())\n verts_2 = (v for v in tree2.in_order_vertices() if not v.is_leaf())\n for i, (a, b) in enumerate(zip(verts_1, verts_2), start=1):\n index[a] = index[b] = i\n\n for root in tree1, tree2:\n hill_children = defaultdict(list)\n # hill_children[OUT] = root\n hill_parent = {root: OUT}\n\n for v in root.breadth_first_vertices():\n if v.is_leaf():\n continue\n left, right = v.left, v.right\n if not right.is_leaf():\n # hill_children[v].append(right)\n hill_parent[right] = v\n if not left.is_leaf():\n my_parent = hill_parent[v]\n # hill_children[my_parent].append(left)\n hill_parent[left] = my_parent\n\n for child, parent in hill_parent.items():\n a, b = index[child], index[parent]\n pairs |= {(a, b), (b, a)}\n\n adj_list = defaultdict(list)\n for a, b in pairs:\n adj_list[a].append(b)\n\n return is_bipartite(adj_list)","def hangman_figure(attempt_left):\n if attempt_left == N_TURNS:\n print('___________')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 1:\n print('___________')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 2:\n print('___________')\n print('| |')\n print('| O')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 3:\n print('___________')\n print('| |')\n print('| O')\n print('| |')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 4:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 5:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 6:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| /')\n print('| |')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 7:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 8:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| |')\n print('|_____')\n if attempt_left == N_TURNS - 9:\n print('___________')\n print('| |')\n print('| O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| | |')\n print('|_____')\n if attempt_left == N_TURNS - 10:\n print('___________')\n print('| |')\n print('| -O')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| | |')\n print('|_____')\n if attempt_left == N_TURNS - 11:\n print('___________')\n print('| |')\n print('| -O-')\n print('| \\\\_|_/')\n print('| |')\n print('| / \\\\')\n print('| | |')\n print('| | |')\n print('|_____')","def part_two(inp: defaultdict) -> int:\n calculate_inside_bags = lambda color: sum(\n int(child[0]) * (calculate_inside_bags(child[1]) + 1) for child in inp[color]\n )\n return calculate_inside_bags(\"shiny gold\")","def _right(self, j):\n return 2 * j + 2","def _right(self, j):\n return 2 * j + 2","def fn(node):\n nonlocal ans \n if not node: return 1\n left, right = fn(node.left), fn(node.right)\n if left == 0 or right == 0: \n ans += 1\n return 2 # add a camera \n if left == 2 or right == 2: return 1\n return 0","def right_child(self, index):\n return 2 * index + 1","def answer():\n for k in range(2,3000):\n for j in range(k-1,0,-1):\n pj, pk = P(j), P(k)\n #print( j, k, pj, pk )\n if isPent(pk-pj):\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\n if isPent(pk+pj) and isPent(pk-pj):\n return pk-pj","def right_child(self, index):\n return 2 * index + 2","def testt_left_right_rotation_five_node_tree():\n from bbst import Bst\n tree = Bst([4, 5, 1, 3, 2])\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\n assert tuple(tree.breadth_first()) == (4, 2, 5, 1, 3)\n assert tuple(tree.pre_order()) == (4, 2, 1, 3, 5)\n assert tuple(tree.post_order()) == (1, 3, 2, 5, 4)\n assert tree.depth() == 3\n assert tree.balance() == -1","def _right_to_left(self, key):\n return self._right_bank.get(key, key)","def cantor() -> bigger.MCG[Edge]: # pylint: disable=too-many-statements\n\n POS, EQ, NEG = +1, 0, -1\n\n def edges() -> Iterable[Edge]:\n for x in naturals():\n for y in [POS, EQ, NEG]:\n yield x, y\n\n def negate(X: Edge) -> Edge:\n return X[0], -X[1]\n\n def invert(sign: int, X: tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\n return X if sign == POS else (negate(X[6]), not X[7], negate(X[4]), not X[5], negate(X[2]), not X[3], negate(X[0]), not X[1])\n\n def link(edge: Edge) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\n n, k = edge\n if k == EQ: # Equator\n if n == 0:\n return ((0, NEG), False, (1, NEG), True, (1, POS), False, (0, POS), True)\n elif n == 1:\n return ((2, POS), False, (0, POS), False, (0, NEG), True, (2, NEG), True)\n else: # n > 1\n return ((3 * n - 3, NEG), False, (3 * n - 1, NEG), True, (3 * n - 1, POS), False, (3 * n - 3, POS), True)\n\n # Northern / Southern hemisphere.\n if n == 0:\n return invert(k, ((0, EQ), False, (1, POS), False, (1, EQ), True, (2, POS), False))\n elif n == 1:\n return invert(k, ((4, POS), False, (3, POS), False, (0, POS), True, (0, EQ), False))\n elif n == 2:\n return invert(k, ((7, POS), False, (6, POS), False, (0, POS), False, (1, EQ), True))\n N, r = n // 3 + 1, n % 3\n incoming = 3 * (N // 2) - (1 if N % 2 else 2)\n if r == 0:\n return invert(k, ((N, EQ), False, (n + 2, POS), False, (incoming, POS), True, (n + 1, POS), False))\n elif r == 1:\n return invert(k, ((6 * N - 2, POS), False, (6 * N - 3, POS), False, (n - 1, POS), False, (incoming, POS), True))\n else: # r == 2:\n return invert(k, ((6 * N + 1, POS), False, (6 * N + 0, POS), False, (n - 2, POS), True, (N, EQ), False))\n\n T = bigger.Triangulation.from_pos(edges, link)\n\n def generator(name: str) -> bigger.Encoding[Edge]: # pylint: disable=too-many-branches\n twist_match = re.match(r\"(?P<curve>[ab])_(?P<n>-?\\d+)$\", name)\n rotate_match = re.match(r\"r$\", name)\n\n if twist_match is not None:\n parameters = twist_match.groupdict()\n curve_name = parameters[\"curve\"]\n N = int(parameters[\"n\"])\n if curve_name == \"a\":\n if N == 1:\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\n else:\n cut_sequence = [(0, EQ), (N, EQ), (3 * N - 3, POS)]\n while N > 1:\n low_N = N // 2\n cut_sequence.append((3 * low_N - (1 if N % 2 else 2), POS))\n if N % 2:\n cut_sequence.append((3 * low_N - 3, POS))\n N = low_N\n elif curve_name == \"b\":\n if N <= 3:\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\n else:\n extend_left = N % 2\n N = N // 2\n cut_sequence = [(N, EQ), (3 * N - 3, POS)]\n while N > 1:\n N_low = N // 2\n cut_sequence.append((3 * N_low - (1 if N % 2 else 2), POS))\n if extend_left:\n cut_sequence.append((3 * N_low - 3, POS))\n if N % 2 != extend_left:\n cut_sequence.append((N_low, EQ))\n break\n N = N_low\n else:\n cut_sequence.append((0, EQ))\n\n curve = T(dict(((x, y * s), 1) for x, y in cut_sequence for s in [+1, -1]))\n return curve.twist()\n elif rotate_match is not None:\n\n def isom(edge: Edge) -> Edge:\n n, k = edge\n if k == EQ:\n if n == 0:\n return (1, EQ)\n elif n == 1:\n return (0, EQ)\n return (n ^ (1 << n.bit_length() - 2), k)\n\n if n == 0:\n return (0, k)\n elif n == 1:\n return (2, k)\n elif n == 2:\n return (1, k)\n N, r = n // 3 + 1, n % 3\n return (3 * (N ^ (1 << N.bit_length() - 2)) - 3 + r, k)\n\n return T.encode([(-1, isom, isom)])\n\n raise ValueError(f\"Unknown mapping class {name}\")\n\n return bigger.MCG(T, generator)","def left_right(steps):\n lengths = lens(steps)\n a_side = []\n b_side = []\n for i in range(len(lengths)):\n if i % 2 == 0:\n a_side.append(steps[i])\n else:\n b_side.append(steps[i])\n return a_side, b_side","def test_right_left__rotation_five_node_tree():\n from bbst import Bst\n tree = Bst([1, 2, 5, 3, 4])\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\n assert tuple(tree.breadth_first()) == (2, 1, 4, 3, 5)\n assert tuple(tree.pre_order()) == (2, 1, 4, 3, 5)\n assert tuple(tree.post_order()) == (1, 3, 5, 4, 2)\n assert tree.depth() == 3\n assert tree.balance() == 1","def test_four_nodes_needs_right_left_rotation(three_del):\n three_del.insert(25)\n three_del.delete(10)\n assert tuple(three_del.in_order()) == (20, 25, 30)\n assert tuple(three_del.breadth_first()) == (25, 20, 30)","def binary_tree(length, depth):\n if depth == 0:\n return # base case\n posx = turtle.xcor()\n posy = turtle.ycor()\n left(length, depth)\n turtle.up()\n turtle.goto(posx, posy)\n #turtle.dot()\n turtle.down()\n right(length, depth)","def r(t, i, j):\n\n #when get to (i,j) position, minus the food with the zombie needs\n t -= grid[i][j]\n\n\n #the food is not enough for rabbit to get to the top left or \n #rabbit can't go left or top. \n if i < 0 or j < 0 or t < 0:\n return food+1\n\n #can get to the top left, t is the remainder.\n elif i == 0 and j == 0:\n return t\n\n #choose the less food grid.\n else:\n return min(r(t, i-1, j), r(t, i, j-1))","def m_put(state,b1,b2):\n if state.holding['hand'] == b1:\n if b2 == 'table':\n return [('putdown',b1)]\n else:\n return [('stack',b1,b2)]\n else:\n return False","def test_left_rotation_four_node_tree():\n from bbst import Bst\n tree = Bst([1, 2, 3, 4, 5])\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\n assert tuple(tree.breadth_first()) == (2, 1, 4, 3, 5)\n assert tuple(tree.pre_order()) == (2, 1, 4, 3, 5)\n assert tuple(tree.post_order()) == (1, 3, 5, 4, 2)\n assert tree.depth() == 3\n assert tree.balance() == 1","def gen_Strikes(L):\r\n p = next_Prim(L)\r\n t = 1\r\n yield t*p\r\n for k in L:\r\n t += k\r\n yield t*p","def find_boyer_moore(T, P):\n n, m = len(T), len(P)\n if m == 0: return 0\n last = {} # Using hash table for fast access\n for k in range(m):\n last[P[k]] = k\n i = m - 1 # i index at T, k index at P\n k = m - 1 # j index of last occurrence of T[i] in P\n while i < n:\n if T[i] == P[k]: # if chars are equal\n \"\"\" INCORRECT PART \"\"\"\n i -= 1 # normal iteration\n k -= 1\n if k == 0:\n return i # check if Patter is complete\n else:\n # if j < k (remember k index at P)\n # shift i += m - (j+1)\n # if j > k\n # shift i += m - k\n j = last.get(T[i], -1) # -1 if item not there\n i += m - (min(k, j+1))\n k = m - 1\n return -1","def solve_gkeeper():\n\n nonlocal field\n nonlocal bench\n nonlocal n_subst\n\n # If the goal keeper n the field received a vote we delete all the\n # remaining goal keepers from the bench\n if find_gkeeper(field):\n bench = delete_gkeeper(bench)\n\n # If the gkeeper in the field has no vote but the there is at least one\n # gkeeper in the bench with vote we make the substitution and delete\n # all the remaining gkeepers from the lineup, if there is any. We\n # finally decrease the n_subst\n elif not find_gkeeper(field) and find_gkeeper(bench):\n gkeeper = find_gkeeper(bench)\n field.insert(0, gkeeper)\n bench = delete_gkeeper(bench)\n n_subst -= 1\n\n # If there is no gkeeper with vote neither in the field nor in the\n # bench than we just decrease the n_subst\n elif not find_gkeeper(field) and not find_gkeeper(bench):\n n_subst -= 1","def TR_algo2(p, vd=2):\n # h will contain the Hilbert index\n h = 0\n # ve and vd contain the entry point and dimension of the current subcube\n # we choose here a main traversal direction N-2 (i.e. z for a cube) to match\n # the illustrations\n ve = 0\n for i in range(M-1, -1, -1):\n # the cell label is constructed in two steps\n # 1. extract the relevant bits from p\n l = [bit_component(px, i) for px in p]\n # 2. construct a integer whose bits are given by l\n l = sum( [lx*2**j for j, lx in enumerate(l)] )\n # transform l into the current subcube\n l = T(ve, vd, l)\n # obtain the gray code ordering from the label l\n w = inverse_gc(l)\n # compose (see [TR] lemma 2.13) the transform of ve and vd\n # with the data of the subcube\n ve = ve ^ (rotate_left(e(w), vd+1))\n vd = (vd + d(w) + 1) % N\n # move the index to more significant bits and add current value\n h = (h << N) | w\n return h","def right(i):\r\n return 2 * i + 2","def tweak(rg):\n (r, g) = rg\n if r == 0 and g == 0:\n return 0, 0\n elif r == 1 and g == 1:\n return 2, 2\n elif r == 0:\n if g == 1:\n g += 1\n else:\n g -= 1\n elif g == 0:\n if r == 1:\n r += 1\n else:\n r -= 1\n else:\n r -= 1\n g -= 1\n return r, g","def test_get_scorable_threes_5ok():\n roll = np.array([3, 3, 3, 3, 3, 1])\n expected = {\n \"one\": 1,\n \"five\": 0,\n \"three-ones\": False,\n \"three-twos\": False,\n \"three-threes\": False,\n \"three-fours\": False,\n \"three-fives\": False,\n \"three-sixes\": False,\n \"four-of-a-kind\": False,\n \"three-and-one\": False,\n \"five-of-a-kind\": True,\n \"six-of-a-kind\": False,\n \"straight\": False,\n \"three-pairs\": False,\n \"four-and-pair\": False,\n \"triplets\": False,\n }\n actual = analyze_roll.get_scorable(roll)\n assert expected == actual","def f(left,right,track=True,fork=0):\r\n # assert round(left.distance(right)) == UNIT\r\n if track :\r\n global pos_tracker, pos_turtle\r\n x = {round(left.xcor()),round(right.xcor())}\r\n y = {round(left.ycor()),round(right.ycor())}\r\n\r\n\r\n result = func(left,right,fork)\r\n #les turtles ne se déplacent pas précisément ;\r\n #on les fait ici arriver sur des coordonnées entières\r\n left.goto(round(left.xcor()),round(left.ycor()))\r\n right.goto(round(right.xcor()),round(right.ycor()))\r\n\r\n if track :\r\n x |= {round(left.xcor()),round(right.xcor())}\r\n y |= {round(left.ycor()),round(right.ycor())}\r\n pos_tracker.add(middle(x,y))\r\n\r\n for l,r in [(left,right)]+result :\r\n pos_turtle[(l,r)] = ahead(l,r)[0]\r\n return result","def right(length, depth):\n turtle.setheading(300)\n turtle.forward(length)\n binary_tree(length / 2, depth - 1)","def right_or_left(self):\n self.scan()\n\n max = 0\n side = 'l'\n\n #analyze scan results\n for angle in self.scan_data:\n #RIGHT SIDE\n if angle < self.MIDPOINT:\n if self.scan_data[angle] > max:\n max = self.scan_data[angle]\n side = 'r'\n #LEFT SIDE\n else:\n if self.scan_data[angle] > max:\n max = self.scan_data[angle]\n side = 'l'\n\n return side","def orient(skeleton, sep_set):\n\n def _rule_1(cpdag):\n \"\"\"Rule_1\n\n Orient i——j into i——>j whenever there is an arrow k——>i\n such that k and j are nonadjacent.\n \"\"\"\n\n columns = list(range(cpdag.shape[1]))\n ind = list(combinations(columns, 2))\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\n # Iteration every (i, j)\n i, j = ij\n if cpdag[i, j] * cpdag[j, i] == 0:\n continue\n # search i——j\n else:\n all_k = [x for x in columns if x not in ij]\n for k in all_k:\n if cpdag[k, i] == 1 and cpdag[i, k] == 0 \\\n and cpdag[k, j] + cpdag[j, k] == 0:\n cpdag[j, i] = 0\n return cpdag\n\n def _rule_2(cpdag):\n \"\"\"Rule_2\n\n Orient i——j into i——>j whenever there is a chain i——>k——>j.\n \"\"\"\n\n columns = list(range(cpdag.shape[1]))\n ind = list(combinations(columns, 2))\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\n # Iteration every (i, j)\n i, j = ij\n if cpdag[i, j] * cpdag[j, i] == 0:\n continue\n # search i——j\n else:\n all_k = [x for x in columns if x not in ij]\n for k in all_k:\n if cpdag[i, k] == 1 and cpdag[k, i] == 0 \\\n and cpdag[k, j] == 1 \\\n and cpdag[j, k] == 0:\n cpdag[j, i] = 0\n return cpdag\n\n def _rule_3(cpdag, sep_set=None):\n \"\"\"Rule_3\n\n Orient i——j into i——>j\n whenever there are two chains i——k——>j and i——l——>j\n such that k and l are non-adjacent.\n \"\"\"\n\n columns = list(range(cpdag.shape[1]))\n ind = list(combinations(columns, 2))\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\n # Iteration every (i, j)\n i, j = ij\n if cpdag[i, j] * cpdag[j, i] == 0:\n continue\n # search i——j\n else:\n for kl in sep_set.keys(): # k and l are nonadjacent.\n k, l = kl\n # if i——k——>j and i——l——>j\n if cpdag[i, k] == 1 \\\n and cpdag[k, i] == 1 \\\n and cpdag[k, j] == 1 \\\n and cpdag[j, k] == 0 \\\n and cpdag[i, l] == 1 \\\n and cpdag[l, i] == 1 \\\n and cpdag[l, j] == 1 \\\n and cpdag[j, l] == 0:\n cpdag[j, i] = 0\n return cpdag\n\n def _rule_4(cpdag, sep_set=None):\n \"\"\"Rule_4\n\n Orient i——j into i——>j\n whenever there are two chains i——k——>l and k——>l——>j\n such that k and j are non-adjacent.\n \"\"\"\n\n columns = list(range(cpdag.shape[1]))\n ind = list(combinations(columns, 2))\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\n # Iteration every (i, j)\n i, j = ij\n if cpdag[i, j] * cpdag[j, i] == 0:\n continue\n # search i——j\n else:\n for kj in sep_set.keys(): # k and j are nonadjacent.\n if j not in kj:\n continue\n else:\n kj = list(kj)\n kj.remove(j)\n k = kj[0]\n ls = [x for x in columns if x not in [i, j, k]]\n for l in ls:\n if cpdag[k, l] == 1 \\\n and cpdag[l, k] == 0 \\\n and cpdag[i, k] == 1 \\\n and cpdag[k, i] == 1 \\\n and cpdag[l, j] == 1 \\\n and cpdag[j, l] == 0:\n cpdag[j, i] = 0\n return cpdag\n\n columns = list(range(skeleton.shape[1]))\n cpdag = deepcopy(skeleton)\n # pre-processing\n for ij in sep_set.keys():\n i, j = ij\n all_k = [x for x in columns if x not in ij]\n for k in all_k:\n if cpdag[i, k] + cpdag[k, i] != 0 \\\n and cpdag[k, j] + cpdag[j, k] != 0:\n if k not in sep_set[ij]:\n if cpdag[i, k] + cpdag[k, i] == 2:\n cpdag[k, i] = 0\n if cpdag[j, k] + cpdag[k, j] == 2:\n cpdag[k, j] = 0\n cpdag = _rule_1(cpdag=cpdag)\n cpdag = _rule_2(cpdag=cpdag)\n cpdag = _rule_3(cpdag=cpdag, sep_set=sep_set)\n cpdag = _rule_4(cpdag=cpdag, sep_set=sep_set)\n\n return cpdag","def _up_left(self, col, row):\n ones = 0\n twos = 0\n for step in range(4):\n\n current = self.layout[col + (step*-1)][row + (step)] #step up and left\n if current == 1: ones+=1\n if current == 2: twos+=1\n\n return self._score_a_quartet(ones, twos)","def gameOfThrones(s):\n y = Counter()\n x = Counter(s)\n\n for a in x:\n if x[a] % 2 == 1:\n y['odd'] += 1\n\n if len(s) % 2 == 1 and y['odd'] > 1:\n return 'NO'\n elif len(s) % 2 == 1 and y['odd'] == 1:\n return 'YES'\n elif len(s) % 2 == 0 and y['odd'] > 0:\n return 'NO'\n elif len(s) % 2 == 0 and y['odd'] == 0:\n return 'YES'","def m_move1(state,b1,b2):\n if b2 != 'hand' and not state.holding['hand']:\n if b2 == 'table':\n return [('clear',b1,True), ('pos', b1, 'hand'), ('pos', b1, b2)]\n else:\n return [('clear',b2,True), ('clear',b1,True), \\\n ('pos', b1, 'hand'), ('pos', b1, b2)]","def right_child_idx(idx):\n return (idx + 1) << 1","def _has_left(self, j):\n return (2 * j + 1) < len(self)","def l_un_degenerate(self):\n self.right = self.tmp","def left_child(self, index):\n return 2 * index","def test_four_nodes_needs_left_right_rotation(three_del):\n three_del.insert(15)\n three_del.delete(30)\n assert tuple(three_del.in_order()) == (10, 15, 20)\n assert tuple(three_del.breadth_first()) == (15, 10, 20)","def bk_p(g,p,r,x, counter):\n print(\"counter:\\t\", counter)\n print(\"p:\\t\", p)\n print(\"r:\\t\", r)\n print(\"x:\\t\", x)\n result = []\n pux = set(p).union(set(x))\n if len(pux) == 0:\n print(\"return r: \", r)\n return r\n else:\n pivot = list(pux)[0]\n pN = [n for n in g.neighbors(pivot)]\n p_copy = copy.deepcopy(p)\n print(\"P_COPY\",p_copy)\n print(\"P_N\",pN)\n for n in pN:\n p_copy.remove(n)\n for v in p_copy:\n print(\"v: \", v)\n vNeighbors = [a for a in g.neighbors(v)]\n print(\"vNeighbors: \\t\", vNeighbors)\n # pnnv, ruv, xnnv\n print(\"================================\")\n result.append(bk_p(g, intersection(p,vNeighbors), r+[v], intersection(x, vNeighbors), counter+1))\n print(\"================================\")\n print(\"result:\\t\", result, \"\\tv: \", v)\n p.remove(v)\n x.append(v)\n print(\"fp:\\t\", p)\n print(\"fr:\\t\", r)\n print(\"fx:\\t\", x)\n return result\n\n def bk_p2(g,r,p,x, counter=0):\n \"\"\"\n Bron-Kerbosch algorithm without pivots (implemented with python sets)\n g: an nx graph\n r: disjoint set of vertices of graph g\n p: disjoint set of vertices of graph g\n x: disjoint set of vertices of graph g\n \"\"\"\n pux = p.union(x)\n if not pux:\n print('Maximal clique found: ', r)\n\n # choose an pivot from pux\n pivot = next(iter(pux))\n neighborsP = list(g.neighbors(pivot))\n for v in p.difference(neighborsP):\n neighborsV = list(g.neighbors(v))\n bk_p(g, r.union([v]), p.intersection(neighborsV), x.intersection(neighborsV), counter+1)\n p.remove(v)\n x.add(v)","def rightDown(self):","def way_to_prewin(self, one):\r\n\t\tkind = [0, 0, 0, 0] \r\n\t\tuseful = []\r\n\t\tscore = 0\r\n\t\tfor part in one.split(\"\\t\"):\r\n\t\t\t#print \"part: {0}\".format(part)\r\n\t\t\ttmp = part.split()\r\n\t\t\tlength = len(tmp)\r\n\t\t\tif (length == 3):\t\t# triple\r\n\t\t\t\tkind[0] += 1\r\n\t\t\t\tscore += 3\r\n\t\t\telif (length == 1):\t\t# single\r\n\t\t\t\tkind[3] += 1\r\n\t\t\telif (tmp[0] == tmp[1]):# pair\r\n\t\t\t\tkind[1] += 1\r\n\t\t\t\tuseful.append(\"{0}\".format(tmp[0]))\r\n\t\t\t\tscore += 2\r\n\t\t\telse:\r\n\t\t\t\tkind[2] += 1\r\n\t\t\t\tn = GameBoard.NextCard(tmp[0])\r\n\t\t\t\tp = GameBoard.PrevCard(tmp[0])\r\n\t\t\t\tnn = GameBoard.NextCard(tmp[1])\r\n\t\t\t\tif (n == tmp[1]):\t# consecutive neighbor\r\n\t\t\t\t\tscore += 2\r\n\t\t\t\t\tif (p != None): useful.append(p)\r\n\t\t\t\t\tif (nn != None): useful.append(nn)\r\n\t\t\t\telse:\r\n\t\t\t\t\tuseful.append(n)\r\n\t\t\t\t\tscore += 1\r\n\r\n\t\t#print \"kind: {0}\".format(kind)\r\n\t\t\"\"\" how many cards can we probably get \"\"\"\r\n\t\tuseful_amount = 0\r\n\t\tfor card in set(useful):\r\n\t\t\tctype = GameBoard.CardType(card)\r\n\t\t\tif (ctype == 1): a = self.wang_list.count(card)\r\n\t\t\telif (ctype == 2): a = self.tube_list.count(card)\r\n\t\t\telif (ctype == 3): a = self.bamb_list.count(card)\r\n\t\t\telif (ctype == 4): a = self.word_list.count(card)\r\n\t\t\telse: a = self.wind_list.count(card)\r\n\t\t\tb = self.gb.drop_list.count(card)\r\n\t\t\tuseful_amount += (4 - a - b)\r\n\r\n\t\t\"\"\"\r\n\t\t1. enumerate, because goal state not too much\r\n\t\t2. counting pong_list so that we can focus on 16 cards\r\n\t\t3. check prewin first\t\r\n\t\t\"\"\"\r\n\t\tgoals = [[4, 1, 1, 0], [5, 0, 0, 1], [4, 2, 0, 0]]\r\n\t\tgpattern = [[\"***\", \"***\", \"***\", \"***\", \"##\", \"$$\"],[\"***\", \"***\", \"***\", \"***\", \"***\", \"/\"],\r\n\t\t\t\t\t[\"***\", \"***\", \"***\", \"***\", \"##\", \"##\"]]\r\n\t\tresult = [0, 0, 0]\r\n\t\tsize = len(self.pong_list) / 3\r\n\t\tif ((size + kind[0]) > 4): return [0, useful_amount, score]\r\n\t\tfor i in range(size): \r\n\t\t\tgpattern[0].remove(\"***\")\r\n\t\t\tgpattern[1].remove(\"***\")\r\n\t\t\tgpattern[2].remove(\"***\")\r\n\t\tfor number in range(3):\r\n\t\t\tk0 = kind[0]\r\n\t\t\tk1 = kind[1]\r\n\t\t\tk2 = kind[2]\r\n\t\t\tk3 = kind[3]\r\n\t\t\tp1 = gpattern[number]\r\n\t\t\tfor i in range(k0): p1.remove(\"***\")\r\n\t\t\tfor i in range(min(k1, goals[number][1])): \r\n\t\t\t\tk1 -= 1\r\n\t\t\t\tp1.remove(\"##\")\r\n\t\t\tfor i in range(min(k2, goals[number][2])):\r\n\t\t\t\tk2 -= 1\r\n\t\t\t\tp1.remove(\"$$\")\r\n\t\t\t#print \"p1: {0}, size: {1}\".format(p1, (k1+k2)*2+k3)\r\n\t\t\tstep = 0\r\n\t\t\ttwo = k1 + k2\r\n\t\t\tfor i in range(len(p1)):\r\n\t\t\t\tlength = len(p1[i])\r\n\t\t\t\tif (length == 3):\r\n\t\t\t\t\tif two:\r\n\t\t\t\t\t\ttwo -= 1\r\n\t\t\t\t\t\tstep += 1\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tstep += 2\r\n\t\t\t\telif (length == 2):\r\n\t\t\t\t\tstep += 1\r\n\t\t\tresult[number] = step\r\n\t\t#print \"steps to goal: {0}, useful: {1}\".format(result, len(useful))\r\n\t\t\r\n\t\treturn [min(result), useful_amount, score]"],"string":"[\n \"def right_child(self, pos): \\n return (2 * pos) + 1\",\n \"def boundary_op_n(v):\\r\\n h = list(v.dic.keys())[0]\\r\\n p = len(h) - 1\\r\\n s = P_chains([],[])\\r\\n if (p != 0) and (isinstance(h, str) != True) and (isinstance(h, frozenset) != True) and (isinstance(h, ImmutableMatrix) != True):\\r\\n if (is_int(list(v.dic.keys())) == True):\\r\\n for u in v.dic.keys():\\r\\n c = 0\\r\\n for i in u: \\r\\n w = list(u)[:]\\r\\n w.remove(i)\\r\\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**c) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n else:\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n return s\\r\\n else:\\r\\n aux = P_chains([],[])\\r\\n D = {}\\r\\n ct = 0\\r\\n st = []\\r\\n for u in v.dic.keys():\\r\\n for x in u:\\r\\n if x not in st:\\r\\n st.append(x)\\r\\n for i in st:\\r\\n D[tuple([ct])] = i\\r\\n ct = ct + 1\\r\\n for u in v.dic.keys():\\r\\n w2 = []\\r\\n for x in u:\\r\\n for y in list(D.keys()):\\r\\n if (x == D[y]):\\r\\n w2.append(y)\\r\\n aux = aux + P_chains([tuple(w2)],[v.dic[u]]) \\r\\n v = aux\\r\\n for u in v.dic.keys():\\r\\n c = 0\\r\\n for i in u: \\r\\n w = list(u)[:]\\r\\n w.remove(i)\\r\\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**c) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n else:\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n s2 = P_chains([],[])\\r\\n for u in s.dic.keys():\\r\\n w2=[]\\r\\n for i in u:\\r\\n w2.append(D[i])\\r\\n s2 = s2 + P_chains([tuple(w2)],[s.dic[u]])\\r\\n \\r\\n return s2\\r\\n else:\\r\\n return s\",\n \"def _left(node):\\n return 2 * node + 1\",\n \"def _left(self, j):\\n return 2 * j + 1\",\n \"def _left(self, j):\\n return 2 * j + 1\",\n \"def middleUp(self):\",\n \"def threes(dice):\\n for i, j, k in combinations(dice, 3):\\n if i == j == k:\\n return 3 * i\\n\\n return 0\",\n \"def needwu(A,B,S,d):\\n AlignementA=\\\"\\\"\\n AlignementB=\\\"\\\"\\n F=matriF(A,B,S,d)\\n i=len(A)-1\\n j=len(B)-1\\n\\n while i>0 and j>0:\\n score=F[i][j]\\n scorediag=F[i-1][j-1]\\n scoreup=F[i][j-1]\\n scoreleft=F[i-1][j]\\n\\n if score==(scorediag+S[ind(A[i])][ind(B[j])]):\\n AlignementA=A[i]+AlignementA\\n AlignementB=B[j]+AlignementB\\n i=i-1\\n j=j-1\\n\\n elif score==(scoreleft+d):\\n AlignementA=A[i]+AlignementA\\n AlignementB=\\\"-\\\"+AlignementB\\n i=i-1\\n\\n elif score==(scoreup+d):\\n AlignementA=\\\"-\\\"+AlignementA\\n AlignementB=B[j]+AlignementB\\n j=j-1\\n\\n while i>0:\\n AlignementA=A[i]+AlignementA\\n AlignementB=\\\"-\\\"+AlignementB\\n i=i-1\\n\\n while j>0:\\n AlignementA=\\\"-\\\"+AlignementA\\n AlignementB=B[j]+AlignementB\\n j=j-1\\n\\n return AlignementA, AlignementB\",\n \"def exchange_branches(self, straight='Down'):\\n\\n d_first = dict() # up branch\\n d_second = dict() # down branch\\n\\n level = len(str(self.n_parent).split(\\\":\\\")) + 1\\n n_num = int(self.n)\\n if straight == 'Down':\\n n_next = int(self.n) + 1\\n else:\\n if straight == 'Up':\\n n_next = int(self.n) - 1\\n else:\\n print('Entered not right straingth!!!')\\n return\\n\\n mask_cur = str(self.n_parent) + \\\":\\\" + str(n_num)\\n mask_next = str(self.n_parent) + \\\":\\\" + str(n_next)\\n # find elements above\\n for k, v in self.d.items():\\n num = int(str(k).split(\\\":\\\")[-1])\\n if len(str(k).split(\\\":\\\")) >= level and str(k).startswith(mask_cur):\\n l_elem = str(k).split(\\\":\\\")\\n if straight == 'Down':\\n num = int(l_elem[level - 1]) + 1\\n else:\\n num = int(l_elem[level - 1]) - 1\\n # summon key\\n s_first = \\\"\\\" # first part of string\\n s_last = \\\"\\\" # last part of string\\n for i in range(0, level - 1):\\n if i == 0:\\n s_first = s_first + l_elem[i]\\n else:\\n s_first = s_first + \\\":\\\" + l_elem[i]\\n try:\\n for j in range(level, len(l_elem)):\\n if j == 0:\\n s_last = s_last + l_elem[j]\\n else:\\n s_last = s_last + \\\":\\\" + l_elem[j]\\n except:\\n pass\\n\\n if s_last.startswith(\\\":\\\"):\\n s = ''\\n for w in range(1, len(s_last)):\\n s = s + s_last[w]\\n s_last = s\\n # summon\\n if s_last:\\n s_summon = str(s_first) + \\\":\\\" + str(num) + \\\":\\\" + str(s_last)\\n else:\\n s_summon = str(s_first) + \\\":\\\" + str(num)\\n\\n # write to dictionary\\n d_first[s_summon] = v\\n self.d.pop(k)\\n\\n if len(str(k).split(\\\":\\\")) >= level and str(k).startswith(mask_next):\\n l_elem = str(k).split(\\\":\\\")\\n if straight == 'Down':\\n num = int(l_elem[level - 1]) - 1\\n else:\\n num = int(l_elem[level - 1]) + 1\\n\\n # summon key\\n s_first = \\\"\\\" # first part of string\\n s_last = \\\"\\\" # last part of string\\n for i in range(0, level - 1):\\n if i == 0:\\n s_first = s_first + l_elem[i]\\n else:\\n s_first = s_first + \\\":\\\" + l_elem[i]\\n try:\\n for j in range(level, len(l_elem)):\\n if j == 0:\\n s_last = s_last + l_elem[j]\\n else:\\n s_last = s_last + \\\":\\\" + l_elem[j]\\n\\n except:\\n pass\\n\\n if s_last.startswith(\\\":\\\"):\\n s = ''\\n for w in range(1, len(s_last)):\\n s = s + s_last[w]\\n s_last = s\\n\\n # summon\\n if s_last:\\n s_summon = str(s_first) + \\\":\\\" + str(num) + \\\":\\\" + str(s_last)\\n else:\\n s_summon = str(s_first) + \\\":\\\" + str(num)\\n\\n # write to dictionary\\n d_second[s_summon] = v\\n self.d.pop(k)\\n\\n for kk, vv in d_first.items():\\n self.d[kk] = vv\\n\\n for kkk, vvv in d_second.items():\\n self.d[kkk] = vvv\",\n \"def needleman_wunsch1(x,y,lodict=None,gop=-2.5, gep=-1.75, local=False):\\n n,m = len(x),len(y)\\n dp = np.zeros((n+1,m+1))\\n pointers = np.zeros((n+1,m+1),np.int32)\\n for i in range(1,n+1):\\n dp[i,0] = dp[i-1,0]+(gep if i>1 else gop)\\n pointers[i,0]=1\\n for j in range(1,m+1):\\n dp[0,j] = dp[0,j-1]+(gep if j>1 else gop)\\n pointers[0,j]=2\\n for i in range(1,n+1):\\n for j in range(1,m+1):\\n if not lodict:\\n if x[i-1] == y[j-1]:\\n match = dp[i-1,j-1]+1\\n else:\\n match = dp[i-1,j-1]-1\\n else:\\n match = dp[i-1,j-1]+lodict[x[i-1],y[j-1]]\\n insert = dp[i-1,j]+(gep if pointers[i-1,j]==1 else gop)\\n delet = dp[i,j-1]+(gep if pointers[i,j-1]==2 else gop)\\n max_score = max([match,insert,delet])\\n dp[i,j] = max_score\\n pointers[i,j] = [match,insert,delet].index(max_score)\\n alg = []\\n i,j = n,m\\n while(i>0 or j>0):\\n pt = pointers[i,j]\\n if pt==0:\\n i-=1\\n j-=1\\n alg = [[x[i],y[j]]]+alg\\n if pt==1:\\n i-=1\\n alg = [[x[i],'-']]+alg\\n if pt==2:\\n j-=1\\n alg = [['-',y[j]]]+alg\\n return dp[-1,-1], alg\",\n \"def left(t):\\r\\n return t(1)\",\n \"def rightUp(self):\",\n \"def left_child(self, pos): \\n return 2 * pos\",\n \"def build_leftpart():\\n # build kelly.\\n build_kelly()\\n # copy kelly to 3.\\n copy(0, 3)\\n\\n # build june in slots 0,1,2\\n build_june()\\n # copy kelly to slot 1\\n copy(3, 1)\\n\\n # smash together to get (june kelly) in 0\\n smash()\\n # copy (june kelly) to 1\\n copy(0, 1)\\n # build horace in 0\\n build_horace(0)\\n # smash together to get (horace (june kelly)) in 0\\n smash()\\n # wrap with an S for the whole left part.\\n apply_card(\\\"S\\\", 0)\",\n \"def build_rightpart():\\n # build in 1: (K dec)\\n apply_card(\\\"put\\\", 1)\\n apply_slot(1, \\\"dec\\\")\\n apply_card(\\\"K\\\", 1)\\n\\n # build in 0: greg\\n build_greg(0)\\n\\n # smash together to get (greg (K dec)) in 0\\n smash()\\n\\n # copy it to 1.\\n apply_card(\\\"put\\\", 1)\\n apply_slot(1, \\\"zero\\\")\\n apply_card(\\\"get\\\", 1)\\n\\n # build horace in 0.\\n build_horace(0)\\n\\n # smash together to get (horace (greg (K dec))) in 0.\\n smash()\\n\\n # Wrap with an S.\\n apply_card(\\\"S\\\", 0)\\n\\n # build ian in 1.\\n build_ian(1)\\n\\n # smash together to get ((S (horace (greg (K dec)))) ian) in 0.\\n smash()\",\n \"def king2(r, n0, rc0, b0, n1, rc1, b1):\\n return n0 * (1. + (r/rc0)**2)**b0 + n1 * (1. + (r/rc1)**2)**b1\",\n \"def _shift(self, c, mark):\\n import pdb\\n #pdb.set_trace()\\n debug(\\\"sequence shift with mark %s\\\", mark)\\n old_marked_left = self.left.marked\\n marked_left = self.left.shift(c, mark) # based on current letter\\n marked_right = self.right.shift(\\n c, old_marked_left or (mark and self.left.empty))\\n \\n return (marked_left and self.right.empty) or marked_right\\n \\\"\\\"\\\"\\n if marked_right:\\n return marked_right + 1\\n else:\\n # TODO, empties advance the counter\\n return max(marked_left, self.right.empty)\\n \\\"\\\"\\\"\",\n \"def left(i):\\r\\n return 2 * i + 1\",\n \"def __left(self,i):\\n return 1+(i<<1)\",\n \"def twist(self):\\n self.right()\\n time.sleep(1)\\n self.stop()\\n self.left()\\n time.sleep(1)\\n self.stop()\",\n \"def right(t):\\r\\n return t(2)\",\n \"def score( canvas ):\\n\\n score = 0\\n\\n score += length_score(canvas)\\n score += angle_score(canvas)\\n\\n # 1. Chainbreaks for all junction loops.\\n\\n # 2. Nucleotides should be at least 15 from ALL other nts. Don't double-count.\\n for seqpos1, nt1 in canvas.nucleotides.iteritems():\\n for seqpos2, nt2 in canvas.nucleotides.iteritems():\\n if seqpos1 >= seqpos2: continue\\n #if distance( nt1, nt2 ) < 15: score += 100\\n # Don't do a square root you don't have to\\n if distance_squared( nt1, nt2 ) < 225: score += 100\\n\\n\\n # 2b. Depending on base pair width, it's possible that the 'best' orientation for two stacks is\\n # for them to be overlapping...\\n # nt --- nt\\n # | nt |-- nt\\n # nt -|- nt |\\n # | nt |-- nt\\n # so, penalize this ( 'between two bp'ed nts' penalized like hitting a nt )\\n for seqpos, nt in canvas.nucleotides.iteritems():\\n for stem in canvas.stems:\\n for bp in stem.base_pairs:\\n if nt == bp.nt1 or nt == bp.nt2:\\n continue\\n # if nt in question is 'in between' nt1 and nt2. how to judge?\\n if nt.x > bp.nt1.x and nt.x < bp.nt2.x \\\\\\n and closer_than( nt.y, bp.nt1.y, canvas.bp_offset_height*0.8 ):\\n score += 100\\n\\n # Look at pairs of adjacent nts in stem\\n for seqpos1, nt1 in stem.nucleotides.iteritems():\\n if seqpos1 + 1 in stem.nucleotides.keys():\\n nt2 = stem.nucleotides[ seqpos1 + 1 ]\\n if nt.y > nt1.y and nt.y < nt2.y \\\\\\n and closer_than( nt.x, nt1.x, canvas.bp_offset_width*0.8 ):\\n score += 100\\n\\n # 3. Stems should be straight and vertical.\\n ### Resolved via kinematics?\\n\\n # 4. Coaxial stacks, where known, should be colinear.\\n for idx1, idx2 in canvas.list_of_coaxialities:\\n # idx1 and idx2 are coaxial stems.\\n # Any two BPs from these stems should do, but -- because I have no idea\\n # how we intend to handle 'alternate-order' stacks (where the first nt in a bp\\n # is stacked on the second nt in another), compare either direction.\\n bp1 = canvas.stems[idx1].base_pairs[0]\\n bp2 = canvas.stems[idx2].base_pairs[0]\\n penalty1 = harmonic_penalty( bp1.nt1.x - bp2.nt1.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt2.x, 0, 1 )\\n penalty2 = harmonic_penalty( bp1.nt1.x - bp2.nt2.x, 0, 1 ) + harmonic_penalty( bp1.nt2.x - bp2.nt1.x, 0, 1 )\\n score += min( penalty1, penalty2 )\\n\\n\\n # 5. Apical loops should be symmetrical and near a circular path.\\n for loop in canvas.loops:\\n for seqpos in loop.nucleotides.keys():\\n pass\\n\\n return score\",\n \"def left_or_right(self):\\n #traversal\\n left_total = 0\\n left_count = 0\\n right_total = 0\\n right_count = 0\\n self.scan()\\n for ang, dist in self.scan_data.items():\\n if ang < self.MIDPOINT:\\n right_total += dist\\n right_count += 1\\n print(\\\"Angle: %d // dist: %d // right_count: %d\\\" % (ang, dist, right_count))\\n else:\\n left_total += dist\\n left_count += 1\\n left_avg = left_total / left_count\\n right_avg = right_total / right_count\\n if left_avg > right_avg:\\n self.turn_by_deg(-45)\\n else:\\n self.turn_by_deg(45)\\n # if robot is facing the wrong way it will turn it around\\n self.exit_bias()\",\n \"def leftUp(self):\",\n \"def substantiate():\",\n \"def right(self):\\n self.counterUp(teamNumber = 2)\",\n \"def rightChild(self, pos):\\n return (2 * pos) + 1\",\n \"def rightChild(self, pos):\\n return (2 * pos) + 1\",\n \"def kung(vectors):\\n m = len(vectors)\\n # if there is only one vector left, return it\\n if m == 1:\\n return vectors\\n #[left,right]\\n left = vectors[0: m//2]\\n right = vectors[m//2: m]\\n\\n nleft = kung(left)\\n nright = kung(right)\\n\\n # left garanteed undominated\\n return merge(nleft, nright)\",\n \"def tower_of_hanoi_stack(n, beg, aux, end):\",\n \"def heads_legs(heads, legs):\\n for i in range(0, heads + 1):\\n cows = heads - i\\n if 4 * cows + 2 * i == legs:\\n chickens = i\\n return chickens, cows\\n return \\\"No solutions.\\\"\",\n \"def test_right_order():\\n assert 'right' == classify_triangle(5,3,4)\",\n \"def needleman_wunsch(x, y, lodict={}, gop=-2.5, gep=-1.75, local=False, indel=''):\\n n, m = len(x), len(y)\\n dp = np.zeros((n + 1, m + 1))\\n pointers = np.zeros((n + 1, m + 1), np.int32)\\n if not local:\\n for i1, c1 in enumerate(x):\\n if gop is None:\\n dp[i1 + 1, 0] = lodict.get((c1, indel), gep)\\n else:\\n dp[i1 + 1, 0] = dp[i1, 0]+(gep if i1 + 1 > 1 else gop)\\n pointers[i1 + 1, 0] = 1\\n for i2, c2 in enumerate(y):\\n if gop is None:\\n dp[0, i2 + 1] = lodict.get((indel, c2), gep)\\n else:\\n dp[0, i2 + 1] = dp[0, i2]+(gep if i2 + 1 > 1 else gop)\\n pointers[0, i2 + 1] = 2\\n for i1, c1 in enumerate(x):\\n for i2, c2 in enumerate(y):\\n match = dp[i1, i2] + lodict.get(\\n (c1, c2),\\n 1 if c1 == c2 else -1)\\n insert = dp[i1, i2 + 1] + (\\n lodict.get((c1, indel), gep) if gop is None else\\n gep if pointers[i1, i2 + 1] == 1 else gop)\\n delet = dp[i1 + 1, i2] + (\\n lodict.get((indel, c2), gep) if gop is None else\\n gep if pointers[i1 + 1, i2] == 2 else gop)\\n pointers[i1 + 1, i2 + 1] = p = np.argmax([match, insert, delet])\\n max_score = [match, insert, delet][p]\\n if local and max_score < 0:\\n max_score = 0\\n dp[i1 + 1, i2 + 1] = max_score\\n alg = []\\n if local:\\n i, j = np.unravel_index(dp.argmax(), dp.shape)\\n else:\\n i, j = n, m\\n score = dp[i, j]\\n while (i > 0 or j > 0):\\n pt = pointers[i, j]\\n if pt == 0:\\n i -= 1\\n j -= 1\\n alg = [(x[i], y[j])] + alg\\n if pt == 1:\\n i -= 1\\n alg = [(x[i], indel)] + alg\\n if pt == 2:\\n j -= 1\\n alg = [(indel, y[j])] + alg\\n if local and dp[i, j] == 0:\\n break\\n return score, alg\",\n \"def _right(node):\\n return 2 * node + 2\",\n \"def straight(handIn):\",\n \"def left(i):\\n return 2*i\",\n \"def ski(right, down):\\n matrix = read_map_into_matrix()\\n outer_selector = (i % down == 0 for i in range(len(matrix)))\\n\\n column = 1\\n trees = 0\\n\\n for row in compress(matrix, outer_selector):\\n inner_selector = (i == column - 1 for i in range(column))\\n\\n col = next(compress(row, inner_selector))\\n\\n if col == \\\"#\\\":\\n trees += 1\\n\\n column += right\\n\\n return trees\",\n \"def test_depth_one_and_two(self):\\n board = Board([[2, 3], [2, 2, 2, 2]],\\n workers={self.workers[i]: (1, i)\\n for i in range(len(self.workers))})\\n # self.assertTrue(tree.do_survive(board, 1, False, \\\"p1\\\", \\\"p2\\\", self.workers[1],\\n # Direction.NORTH))\\n # self.assertTrue(tree.do_survive(board, 1, False, \\\"p1\\\", \\\"p2\\\", self.workers[0],\\n # Direction.NORTH, Direction.EAST))\\n # self.assertTrue(tree.do_survive(board, 1, False, \\\"p1\\\", \\\"p2\\\", self.workers[0],\\n # Direction.SOUTH, Direction.EAST))\\n # self.assertTrue(tree.do_survive(board, 1, False, \\\"p1\\\", \\\"p2\\\",self.workers[1],\\n # Direction.SOUTH, Direction.EAST))\\n # self.assertFalse(tree.do_survive(board, 2, False, \\\"p1\\\", \\\"p2\\\",self.workers[1],\\n # Direction.SOUTH, Direction.EAST))\",\n \"def __right(self,i):\\n return (1+i)<<1\",\n \"def get_left_right_stoichiometries(r1):\\n r1_left = [(str(c), get_coefficient(r1,c,'left')) for c in \\n db[r1].slot_values('left')]\\n r1_left.sort()\\n r1_right = [(str(c), get_coefficient(r1,c,'right')) for c in \\n db[r1].slot_values('right')]\\n r1_right.sort()\\n \\n return tuple(r1_left), tuple(r1_right)\",\n \"def test_splitting_on_feature(num = 0):\\n left = [0,0]\\n right = [0,0]\\n for i, side in enumerate(train_matrix_df[num]):\\n if int(side) == 0: \\n if train_labels_df.ix[i]['candy_id'] == 0:\\n left[0] += 1\\n else:\\n left[1] += 1\\n else:\\n if train_labels_df.ix[i]['candy_id'] == 0:\\n right[0] += 1\\n else:\\n right[1] += 1\\n\\n #print \\\" %s goes to the %i side\\\" %(train_labels_df.ix[i]['candy'], side)\\n\\n print str(left) + \\\"<--left -- + -- right-->\\\" + str(right)\",\n \"def simple_chained_rep_rnn_phi(t1, t2):\\n return t1.leaves() + t2.leaves()\",\n \"def question4(T, r, n1, n2):\\n\\tif len(T) == 0:\\n\\t\\treturn T\\n\\telif len(T) == 1:\\n\\t\\treturn r\\n\\tindex_holder = None\\n\\tparent1 = []\\n\\twhile index_holder != r:\\n\\t\\tfor a in range(len(T)):\\n\\t\\t\\tif T[a][n1] == 1:\\n\\t\\t\\t\\tindex_holder = a\\n\\t\\t\\t\\tn1 = index_holder\\n\\t\\t\\t\\tparent1.append(index_holder)\\n\\tother_index = None\\n\\tparent2 = []\\n\\twhile other_index != r:\\n\\t\\tfor a in range(len(T)):\\n\\t\\t\\tif T[a][n2] == 1:\\n\\t\\t\\t\\tother_index = a\\n\\t\\t\\t\\tn2 = other_index\\n\\t\\t\\t\\tparent2.append(other_index)\\n\\tfor a1 in parent1:\\n\\t\\tfor a2 in parent2:\\n\\t\\t\\tif a1 == a2:\\n\\t\\t\\t\\treturn a1\",\n \"def get_others(map_, r, c):\\n nums = 0\\n # your code here\\n if r == 0 and c == 0: #top left corder\\n nums += 2\\n if len(map_[0]) > 1:\\n if map_[r][c+1] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n elif r == 0 and c == len(map_[0])-1: #top right corner\\n nums += 2\\n if len(map_[0]) > 1:\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n elif r == len(map_)-1 and c == 0: #bottom left corder\\n nums += 2\\n if len(map_[0]) > 1:\\n if map_[r][c+1] == 0:\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n elif r == len(map_)-1 and c == len(map_[0])-1: #bottom right corner\\n nums += 2\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n elif r == 0: # top edge, excluding corner\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r][c+1] == 0:\\n nums += 1\\n if len(map_) > r and map_[r+1][c] == 0:\\n nums += 1\\n elif r == len(map_)-1: # bottom edge, excluding corner\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r][c+1] == 0:\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n elif c == 0: # left edge, excluding corner\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n if len(map_[0]) > c and map_[r][c+1] == 0:\\n nums += 1\\n elif c == len(map_[0])-1: # right edge. excluding corner\\n nums += 1\\n if map_[r-1][c] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n else: # the rest, excluding edge and corner\\n if map_[r-1][c] == 0:\\n nums += 1\\n if map_[r+1][c] == 0:\\n nums += 1\\n if map_[r][c-1] == 0:\\n nums += 1\\n if map_[r][c+1] == 0:\\n nums += 1\\n return nums\",\n \"def _left(self, index):\\r\\n return 2*index + 1\",\n \"def step2(self):\\n\\t\\tif self.b[self.k - 1] == 'a':\\n\\t\\t\\tif self.ends(\\\"ational\\\"): self.r(\\\"ate\\\")\\n\\t\\t\\telif self.ends(\\\"tional\\\"): self.r(\\\"tion\\\")\\n\\t\\telif self.b[self.k - 1] == 'c':\\n\\t\\t\\tif self.ends(\\\"enci\\\"):\\t self.r(\\\"ence\\\")\\n\\t\\t\\telif self.ends(\\\"anci\\\"): self.r(\\\"ance\\\")\\n\\t\\telif self.b[self.k - 1] == 'e':\\n\\t\\t\\tif self.ends(\\\"izer\\\"):\\t self.r(\\\"ize\\\")\\n\\t\\telif self.b[self.k - 1] == 'l':\\n\\t\\t\\tif self.ends(\\\"bli\\\"):\\t self.r(\\\"ble\\\") # --DEPARTURE--\\n\\t\\t\\t# To match the published algorithm, replace this phrase with\\n\\t\\t\\t#\\tif self.ends(\\\"abli\\\"):\\t self.r(\\\"able\\\")\\n\\t\\t\\telif self.ends(\\\"alli\\\"): self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"entli\\\"): self.r(\\\"ent\\\")\\n\\t\\t\\telif self.ends(\\\"eli\\\"):\\t self.r(\\\"e\\\")\\n\\t\\t\\telif self.ends(\\\"ousli\\\"): self.r(\\\"ous\\\")\\n\\t\\telif self.b[self.k - 1] == 'o':\\n\\t\\t\\tif self.ends(\\\"ization\\\"): self.r(\\\"ize\\\")\\n\\t\\t\\telif self.ends(\\\"ation\\\"): self.r(\\\"ate\\\")\\n\\t\\t\\telif self.ends(\\\"ator\\\"): self.r(\\\"ate\\\")\\n\\t\\telif self.b[self.k - 1] == 's':\\n\\t\\t\\tif self.ends(\\\"alism\\\"):\\t self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"iveness\\\"): self.r(\\\"ive\\\")\\n\\t\\t\\telif self.ends(\\\"fulness\\\"): self.r(\\\"ful\\\")\\n\\t\\t\\telif self.ends(\\\"ousness\\\"): self.r(\\\"ous\\\")\\n\\t\\telif self.b[self.k - 1] == 't':\\n\\t\\t\\tif self.ends(\\\"aliti\\\"):\\t self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"iviti\\\"): self.r(\\\"ive\\\")\\n\\t\\t\\telif self.ends(\\\"biliti\\\"): self.r(\\\"ble\\\")\\n\\t\\telif self.b[self.k - 1] == 'g': # --DEPARTURE--\\n\\t\\t\\tif self.ends(\\\"logi\\\"):\\t self.r(\\\"log\\\")\\n\\t\\t# To match the published algorithm, delete this phrase\",\n \"def _right(self, col, row):\\n ones = 0\\n twos = 0\\n for step in range(4):\\n current = self.layout[col + (step)][row] #step and right\\n if current == 1: ones+=1\\n if current == 2: twos+=1\\n\\n return self._score_a_quartet(ones, twos)\",\n \"def king(r, n0, rc, b):\\n return n0 * (1. + (r/rc)**2)**b\",\n \"def turn_around():\\n for i in range(2):\\n turn_left()\",\n \"def snake(A, B, M, N, k, y):\\n\\n x = y - k\\n while (x < M) and (y < N) and (A[x] == B[y]):\\n x = x + 1\\n y = y + 1\\n return y\",\n \"def middleDown(self):\",\n \"def leftChild(self, pos):\\n return 2 * pos\",\n \"def leftChild(self, pos):\\n return 2 * pos\",\n \"def sprout_leaves(t, vals):\",\n \"def right_or_left(self): \\n right_sum = 0\\n right_avg = 0\\n left_sum = 0\\n left_avg = 0\\n self.scan()\\n for angle in self.scan_data:\\n if angle < self.MIDPOINT:\\n right_sum += self.scan_data[angle]\\n right_avg += 1\\n else: \\n left_avg += self.scan_data[angle]\\n left_avg += 1\\n\\n left_avg = left_sum / left_avg \\n right_avg = right_sum / right_avg\\n\\n if left_avg > right_avg: \\n return 'l' \\n else:\\n return 'r'\",\n \"def test_right_rotation_four_node_tree():\\n from bbst import Bst\\n tree = Bst([5, 4, 3, 2, 1])\\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\\n assert tuple(tree.breadth_first()) == (4, 2, 5, 1, 3)\\n assert tuple(tree.pre_order()) == (4, 2, 1, 3, 5)\\n assert tuple(tree.post_order()) == (1, 3, 2, 5, 4)\\n assert tree.depth() == 3\\n assert tree.balance() == -1\",\n \"def ht(node):\\n n = 0\\n while node: n, node = n+1, node.left\\n return n\",\n \"def go_down(self):\\n\\n d_first = dict() # up branch\\n #d_second = dict() # down branch\\n\\n level = len(str(self.n_parent).split(\\\":\\\")) + 1\\n n_num = int(self.n)\\n\\n n_next = int(self.n) + 1\\n\\n mask_cur = str(self.n_parent) + \\\":\\\" + str(n_num)\\n #mask_next = str(self.n_parent) + \\\":\\\" + str(n_next)\\n # find elements above\\n for k, v in self.d.items():\\n num = int(str(k).split(\\\":\\\")[-1])\\n if len(str(k).split(\\\":\\\")) >= level and str(k).startswith(mask_cur):\\n l_elem = str(k).split(\\\":\\\")\\n\\n num = int(l_elem[level - 1]) + 1\\n #else:\\n # num = int(l_elem[level - 1]) - 1\\n # summon key\\n s_first = \\\"\\\" # first part of string\\n s_last = \\\"\\\" # last part of string\\n for i in range(0, level - 1):\\n if i == 0:\\n s_first = s_first + l_elem[i]\\n else:\\n s_first = s_first + \\\":\\\" + l_elem[i]\\n try:\\n for j in range(level, len(l_elem)):\\n if j == 0:\\n s_last = s_last + l_elem[j]\\n else:\\n s_last = s_last + \\\":\\\" + l_elem[j]\\n except:\\n pass\\n\\n if s_last.startswith(\\\":\\\"):\\n s = ''\\n for w in range(1, len(s_last)):\\n s = s + s_last[w]\\n s_last = s\\n # summon\\n if s_last:\\n s_summon = str(s_first) + \\\":\\\" + str(num) + \\\":\\\" + str(s_last)\\n else:\\n s_summon = str(s_first) + \\\":\\\" + str(num)\\n\\n # write to dictionary\\n d_first[s_summon] = v\\n self.d.pop(k)\\n\\n\\n\\n for kk, vv in d_first.items():\\n self.d[kk] = vv\",\n \"def positive_left_right_requirements(\\n self,\\n ) -> Tuple[Tuple[GriddedPerm, ...], Tuple[GriddedPerm, ...]]:\\n left, right = [], []\\n for (x, y) in self._tiling.active_cells:\\n if self._fuse_row and y == self._row_idx:\\n left.append(GriddedPerm.single_cell((0,), (x, y)))\\n right.append(GriddedPerm.single_cell((0,), (x, y + 1)))\\n if not self._fuse_row and x == self._col_idx:\\n left.append(GriddedPerm.single_cell((0,), (x, y)))\\n right.append(GriddedPerm.single_cell((0,), (x + 1, y)))\\n return tuple(sorted(left)), tuple(sorted(right))\",\n \"def roll(state, d):\\n (p, me, you, pending) = state\\n if d == 1:\\n return (other[p], you, me+1, 0) # pig out; other player's turn\\n else:\\n return (p, me, you, pending+d) # accumulate die roll in pending\",\n \"def is_oriented(word1: str, word2: str):\\n tree1, tree2, label_to_vertex = construct_trees(word1, word2)\\n OUT = \\\"OUT\\\"\\n pairs = set()\\n\\n index = {OUT: 0}\\n\\n verts_1 = (v for v in tree1.in_order_vertices() if not v.is_leaf())\\n verts_2 = (v for v in tree2.in_order_vertices() if not v.is_leaf())\\n for i, (a, b) in enumerate(zip(verts_1, verts_2), start=1):\\n index[a] = index[b] = i\\n\\n for root in tree1, tree2:\\n hill_children = defaultdict(list)\\n # hill_children[OUT] = root\\n hill_parent = {root: OUT}\\n\\n for v in root.breadth_first_vertices():\\n if v.is_leaf():\\n continue\\n left, right = v.left, v.right\\n if not right.is_leaf():\\n # hill_children[v].append(right)\\n hill_parent[right] = v\\n if not left.is_leaf():\\n my_parent = hill_parent[v]\\n # hill_children[my_parent].append(left)\\n hill_parent[left] = my_parent\\n\\n for child, parent in hill_parent.items():\\n a, b = index[child], index[parent]\\n pairs |= {(a, b), (b, a)}\\n\\n adj_list = defaultdict(list)\\n for a, b in pairs:\\n adj_list[a].append(b)\\n\\n return is_bipartite(adj_list)\",\n \"def hangman_figure(attempt_left):\\n if attempt_left == N_TURNS:\\n print('___________')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 1:\\n print('___________')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 2:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 3:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| |')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 4:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 5:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('|')\\n print('|')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 6:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| /')\\n print('| |')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 7:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('|')\\n print('|_____')\\n if attempt_left == N_TURNS - 8:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| |')\\n print('|_____')\\n if attempt_left == N_TURNS - 9:\\n print('___________')\\n print('| |')\\n print('| O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| | |')\\n print('|_____')\\n if attempt_left == N_TURNS - 10:\\n print('___________')\\n print('| |')\\n print('| -O')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| | |')\\n print('|_____')\\n if attempt_left == N_TURNS - 11:\\n print('___________')\\n print('| |')\\n print('| -O-')\\n print('| \\\\\\\\_|_/')\\n print('| |')\\n print('| / \\\\\\\\')\\n print('| | |')\\n print('| | |')\\n print('|_____')\",\n \"def part_two(inp: defaultdict) -> int:\\n calculate_inside_bags = lambda color: sum(\\n int(child[0]) * (calculate_inside_bags(child[1]) + 1) for child in inp[color]\\n )\\n return calculate_inside_bags(\\\"shiny gold\\\")\",\n \"def _right(self, j):\\n return 2 * j + 2\",\n \"def _right(self, j):\\n return 2 * j + 2\",\n \"def fn(node):\\n nonlocal ans \\n if not node: return 1\\n left, right = fn(node.left), fn(node.right)\\n if left == 0 or right == 0: \\n ans += 1\\n return 2 # add a camera \\n if left == 2 or right == 2: return 1\\n return 0\",\n \"def right_child(self, index):\\n return 2 * index + 1\",\n \"def answer():\\n for k in range(2,3000):\\n for j in range(k-1,0,-1):\\n pj, pk = P(j), P(k)\\n #print( j, k, pj, pk )\\n if isPent(pk-pj):\\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\\n if isPent(pk+pj) and isPent(pk-pj):\\n return pk-pj\",\n \"def right_child(self, index):\\n return 2 * index + 2\",\n \"def testt_left_right_rotation_five_node_tree():\\n from bbst import Bst\\n tree = Bst([4, 5, 1, 3, 2])\\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\\n assert tuple(tree.breadth_first()) == (4, 2, 5, 1, 3)\\n assert tuple(tree.pre_order()) == (4, 2, 1, 3, 5)\\n assert tuple(tree.post_order()) == (1, 3, 2, 5, 4)\\n assert tree.depth() == 3\\n assert tree.balance() == -1\",\n \"def _right_to_left(self, key):\\n return self._right_bank.get(key, key)\",\n \"def cantor() -> bigger.MCG[Edge]: # pylint: disable=too-many-statements\\n\\n POS, EQ, NEG = +1, 0, -1\\n\\n def edges() -> Iterable[Edge]:\\n for x in naturals():\\n for y in [POS, EQ, NEG]:\\n yield x, y\\n\\n def negate(X: Edge) -> Edge:\\n return X[0], -X[1]\\n\\n def invert(sign: int, X: tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\\n return X if sign == POS else (negate(X[6]), not X[7], negate(X[4]), not X[5], negate(X[2]), not X[3], negate(X[0]), not X[1])\\n\\n def link(edge: Edge) -> tuple[Edge, bool, Edge, bool, Edge, bool, Edge, bool]:\\n n, k = edge\\n if k == EQ: # Equator\\n if n == 0:\\n return ((0, NEG), False, (1, NEG), True, (1, POS), False, (0, POS), True)\\n elif n == 1:\\n return ((2, POS), False, (0, POS), False, (0, NEG), True, (2, NEG), True)\\n else: # n > 1\\n return ((3 * n - 3, NEG), False, (3 * n - 1, NEG), True, (3 * n - 1, POS), False, (3 * n - 3, POS), True)\\n\\n # Northern / Southern hemisphere.\\n if n == 0:\\n return invert(k, ((0, EQ), False, (1, POS), False, (1, EQ), True, (2, POS), False))\\n elif n == 1:\\n return invert(k, ((4, POS), False, (3, POS), False, (0, POS), True, (0, EQ), False))\\n elif n == 2:\\n return invert(k, ((7, POS), False, (6, POS), False, (0, POS), False, (1, EQ), True))\\n N, r = n // 3 + 1, n % 3\\n incoming = 3 * (N // 2) - (1 if N % 2 else 2)\\n if r == 0:\\n return invert(k, ((N, EQ), False, (n + 2, POS), False, (incoming, POS), True, (n + 1, POS), False))\\n elif r == 1:\\n return invert(k, ((6 * N - 2, POS), False, (6 * N - 3, POS), False, (n - 1, POS), False, (incoming, POS), True))\\n else: # r == 2:\\n return invert(k, ((6 * N + 1, POS), False, (6 * N + 0, POS), False, (n - 2, POS), True, (N, EQ), False))\\n\\n T = bigger.Triangulation.from_pos(edges, link)\\n\\n def generator(name: str) -> bigger.Encoding[Edge]: # pylint: disable=too-many-branches\\n twist_match = re.match(r\\\"(?P<curve>[ab])_(?P<n>-?\\\\d+)$\\\", name)\\n rotate_match = re.match(r\\\"r$\\\", name)\\n\\n if twist_match is not None:\\n parameters = twist_match.groupdict()\\n curve_name = parameters[\\\"curve\\\"]\\n N = int(parameters[\\\"n\\\"])\\n if curve_name == \\\"a\\\":\\n if N == 1:\\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\\n else:\\n cut_sequence = [(0, EQ), (N, EQ), (3 * N - 3, POS)]\\n while N > 1:\\n low_N = N // 2\\n cut_sequence.append((3 * low_N - (1 if N % 2 else 2), POS))\\n if N % 2:\\n cut_sequence.append((3 * low_N - 3, POS))\\n N = low_N\\n elif curve_name == \\\"b\\\":\\n if N <= 3:\\n cut_sequence = [(0, EQ), (0, POS), (1, EQ)]\\n else:\\n extend_left = N % 2\\n N = N // 2\\n cut_sequence = [(N, EQ), (3 * N - 3, POS)]\\n while N > 1:\\n N_low = N // 2\\n cut_sequence.append((3 * N_low - (1 if N % 2 else 2), POS))\\n if extend_left:\\n cut_sequence.append((3 * N_low - 3, POS))\\n if N % 2 != extend_left:\\n cut_sequence.append((N_low, EQ))\\n break\\n N = N_low\\n else:\\n cut_sequence.append((0, EQ))\\n\\n curve = T(dict(((x, y * s), 1) for x, y in cut_sequence for s in [+1, -1]))\\n return curve.twist()\\n elif rotate_match is not None:\\n\\n def isom(edge: Edge) -> Edge:\\n n, k = edge\\n if k == EQ:\\n if n == 0:\\n return (1, EQ)\\n elif n == 1:\\n return (0, EQ)\\n return (n ^ (1 << n.bit_length() - 2), k)\\n\\n if n == 0:\\n return (0, k)\\n elif n == 1:\\n return (2, k)\\n elif n == 2:\\n return (1, k)\\n N, r = n // 3 + 1, n % 3\\n return (3 * (N ^ (1 << N.bit_length() - 2)) - 3 + r, k)\\n\\n return T.encode([(-1, isom, isom)])\\n\\n raise ValueError(f\\\"Unknown mapping class {name}\\\")\\n\\n return bigger.MCG(T, generator)\",\n \"def left_right(steps):\\n lengths = lens(steps)\\n a_side = []\\n b_side = []\\n for i in range(len(lengths)):\\n if i % 2 == 0:\\n a_side.append(steps[i])\\n else:\\n b_side.append(steps[i])\\n return a_side, b_side\",\n \"def test_right_left__rotation_five_node_tree():\\n from bbst import Bst\\n tree = Bst([1, 2, 5, 3, 4])\\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\\n assert tuple(tree.breadth_first()) == (2, 1, 4, 3, 5)\\n assert tuple(tree.pre_order()) == (2, 1, 4, 3, 5)\\n assert tuple(tree.post_order()) == (1, 3, 5, 4, 2)\\n assert tree.depth() == 3\\n assert tree.balance() == 1\",\n \"def test_four_nodes_needs_right_left_rotation(three_del):\\n three_del.insert(25)\\n three_del.delete(10)\\n assert tuple(three_del.in_order()) == (20, 25, 30)\\n assert tuple(three_del.breadth_first()) == (25, 20, 30)\",\n \"def binary_tree(length, depth):\\n if depth == 0:\\n return # base case\\n posx = turtle.xcor()\\n posy = turtle.ycor()\\n left(length, depth)\\n turtle.up()\\n turtle.goto(posx, posy)\\n #turtle.dot()\\n turtle.down()\\n right(length, depth)\",\n \"def r(t, i, j):\\n\\n #when get to (i,j) position, minus the food with the zombie needs\\n t -= grid[i][j]\\n\\n\\n #the food is not enough for rabbit to get to the top left or \\n #rabbit can't go left or top. \\n if i < 0 or j < 0 or t < 0:\\n return food+1\\n\\n #can get to the top left, t is the remainder.\\n elif i == 0 and j == 0:\\n return t\\n\\n #choose the less food grid.\\n else:\\n return min(r(t, i-1, j), r(t, i, j-1))\",\n \"def m_put(state,b1,b2):\\n if state.holding['hand'] == b1:\\n if b2 == 'table':\\n return [('putdown',b1)]\\n else:\\n return [('stack',b1,b2)]\\n else:\\n return False\",\n \"def test_left_rotation_four_node_tree():\\n from bbst import Bst\\n tree = Bst([1, 2, 3, 4, 5])\\n assert tuple(tree.in_order()) == (1, 2, 3, 4, 5)\\n assert tuple(tree.breadth_first()) == (2, 1, 4, 3, 5)\\n assert tuple(tree.pre_order()) == (2, 1, 4, 3, 5)\\n assert tuple(tree.post_order()) == (1, 3, 5, 4, 2)\\n assert tree.depth() == 3\\n assert tree.balance() == 1\",\n \"def gen_Strikes(L):\\r\\n p = next_Prim(L)\\r\\n t = 1\\r\\n yield t*p\\r\\n for k in L:\\r\\n t += k\\r\\n yield t*p\",\n \"def find_boyer_moore(T, P):\\n n, m = len(T), len(P)\\n if m == 0: return 0\\n last = {} # Using hash table for fast access\\n for k in range(m):\\n last[P[k]] = k\\n i = m - 1 # i index at T, k index at P\\n k = m - 1 # j index of last occurrence of T[i] in P\\n while i < n:\\n if T[i] == P[k]: # if chars are equal\\n \\\"\\\"\\\" INCORRECT PART \\\"\\\"\\\"\\n i -= 1 # normal iteration\\n k -= 1\\n if k == 0:\\n return i # check if Patter is complete\\n else:\\n # if j < k (remember k index at P)\\n # shift i += m - (j+1)\\n # if j > k\\n # shift i += m - k\\n j = last.get(T[i], -1) # -1 if item not there\\n i += m - (min(k, j+1))\\n k = m - 1\\n return -1\",\n \"def solve_gkeeper():\\n\\n nonlocal field\\n nonlocal bench\\n nonlocal n_subst\\n\\n # If the goal keeper n the field received a vote we delete all the\\n # remaining goal keepers from the bench\\n if find_gkeeper(field):\\n bench = delete_gkeeper(bench)\\n\\n # If the gkeeper in the field has no vote but the there is at least one\\n # gkeeper in the bench with vote we make the substitution and delete\\n # all the remaining gkeepers from the lineup, if there is any. We\\n # finally decrease the n_subst\\n elif not find_gkeeper(field) and find_gkeeper(bench):\\n gkeeper = find_gkeeper(bench)\\n field.insert(0, gkeeper)\\n bench = delete_gkeeper(bench)\\n n_subst -= 1\\n\\n # If there is no gkeeper with vote neither in the field nor in the\\n # bench than we just decrease the n_subst\\n elif not find_gkeeper(field) and not find_gkeeper(bench):\\n n_subst -= 1\",\n \"def TR_algo2(p, vd=2):\\n # h will contain the Hilbert index\\n h = 0\\n # ve and vd contain the entry point and dimension of the current subcube\\n # we choose here a main traversal direction N-2 (i.e. z for a cube) to match\\n # the illustrations\\n ve = 0\\n for i in range(M-1, -1, -1):\\n # the cell label is constructed in two steps\\n # 1. extract the relevant bits from p\\n l = [bit_component(px, i) for px in p]\\n # 2. construct a integer whose bits are given by l\\n l = sum( [lx*2**j for j, lx in enumerate(l)] )\\n # transform l into the current subcube\\n l = T(ve, vd, l)\\n # obtain the gray code ordering from the label l\\n w = inverse_gc(l)\\n # compose (see [TR] lemma 2.13) the transform of ve and vd\\n # with the data of the subcube\\n ve = ve ^ (rotate_left(e(w), vd+1))\\n vd = (vd + d(w) + 1) % N\\n # move the index to more significant bits and add current value\\n h = (h << N) | w\\n return h\",\n \"def right(i):\\r\\n return 2 * i + 2\",\n \"def tweak(rg):\\n (r, g) = rg\\n if r == 0 and g == 0:\\n return 0, 0\\n elif r == 1 and g == 1:\\n return 2, 2\\n elif r == 0:\\n if g == 1:\\n g += 1\\n else:\\n g -= 1\\n elif g == 0:\\n if r == 1:\\n r += 1\\n else:\\n r -= 1\\n else:\\n r -= 1\\n g -= 1\\n return r, g\",\n \"def test_get_scorable_threes_5ok():\\n roll = np.array([3, 3, 3, 3, 3, 1])\\n expected = {\\n \\\"one\\\": 1,\\n \\\"five\\\": 0,\\n \\\"three-ones\\\": False,\\n \\\"three-twos\\\": False,\\n \\\"three-threes\\\": False,\\n \\\"three-fours\\\": False,\\n \\\"three-fives\\\": False,\\n \\\"three-sixes\\\": False,\\n \\\"four-of-a-kind\\\": False,\\n \\\"three-and-one\\\": False,\\n \\\"five-of-a-kind\\\": True,\\n \\\"six-of-a-kind\\\": False,\\n \\\"straight\\\": False,\\n \\\"three-pairs\\\": False,\\n \\\"four-and-pair\\\": False,\\n \\\"triplets\\\": False,\\n }\\n actual = analyze_roll.get_scorable(roll)\\n assert expected == actual\",\n \"def f(left,right,track=True,fork=0):\\r\\n # assert round(left.distance(right)) == UNIT\\r\\n if track :\\r\\n global pos_tracker, pos_turtle\\r\\n x = {round(left.xcor()),round(right.xcor())}\\r\\n y = {round(left.ycor()),round(right.ycor())}\\r\\n\\r\\n\\r\\n result = func(left,right,fork)\\r\\n #les turtles ne se déplacent pas précisément ;\\r\\n #on les fait ici arriver sur des coordonnées entières\\r\\n left.goto(round(left.xcor()),round(left.ycor()))\\r\\n right.goto(round(right.xcor()),round(right.ycor()))\\r\\n\\r\\n if track :\\r\\n x |= {round(left.xcor()),round(right.xcor())}\\r\\n y |= {round(left.ycor()),round(right.ycor())}\\r\\n pos_tracker.add(middle(x,y))\\r\\n\\r\\n for l,r in [(left,right)]+result :\\r\\n pos_turtle[(l,r)] = ahead(l,r)[0]\\r\\n return result\",\n \"def right(length, depth):\\n turtle.setheading(300)\\n turtle.forward(length)\\n binary_tree(length / 2, depth - 1)\",\n \"def right_or_left(self):\\n self.scan()\\n\\n max = 0\\n side = 'l'\\n\\n #analyze scan results\\n for angle in self.scan_data:\\n #RIGHT SIDE\\n if angle < self.MIDPOINT:\\n if self.scan_data[angle] > max:\\n max = self.scan_data[angle]\\n side = 'r'\\n #LEFT SIDE\\n else:\\n if self.scan_data[angle] > max:\\n max = self.scan_data[angle]\\n side = 'l'\\n\\n return side\",\n \"def orient(skeleton, sep_set):\\n\\n def _rule_1(cpdag):\\n \\\"\\\"\\\"Rule_1\\n\\n Orient i——j into i——>j whenever there is an arrow k——>i\\n such that k and j are nonadjacent.\\n \\\"\\\"\\\"\\n\\n columns = list(range(cpdag.shape[1]))\\n ind = list(combinations(columns, 2))\\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\\n # Iteration every (i, j)\\n i, j = ij\\n if cpdag[i, j] * cpdag[j, i] == 0:\\n continue\\n # search i——j\\n else:\\n all_k = [x for x in columns if x not in ij]\\n for k in all_k:\\n if cpdag[k, i] == 1 and cpdag[i, k] == 0 \\\\\\n and cpdag[k, j] + cpdag[j, k] == 0:\\n cpdag[j, i] = 0\\n return cpdag\\n\\n def _rule_2(cpdag):\\n \\\"\\\"\\\"Rule_2\\n\\n Orient i——j into i——>j whenever there is a chain i——>k——>j.\\n \\\"\\\"\\\"\\n\\n columns = list(range(cpdag.shape[1]))\\n ind = list(combinations(columns, 2))\\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\\n # Iteration every (i, j)\\n i, j = ij\\n if cpdag[i, j] * cpdag[j, i] == 0:\\n continue\\n # search i——j\\n else:\\n all_k = [x for x in columns if x not in ij]\\n for k in all_k:\\n if cpdag[i, k] == 1 and cpdag[k, i] == 0 \\\\\\n and cpdag[k, j] == 1 \\\\\\n and cpdag[j, k] == 0:\\n cpdag[j, i] = 0\\n return cpdag\\n\\n def _rule_3(cpdag, sep_set=None):\\n \\\"\\\"\\\"Rule_3\\n\\n Orient i——j into i——>j\\n whenever there are two chains i——k——>j and i——l——>j\\n such that k and l are non-adjacent.\\n \\\"\\\"\\\"\\n\\n columns = list(range(cpdag.shape[1]))\\n ind = list(combinations(columns, 2))\\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\\n # Iteration every (i, j)\\n i, j = ij\\n if cpdag[i, j] * cpdag[j, i] == 0:\\n continue\\n # search i——j\\n else:\\n for kl in sep_set.keys(): # k and l are nonadjacent.\\n k, l = kl\\n # if i——k——>j and i——l——>j\\n if cpdag[i, k] == 1 \\\\\\n and cpdag[k, i] == 1 \\\\\\n and cpdag[k, j] == 1 \\\\\\n and cpdag[j, k] == 0 \\\\\\n and cpdag[i, l] == 1 \\\\\\n and cpdag[l, i] == 1 \\\\\\n and cpdag[l, j] == 1 \\\\\\n and cpdag[j, l] == 0:\\n cpdag[j, i] = 0\\n return cpdag\\n\\n def _rule_4(cpdag, sep_set=None):\\n \\\"\\\"\\\"Rule_4\\n\\n Orient i——j into i——>j\\n whenever there are two chains i——k——>l and k——>l——>j\\n such that k and j are non-adjacent.\\n \\\"\\\"\\\"\\n\\n columns = list(range(cpdag.shape[1]))\\n ind = list(combinations(columns, 2))\\n for ij in sorted(ind, key=lambda x: (x[1], x[0])):\\n # Iteration every (i, j)\\n i, j = ij\\n if cpdag[i, j] * cpdag[j, i] == 0:\\n continue\\n # search i——j\\n else:\\n for kj in sep_set.keys(): # k and j are nonadjacent.\\n if j not in kj:\\n continue\\n else:\\n kj = list(kj)\\n kj.remove(j)\\n k = kj[0]\\n ls = [x for x in columns if x not in [i, j, k]]\\n for l in ls:\\n if cpdag[k, l] == 1 \\\\\\n and cpdag[l, k] == 0 \\\\\\n and cpdag[i, k] == 1 \\\\\\n and cpdag[k, i] == 1 \\\\\\n and cpdag[l, j] == 1 \\\\\\n and cpdag[j, l] == 0:\\n cpdag[j, i] = 0\\n return cpdag\\n\\n columns = list(range(skeleton.shape[1]))\\n cpdag = deepcopy(skeleton)\\n # pre-processing\\n for ij in sep_set.keys():\\n i, j = ij\\n all_k = [x for x in columns if x not in ij]\\n for k in all_k:\\n if cpdag[i, k] + cpdag[k, i] != 0 \\\\\\n and cpdag[k, j] + cpdag[j, k] != 0:\\n if k not in sep_set[ij]:\\n if cpdag[i, k] + cpdag[k, i] == 2:\\n cpdag[k, i] = 0\\n if cpdag[j, k] + cpdag[k, j] == 2:\\n cpdag[k, j] = 0\\n cpdag = _rule_1(cpdag=cpdag)\\n cpdag = _rule_2(cpdag=cpdag)\\n cpdag = _rule_3(cpdag=cpdag, sep_set=sep_set)\\n cpdag = _rule_4(cpdag=cpdag, sep_set=sep_set)\\n\\n return cpdag\",\n \"def _up_left(self, col, row):\\n ones = 0\\n twos = 0\\n for step in range(4):\\n\\n current = self.layout[col + (step*-1)][row + (step)] #step up and left\\n if current == 1: ones+=1\\n if current == 2: twos+=1\\n\\n return self._score_a_quartet(ones, twos)\",\n \"def gameOfThrones(s):\\n y = Counter()\\n x = Counter(s)\\n\\n for a in x:\\n if x[a] % 2 == 1:\\n y['odd'] += 1\\n\\n if len(s) % 2 == 1 and y['odd'] > 1:\\n return 'NO'\\n elif len(s) % 2 == 1 and y['odd'] == 1:\\n return 'YES'\\n elif len(s) % 2 == 0 and y['odd'] > 0:\\n return 'NO'\\n elif len(s) % 2 == 0 and y['odd'] == 0:\\n return 'YES'\",\n \"def m_move1(state,b1,b2):\\n if b2 != 'hand' and not state.holding['hand']:\\n if b2 == 'table':\\n return [('clear',b1,True), ('pos', b1, 'hand'), ('pos', b1, b2)]\\n else:\\n return [('clear',b2,True), ('clear',b1,True), \\\\\\n ('pos', b1, 'hand'), ('pos', b1, b2)]\",\n \"def right_child_idx(idx):\\n return (idx + 1) << 1\",\n \"def _has_left(self, j):\\n return (2 * j + 1) < len(self)\",\n \"def l_un_degenerate(self):\\n self.right = self.tmp\",\n \"def left_child(self, index):\\n return 2 * index\",\n \"def test_four_nodes_needs_left_right_rotation(three_del):\\n three_del.insert(15)\\n three_del.delete(30)\\n assert tuple(three_del.in_order()) == (10, 15, 20)\\n assert tuple(three_del.breadth_first()) == (15, 10, 20)\",\n \"def bk_p(g,p,r,x, counter):\\n print(\\\"counter:\\\\t\\\", counter)\\n print(\\\"p:\\\\t\\\", p)\\n print(\\\"r:\\\\t\\\", r)\\n print(\\\"x:\\\\t\\\", x)\\n result = []\\n pux = set(p).union(set(x))\\n if len(pux) == 0:\\n print(\\\"return r: \\\", r)\\n return r\\n else:\\n pivot = list(pux)[0]\\n pN = [n for n in g.neighbors(pivot)]\\n p_copy = copy.deepcopy(p)\\n print(\\\"P_COPY\\\",p_copy)\\n print(\\\"P_N\\\",pN)\\n for n in pN:\\n p_copy.remove(n)\\n for v in p_copy:\\n print(\\\"v: \\\", v)\\n vNeighbors = [a for a in g.neighbors(v)]\\n print(\\\"vNeighbors: \\\\t\\\", vNeighbors)\\n # pnnv, ruv, xnnv\\n print(\\\"================================\\\")\\n result.append(bk_p(g, intersection(p,vNeighbors), r+[v], intersection(x, vNeighbors), counter+1))\\n print(\\\"================================\\\")\\n print(\\\"result:\\\\t\\\", result, \\\"\\\\tv: \\\", v)\\n p.remove(v)\\n x.append(v)\\n print(\\\"fp:\\\\t\\\", p)\\n print(\\\"fr:\\\\t\\\", r)\\n print(\\\"fx:\\\\t\\\", x)\\n return result\\n\\n def bk_p2(g,r,p,x, counter=0):\\n \\\"\\\"\\\"\\n Bron-Kerbosch algorithm without pivots (implemented with python sets)\\n g: an nx graph\\n r: disjoint set of vertices of graph g\\n p: disjoint set of vertices of graph g\\n x: disjoint set of vertices of graph g\\n \\\"\\\"\\\"\\n pux = p.union(x)\\n if not pux:\\n print('Maximal clique found: ', r)\\n\\n # choose an pivot from pux\\n pivot = next(iter(pux))\\n neighborsP = list(g.neighbors(pivot))\\n for v in p.difference(neighborsP):\\n neighborsV = list(g.neighbors(v))\\n bk_p(g, r.union([v]), p.intersection(neighborsV), x.intersection(neighborsV), counter+1)\\n p.remove(v)\\n x.add(v)\",\n \"def rightDown(self):\",\n \"def way_to_prewin(self, one):\\r\\n\\t\\tkind = [0, 0, 0, 0] \\r\\n\\t\\tuseful = []\\r\\n\\t\\tscore = 0\\r\\n\\t\\tfor part in one.split(\\\"\\\\t\\\"):\\r\\n\\t\\t\\t#print \\\"part: {0}\\\".format(part)\\r\\n\\t\\t\\ttmp = part.split()\\r\\n\\t\\t\\tlength = len(tmp)\\r\\n\\t\\t\\tif (length == 3):\\t\\t# triple\\r\\n\\t\\t\\t\\tkind[0] += 1\\r\\n\\t\\t\\t\\tscore += 3\\r\\n\\t\\t\\telif (length == 1):\\t\\t# single\\r\\n\\t\\t\\t\\tkind[3] += 1\\r\\n\\t\\t\\telif (tmp[0] == tmp[1]):# pair\\r\\n\\t\\t\\t\\tkind[1] += 1\\r\\n\\t\\t\\t\\tuseful.append(\\\"{0}\\\".format(tmp[0]))\\r\\n\\t\\t\\t\\tscore += 2\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tkind[2] += 1\\r\\n\\t\\t\\t\\tn = GameBoard.NextCard(tmp[0])\\r\\n\\t\\t\\t\\tp = GameBoard.PrevCard(tmp[0])\\r\\n\\t\\t\\t\\tnn = GameBoard.NextCard(tmp[1])\\r\\n\\t\\t\\t\\tif (n == tmp[1]):\\t# consecutive neighbor\\r\\n\\t\\t\\t\\t\\tscore += 2\\r\\n\\t\\t\\t\\t\\tif (p != None): useful.append(p)\\r\\n\\t\\t\\t\\t\\tif (nn != None): useful.append(nn)\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tuseful.append(n)\\r\\n\\t\\t\\t\\t\\tscore += 1\\r\\n\\r\\n\\t\\t#print \\\"kind: {0}\\\".format(kind)\\r\\n\\t\\t\\\"\\\"\\\" how many cards can we probably get \\\"\\\"\\\"\\r\\n\\t\\tuseful_amount = 0\\r\\n\\t\\tfor card in set(useful):\\r\\n\\t\\t\\tctype = GameBoard.CardType(card)\\r\\n\\t\\t\\tif (ctype == 1): a = self.wang_list.count(card)\\r\\n\\t\\t\\telif (ctype == 2): a = self.tube_list.count(card)\\r\\n\\t\\t\\telif (ctype == 3): a = self.bamb_list.count(card)\\r\\n\\t\\t\\telif (ctype == 4): a = self.word_list.count(card)\\r\\n\\t\\t\\telse: a = self.wind_list.count(card)\\r\\n\\t\\t\\tb = self.gb.drop_list.count(card)\\r\\n\\t\\t\\tuseful_amount += (4 - a - b)\\r\\n\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\t\\t1. enumerate, because goal state not too much\\r\\n\\t\\t2. counting pong_list so that we can focus on 16 cards\\r\\n\\t\\t3. check prewin first\\t\\r\\n\\t\\t\\\"\\\"\\\"\\r\\n\\t\\tgoals = [[4, 1, 1, 0], [5, 0, 0, 1], [4, 2, 0, 0]]\\r\\n\\t\\tgpattern = [[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"##\\\", \\\"$$\\\"],[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"/\\\"],\\r\\n\\t\\t\\t\\t\\t[\\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"***\\\", \\\"##\\\", \\\"##\\\"]]\\r\\n\\t\\tresult = [0, 0, 0]\\r\\n\\t\\tsize = len(self.pong_list) / 3\\r\\n\\t\\tif ((size + kind[0]) > 4): return [0, useful_amount, score]\\r\\n\\t\\tfor i in range(size): \\r\\n\\t\\t\\tgpattern[0].remove(\\\"***\\\")\\r\\n\\t\\t\\tgpattern[1].remove(\\\"***\\\")\\r\\n\\t\\t\\tgpattern[2].remove(\\\"***\\\")\\r\\n\\t\\tfor number in range(3):\\r\\n\\t\\t\\tk0 = kind[0]\\r\\n\\t\\t\\tk1 = kind[1]\\r\\n\\t\\t\\tk2 = kind[2]\\r\\n\\t\\t\\tk3 = kind[3]\\r\\n\\t\\t\\tp1 = gpattern[number]\\r\\n\\t\\t\\tfor i in range(k0): p1.remove(\\\"***\\\")\\r\\n\\t\\t\\tfor i in range(min(k1, goals[number][1])): \\r\\n\\t\\t\\t\\tk1 -= 1\\r\\n\\t\\t\\t\\tp1.remove(\\\"##\\\")\\r\\n\\t\\t\\tfor i in range(min(k2, goals[number][2])):\\r\\n\\t\\t\\t\\tk2 -= 1\\r\\n\\t\\t\\t\\tp1.remove(\\\"$$\\\")\\r\\n\\t\\t\\t#print \\\"p1: {0}, size: {1}\\\".format(p1, (k1+k2)*2+k3)\\r\\n\\t\\t\\tstep = 0\\r\\n\\t\\t\\ttwo = k1 + k2\\r\\n\\t\\t\\tfor i in range(len(p1)):\\r\\n\\t\\t\\t\\tlength = len(p1[i])\\r\\n\\t\\t\\t\\tif (length == 3):\\r\\n\\t\\t\\t\\t\\tif two:\\r\\n\\t\\t\\t\\t\\t\\ttwo -= 1\\r\\n\\t\\t\\t\\t\\t\\tstep += 1\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tstep += 2\\r\\n\\t\\t\\t\\telif (length == 2):\\r\\n\\t\\t\\t\\t\\tstep += 1\\r\\n\\t\\t\\tresult[number] = step\\r\\n\\t\\t#print \\\"steps to goal: {0}, useful: {1}\\\".format(result, len(useful))\\r\\n\\t\\t\\r\\n\\t\\treturn [min(result), useful_amount, score]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5672551","0.56521153","0.5564578","0.5561289","0.5561289","0.55153245","0.54989326","0.5496743","0.54880667","0.54845977","0.5477298","0.54354954","0.5426299","0.54248595","0.54067","0.538001","0.5370772","0.5370066","0.5360813","0.5335627","0.53286135","0.53194714","0.531928","0.53094757","0.52779627","0.5265633","0.5262112","0.5262112","0.5248677","0.5243677","0.5230456","0.5221479","0.52213854","0.5216191","0.5195972","0.5191282","0.5173319","0.5165491","0.5144961","0.51391274","0.51354593","0.51253045","0.5111918","0.51044405","0.50964314","0.5091978","0.50798184","0.5074108","0.507388","0.5069084","0.5066674","0.50555044","0.50555044","0.5050694","0.5049491","0.5045124","0.5042866","0.50413287","0.502911","0.50268644","0.50231934","0.5021294","0.50188375","0.5018245","0.5018245","0.50175947","0.5006876","0.5004394","0.49981228","0.49874014","0.49870297","0.49818683","0.4972219","0.495449","0.49524456","0.49519494","0.4948561","0.49453023","0.49429345","0.49380937","0.49270254","0.49240193","0.49226466","0.49144214","0.4911784","0.49111217","0.49110353","0.49040362","0.4899532","0.4886239","0.488445","0.48819336","0.48779094","0.48759422","0.48720616","0.4871929","0.48699886","0.48691195","0.48673466","0.48648947","0.48619023"],"string":"[\n \"0.5672551\",\n \"0.56521153\",\n \"0.5564578\",\n \"0.5561289\",\n \"0.5561289\",\n \"0.55153245\",\n \"0.54989326\",\n \"0.5496743\",\n \"0.54880667\",\n \"0.54845977\",\n \"0.5477298\",\n \"0.54354954\",\n \"0.5426299\",\n \"0.54248595\",\n \"0.54067\",\n \"0.538001\",\n \"0.5370772\",\n \"0.5370066\",\n \"0.5360813\",\n \"0.5335627\",\n \"0.53286135\",\n \"0.53194714\",\n \"0.531928\",\n \"0.53094757\",\n \"0.52779627\",\n \"0.5265633\",\n \"0.5262112\",\n \"0.5262112\",\n \"0.5248677\",\n \"0.5243677\",\n \"0.5230456\",\n \"0.5221479\",\n \"0.52213854\",\n \"0.5216191\",\n \"0.5195972\",\n \"0.5191282\",\n \"0.5173319\",\n \"0.5165491\",\n \"0.5144961\",\n \"0.51391274\",\n \"0.51354593\",\n \"0.51253045\",\n \"0.5111918\",\n \"0.51044405\",\n \"0.50964314\",\n \"0.5091978\",\n \"0.50798184\",\n \"0.5074108\",\n \"0.507388\",\n \"0.5069084\",\n \"0.5066674\",\n \"0.50555044\",\n \"0.50555044\",\n \"0.5050694\",\n \"0.5049491\",\n \"0.5045124\",\n \"0.5042866\",\n \"0.50413287\",\n \"0.502911\",\n \"0.50268644\",\n \"0.50231934\",\n \"0.5021294\",\n \"0.50188375\",\n \"0.5018245\",\n \"0.5018245\",\n \"0.50175947\",\n \"0.5006876\",\n \"0.5004394\",\n \"0.49981228\",\n \"0.49874014\",\n \"0.49870297\",\n \"0.49818683\",\n \"0.4972219\",\n \"0.495449\",\n \"0.49524456\",\n \"0.49519494\",\n \"0.4948561\",\n \"0.49453023\",\n \"0.49429345\",\n \"0.49380937\",\n \"0.49270254\",\n \"0.49240193\",\n \"0.49226466\",\n \"0.49144214\",\n \"0.4911784\",\n \"0.49111217\",\n \"0.49110353\",\n \"0.49040362\",\n \"0.4899532\",\n \"0.4886239\",\n \"0.488445\",\n \"0.48819336\",\n \"0.48779094\",\n \"0.48759422\",\n \"0.48720616\",\n \"0.4871929\",\n \"0.48699886\",\n \"0.48691195\",\n \"0.48673466\",\n \"0.48648947\",\n \"0.48619023\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13283,"cells":{"query":{"kind":"string","value":"r\"\"\"Computes fingerprints of the input strings."},"document":{"kind":"string","value":"def _sdca_fprint(input, name=None):\n result = _op_def_lib.apply_op(\"SdcaFprint\", input=input, name=name)\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def fingerprint(self, algorithm):","def hash_all(strs, digest=None):\r\n digest = digest or hashlib.sha1()\r\n for s in strs:\r\n digest.update(s)\r\n return digest.hexdigest()","def compute_fingerprint(self):\n\t\t# initialize tensorflow session\n\t\tsess = tf.InteractiveSession()\n\t\tclf_image = wb_clf(config.clf_image_filename, reshape_size=None, input_dim=(100,200), \n\t\t\t\t\t\t\tname=\"image\", ALEXNET=True)\n\t\tclf_blot = wb_clf(config.clf_blot_filename, input_dim=(15,30), reshape_size=4*8*64, name=\"blot\")\n\t\tsess.run(tf.global_variables_initializer())\n\t\t# create western blot fingerprinting object\n\t\tWB = WesternBlot(clf_image=clf_image, clf_blot=clf_blot)\n\t\tWB.figure = self.figure\n\t\tWB.figure_gray = cv2.cvtColor(self.figure, cv2.COLOR_BGR2GRAY)\n\t\t# compute fingerprint\n\t\tWB.westernBlotExtractor(VISUALIZE=False)\n\t\tself.local_database = WB.Fingerprint","def patterns_hash(patterns):\n return hash(\"\".join(map(str, patterns)))\n # return sum((3**(5 * i) + 1) * (p + 1) for i, p in enumerate(patterns))","def test6(self):\n smis = [ 'CCC(O)C(=O)O','c1ccccc1','C1CCCCC1','C1NCCCC1','CNCNCNC']\n for smi in smis:\n m = Chem.MolFromSmiles(smi)\n fp1 = Chem.RDKFingerprint(m,2,7,4096)\n fp2 = DataStructs.FoldFingerprint(fp1,2)\n fp3 = Chem.RDKFingerprint(m,2,7,2048)\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\n fp2 = DataStructs.FoldFingerprint(fp2,2)\n fp3 = Chem.RDKFingerprint(m,2,7,1024)\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\n fp2 = DataStructs.FoldFingerprint(fp1,4)\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())","def hash_all(strs: typing.Iterable[bytes | str]) -> str:\n digest = hashlib.sha1()\n for s in strs:\n s = ensure_binary(s)\n digest.update(s)\n return digest.hexdigest()","def process_strings(self):\n for string in self.input:\n matcher = self.choose_algorithm()\n matcher.find_match(string, self.case_insensitive)\n self.__results = matcher.results\n\n if self.counter:\n self.__results = matcher.counts\n\n if self.__results:\n self.output(string)","def hash(plainString):\n result = plainString\n for i in range(0,12):\n result = hashHelp(result)\n return result","def pre_compute_hashes(s, M1, M2, X):\n n = len(s)\n h1 = [0 for _ in range(n+1)]\n h2 = [0 for _ in range(n+1)]\n for i in range(1, n+1):\n ch = ord(s[i-1])\n h1[i] = (X*h1[i-1] + ch) % M1\n h2[i] = (X*h2[i-1] + ch) % M2\n return h1, h2","def hashHelp(plainString):\n # hashed = plainString\n n = len(plainString) // 4\n\n a = plainString[0:n]\n b = plainString[n : n * 2]\n c = plainString[n * 2 : n * 3]\n d = plainString[n * 3 : len(plainString)]\n\n if len(a) == 0 or len(b) == 0 or len(c) == 0 or len(d) == 0:\n raise Exception(\"Error string not long enough, use at least 4 characters\")\n\n numA = numToBin(functionF(a,d))\n numB = numToBin(strToNum(b))\n numC = numToBin(bitShift(c))\n numD = numToBin(functionG(a,b,c,d))\n\n # hashed = A + B + numC + D\n # hashed = numA + '|' + numB + '|' + numC + '|' + numD\n hashed = text_from_bits(numD + numA + numB + numC)\n hashed = numbersToLetters(hashed)\n return hashed","def compute_multiple_minhashes(strings: List[str]) -> List[LeanMinHash]:\n return [\n LeanMinHash(mh)\n for mh in MinHash.bulk(\n [string_encoder(s) for s in strings], num_perm=PERMUTATIONS\n )\n ]","def run_algorithms(string_list):\n\tstring_count = int(string_list[0])\n\n\tfor i in range(1, string_count+1):\n\t\tstring = string_list[i]\n\t\tprint(\"Phrase number: \", i)\n\t\tprint(string, \"\\n\")\n\t\tsplit_string = []\n\t\tmemo = set()\n\n\t\tprint(\"Iterative attempt:\")\n\t\tif iterative_string_split(string, split_string) is True:\n\t\t\tprint(\"YES, can be split.\")\n\t\t\tprint(print_string_list(split_string))\n\t\telse:\n\t\t\tprint(\"NO, cannot be split.\")\n\n\t\tsplit_string = []\n\n\t\tprint(\"\\nMemoized attempt:\")\n\t\tif recursive_string_split(string, 0, split_string, memo) is True:\n\t\t\tprint(\"YES, can be split.\")\n\t\t\tsplit_string.reverse()\n\t\t\tprint(print_string_list(split_string))\n\n\t\telse:\n\t\t\tprint(\"NO, cannot be split.\")\n\n\t\tprint(\"\\n\")","def fingerprint(keyed_data, digest_size=16):\n h = blake2b(digest_size=16)\n for key in sorted(keyed_data.keys()):\n val = keyed_data[key]\n s = json.dumps(val, sort_keys=True, cls=NpEncoder).encode()\n h.update(s)\n return h.hexdigest()","def _precompute_substrings(self, p: int) -> List[int]:\n hash_vals: List[int] = [0]\n for i in range(len(self._s)):\n val = (hash_vals[i] * self.X + ord(self._s[i])) % p\n hash_vals.append(val)\n\n return hash_vals","def compute_fingerprint(path_list):\n\n hasher = hashlib.sha1()\n\n for path_item in path_list:\n\n # For directories, create a hash based on the modification times\n # of first-level subdirectories\n if os.path.isdir(path_item):\n for dirname in sorted(os.listdir(path_item)):\n path_name = os.path.join(path_item, dirname)\n if os.path.isdir(path_name):\n hasher.update(str(os.stat(path_name).st_mtime).encode('utf-8'))\n\n # For files, hash the contents of the file\n if os.path.isfile(path_item):\n with open(path_item, \"rb\") as file_handle:\n hasher.update(file_handle.read())\n\n return hasher.hexdigest()","def part1(input_string):\n twos, threes = 0, 0\n for line in input_string:\n letters_seen = {}\n for char in line:\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\n if 2 in letters_seen.values():\n twos += 1\n if 3 in letters_seen.values():\n threes += 1\n return threes * twos","def fingerprints(files, model, size=(224, 224), modelname='VGG16'):\n all_results = {}\n fingerprints = []\n for fn in tqdm.tqdm(files, total=len(files)):\n result = fingerprint(fn, model, size, modelname=modelname)\n if len(result) > 0:\n all_results[fn] = result\n\n # return dict((fn, fingerprint(fn, model, size)) for fn in files)\n return all_results","def main():\n inputStr = input(\"Enter string to be hashed: \")\n print(f\"Hashed string: {hash(inputStr.replace(' ', ''))}\")","def convert_to_fingerprint(s):\n\n\ttry:\n\t\t# Convert SMILES to Molecule object\n\t\tmolecule = Chem.MolFromSmiles(s)\n\t\t# Get MACCS Key from Molecule object\n\t\tmaccs_key = MACCSkeys.GenMACCSKeys(molecule)\n\t\treturn maccs_key.ToBitString()\n\texcept:\n\t\treturn None","def compute_fingerprint(path_list):\r\n\r\n hasher = hashlib.sha1()\r\n\r\n for path in path_list:\r\n\r\n # For directories, create a hash based on the modification times\r\n # of first-level subdirectories\r\n if os.path.isdir(path):\r\n for dirname in sorted(os.listdir(path)):\r\n p = os.path.join(path, dirname)\r\n if os.path.isdir(p):\r\n hasher.update(str(os.stat(p).st_mtime))\r\n\r\n # For files, hash the contents of the file\r\n if os.path.isfile(path):\r\n with open(path, \"rb\") as file_handle:\r\n hasher.update(file_handle.read())\r\n\r\n return hasher.hexdigest()","def chunk_hashes(str):\n chunk = 1024*1024\n chunk_count = int(math.ceil(len(str)/float(chunk)))\n chunks = [str[i*chunk:(i+1)*chunk] for i in range(chunk_count)]\n return [hashlib.sha256(x).digest() for x in chunks]","def computeHash(string):\n\tif isBytes(string):\n\t\tstring = string.decode(\"latin-1\")\n\thash_ = 63689\n\tfor char in string:\n\t\thash_ = hash_ * 378551 + ord(char)\n\treturn hash_ % 65536","def fasthash(string):\r\n md4 = hashlib.new(\"md4\")\r\n md4.update(string)\r\n return md4.hexdigest()","def generateFingerprint(molecule, numInts=32, pathLength=7):\n \n paths = LinearPaths.generatePaths(molecule, maxdepth=pathLength)\n fp = Fingerprint.Fingerprint(numIntegers=numInts)\n\n for path in paths:\n fp.addPath(path)\n\n return fp","def get_similarity(string1, string2, probabilities, characters):\n\n strict_counter = 0\n weak_counter = 0\n for i in range(0, len(string1)):\n if string1[i] == string2[i]:\n strict_counter+=1\n\n k = 0\n for prob in probabilities[i]:\n if ((prob != 0) & (string1[i] == characters[k])):\n weak_counter += 1\n break\n \n k+=1\n\n # Return list containing strict and weak probabilities\n return [(strict_counter / len(string1)) * 100, \n (weak_counter / len(string1)) * 100]","def fingerprint(public_key):\r\n\r\n return hashlib.new('ripemd160', hashlib.sha256(public_key).digest()).digest()[:4]","def format_fingerprint(fpr):\n count = 0\n fingerprint = ''\n chunks = [i for i in re.split('([A-F0-9]{4})', fpr) if i]\n for chunk in chunks:\n count += 1\n fingerprint += ' %s' % chunk\n if count == len(chunks)/2:\n fingerprint += ' '\n\n return fingerprint.strip()","def _certificate_fingerprint(identity):\n fingerprint, stderr = _check_output([\n \"openssl\",\n \"x509\",\n \"-inform\",\n \"DER\",\n \"-noout\",\n \"-fingerprint\",\n ],\n inputstr=identity)\n fingerprint = fingerprint.strip()\n fingerprint = fingerprint.replace(\"SHA1 Fingerprint=\", \"\")\n fingerprint = fingerprint.replace(\":\", \"\")\n return fingerprint","def signature(s):\r\n # TODO: rewrite using sorted()\r\n t = list(s)\r\n f=[]\r\n i,j=0\r\n for i in range(len(s)):\r\n for j in range (len(s)-1):\r\n if i!=j:\r\n t[i],t[j]=t[j],t[i]\r\n z=''.join(t)\r\n f.append(z)\r\n return f","def create_ids(input):\r\n return hashlib.md5(input)","def precompute_hashes(text, pattern_len, p, x):\n\n if len(text) < pattern_len or pattern_len == 0:\n return []\n\n hashes = [ 0 ] * (len(text) - pattern_len + 1)\n\n slice = text[len(text) - pattern_len:]\n hashes[len(text) - pattern_len] = SearchPattern.poly_hash(\n slice, p, x)\n\n y = 1\n for i in range(1, pattern_len + 1):\n y = (y * x) % p\n for i in range(len(text) - pattern_len - 1, -1, -1):\n hashes[i] = (x * hashes[i + 1] + ord(text[i]) -\n y * ord(text[i + pattern_len])) % p\n\n return hashes","def solution(s):","def string_features_hex(hexstr):\n out = dict([(x,0) for x in hexabet])\n ct = dict(Counter(hexstr.split()))\n N = len(hexstr.split())\n for k in out.keys():\n if k in ct.keys():\n out[k] += ct[k]\n out = [v[1] for v in sorted(out.iteritems(), key=lambda (k,v): k)]\n out = [float(x)/N for x in out]\n return out","def sherlockAndAnagrams(s):\n\n dic = {}\n\n count = 0\n for i in range(len(s)):\n for j in range(i+1, len(s)+1):\n substrings = sorted(list(s[i:j]))\n joined_ss = ''.join(substrings)\n if joined_ss != '':\n if joined_ss in dic:\n count += dic[joined_ss]\n dic[joined_ss] += 1\n else:\n dic[joined_ss] = 1 \n print(dic)\n return count","def input_to_hash(self, keys):\n basic_keys = []\n for i, key in enumerate(keys):\n s = ''\n #print(max(key), min(key))\n for val in key:\n s += \"{:04x}\".format(val)\n basic_keys.append(s)\n return basic_keys","def fingerprint():\n files = (glob.glob(base_dir + '**/*.html') +\n glob.glob(base_dir + '*.html') +\n glob.glob(base_dir + 'core.js'))\n\n md5s = OrderedDict()\n\n for fil in sorted(files):\n name = fil[len(base_dir):]\n with open(fil) as fp:\n md5 = hashlib.md5(fp.read().encode('utf-8')).hexdigest()\n md5s[name] = md5\n\n template = \"\"\"\\\"\\\"\\\"DO NOT MODIFY. Auto-generated by script/fingerprint_frontend.\\\"\\\"\\\"\n\nFINGERPRINTS = {}\n\"\"\"\n\n result = template.format(json.dumps(md5s, indent=4))\n\n with open(fingerprint_file, 'w') as fp:\n fp.write(result)","def call_fingerprint(cls, args, kwargs):\n return hasher(getcallargs(cls.__init__, None, *args, **kwargs))","def compress(string):\n \n # Build the dictionary.\n dict_size = 256\n seen = dict((chr(i), i) for i in range(dict_size))\n \n p = \"\"\n output = 0\n for c in string:\n pc = p + c\n if pc in seen:\n p = pc\n else:\n # We have not seen this. Output the stuff.\n output += 1\n seen[pc] = dict_size\n dict_size += 1\n p = c\n \n # Output the code for w.\n return output * 12","def my_md5(inp):\n # https://en.wikipedia.org/wiki/MD5#Pseudocode\n global s, K # `s` and `K` are global\n\n # Initialize variables\n a0 = 0x67452301 # A\n b0 = 0xefcdab89 # B\n c0 = 0x98badcfe # C\n d0 = 0x10325476 # D\n\n # Convert input string to bit string\n msg = ''.join(f'{ord(i):08b}' for i in inp)\n\n # append \"1\" bit to message\n msg += '1'\n\n # append \"0\" bit until message length in bits = 448 (mod 512)\n msg += '0'*(448 - len(msg))\n\n # append original length in bits mod 2**64 to message\n msg += '{0:064b}'.format(ch_endian64(len(inp)*8))\n\n assert len(msg) == 512\n\n # Process the message in successive 512-bit chunks:\n # for each 512-bit chunk of padded message do\n # break chunk into sixteen 32-bit words M[j], 0 <= j <= 15\n #\n # ~> We have 1 chunk, so no need for that\n\n # Initialize hash value for this chunk:\n A, B, C, D = a0, b0, c0, d0 \n b_values = []\n\n # Main loop:\n for i in range(64):\n if 0 <= i and i <= 15:\n F = (B & C) | (~B & D)\n g = i\n elif 16 <= i and i <= 31:\n F = (D & B) | (~D & C)\n g = (5*i + 1) % 16\n elif 32 <= i and i <= 47:\n F = B ^ C ^ D\n g = (3*i + 5) % 16\n elif 48 <= i <= 63:\n F = C ^ (B | ~D)\n g = (7*i) % 16\n\n F &= 0xFFFFFFFF\n\n inp_chunk = ch_endian(int(msg[32*g:32*g + 32], 2))\n\n # Be wary of the below definitions of a,b,c,d\n F = (F + A + K[i] + inp_chunk) & 0xFFFFFFFF # M[g] must be a 32-bits block\n A = D\n D = C\n C = B\n B = (B + rol(F, s[i])) & 0xFFFFFFFF\n\n print(f'{i:2d}: A:{A:08X}, B:{B:08X}, C:{C:08X}, D:{D:08X} ~> g:{g} $ {inp_chunk:08X} $ X:{B & 0x3FF:03X}')\n\n b_values.append(B & 0x3FF) # Get the leak.\n\n # Add this chunk's hash to result so far:\n a0 = (a0 + A) & 0xFFFFFFFF\n b0 = (b0 + B) & 0xFFFFFFFF\n c0 = (c0 + C) & 0xFFFFFFFF\n d0 = (d0 + D) & 0xFFFFFFFF\n # end for\n\n a0 = ch_endian(a0)\n b0 = ch_endian(b0)\n c0 = ch_endian(c0)\n d0 = ch_endian(d0)\n\n print(f'{a0:08X}-{b0:08X}-{c0:08X}-{d0:08X}')\n \n # var char digest[16] := a0 append b0 append c0 append d0 // (Output is in little-endian)\n print(f'{a0:08x}{b0:08x}{c0:08x}{d0:08x}')\n\n return b_values","def compute_pair_frequencies(text, alphabet_size=256):\n\n curr = text[1:]\n prev = text[:-1]\n pairs = np.stack([prev, curr])\n\n print(\"Counting pairs . . .\")\n (char1, char2), counts = np.unique(pairs, return_counts=True, axis=1)\n print(\"Done.\\n\")\n\n joints = np.zeros((alphabet_size, alphabet_size))\n joints[char1, char2] = counts / np.sum(counts)\n assert np.isclose(np.sum(joints), 1.0)\n\n return joints","def song_fp(samples, prnt_spectro=False):\n\n t, f = peak_find(samples, prnt_spectro)\n\n fingerprints = set()\n for n, t1 in enumerate(t) :\n for j, t2 in enumerate(t[min(n + 1, len(t) - 1) : min(n + 20, len(t))]) :\n if n + j + 1 < len(t) :\n fingerprints.add((f[n], f[n + j + 1], t2 - t1))\n\n return frozenset(fingerprints)","def test_string_to_hex():\n strings = ['helloworld', 'HelloWorld', 'HELLOWORLD', 'Hello WorLd', 'hElLo W Or L d', 'h e l l o w o r l d']\n\n for i, word in enumerate(strings):\n assert pi_finder.string_to_hex(word, hex_dict) == '68656c6c6f776f726c64'","def hashing(smiles):\n import hashlib\n hash_object = hashlib.md5(canonical_smiles_from_smiles(smiles).encode(\"utf-8\"))\n return hash_object.hexdigest()","def hash(string):\n hs = 0\n for s in string:\n hs += ord(s)\n return hs","def rec_freq(markers):\n keys = list(markers.keys())\n rf_pairs = {}\n for i in range(len(markers)):\n for j in range(i + 1, len(markers)):\n m1 = markers[keys[i]][0]\n m2 = markers[keys[j]][0]\n tot_len = 0\n score = 0\n if len(m1) != len(m2):\n print(\"Error, sequences aren't same length.\", keys[i], keys[j])\n exit()\n for k in range(len(m1)):\n c1 = m1[k]\n c2 = m2[k]\n if c1 == \"-\" or c2 == \"-\":\n continue\n if c1 != c2:\n score += 1\n tot_len += 1\n\n rf = score / tot_len * 100\n rf_pairs[(keys[i], keys[j])] = rf\n return rf_pairs","def hashstring(astring, tablesize):\n \n sum = 0\n for pos in range(len(astring)):\n # to account for anagrams, we give weightage to positions of the letters to give different hash values\n sum = sum + ord(astring[pos]) * (pos + 1)\n \n return sum % tablesize","def HashAlgorithm(self) -> _n_7_t_0:","def fingerprint(samp):\r\n wid = samp.shape[1]\r\n\r\n d = np.r_[\r\n np.full((1, wid), True, dtype=bool),\r\n np.diff(np.sort(samp, axis=0), 1, 0) != 0,\r\n np.full((1, wid), True, dtype=bool)\r\n ]\r\n\r\n f_col = []\r\n f_max = 0\r\n\r\n for k in range(wid):\r\n a = np.diff(np.flatnonzero(d[:, k]))\r\n a_max = a.max()\r\n hist, _ = np.histogram(a, bins=a_max, range=(1, a_max + 1))\r\n f_col.append(hist)\r\n if a_max > f_max:\r\n f_max = a_max\r\n\r\n return np.array([np.r_[col, [0] * (f_max - len(col))] for col in f_col]).T","def hashing(file,pp):\n\n def myhash(instring):\n # sdbm hash\n res = 0\n for t in instring:\n res = (ord(t) + (res<<6) + (res<<16) - res) % 2**32\n return res\n\n return hex(myhash(file.replace('\\\\','/')+\":\"+pp))","def calculate_rule_hash(self, rule):\r\n hash_strings = []\r\n condition_string_prefaces = (\"$\", \"!\", \"#\", \"@\")\r\n # dictionary for substitutions\r\n string_substitutions = {}\r\n all_strings = []\r\n # original code used md5\r\n # m = hashlib.md5()\r\n m = hashlib.sha3_256()\r\n # Adding all string contents to the list\r\n if 'strings' in rule:\r\n for s in rule['strings']:\r\n if s['type'] == \"byte\":\r\n # original code just needed to append the converted hex code as a string. We need to create the dictionary entries for substitutions as well\r\n # hash_strings.append(re.sub(r'[^a-fA-F\\?0-9]+', '', s['value']))\r\n byte_code_string = re.sub(r'[^a-fA-F\\?0-9]+', '', s['value'])\r\n dict_entry = {s['name']: byte_code_string}\r\n string_substitutions.update(dict_entry)\r\n hash_strings.append(byte_code_string)\r\n else:\r\n # The following line was the only portion of this else statement in the original code\r\n # This change takes modifiers into account for string arguments\r\n # hash_strings.append(s['value'])\r\n string_and_modifiers = []\r\n string_and_modifiers.append(s['value'])\r\n if 'modifiers' in s:\r\n for modifier in s['modifiers']:\r\n string_and_modifiers.append(modifier)\r\n string_and_modifiers = \" \".join(string_and_modifiers)\r\n all_strings.append(\"$\"+string_and_modifiers)\r\n dict_entry = {s['name']: string_and_modifiers}\r\n string_substitutions.update(dict_entry)\r\n #hash_strings.append(\"$\"+string_and_modifiers)\r\n all_strings = self.resort_stings_add_commas(all_strings)\r\n # Adding the components of the condition to the list (except the variables)\r\n all_wild_card_1 = \"\\$\\*\"\r\n all_wild_card_2 = \"them\"\r\n for e in rule['condition_terms']:\r\n if re.match(all_wild_card_1, e) or re.match(all_wild_card_2, e):\r\n hash_strings.extend(all_strings)\r\n elif e.startswith(condition_string_prefaces):\r\n if len(e) > 1:\r\n string_preface, string_name = e[:1], e[1:]\r\n string_name = \"$\" + string_name\r\n if e.endswith(\"*\"):\r\n hash_strings.extend(self.resort_stings_add_commas(self.regex_match_string_names_for_values(string_preface, string_name, string_substitutions)))\r\n #hash_strings.extend(\"Pull all the matching strings\")\r\n else:\r\n if string_name in string_substitutions:\r\n substituted = string_preface + string_substitutions[string_name]\r\n hash_strings.append(substituted)\r\n else:\r\n hash_strings.append(e)\r\n else:\r\n hash_strings.append(e)\r\n else:\r\n hash_strings.append(e)\r\n # Generate a hash from the sorted contents\r\n #hash_strings.sort()\r\n m.update(\"\".join(hash_strings).encode(\"ascii\"))\r\n return m.hexdigest()","def main():\n\tprint 'Introduce string: '\n\ts = raw_input()\n\treturn if_unique_chars_one(s)","def fingerprint(publicKeyN, publicKeyE=65537L):\n asn1Str = encoder.encode(univ.Sequence().setComponentByPosition(0, univ.Integer(publicKeyN)).setComponentByPosition(1, univ.Integer(publicKeyE)))\n hashString = hashlib.sha1(asn1Str).digest()\n hexlifiedHash = binascii.hexlify(hashString)\n return hexlifiedHash.upper()","def hashing_info(string):#KEY HASHING FUNCTION\n nodeInfo = string.encode('utf-8')\n\n #md5 -> 2^7 = 128 bits\n hash_object = hashlib.md5()\n hash_object.update(nodeInfo)\n\n tmp = hash_object.hexdigest()\n tmp = int(tmp,16)\n\n result = tmp >> (128-16)\n return result","def encode(string_):\n return (lambda f, s: f(list( ord(c) for c in str(string_) ) , \\\n s))(lambda f, s: sum(f[i] * 256 ** i for i in \\\n range(len(f))), str(string_))","def main(argv):\n\n # test strings\n input_strings = [\n \"Foursemestersofchemistry(CHM111/113,CHM112/114,CHM211/213,andCHM212-/214),twosemestersofphysics (PCS201/20\" +\n \"3andPCS202/204) andmathematicsthroughcalculusI(MAT160)arerequired.\",\n \"Mathematicsmajorsarerequiredtocomplete:MAT 160, MAT 260, andMAT 360(CalculusI, II, andIII:12credits), MAT\" +\n \" 302 (LinearAlgebra:3credits), plusatleastfouradditionalupperlevelmathematicscourses(atleast12credits) and\" +\n \"CSC110 (IntroductiontoComputerProgramming:2-4 credits),or MAT151I(Computer ApplicationsforScienceand Mathem\" +\n \"atics: 3 credits).EachstudentmustalsocompleteaJunior Seminar (MAT398/399:2 credits)andSenior Experience(MAT4\" +\n \"98/499: 4 credits)inmathematics. \",\n \"EQUALEDUCATIONALANDEMPLOYMENTOPPORTUNITYPOLICY\",\n \"Caldwell, New Jersey, has seen\\n many changes over the years and was recently ranked by NJMonthly Magazine \" +\n \"as one of the best places to live in all of New Jersey. A short walk brings students to the revitalized \" +\n \"center of town, where shops, a movie theater, wi-fi hot spots andlotsoftastyrestaurantsprovidegreatoptions\" +\n \"forfun. Manyshopsparticipateinadiscount program for Caldwell University students, making the town affordable\" +\n \" on student budgets.\",\n \"If there is anaturaldisaster that interrupts a student’slong-termparticipationinacourse(s),CarlowUniversity\" +\n \"willapprise students oftheoptionsavailabletocompletetheiracademic coursework. \",\n \"PREREQUISITES:BSM103 ANDBSM226. \",\n \"Continuum and atomistic descriptions of diffusion in solids. Reactionsinvolving surfaces and interfaces, in\" +\n \"cluding evaporation, adsorption,grain growth, and coarsening. Phase transformation kinetics, includingnucle\" +\n \"ation, growth, solidification, spinodal decomposition, and martensitictransformations. Analysis of systems \" +\n \"with multiple kinetic mechanisms(typical examples include oxidation, crystal growth, and sintering).Prerequ\" +\n \"isite: background in basic thermodynamics. Recommended:ENGN 1410 or 2410 or equivalent.\",\n \"poststructuralistsmisusethewordduetoNewton'sthirdlaw\"]\n\n for input_string in input_strings:\n processed = punct_split(input_string)\n\n print(input_string)\n print(processed)\n print()","def sherlockAndAnagrams(s):\n counter, len_s = 0, len(s)\n \n print(f\"Original string: {s}. length: {len_s}\")\n for chunk in range(1, len_s):\n arr = []\n for i in range(0, len_s - chunk + 1):\n ex1 = \"\".join(s[i:i+chunk])\n ex = \"\".join(sorted(s[i:i+chunk]))\n print(f\"chunk: {chunk}, i: {i}, sub: {ex1}, sub_sorted: {ex}\")\n arr.append(ex)\n\n c = Counter(arr)\n for key in c:\n val = c[key]\n if val > 1:\n counter += (val * (val - 1)) // 2\n \n print(f\"chunk: {chunk}, # counter: {counter}, Counter: {str(c)}\\n\")\n print(f\"Result: {counter}.\")\n return counter","def _hexdigests(self):\n\n return tuple(self._hashers[algo].hexdigest() for algo in self.algos)","def customHashFunc(str):\n return sum(ord(chr) for chr in str)%128","def compress(string):","def compress(string):","def find_pairs(words): \n pass","def pack(self, input_string):\r\n #This function lacks basic error checking....\r\n klaf = ''\r\n for s in input_string:\r\n klaf += bin((ord(s) % 128) % 64)[2:].zfill(6)\r\n result = ''\r\n for i in range(0, 6):\r\n result = result + hex(int('' + klaf[i * 8:i * 8 + 8],\r\n 2))[2:].zfill(2)\r\n return result","def gather_values(x):\n\n\tassert isinstance(x, list)\n\tassert len(x) > 0 \n\n\tfor bitstrings in x:\n\t\tassert isinstance(bitstrings, str)\n\n\tcounter = True\n\tfor bitstrings in x: #Asserting input strings are bits only\n\t\tfor no in bitstrings: \n\t\t\tif (no != \"1\") and (no != \"0\"):\n\t\t\t\tcounter = False\n\tassert (counter == True )\n\n\tbit_length = len(x[0])\n\n\tfor bitstrings in x: \n\t\tassert len(bitstrings) == bit_length \n\n\t#assertions end\n\n\n\tunique_list = []\n\n\tfrequency_list = []\n\n\tmy_dict = {}\n\n\tfor bitstrings in x: #Extracting Keys\n\t\tif bitstrings not in unique_list:\n\t\t\tunique_list.append(bitstrings)\n\n\t# mapped_dictionary = map_bitstring(unique_list)\n\n\tfor unique_bitstrings in unique_list: \n\t\tcounter = 0 \n\t\tfor bitstring in x: \n\t\t\tif unique_bitstrings == bitstring:\n\t\t\t\tcounter += 1 \n\n\t\t#At this point we have the frequency of the iterative variable \n\n\t\tnew_value = []\n\n\t\tfor i in range(counter):\n\t\t\tnew_value.append(map_bitstring_digit(unique_bitstrings))\n\n\n\t\tmy_dict.update({unique_bitstrings : new_value})\n\n\n\treturn my_dict","def compression(s):","def solve(in_str):\n\n return ','.join(sorted(imap(lambda x: ''.join(x),permutations(in_str))))","def compute_idfs(documents):\n words = set()\n for file in documents:\n words.update(documents[file])\n\n idfs = dict()\n for word in words:\n tw = sum(word in documents[file] for file in documents)\n idf = math.log(len(documents)/ tw )\n idfs[word] = idf\n\n return idfs","def _gpg_fingerprints(self) -> List[str]:\n return self._gpg_keys.fingerprints","def fingerprint(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"fingerprint\")","def get_fingerprint():\n for fingerimg in range(1, 3):\n if fingerimg == 1:\n print(\"Place finger on sensor...\", end=\"\", flush=True)\n else:\n print(\"Place same finger again...\", end=\"\", flush=True)\n \n cont = 0\n\n while True:\n i = finger.get_image()\n if i == adafruit_fingerprint.OK:\n print(\"Image taken\")\n break\n if i == adafruit_fingerprint.NOFINGER:\n print(\".\", end=\"\", flush=True)\n time.sleep(0.01)\n cont += 1\n if cont >= 100:\n print(\"Tiempo de espera agotado\")\n return {'success': False, 'mismatch': False, 'msg': \"No se ha detectado la huella, intente nuevamente\"}\n elif i == adafruit_fingerprint.IMAGEFAIL:\n print(\"Imaging error\")\n return False\n else:\n print(\"Other error\")\n return {'success': False, 'mismatch': False, 'msg': \"Fallo al tomar la huella, intente nuevamente\"}\n\n print(\"Templating...\", end=\"\", flush=True)\n i = finger.image_2_tz(fingerimg)\n if i == adafruit_fingerprint.OK:\n print(\"Templated\")\n else:\n if i == adafruit_fingerprint.IMAGEMESS:\n print(\"Image too messy\")\n elif i == adafruit_fingerprint.FEATUREFAIL:\n print(\"Could not identify features\")\n elif i == adafruit_fingerprint.INVALIDIMAGE:\n print(\"Image invalid\")\n else:\n print(\"Other error\")\n return {'success': False, 'mismatch': False, 'msg': \"Fallo al tomar la huella, intente nuevamente\"}\n\n if fingerimg == 1:\n print(\"Remove finger\")\n while i != adafruit_fingerprint.NOFINGER:\n i = finger.get_image()\n\n print(\"Creating model...\", end=\"\", flush=True)\n i = finger.create_model()\n if i == adafruit_fingerprint.OK:\n print(\"Created\")\n else:\n if i == adafruit_fingerprint.ENROLLMISMATCH:\n print(\"Prints did not match\")\n return {'success': False, 'mismatch': True, 'msg': \"Las huellas ingresadas no coinciden, intente nuevamente\"}\n else:\n print(\"Other error\")\n return {'success': False, 'mismatch': False, 'msg': \"Fallo al tomar la huella, intente nuevamente\"}\n\n print(\"Downloading template...\")\n data = finger.get_fpdata(\"char\", 1)\n filename = f\"{uuid.uuid4()}.dat\"\n with open(f\"./fingers/{filename}\", \"wb\") as file:\n file.write(bytearray(data))\n print(f\"Template is saved in {filename} file.\")\n \n return {'success': True, 'msg': \"Imagen tomada satisfactoriamente\", 'data': filename}","def fingerprint(self, key):\n base64_pub = self.base64_pub_encode(key)\n return SHA256.new(base64_pub.encode('utf-8')).digest()","def _hexdigests(self):\n\n for algo in self.algos:\n q = self._queues[algo]\n q.put(b'') # Terminate\n self._threads[algo].join()\n assert q.empty()\n return super(MtHasher, self)._hexdigests()","def compute_pdq(iobytes):\n #hash_vector, quality = pdqhash.compute(ensure_pil(im))\n #print(type(hash_vector))\n #print(hash_vector)\n #return hash_vector.ravel().tolist()\n pdq_hasher = PDQHasher()\n hash_and_qual = pdq_hasher.fromBufferedImage(iobytes)\n #hash_array = imagehash.hex_to_hash(hash_and_qual.getHash().toHexString())\n #return hash_array.hash.ravel().tolist()\n return hash_and_qual.getHash().dumpBitsFlat() #This is a string of 0's and 1's","def dawkins_algorithm(strlen=28):\n copies = copy_string(generate_string(strlen))\n new_score = 0\n\n while new_score < 28:\n for index, s in enumerate(copies):\n current_score = compare(s)\n mutated_string = mutate_string(s)\n new_score = compare(mutated_string)\n if new_score > current_score:\n copies[index] = mutated_string\n print(mutated_string)\n\n if new_score == strlen:\n break\n\n copies = copy_string(find_best_candidate(copies))\n\n return print(\"Done\")","def get_fingerprints(self, jid: JID) -> List[str]:\n return []","def fingerprint(self) -> str:\n fp = self.sha256.hex()\n return fp","def _build_hash_table(arr: [str]):\n ht = {}\n for cur_str in arr:\n\n anagram = cur_str[::-1]\n if cur_str in ht.keys():\n # This string is an anagram of some previous\n # Increase anagram count for hash table item\n (original, orig_cnt, anag_cnt) = ht[cur_str]\n ht[cur_str] = (original, orig_cnt, anag_cnt + 1)\n elif anagram in ht.keys():\n # This string equals to some prevoius\n # Increase original count for hash table item\n (original, orig_cnt, anag_cnt) = ht[anagram]\n ht[anagram] = (original, orig_cnt+1, anag_cnt)\n else:\n # This string is new\n ht[anagram] = (cur_str, 1, 0)\n return ht","def test_hash(self):\r\n self.assertEqual(processor_hash('test'), 'GqNJWF7X7L07nEhqMAZ+OVyks1Y=')\r\n self.assertEqual(processor_hash('edx '), '/KowheysqM2PFYuxVKg0P8Flfk4=')","def hash_string(input_str):\n input_b = str.encode(input_str)\n input_hash = hashlib.md5(input_b.lower())\n input_hash_str = input_hash.hexdigest()\n\n return input_hash_str","def test_pattern_matching(self):\n\n for hashtype in [HashTypes.SHA1, HashTypes.SHA2, HashTypes.SHA3, ]:\n self.do_test_pattern_matching(hashtype)","def fn(i, k, lower, upper):\n if k == len(evil): return 0 # boundary condition \n if i == n: return 1 \n lo = ascii_lowercase.index(s1[i]) if lower else 0\n hi = ascii_lowercase.index(s2[i]) if upper else 25\n \n ans = 0\n for x in range(lo, hi+1): \n kk = k \n while kk and evil[kk] != ascii_lowercase[x]: \n kk = lps[kk-1]\n if evil[kk] == ascii_lowercase[x]: kk += 1\n ans += fn(i+1, kk, lower and x == lo, upper and x == hi)\n return ans","def count(string):\n unique = dict()\n for elem in string:\n if elem in unique:\n unique[elem] = unique[elem]+1\n else:\n unique[elem] = 1\n return unique","def elf_hash(s):\n h = 0\n for c in s:\n h = (h << 4) + ord(c)\n t = (h & 0xF0000000)\n if t != 0:\n h = h ^ (t >> 24)\n h = h & ~t\n return h","def test_str_fac():\n structure = Material(input)\n assert (np.abs(structure.calc_nuc_str_fac((2., 0., 0.))) ** 2 - 1702170.4663405998 < 1e-6)\n assert (np.abs(structure.calc_nuc_str_fac((2, 0, 0))) ** 2 - 1702170.4663405998 < 1e-6)\n assert (np.abs(structure.calc_nuc_str_fac((0, 2., 0))) ** 2 - 1702170.4663405998 < 1e-6)\n assert (np.abs(structure.calc_nuc_str_fac((0, 2, 0))) ** 2 - 1702170.4663405998 < 1e-6)\n\n ndarray_example = np.linspace(0.5, 1.5, 21)\n assert (np.sum(abs(structure.calc_nuc_str_fac((ndarray_example, 0, 0))) ** 2) - 7058726.6759794801 < 1e-6)\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, ndarray_example, 0))) ** 2) - 7058726.6759794801 < 1e-6)\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, 0, ndarray_example))) ** 2) - 16831011.814390473 < 1e-6)\n assert (\n np.sum(abs(structure.calc_nuc_str_fac((ndarray_example, ndarray_example, 0))) ** 2) - 10616602.544519115 < 1e-6)\n\n list_example = list(ndarray_example)\n assert (np.sum(abs(structure.calc_nuc_str_fac((list_example, 0, 0))) ** 2) - 7058726.6759794801 < 1e-6)\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, list_example, 0))) ** 2) - 7058726.6759794801 < 1e-6)\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, 0, list_example))) ** 2) - 16831011.814390473 < 1e-6)\n\n tuple_example = tuple(ndarray_example)\n assert (np.sum(abs(structure.calc_nuc_str_fac((tuple_example, 0, 0))) ** 2) - 7058726.6759794801 < 1e-6)\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, tuple_example, 0))) ** 2) - 7058726.6759794801 < 1e-6)\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, 0, tuple_example))) ** 2) - 16831011.814390473 < 1e-6)","def _compute_digest(self) -> str:\n return compute_numpy_digest(self._features, self._targets)","def build_permutation_dictionary(input_string):\n string_contents = {}\n\n for char in input_string:\n if char not in string_contents:\n string_contents[char] = 0\n else:\n string_contents[char] += 1\n\n return string_contents","def frequency(string):\n string=string.lower()\n string=[\"%s%s \" %(string[i],string[i+1]) for i in range(len(string)-1)]\n return Counter(string)","def group_isomorphic(strs):\n\n def encode(s):\n r, d = [], {}\n for c in s:\n if c not in d:\n d[c] = len(d)\n r.append(d[c])\n return str(r)\n\n m = defaultdict(list)\n for s in strs:\n m[encode(s)].append(s)\n\n return list(m.values())","def signature(s, n, hash_function=_crc32_hash):\n return set(sorted((hash_function(e), e) for e in s)[:n])","def distinct_substrigns(str1, k):\n hash_map = {}\n n = len(str1)\n start = 0 \n end = 1\n hash_map[str1[start]] = 1\n res = [] \n\n while end < n:\n print (\"hash_map is :\", hash_map)\n if str1[end] not in hash_map: \n hash_map[str1[end]] = 1\n else:\n while str1[start]!=str1[end]:\n del hash_map[str1[start]]\n start += 1\n start += 1\n\n if end-start+1 == k:\n temp = str1[start:end+1]\n if temp not in res:\n res.append(temp)\n del hash_map[str1[start]]\n start += 1\n end += 1\n #print(end,start)\n return res","def set_hashes(s, hash_function=_crc32_hash):\n return {(hash_function(e), e) for e in s}","def getFreq(encrypted):\n freq = {}\n for i in encrypted:\n freq[i] = 0\n for i in encrypted:\n freq[i] += 1.0 \n return freq","def kSimilarity(self, s1: str, s2: str) -> int:\n def neighbors(s: str) -> Iterator[str]:\n i = 0\n while s[i] == s2[i]: # Skip the already swapped chars.\n i += 1\n\n t = list(s)\n for j in range(i + 1, N):\n # Make a swap.\n if s[j] == s2[i] and s[j] != s2[j]:\n t[i], t[j] = t[j], t[i]\n yield ''.join(t)\n t[i], t[j] = t[j], t[i]\n\n N = len(s1)\n queue = deque([(s1, 0)])\n visited = {s1}\n while queue:\n s, swapCnt = queue.popleft()\n if s == s2:\n return swapCnt\n\n swapCnt += 1\n for neighbor in neighbors(s):\n if neighbor not in visited:\n visited.add(neighbor)\n queue.append((neighbor, swapCnt))","def fnv1(self, key, seed=0):\n # def fnv1(self, key):\n\n # Your code here\n \"\"\"\n Returns: The FNV-1 hash (64-bit) of a given string. \n \"\"\"\n #Constants : Fails the tests\n # FNV_prime = 1099511628211\n # offset_basis = 14695981039346656037\n\n # #FNV-1a Hash Function\n # hash = offset_basis + seed\n # # hash = offset_basis\n # for c in key:\n # hash = hash * FNV_prime\n # hash = hash ^ ord(c)\n # return hash\n\n \"\"\"\n Returns: The FNV-1a (alternate) hash of a given string\n \"\"\"\n # #Constants : Passes the tests\n # FNV_prime = 1099511628211\n # offset_basis = 14695981039346656037\n\n # #FNV-1a alternate Hash Function\n # hash = offset_basis + seed\n # for c in key:\n # hash = hash ^ ord(c)\n # hash = hash * FNV_prime\n # return hash","def fingerprint(self, file):\n raise NotImplementedError()","def sherlockAndAnagrams(s):\n # A Dict of palindromes and their counts.\n palindrome_counts = {}\n\n # Get all substrings of length len(s)/c\n for substring_length in range(len(s) - 1):\n for substring_starting_index in range(len(s) - substring_length):\n substring_end_index = substring_starting_index + substring_length + 1\n substring = s[substring_starting_index:substring_end_index]\n # TODO: Sorting is an inefficient way to \"hash\" by palindrome.\n # A letter count dict would be more efficient (in the initial grouping).\n substring_arr = list(substring)\n substring_arr.sort()\n sorted_substring = \"\".join(substring_arr)\n\n if palindrome_counts.get(sorted_substring):\n palindrome_counts[sorted_substring] += 1\n else:\n palindrome_counts[sorted_substring] = 1\n\n return sum([_two_of_m(val) for val in palindrome_counts.values()])","def symbolsAssign(clusters):\n \n alphabet = ['A','a','B','b','C','c','D','d','E','e',\n 'F','f','G','g','H','h','I','i','J','j',\n 'K','k','L','l','M','m','N','n','O','o',\n 'P','p','Q','q','R','r','S','s','T','t',\n 'U','u','V','v','W','w','X','x','Y','y','Z','z']\n \n clusters = pd.Series(clusters)\n N = len(clusters.unique())\n\n cluster_sort = [0] * N \n counter = collections.Counter(clusters)\n for ind, el in enumerate(counter.most_common()):\n cluster_sort[ind] = el[0]\n\n if N >= len(alphabet):\n alphabet = [chr(i+33) for i in range(0, N)]\n else:\n alphabet = alphabet[:N]\n hashm = dict(zip(cluster_sort + alphabet, alphabet + cluster_sort))\n strings = [hashm[i] for i in clusters]\n return strings, hashm","def get_fingerprints(fp, format = None):\n\n spectrum, axis_freqs, axis_times = do_fft(*get_raw(fp, format))\n peaks = find_peaks(spectrum, axis_freqs, axis_times)\n fingerprints = calculate_fingerprints(peaks)\n\n return fingerprints","def fingerprint_public_key_blob(blob):\n hash = sha256(blob).digest()\n encoded = b64encode(hash).decode('UTF-8').rstrip('=')\n return 'SHA256:{}'.format(encoded)","def jaccard_similarity(string1, string2):\n\n a = set(string1.split())\n b = set(string2.split())\n\n similarity = float(\n len(a.intersection(b)) * 1.0\n / len(a.union(b)))\n\n return similarity","def encode(string, password):\r\n\r\n print(\"Calling encode...\")\r\n\r\n password = [p for p in password] # Set the password as an array\r\n encrypted_string = \"\" # To hold encrypted text.\r\n string_array = [] # To store the string as an array\r\n skipped_loop = 0 # For handling the \\\\x00 character\r\n\r\n # Scrambled hash array to use\r\n hash_array = set_hash_array(set_base_hash_array(), password)\r\n # Next array to use once the first is empty\r\n hash_array_next = set_hash_array(hash_array, password)\r\n\r\n for index, step in enumerate(string):\r\n # If a NULL_STRING is found, skip over the individual characters\r\n # until the next valid character is reached\r\n if skipped_loop > 0:\r\n skipped_loop -= 1\r\n continue\r\n\r\n if step == chr(92): # The \\ character\r\n # Check if the \\ symbol is part of the NULL_STRING\r\n if string[index : (index + 4)] == NULL_STRING:\r\n string_array.append(NULL_STRING)\r\n # Sets number of loops to skip based on NULL_STRING length\r\n skipped_loop = len(NULL_STRING) - 1\r\n else:\r\n string_array.append(step) # Only the \\ character was found\r\n\r\n else:\r\n # Otherwise, just append the found character\r\n string_array.append(step)\r\n\r\n # Once the string array is filled, move into the encoding phase\r\n if len(string_array) == STRING_LENGTH:\r\n\r\n # Checks if hash_array has enough characters to meet STRING_LENGTH\r\n if len(hash_array) < STRING_LENGTH:\r\n # If not, find how many character from the hash_array_next to use\r\n next_array_len = STRING_LENGTH - len(hash_array)\r\n # Set password_array\r\n password_array = hash_array + hash_array_next[:next_array_len]\r\n # Reset hash_array from the next one\r\n hash_array = hash_array_next\r\n # Create a new hash_array_next\r\n hash_array_next = set_hash_array(hash_array, password)\r\n # Finally, now that hash_array is the old hash_array_next and a\r\n # few characters were used, remove those values\r\n hash_array = hash_array[next_array_len:]\r\n else:\r\n # Create the password array\r\n password_array = hash_array[:STRING_LENGTH]\r\n # Remove those used values from the hash_array\r\n hash_array = hash_array[STRING_LENGTH:]\r\n\r\n # Do the encrypt functions\r\n encrypted_string += set_encode(string_array, password_array)\r\n # Reset string_array to empty for the next pass\r\n string_array = []\r\n\r\n # This is for catching the last chunk of string that may not meet STRING_LENGTH requirements\r\n if string_array != []:\r\n # Calls function to pad out the last array to match STRING_LENGTH\r\n # Pass hash_array and hash_array_next as one big array to avoice\r\n # an array being too small\r\n string_array = set_string(string_array, (hash_array + hash_array_next))\r\n\r\n if len(hash_array) < STRING_LENGTH:\r\n # If not, find how many character from the hash_array_next to use\r\n next_array_len = STRING_LENGTH - len(hash_array)\r\n # Set password_array\r\n password_array = hash_array + hash_array_next[:next_array_len]\r\n else:\r\n # Create the password array padded with the hash_array\r\n # password_array = password + hash_array[len(password) : STRING_LENGTH]\r\n password_array = hash_array[:STRING_LENGTH]\r\n\r\n # Build out the encrypted_string\r\n encrypted_string += set_encode(string_array, password_array)\r\n\r\n return encrypted_string","def preprocess_hashes(tex):\n blocks = catlist()\n rx = hash_rx\n m = rx.search(tex)\n while m:\n if len(m.group(2)) > 40:\n tex2htm.warn(\"Possible runaway hash: {}\".format(text_sample(m.group(2))))\n raise(None)\n blocks.append(tex[:m.start()])\n blocks.append(re.sub(r'(^|[^\\\\])%', r'\\1\\%', m.group(0)))\n tex = tex[m.end():]\n m = rx.search(tex)\n blocks.append(tex)\n return \"\".join(blocks)"],"string":"[\n \"def fingerprint(self, algorithm):\",\n \"def hash_all(strs, digest=None):\\r\\n digest = digest or hashlib.sha1()\\r\\n for s in strs:\\r\\n digest.update(s)\\r\\n return digest.hexdigest()\",\n \"def compute_fingerprint(self):\\n\\t\\t# initialize tensorflow session\\n\\t\\tsess = tf.InteractiveSession()\\n\\t\\tclf_image = wb_clf(config.clf_image_filename, reshape_size=None, input_dim=(100,200), \\n\\t\\t\\t\\t\\t\\t\\tname=\\\"image\\\", ALEXNET=True)\\n\\t\\tclf_blot = wb_clf(config.clf_blot_filename, input_dim=(15,30), reshape_size=4*8*64, name=\\\"blot\\\")\\n\\t\\tsess.run(tf.global_variables_initializer())\\n\\t\\t# create western blot fingerprinting object\\n\\t\\tWB = WesternBlot(clf_image=clf_image, clf_blot=clf_blot)\\n\\t\\tWB.figure = self.figure\\n\\t\\tWB.figure_gray = cv2.cvtColor(self.figure, cv2.COLOR_BGR2GRAY)\\n\\t\\t# compute fingerprint\\n\\t\\tWB.westernBlotExtractor(VISUALIZE=False)\\n\\t\\tself.local_database = WB.Fingerprint\",\n \"def patterns_hash(patterns):\\n return hash(\\\"\\\".join(map(str, patterns)))\\n # return sum((3**(5 * i) + 1) * (p + 1) for i, p in enumerate(patterns))\",\n \"def test6(self):\\n smis = [ 'CCC(O)C(=O)O','c1ccccc1','C1CCCCC1','C1NCCCC1','CNCNCNC']\\n for smi in smis:\\n m = Chem.MolFromSmiles(smi)\\n fp1 = Chem.RDKFingerprint(m,2,7,4096)\\n fp2 = DataStructs.FoldFingerprint(fp1,2)\\n fp3 = Chem.RDKFingerprint(m,2,7,2048)\\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\\n fp2 = DataStructs.FoldFingerprint(fp2,2)\\n fp3 = Chem.RDKFingerprint(m,2,7,1024)\\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\\n fp2 = DataStructs.FoldFingerprint(fp1,4)\\n assert tuple(fp2.GetOnBits())==tuple(fp3.GetOnBits())\",\n \"def hash_all(strs: typing.Iterable[bytes | str]) -> str:\\n digest = hashlib.sha1()\\n for s in strs:\\n s = ensure_binary(s)\\n digest.update(s)\\n return digest.hexdigest()\",\n \"def process_strings(self):\\n for string in self.input:\\n matcher = self.choose_algorithm()\\n matcher.find_match(string, self.case_insensitive)\\n self.__results = matcher.results\\n\\n if self.counter:\\n self.__results = matcher.counts\\n\\n if self.__results:\\n self.output(string)\",\n \"def hash(plainString):\\n result = plainString\\n for i in range(0,12):\\n result = hashHelp(result)\\n return result\",\n \"def pre_compute_hashes(s, M1, M2, X):\\n n = len(s)\\n h1 = [0 for _ in range(n+1)]\\n h2 = [0 for _ in range(n+1)]\\n for i in range(1, n+1):\\n ch = ord(s[i-1])\\n h1[i] = (X*h1[i-1] + ch) % M1\\n h2[i] = (X*h2[i-1] + ch) % M2\\n return h1, h2\",\n \"def hashHelp(plainString):\\n # hashed = plainString\\n n = len(plainString) // 4\\n\\n a = plainString[0:n]\\n b = plainString[n : n * 2]\\n c = plainString[n * 2 : n * 3]\\n d = plainString[n * 3 : len(plainString)]\\n\\n if len(a) == 0 or len(b) == 0 or len(c) == 0 or len(d) == 0:\\n raise Exception(\\\"Error string not long enough, use at least 4 characters\\\")\\n\\n numA = numToBin(functionF(a,d))\\n numB = numToBin(strToNum(b))\\n numC = numToBin(bitShift(c))\\n numD = numToBin(functionG(a,b,c,d))\\n\\n # hashed = A + B + numC + D\\n # hashed = numA + '|' + numB + '|' + numC + '|' + numD\\n hashed = text_from_bits(numD + numA + numB + numC)\\n hashed = numbersToLetters(hashed)\\n return hashed\",\n \"def compute_multiple_minhashes(strings: List[str]) -> List[LeanMinHash]:\\n return [\\n LeanMinHash(mh)\\n for mh in MinHash.bulk(\\n [string_encoder(s) for s in strings], num_perm=PERMUTATIONS\\n )\\n ]\",\n \"def run_algorithms(string_list):\\n\\tstring_count = int(string_list[0])\\n\\n\\tfor i in range(1, string_count+1):\\n\\t\\tstring = string_list[i]\\n\\t\\tprint(\\\"Phrase number: \\\", i)\\n\\t\\tprint(string, \\\"\\\\n\\\")\\n\\t\\tsplit_string = []\\n\\t\\tmemo = set()\\n\\n\\t\\tprint(\\\"Iterative attempt:\\\")\\n\\t\\tif iterative_string_split(string, split_string) is True:\\n\\t\\t\\tprint(\\\"YES, can be split.\\\")\\n\\t\\t\\tprint(print_string_list(split_string))\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"NO, cannot be split.\\\")\\n\\n\\t\\tsplit_string = []\\n\\n\\t\\tprint(\\\"\\\\nMemoized attempt:\\\")\\n\\t\\tif recursive_string_split(string, 0, split_string, memo) is True:\\n\\t\\t\\tprint(\\\"YES, can be split.\\\")\\n\\t\\t\\tsplit_string.reverse()\\n\\t\\t\\tprint(print_string_list(split_string))\\n\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"NO, cannot be split.\\\")\\n\\n\\t\\tprint(\\\"\\\\n\\\")\",\n \"def fingerprint(keyed_data, digest_size=16):\\n h = blake2b(digest_size=16)\\n for key in sorted(keyed_data.keys()):\\n val = keyed_data[key]\\n s = json.dumps(val, sort_keys=True, cls=NpEncoder).encode()\\n h.update(s)\\n return h.hexdigest()\",\n \"def _precompute_substrings(self, p: int) -> List[int]:\\n hash_vals: List[int] = [0]\\n for i in range(len(self._s)):\\n val = (hash_vals[i] * self.X + ord(self._s[i])) % p\\n hash_vals.append(val)\\n\\n return hash_vals\",\n \"def compute_fingerprint(path_list):\\n\\n hasher = hashlib.sha1()\\n\\n for path_item in path_list:\\n\\n # For directories, create a hash based on the modification times\\n # of first-level subdirectories\\n if os.path.isdir(path_item):\\n for dirname in sorted(os.listdir(path_item)):\\n path_name = os.path.join(path_item, dirname)\\n if os.path.isdir(path_name):\\n hasher.update(str(os.stat(path_name).st_mtime).encode('utf-8'))\\n\\n # For files, hash the contents of the file\\n if os.path.isfile(path_item):\\n with open(path_item, \\\"rb\\\") as file_handle:\\n hasher.update(file_handle.read())\\n\\n return hasher.hexdigest()\",\n \"def part1(input_string):\\n twos, threes = 0, 0\\n for line in input_string:\\n letters_seen = {}\\n for char in line:\\n letters_seen[char] = letters_seen.setdefault(char, 0)+1\\n if 2 in letters_seen.values():\\n twos += 1\\n if 3 in letters_seen.values():\\n threes += 1\\n return threes * twos\",\n \"def fingerprints(files, model, size=(224, 224), modelname='VGG16'):\\n all_results = {}\\n fingerprints = []\\n for fn in tqdm.tqdm(files, total=len(files)):\\n result = fingerprint(fn, model, size, modelname=modelname)\\n if len(result) > 0:\\n all_results[fn] = result\\n\\n # return dict((fn, fingerprint(fn, model, size)) for fn in files)\\n return all_results\",\n \"def main():\\n inputStr = input(\\\"Enter string to be hashed: \\\")\\n print(f\\\"Hashed string: {hash(inputStr.replace(' ', ''))}\\\")\",\n \"def convert_to_fingerprint(s):\\n\\n\\ttry:\\n\\t\\t# Convert SMILES to Molecule object\\n\\t\\tmolecule = Chem.MolFromSmiles(s)\\n\\t\\t# Get MACCS Key from Molecule object\\n\\t\\tmaccs_key = MACCSkeys.GenMACCSKeys(molecule)\\n\\t\\treturn maccs_key.ToBitString()\\n\\texcept:\\n\\t\\treturn None\",\n \"def compute_fingerprint(path_list):\\r\\n\\r\\n hasher = hashlib.sha1()\\r\\n\\r\\n for path in path_list:\\r\\n\\r\\n # For directories, create a hash based on the modification times\\r\\n # of first-level subdirectories\\r\\n if os.path.isdir(path):\\r\\n for dirname in sorted(os.listdir(path)):\\r\\n p = os.path.join(path, dirname)\\r\\n if os.path.isdir(p):\\r\\n hasher.update(str(os.stat(p).st_mtime))\\r\\n\\r\\n # For files, hash the contents of the file\\r\\n if os.path.isfile(path):\\r\\n with open(path, \\\"rb\\\") as file_handle:\\r\\n hasher.update(file_handle.read())\\r\\n\\r\\n return hasher.hexdigest()\",\n \"def chunk_hashes(str):\\n chunk = 1024*1024\\n chunk_count = int(math.ceil(len(str)/float(chunk)))\\n chunks = [str[i*chunk:(i+1)*chunk] for i in range(chunk_count)]\\n return [hashlib.sha256(x).digest() for x in chunks]\",\n \"def computeHash(string):\\n\\tif isBytes(string):\\n\\t\\tstring = string.decode(\\\"latin-1\\\")\\n\\thash_ = 63689\\n\\tfor char in string:\\n\\t\\thash_ = hash_ * 378551 + ord(char)\\n\\treturn hash_ % 65536\",\n \"def fasthash(string):\\r\\n md4 = hashlib.new(\\\"md4\\\")\\r\\n md4.update(string)\\r\\n return md4.hexdigest()\",\n \"def generateFingerprint(molecule, numInts=32, pathLength=7):\\n \\n paths = LinearPaths.generatePaths(molecule, maxdepth=pathLength)\\n fp = Fingerprint.Fingerprint(numIntegers=numInts)\\n\\n for path in paths:\\n fp.addPath(path)\\n\\n return fp\",\n \"def get_similarity(string1, string2, probabilities, characters):\\n\\n strict_counter = 0\\n weak_counter = 0\\n for i in range(0, len(string1)):\\n if string1[i] == string2[i]:\\n strict_counter+=1\\n\\n k = 0\\n for prob in probabilities[i]:\\n if ((prob != 0) & (string1[i] == characters[k])):\\n weak_counter += 1\\n break\\n \\n k+=1\\n\\n # Return list containing strict and weak probabilities\\n return [(strict_counter / len(string1)) * 100, \\n (weak_counter / len(string1)) * 100]\",\n \"def fingerprint(public_key):\\r\\n\\r\\n return hashlib.new('ripemd160', hashlib.sha256(public_key).digest()).digest()[:4]\",\n \"def format_fingerprint(fpr):\\n count = 0\\n fingerprint = ''\\n chunks = [i for i in re.split('([A-F0-9]{4})', fpr) if i]\\n for chunk in chunks:\\n count += 1\\n fingerprint += ' %s' % chunk\\n if count == len(chunks)/2:\\n fingerprint += ' '\\n\\n return fingerprint.strip()\",\n \"def _certificate_fingerprint(identity):\\n fingerprint, stderr = _check_output([\\n \\\"openssl\\\",\\n \\\"x509\\\",\\n \\\"-inform\\\",\\n \\\"DER\\\",\\n \\\"-noout\\\",\\n \\\"-fingerprint\\\",\\n ],\\n inputstr=identity)\\n fingerprint = fingerprint.strip()\\n fingerprint = fingerprint.replace(\\\"SHA1 Fingerprint=\\\", \\\"\\\")\\n fingerprint = fingerprint.replace(\\\":\\\", \\\"\\\")\\n return fingerprint\",\n \"def signature(s):\\r\\n # TODO: rewrite using sorted()\\r\\n t = list(s)\\r\\n f=[]\\r\\n i,j=0\\r\\n for i in range(len(s)):\\r\\n for j in range (len(s)-1):\\r\\n if i!=j:\\r\\n t[i],t[j]=t[j],t[i]\\r\\n z=''.join(t)\\r\\n f.append(z)\\r\\n return f\",\n \"def create_ids(input):\\r\\n return hashlib.md5(input)\",\n \"def precompute_hashes(text, pattern_len, p, x):\\n\\n if len(text) < pattern_len or pattern_len == 0:\\n return []\\n\\n hashes = [ 0 ] * (len(text) - pattern_len + 1)\\n\\n slice = text[len(text) - pattern_len:]\\n hashes[len(text) - pattern_len] = SearchPattern.poly_hash(\\n slice, p, x)\\n\\n y = 1\\n for i in range(1, pattern_len + 1):\\n y = (y * x) % p\\n for i in range(len(text) - pattern_len - 1, -1, -1):\\n hashes[i] = (x * hashes[i + 1] + ord(text[i]) -\\n y * ord(text[i + pattern_len])) % p\\n\\n return hashes\",\n \"def solution(s):\",\n \"def string_features_hex(hexstr):\\n out = dict([(x,0) for x in hexabet])\\n ct = dict(Counter(hexstr.split()))\\n N = len(hexstr.split())\\n for k in out.keys():\\n if k in ct.keys():\\n out[k] += ct[k]\\n out = [v[1] for v in sorted(out.iteritems(), key=lambda (k,v): k)]\\n out = [float(x)/N for x in out]\\n return out\",\n \"def sherlockAndAnagrams(s):\\n\\n dic = {}\\n\\n count = 0\\n for i in range(len(s)):\\n for j in range(i+1, len(s)+1):\\n substrings = sorted(list(s[i:j]))\\n joined_ss = ''.join(substrings)\\n if joined_ss != '':\\n if joined_ss in dic:\\n count += dic[joined_ss]\\n dic[joined_ss] += 1\\n else:\\n dic[joined_ss] = 1 \\n print(dic)\\n return count\",\n \"def input_to_hash(self, keys):\\n basic_keys = []\\n for i, key in enumerate(keys):\\n s = ''\\n #print(max(key), min(key))\\n for val in key:\\n s += \\\"{:04x}\\\".format(val)\\n basic_keys.append(s)\\n return basic_keys\",\n \"def fingerprint():\\n files = (glob.glob(base_dir + '**/*.html') +\\n glob.glob(base_dir + '*.html') +\\n glob.glob(base_dir + 'core.js'))\\n\\n md5s = OrderedDict()\\n\\n for fil in sorted(files):\\n name = fil[len(base_dir):]\\n with open(fil) as fp:\\n md5 = hashlib.md5(fp.read().encode('utf-8')).hexdigest()\\n md5s[name] = md5\\n\\n template = \\\"\\\"\\\"\\\\\\\"\\\\\\\"\\\\\\\"DO NOT MODIFY. Auto-generated by script/fingerprint_frontend.\\\\\\\"\\\\\\\"\\\\\\\"\\n\\nFINGERPRINTS = {}\\n\\\"\\\"\\\"\\n\\n result = template.format(json.dumps(md5s, indent=4))\\n\\n with open(fingerprint_file, 'w') as fp:\\n fp.write(result)\",\n \"def call_fingerprint(cls, args, kwargs):\\n return hasher(getcallargs(cls.__init__, None, *args, **kwargs))\",\n \"def compress(string):\\n \\n # Build the dictionary.\\n dict_size = 256\\n seen = dict((chr(i), i) for i in range(dict_size))\\n \\n p = \\\"\\\"\\n output = 0\\n for c in string:\\n pc = p + c\\n if pc in seen:\\n p = pc\\n else:\\n # We have not seen this. Output the stuff.\\n output += 1\\n seen[pc] = dict_size\\n dict_size += 1\\n p = c\\n \\n # Output the code for w.\\n return output * 12\",\n \"def my_md5(inp):\\n # https://en.wikipedia.org/wiki/MD5#Pseudocode\\n global s, K # `s` and `K` are global\\n\\n # Initialize variables\\n a0 = 0x67452301 # A\\n b0 = 0xefcdab89 # B\\n c0 = 0x98badcfe # C\\n d0 = 0x10325476 # D\\n\\n # Convert input string to bit string\\n msg = ''.join(f'{ord(i):08b}' for i in inp)\\n\\n # append \\\"1\\\" bit to message\\n msg += '1'\\n\\n # append \\\"0\\\" bit until message length in bits = 448 (mod 512)\\n msg += '0'*(448 - len(msg))\\n\\n # append original length in bits mod 2**64 to message\\n msg += '{0:064b}'.format(ch_endian64(len(inp)*8))\\n\\n assert len(msg) == 512\\n\\n # Process the message in successive 512-bit chunks:\\n # for each 512-bit chunk of padded message do\\n # break chunk into sixteen 32-bit words M[j], 0 <= j <= 15\\n #\\n # ~> We have 1 chunk, so no need for that\\n\\n # Initialize hash value for this chunk:\\n A, B, C, D = a0, b0, c0, d0 \\n b_values = []\\n\\n # Main loop:\\n for i in range(64):\\n if 0 <= i and i <= 15:\\n F = (B & C) | (~B & D)\\n g = i\\n elif 16 <= i and i <= 31:\\n F = (D & B) | (~D & C)\\n g = (5*i + 1) % 16\\n elif 32 <= i and i <= 47:\\n F = B ^ C ^ D\\n g = (3*i + 5) % 16\\n elif 48 <= i <= 63:\\n F = C ^ (B | ~D)\\n g = (7*i) % 16\\n\\n F &= 0xFFFFFFFF\\n\\n inp_chunk = ch_endian(int(msg[32*g:32*g + 32], 2))\\n\\n # Be wary of the below definitions of a,b,c,d\\n F = (F + A + K[i] + inp_chunk) & 0xFFFFFFFF # M[g] must be a 32-bits block\\n A = D\\n D = C\\n C = B\\n B = (B + rol(F, s[i])) & 0xFFFFFFFF\\n\\n print(f'{i:2d}: A:{A:08X}, B:{B:08X}, C:{C:08X}, D:{D:08X} ~> g:{g} $ {inp_chunk:08X} $ X:{B & 0x3FF:03X}')\\n\\n b_values.append(B & 0x3FF) # Get the leak.\\n\\n # Add this chunk's hash to result so far:\\n a0 = (a0 + A) & 0xFFFFFFFF\\n b0 = (b0 + B) & 0xFFFFFFFF\\n c0 = (c0 + C) & 0xFFFFFFFF\\n d0 = (d0 + D) & 0xFFFFFFFF\\n # end for\\n\\n a0 = ch_endian(a0)\\n b0 = ch_endian(b0)\\n c0 = ch_endian(c0)\\n d0 = ch_endian(d0)\\n\\n print(f'{a0:08X}-{b0:08X}-{c0:08X}-{d0:08X}')\\n \\n # var char digest[16] := a0 append b0 append c0 append d0 // (Output is in little-endian)\\n print(f'{a0:08x}{b0:08x}{c0:08x}{d0:08x}')\\n\\n return b_values\",\n \"def compute_pair_frequencies(text, alphabet_size=256):\\n\\n curr = text[1:]\\n prev = text[:-1]\\n pairs = np.stack([prev, curr])\\n\\n print(\\\"Counting pairs . . .\\\")\\n (char1, char2), counts = np.unique(pairs, return_counts=True, axis=1)\\n print(\\\"Done.\\\\n\\\")\\n\\n joints = np.zeros((alphabet_size, alphabet_size))\\n joints[char1, char2] = counts / np.sum(counts)\\n assert np.isclose(np.sum(joints), 1.0)\\n\\n return joints\",\n \"def song_fp(samples, prnt_spectro=False):\\n\\n t, f = peak_find(samples, prnt_spectro)\\n\\n fingerprints = set()\\n for n, t1 in enumerate(t) :\\n for j, t2 in enumerate(t[min(n + 1, len(t) - 1) : min(n + 20, len(t))]) :\\n if n + j + 1 < len(t) :\\n fingerprints.add((f[n], f[n + j + 1], t2 - t1))\\n\\n return frozenset(fingerprints)\",\n \"def test_string_to_hex():\\n strings = ['helloworld', 'HelloWorld', 'HELLOWORLD', 'Hello WorLd', 'hElLo W Or L d', 'h e l l o w o r l d']\\n\\n for i, word in enumerate(strings):\\n assert pi_finder.string_to_hex(word, hex_dict) == '68656c6c6f776f726c64'\",\n \"def hashing(smiles):\\n import hashlib\\n hash_object = hashlib.md5(canonical_smiles_from_smiles(smiles).encode(\\\"utf-8\\\"))\\n return hash_object.hexdigest()\",\n \"def hash(string):\\n hs = 0\\n for s in string:\\n hs += ord(s)\\n return hs\",\n \"def rec_freq(markers):\\n keys = list(markers.keys())\\n rf_pairs = {}\\n for i in range(len(markers)):\\n for j in range(i + 1, len(markers)):\\n m1 = markers[keys[i]][0]\\n m2 = markers[keys[j]][0]\\n tot_len = 0\\n score = 0\\n if len(m1) != len(m2):\\n print(\\\"Error, sequences aren't same length.\\\", keys[i], keys[j])\\n exit()\\n for k in range(len(m1)):\\n c1 = m1[k]\\n c2 = m2[k]\\n if c1 == \\\"-\\\" or c2 == \\\"-\\\":\\n continue\\n if c1 != c2:\\n score += 1\\n tot_len += 1\\n\\n rf = score / tot_len * 100\\n rf_pairs[(keys[i], keys[j])] = rf\\n return rf_pairs\",\n \"def hashstring(astring, tablesize):\\n \\n sum = 0\\n for pos in range(len(astring)):\\n # to account for anagrams, we give weightage to positions of the letters to give different hash values\\n sum = sum + ord(astring[pos]) * (pos + 1)\\n \\n return sum % tablesize\",\n \"def HashAlgorithm(self) -> _n_7_t_0:\",\n \"def fingerprint(samp):\\r\\n wid = samp.shape[1]\\r\\n\\r\\n d = np.r_[\\r\\n np.full((1, wid), True, dtype=bool),\\r\\n np.diff(np.sort(samp, axis=0), 1, 0) != 0,\\r\\n np.full((1, wid), True, dtype=bool)\\r\\n ]\\r\\n\\r\\n f_col = []\\r\\n f_max = 0\\r\\n\\r\\n for k in range(wid):\\r\\n a = np.diff(np.flatnonzero(d[:, k]))\\r\\n a_max = a.max()\\r\\n hist, _ = np.histogram(a, bins=a_max, range=(1, a_max + 1))\\r\\n f_col.append(hist)\\r\\n if a_max > f_max:\\r\\n f_max = a_max\\r\\n\\r\\n return np.array([np.r_[col, [0] * (f_max - len(col))] for col in f_col]).T\",\n \"def hashing(file,pp):\\n\\n def myhash(instring):\\n # sdbm hash\\n res = 0\\n for t in instring:\\n res = (ord(t) + (res<<6) + (res<<16) - res) % 2**32\\n return res\\n\\n return hex(myhash(file.replace('\\\\\\\\','/')+\\\":\\\"+pp))\",\n \"def calculate_rule_hash(self, rule):\\r\\n hash_strings = []\\r\\n condition_string_prefaces = (\\\"$\\\", \\\"!\\\", \\\"#\\\", \\\"@\\\")\\r\\n # dictionary for substitutions\\r\\n string_substitutions = {}\\r\\n all_strings = []\\r\\n # original code used md5\\r\\n # m = hashlib.md5()\\r\\n m = hashlib.sha3_256()\\r\\n # Adding all string contents to the list\\r\\n if 'strings' in rule:\\r\\n for s in rule['strings']:\\r\\n if s['type'] == \\\"byte\\\":\\r\\n # original code just needed to append the converted hex code as a string. We need to create the dictionary entries for substitutions as well\\r\\n # hash_strings.append(re.sub(r'[^a-fA-F\\\\?0-9]+', '', s['value']))\\r\\n byte_code_string = re.sub(r'[^a-fA-F\\\\?0-9]+', '', s['value'])\\r\\n dict_entry = {s['name']: byte_code_string}\\r\\n string_substitutions.update(dict_entry)\\r\\n hash_strings.append(byte_code_string)\\r\\n else:\\r\\n # The following line was the only portion of this else statement in the original code\\r\\n # This change takes modifiers into account for string arguments\\r\\n # hash_strings.append(s['value'])\\r\\n string_and_modifiers = []\\r\\n string_and_modifiers.append(s['value'])\\r\\n if 'modifiers' in s:\\r\\n for modifier in s['modifiers']:\\r\\n string_and_modifiers.append(modifier)\\r\\n string_and_modifiers = \\\" \\\".join(string_and_modifiers)\\r\\n all_strings.append(\\\"$\\\"+string_and_modifiers)\\r\\n dict_entry = {s['name']: string_and_modifiers}\\r\\n string_substitutions.update(dict_entry)\\r\\n #hash_strings.append(\\\"$\\\"+string_and_modifiers)\\r\\n all_strings = self.resort_stings_add_commas(all_strings)\\r\\n # Adding the components of the condition to the list (except the variables)\\r\\n all_wild_card_1 = \\\"\\\\$\\\\*\\\"\\r\\n all_wild_card_2 = \\\"them\\\"\\r\\n for e in rule['condition_terms']:\\r\\n if re.match(all_wild_card_1, e) or re.match(all_wild_card_2, e):\\r\\n hash_strings.extend(all_strings)\\r\\n elif e.startswith(condition_string_prefaces):\\r\\n if len(e) > 1:\\r\\n string_preface, string_name = e[:1], e[1:]\\r\\n string_name = \\\"$\\\" + string_name\\r\\n if e.endswith(\\\"*\\\"):\\r\\n hash_strings.extend(self.resort_stings_add_commas(self.regex_match_string_names_for_values(string_preface, string_name, string_substitutions)))\\r\\n #hash_strings.extend(\\\"Pull all the matching strings\\\")\\r\\n else:\\r\\n if string_name in string_substitutions:\\r\\n substituted = string_preface + string_substitutions[string_name]\\r\\n hash_strings.append(substituted)\\r\\n else:\\r\\n hash_strings.append(e)\\r\\n else:\\r\\n hash_strings.append(e)\\r\\n else:\\r\\n hash_strings.append(e)\\r\\n # Generate a hash from the sorted contents\\r\\n #hash_strings.sort()\\r\\n m.update(\\\"\\\".join(hash_strings).encode(\\\"ascii\\\"))\\r\\n return m.hexdigest()\",\n \"def main():\\n\\tprint 'Introduce string: '\\n\\ts = raw_input()\\n\\treturn if_unique_chars_one(s)\",\n \"def fingerprint(publicKeyN, publicKeyE=65537L):\\n asn1Str = encoder.encode(univ.Sequence().setComponentByPosition(0, univ.Integer(publicKeyN)).setComponentByPosition(1, univ.Integer(publicKeyE)))\\n hashString = hashlib.sha1(asn1Str).digest()\\n hexlifiedHash = binascii.hexlify(hashString)\\n return hexlifiedHash.upper()\",\n \"def hashing_info(string):#KEY HASHING FUNCTION\\n nodeInfo = string.encode('utf-8')\\n\\n #md5 -> 2^7 = 128 bits\\n hash_object = hashlib.md5()\\n hash_object.update(nodeInfo)\\n\\n tmp = hash_object.hexdigest()\\n tmp = int(tmp,16)\\n\\n result = tmp >> (128-16)\\n return result\",\n \"def encode(string_):\\n return (lambda f, s: f(list( ord(c) for c in str(string_) ) , \\\\\\n s))(lambda f, s: sum(f[i] * 256 ** i for i in \\\\\\n range(len(f))), str(string_))\",\n \"def main(argv):\\n\\n # test strings\\n input_strings = [\\n \\\"Foursemestersofchemistry(CHM111/113,CHM112/114,CHM211/213,andCHM212-/214),twosemestersofphysics (PCS201/20\\\" +\\n \\\"3andPCS202/204) andmathematicsthroughcalculusI(MAT160)arerequired.\\\",\\n \\\"Mathematicsmajorsarerequiredtocomplete:MAT 160, MAT 260, andMAT 360(CalculusI, II, andIII:12credits), MAT\\\" +\\n \\\" 302 (LinearAlgebra:3credits), plusatleastfouradditionalupperlevelmathematicscourses(atleast12credits) and\\\" +\\n \\\"CSC110 (IntroductiontoComputerProgramming:2-4 credits),or MAT151I(Computer ApplicationsforScienceand Mathem\\\" +\\n \\\"atics: 3 credits).EachstudentmustalsocompleteaJunior Seminar (MAT398/399:2 credits)andSenior Experience(MAT4\\\" +\\n \\\"98/499: 4 credits)inmathematics. \\\",\\n \\\"EQUALEDUCATIONALANDEMPLOYMENTOPPORTUNITYPOLICY\\\",\\n \\\"Caldwell, New Jersey, has seen\\\\n many changes over the years and was recently ranked by NJMonthly Magazine \\\" +\\n \\\"as one of the best places to live in all of New Jersey. A short walk brings students to the revitalized \\\" +\\n \\\"center of town, where shops, a movie theater, wi-fi hot spots andlotsoftastyrestaurantsprovidegreatoptions\\\" +\\n \\\"forfun. Manyshopsparticipateinadiscount program for Caldwell University students, making the town affordable\\\" +\\n \\\" on student budgets.\\\",\\n \\\"If there is anaturaldisaster that interrupts a student’slong-termparticipationinacourse(s),CarlowUniversity\\\" +\\n \\\"willapprise students oftheoptionsavailabletocompletetheiracademic coursework. \\\",\\n \\\"PREREQUISITES:BSM103 ANDBSM226. \\\",\\n \\\"Continuum and atomistic descriptions of diffusion in solids. Reactionsinvolving surfaces and interfaces, in\\\" +\\n \\\"cluding evaporation, adsorption,grain growth, and coarsening. Phase transformation kinetics, includingnucle\\\" +\\n \\\"ation, growth, solidification, spinodal decomposition, and martensitictransformations. Analysis of systems \\\" +\\n \\\"with multiple kinetic mechanisms(typical examples include oxidation, crystal growth, and sintering).Prerequ\\\" +\\n \\\"isite: background in basic thermodynamics. Recommended:ENGN 1410 or 2410 or equivalent.\\\",\\n \\\"poststructuralistsmisusethewordduetoNewton'sthirdlaw\\\"]\\n\\n for input_string in input_strings:\\n processed = punct_split(input_string)\\n\\n print(input_string)\\n print(processed)\\n print()\",\n \"def sherlockAndAnagrams(s):\\n counter, len_s = 0, len(s)\\n \\n print(f\\\"Original string: {s}. length: {len_s}\\\")\\n for chunk in range(1, len_s):\\n arr = []\\n for i in range(0, len_s - chunk + 1):\\n ex1 = \\\"\\\".join(s[i:i+chunk])\\n ex = \\\"\\\".join(sorted(s[i:i+chunk]))\\n print(f\\\"chunk: {chunk}, i: {i}, sub: {ex1}, sub_sorted: {ex}\\\")\\n arr.append(ex)\\n\\n c = Counter(arr)\\n for key in c:\\n val = c[key]\\n if val > 1:\\n counter += (val * (val - 1)) // 2\\n \\n print(f\\\"chunk: {chunk}, # counter: {counter}, Counter: {str(c)}\\\\n\\\")\\n print(f\\\"Result: {counter}.\\\")\\n return counter\",\n \"def _hexdigests(self):\\n\\n return tuple(self._hashers[algo].hexdigest() for algo in self.algos)\",\n \"def customHashFunc(str):\\n return sum(ord(chr) for chr in str)%128\",\n \"def compress(string):\",\n \"def compress(string):\",\n \"def find_pairs(words): \\n pass\",\n \"def pack(self, input_string):\\r\\n #This function lacks basic error checking....\\r\\n klaf = ''\\r\\n for s in input_string:\\r\\n klaf += bin((ord(s) % 128) % 64)[2:].zfill(6)\\r\\n result = ''\\r\\n for i in range(0, 6):\\r\\n result = result + hex(int('' + klaf[i * 8:i * 8 + 8],\\r\\n 2))[2:].zfill(2)\\r\\n return result\",\n \"def gather_values(x):\\n\\n\\tassert isinstance(x, list)\\n\\tassert len(x) > 0 \\n\\n\\tfor bitstrings in x:\\n\\t\\tassert isinstance(bitstrings, str)\\n\\n\\tcounter = True\\n\\tfor bitstrings in x: #Asserting input strings are bits only\\n\\t\\tfor no in bitstrings: \\n\\t\\t\\tif (no != \\\"1\\\") and (no != \\\"0\\\"):\\n\\t\\t\\t\\tcounter = False\\n\\tassert (counter == True )\\n\\n\\tbit_length = len(x[0])\\n\\n\\tfor bitstrings in x: \\n\\t\\tassert len(bitstrings) == bit_length \\n\\n\\t#assertions end\\n\\n\\n\\tunique_list = []\\n\\n\\tfrequency_list = []\\n\\n\\tmy_dict = {}\\n\\n\\tfor bitstrings in x: #Extracting Keys\\n\\t\\tif bitstrings not in unique_list:\\n\\t\\t\\tunique_list.append(bitstrings)\\n\\n\\t# mapped_dictionary = map_bitstring(unique_list)\\n\\n\\tfor unique_bitstrings in unique_list: \\n\\t\\tcounter = 0 \\n\\t\\tfor bitstring in x: \\n\\t\\t\\tif unique_bitstrings == bitstring:\\n\\t\\t\\t\\tcounter += 1 \\n\\n\\t\\t#At this point we have the frequency of the iterative variable \\n\\n\\t\\tnew_value = []\\n\\n\\t\\tfor i in range(counter):\\n\\t\\t\\tnew_value.append(map_bitstring_digit(unique_bitstrings))\\n\\n\\n\\t\\tmy_dict.update({unique_bitstrings : new_value})\\n\\n\\n\\treturn my_dict\",\n \"def compression(s):\",\n \"def solve(in_str):\\n\\n return ','.join(sorted(imap(lambda x: ''.join(x),permutations(in_str))))\",\n \"def compute_idfs(documents):\\n words = set()\\n for file in documents:\\n words.update(documents[file])\\n\\n idfs = dict()\\n for word in words:\\n tw = sum(word in documents[file] for file in documents)\\n idf = math.log(len(documents)/ tw )\\n idfs[word] = idf\\n\\n return idfs\",\n \"def _gpg_fingerprints(self) -> List[str]:\\n return self._gpg_keys.fingerprints\",\n \"def fingerprint(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"fingerprint\\\")\",\n \"def get_fingerprint():\\n for fingerimg in range(1, 3):\\n if fingerimg == 1:\\n print(\\\"Place finger on sensor...\\\", end=\\\"\\\", flush=True)\\n else:\\n print(\\\"Place same finger again...\\\", end=\\\"\\\", flush=True)\\n \\n cont = 0\\n\\n while True:\\n i = finger.get_image()\\n if i == adafruit_fingerprint.OK:\\n print(\\\"Image taken\\\")\\n break\\n if i == adafruit_fingerprint.NOFINGER:\\n print(\\\".\\\", end=\\\"\\\", flush=True)\\n time.sleep(0.01)\\n cont += 1\\n if cont >= 100:\\n print(\\\"Tiempo de espera agotado\\\")\\n return {'success': False, 'mismatch': False, 'msg': \\\"No se ha detectado la huella, intente nuevamente\\\"}\\n elif i == adafruit_fingerprint.IMAGEFAIL:\\n print(\\\"Imaging error\\\")\\n return False\\n else:\\n print(\\\"Other error\\\")\\n return {'success': False, 'mismatch': False, 'msg': \\\"Fallo al tomar la huella, intente nuevamente\\\"}\\n\\n print(\\\"Templating...\\\", end=\\\"\\\", flush=True)\\n i = finger.image_2_tz(fingerimg)\\n if i == adafruit_fingerprint.OK:\\n print(\\\"Templated\\\")\\n else:\\n if i == adafruit_fingerprint.IMAGEMESS:\\n print(\\\"Image too messy\\\")\\n elif i == adafruit_fingerprint.FEATUREFAIL:\\n print(\\\"Could not identify features\\\")\\n elif i == adafruit_fingerprint.INVALIDIMAGE:\\n print(\\\"Image invalid\\\")\\n else:\\n print(\\\"Other error\\\")\\n return {'success': False, 'mismatch': False, 'msg': \\\"Fallo al tomar la huella, intente nuevamente\\\"}\\n\\n if fingerimg == 1:\\n print(\\\"Remove finger\\\")\\n while i != adafruit_fingerprint.NOFINGER:\\n i = finger.get_image()\\n\\n print(\\\"Creating model...\\\", end=\\\"\\\", flush=True)\\n i = finger.create_model()\\n if i == adafruit_fingerprint.OK:\\n print(\\\"Created\\\")\\n else:\\n if i == adafruit_fingerprint.ENROLLMISMATCH:\\n print(\\\"Prints did not match\\\")\\n return {'success': False, 'mismatch': True, 'msg': \\\"Las huellas ingresadas no coinciden, intente nuevamente\\\"}\\n else:\\n print(\\\"Other error\\\")\\n return {'success': False, 'mismatch': False, 'msg': \\\"Fallo al tomar la huella, intente nuevamente\\\"}\\n\\n print(\\\"Downloading template...\\\")\\n data = finger.get_fpdata(\\\"char\\\", 1)\\n filename = f\\\"{uuid.uuid4()}.dat\\\"\\n with open(f\\\"./fingers/{filename}\\\", \\\"wb\\\") as file:\\n file.write(bytearray(data))\\n print(f\\\"Template is saved in {filename} file.\\\")\\n \\n return {'success': True, 'msg': \\\"Imagen tomada satisfactoriamente\\\", 'data': filename}\",\n \"def fingerprint(self, key):\\n base64_pub = self.base64_pub_encode(key)\\n return SHA256.new(base64_pub.encode('utf-8')).digest()\",\n \"def _hexdigests(self):\\n\\n for algo in self.algos:\\n q = self._queues[algo]\\n q.put(b'') # Terminate\\n self._threads[algo].join()\\n assert q.empty()\\n return super(MtHasher, self)._hexdigests()\",\n \"def compute_pdq(iobytes):\\n #hash_vector, quality = pdqhash.compute(ensure_pil(im))\\n #print(type(hash_vector))\\n #print(hash_vector)\\n #return hash_vector.ravel().tolist()\\n pdq_hasher = PDQHasher()\\n hash_and_qual = pdq_hasher.fromBufferedImage(iobytes)\\n #hash_array = imagehash.hex_to_hash(hash_and_qual.getHash().toHexString())\\n #return hash_array.hash.ravel().tolist()\\n return hash_and_qual.getHash().dumpBitsFlat() #This is a string of 0's and 1's\",\n \"def dawkins_algorithm(strlen=28):\\n copies = copy_string(generate_string(strlen))\\n new_score = 0\\n\\n while new_score < 28:\\n for index, s in enumerate(copies):\\n current_score = compare(s)\\n mutated_string = mutate_string(s)\\n new_score = compare(mutated_string)\\n if new_score > current_score:\\n copies[index] = mutated_string\\n print(mutated_string)\\n\\n if new_score == strlen:\\n break\\n\\n copies = copy_string(find_best_candidate(copies))\\n\\n return print(\\\"Done\\\")\",\n \"def get_fingerprints(self, jid: JID) -> List[str]:\\n return []\",\n \"def fingerprint(self) -> str:\\n fp = self.sha256.hex()\\n return fp\",\n \"def _build_hash_table(arr: [str]):\\n ht = {}\\n for cur_str in arr:\\n\\n anagram = cur_str[::-1]\\n if cur_str in ht.keys():\\n # This string is an anagram of some previous\\n # Increase anagram count for hash table item\\n (original, orig_cnt, anag_cnt) = ht[cur_str]\\n ht[cur_str] = (original, orig_cnt, anag_cnt + 1)\\n elif anagram in ht.keys():\\n # This string equals to some prevoius\\n # Increase original count for hash table item\\n (original, orig_cnt, anag_cnt) = ht[anagram]\\n ht[anagram] = (original, orig_cnt+1, anag_cnt)\\n else:\\n # This string is new\\n ht[anagram] = (cur_str, 1, 0)\\n return ht\",\n \"def test_hash(self):\\r\\n self.assertEqual(processor_hash('test'), 'GqNJWF7X7L07nEhqMAZ+OVyks1Y=')\\r\\n self.assertEqual(processor_hash('edx '), '/KowheysqM2PFYuxVKg0P8Flfk4=')\",\n \"def hash_string(input_str):\\n input_b = str.encode(input_str)\\n input_hash = hashlib.md5(input_b.lower())\\n input_hash_str = input_hash.hexdigest()\\n\\n return input_hash_str\",\n \"def test_pattern_matching(self):\\n\\n for hashtype in [HashTypes.SHA1, HashTypes.SHA2, HashTypes.SHA3, ]:\\n self.do_test_pattern_matching(hashtype)\",\n \"def fn(i, k, lower, upper):\\n if k == len(evil): return 0 # boundary condition \\n if i == n: return 1 \\n lo = ascii_lowercase.index(s1[i]) if lower else 0\\n hi = ascii_lowercase.index(s2[i]) if upper else 25\\n \\n ans = 0\\n for x in range(lo, hi+1): \\n kk = k \\n while kk and evil[kk] != ascii_lowercase[x]: \\n kk = lps[kk-1]\\n if evil[kk] == ascii_lowercase[x]: kk += 1\\n ans += fn(i+1, kk, lower and x == lo, upper and x == hi)\\n return ans\",\n \"def count(string):\\n unique = dict()\\n for elem in string:\\n if elem in unique:\\n unique[elem] = unique[elem]+1\\n else:\\n unique[elem] = 1\\n return unique\",\n \"def elf_hash(s):\\n h = 0\\n for c in s:\\n h = (h << 4) + ord(c)\\n t = (h & 0xF0000000)\\n if t != 0:\\n h = h ^ (t >> 24)\\n h = h & ~t\\n return h\",\n \"def test_str_fac():\\n structure = Material(input)\\n assert (np.abs(structure.calc_nuc_str_fac((2., 0., 0.))) ** 2 - 1702170.4663405998 < 1e-6)\\n assert (np.abs(structure.calc_nuc_str_fac((2, 0, 0))) ** 2 - 1702170.4663405998 < 1e-6)\\n assert (np.abs(structure.calc_nuc_str_fac((0, 2., 0))) ** 2 - 1702170.4663405998 < 1e-6)\\n assert (np.abs(structure.calc_nuc_str_fac((0, 2, 0))) ** 2 - 1702170.4663405998 < 1e-6)\\n\\n ndarray_example = np.linspace(0.5, 1.5, 21)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((ndarray_example, 0, 0))) ** 2) - 7058726.6759794801 < 1e-6)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, ndarray_example, 0))) ** 2) - 7058726.6759794801 < 1e-6)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, 0, ndarray_example))) ** 2) - 16831011.814390473 < 1e-6)\\n assert (\\n np.sum(abs(structure.calc_nuc_str_fac((ndarray_example, ndarray_example, 0))) ** 2) - 10616602.544519115 < 1e-6)\\n\\n list_example = list(ndarray_example)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((list_example, 0, 0))) ** 2) - 7058726.6759794801 < 1e-6)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, list_example, 0))) ** 2) - 7058726.6759794801 < 1e-6)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, 0, list_example))) ** 2) - 16831011.814390473 < 1e-6)\\n\\n tuple_example = tuple(ndarray_example)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((tuple_example, 0, 0))) ** 2) - 7058726.6759794801 < 1e-6)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, tuple_example, 0))) ** 2) - 7058726.6759794801 < 1e-6)\\n assert (np.sum(abs(structure.calc_nuc_str_fac((0, 0, tuple_example))) ** 2) - 16831011.814390473 < 1e-6)\",\n \"def _compute_digest(self) -> str:\\n return compute_numpy_digest(self._features, self._targets)\",\n \"def build_permutation_dictionary(input_string):\\n string_contents = {}\\n\\n for char in input_string:\\n if char not in string_contents:\\n string_contents[char] = 0\\n else:\\n string_contents[char] += 1\\n\\n return string_contents\",\n \"def frequency(string):\\n string=string.lower()\\n string=[\\\"%s%s \\\" %(string[i],string[i+1]) for i in range(len(string)-1)]\\n return Counter(string)\",\n \"def group_isomorphic(strs):\\n\\n def encode(s):\\n r, d = [], {}\\n for c in s:\\n if c not in d:\\n d[c] = len(d)\\n r.append(d[c])\\n return str(r)\\n\\n m = defaultdict(list)\\n for s in strs:\\n m[encode(s)].append(s)\\n\\n return list(m.values())\",\n \"def signature(s, n, hash_function=_crc32_hash):\\n return set(sorted((hash_function(e), e) for e in s)[:n])\",\n \"def distinct_substrigns(str1, k):\\n hash_map = {}\\n n = len(str1)\\n start = 0 \\n end = 1\\n hash_map[str1[start]] = 1\\n res = [] \\n\\n while end < n:\\n print (\\\"hash_map is :\\\", hash_map)\\n if str1[end] not in hash_map: \\n hash_map[str1[end]] = 1\\n else:\\n while str1[start]!=str1[end]:\\n del hash_map[str1[start]]\\n start += 1\\n start += 1\\n\\n if end-start+1 == k:\\n temp = str1[start:end+1]\\n if temp not in res:\\n res.append(temp)\\n del hash_map[str1[start]]\\n start += 1\\n end += 1\\n #print(end,start)\\n return res\",\n \"def set_hashes(s, hash_function=_crc32_hash):\\n return {(hash_function(e), e) for e in s}\",\n \"def getFreq(encrypted):\\n freq = {}\\n for i in encrypted:\\n freq[i] = 0\\n for i in encrypted:\\n freq[i] += 1.0 \\n return freq\",\n \"def kSimilarity(self, s1: str, s2: str) -> int:\\n def neighbors(s: str) -> Iterator[str]:\\n i = 0\\n while s[i] == s2[i]: # Skip the already swapped chars.\\n i += 1\\n\\n t = list(s)\\n for j in range(i + 1, N):\\n # Make a swap.\\n if s[j] == s2[i] and s[j] != s2[j]:\\n t[i], t[j] = t[j], t[i]\\n yield ''.join(t)\\n t[i], t[j] = t[j], t[i]\\n\\n N = len(s1)\\n queue = deque([(s1, 0)])\\n visited = {s1}\\n while queue:\\n s, swapCnt = queue.popleft()\\n if s == s2:\\n return swapCnt\\n\\n swapCnt += 1\\n for neighbor in neighbors(s):\\n if neighbor not in visited:\\n visited.add(neighbor)\\n queue.append((neighbor, swapCnt))\",\n \"def fnv1(self, key, seed=0):\\n # def fnv1(self, key):\\n\\n # Your code here\\n \\\"\\\"\\\"\\n Returns: The FNV-1 hash (64-bit) of a given string. \\n \\\"\\\"\\\"\\n #Constants : Fails the tests\\n # FNV_prime = 1099511628211\\n # offset_basis = 14695981039346656037\\n\\n # #FNV-1a Hash Function\\n # hash = offset_basis + seed\\n # # hash = offset_basis\\n # for c in key:\\n # hash = hash * FNV_prime\\n # hash = hash ^ ord(c)\\n # return hash\\n\\n \\\"\\\"\\\"\\n Returns: The FNV-1a (alternate) hash of a given string\\n \\\"\\\"\\\"\\n # #Constants : Passes the tests\\n # FNV_prime = 1099511628211\\n # offset_basis = 14695981039346656037\\n\\n # #FNV-1a alternate Hash Function\\n # hash = offset_basis + seed\\n # for c in key:\\n # hash = hash ^ ord(c)\\n # hash = hash * FNV_prime\\n # return hash\",\n \"def fingerprint(self, file):\\n raise NotImplementedError()\",\n \"def sherlockAndAnagrams(s):\\n # A Dict of palindromes and their counts.\\n palindrome_counts = {}\\n\\n # Get all substrings of length len(s)/c\\n for substring_length in range(len(s) - 1):\\n for substring_starting_index in range(len(s) - substring_length):\\n substring_end_index = substring_starting_index + substring_length + 1\\n substring = s[substring_starting_index:substring_end_index]\\n # TODO: Sorting is an inefficient way to \\\"hash\\\" by palindrome.\\n # A letter count dict would be more efficient (in the initial grouping).\\n substring_arr = list(substring)\\n substring_arr.sort()\\n sorted_substring = \\\"\\\".join(substring_arr)\\n\\n if palindrome_counts.get(sorted_substring):\\n palindrome_counts[sorted_substring] += 1\\n else:\\n palindrome_counts[sorted_substring] = 1\\n\\n return sum([_two_of_m(val) for val in palindrome_counts.values()])\",\n \"def symbolsAssign(clusters):\\n \\n alphabet = ['A','a','B','b','C','c','D','d','E','e',\\n 'F','f','G','g','H','h','I','i','J','j',\\n 'K','k','L','l','M','m','N','n','O','o',\\n 'P','p','Q','q','R','r','S','s','T','t',\\n 'U','u','V','v','W','w','X','x','Y','y','Z','z']\\n \\n clusters = pd.Series(clusters)\\n N = len(clusters.unique())\\n\\n cluster_sort = [0] * N \\n counter = collections.Counter(clusters)\\n for ind, el in enumerate(counter.most_common()):\\n cluster_sort[ind] = el[0]\\n\\n if N >= len(alphabet):\\n alphabet = [chr(i+33) for i in range(0, N)]\\n else:\\n alphabet = alphabet[:N]\\n hashm = dict(zip(cluster_sort + alphabet, alphabet + cluster_sort))\\n strings = [hashm[i] for i in clusters]\\n return strings, hashm\",\n \"def get_fingerprints(fp, format = None):\\n\\n spectrum, axis_freqs, axis_times = do_fft(*get_raw(fp, format))\\n peaks = find_peaks(spectrum, axis_freqs, axis_times)\\n fingerprints = calculate_fingerprints(peaks)\\n\\n return fingerprints\",\n \"def fingerprint_public_key_blob(blob):\\n hash = sha256(blob).digest()\\n encoded = b64encode(hash).decode('UTF-8').rstrip('=')\\n return 'SHA256:{}'.format(encoded)\",\n \"def jaccard_similarity(string1, string2):\\n\\n a = set(string1.split())\\n b = set(string2.split())\\n\\n similarity = float(\\n len(a.intersection(b)) * 1.0\\n / len(a.union(b)))\\n\\n return similarity\",\n \"def encode(string, password):\\r\\n\\r\\n print(\\\"Calling encode...\\\")\\r\\n\\r\\n password = [p for p in password] # Set the password as an array\\r\\n encrypted_string = \\\"\\\" # To hold encrypted text.\\r\\n string_array = [] # To store the string as an array\\r\\n skipped_loop = 0 # For handling the \\\\\\\\x00 character\\r\\n\\r\\n # Scrambled hash array to use\\r\\n hash_array = set_hash_array(set_base_hash_array(), password)\\r\\n # Next array to use once the first is empty\\r\\n hash_array_next = set_hash_array(hash_array, password)\\r\\n\\r\\n for index, step in enumerate(string):\\r\\n # If a NULL_STRING is found, skip over the individual characters\\r\\n # until the next valid character is reached\\r\\n if skipped_loop > 0:\\r\\n skipped_loop -= 1\\r\\n continue\\r\\n\\r\\n if step == chr(92): # The \\\\ character\\r\\n # Check if the \\\\ symbol is part of the NULL_STRING\\r\\n if string[index : (index + 4)] == NULL_STRING:\\r\\n string_array.append(NULL_STRING)\\r\\n # Sets number of loops to skip based on NULL_STRING length\\r\\n skipped_loop = len(NULL_STRING) - 1\\r\\n else:\\r\\n string_array.append(step) # Only the \\\\ character was found\\r\\n\\r\\n else:\\r\\n # Otherwise, just append the found character\\r\\n string_array.append(step)\\r\\n\\r\\n # Once the string array is filled, move into the encoding phase\\r\\n if len(string_array) == STRING_LENGTH:\\r\\n\\r\\n # Checks if hash_array has enough characters to meet STRING_LENGTH\\r\\n if len(hash_array) < STRING_LENGTH:\\r\\n # If not, find how many character from the hash_array_next to use\\r\\n next_array_len = STRING_LENGTH - len(hash_array)\\r\\n # Set password_array\\r\\n password_array = hash_array + hash_array_next[:next_array_len]\\r\\n # Reset hash_array from the next one\\r\\n hash_array = hash_array_next\\r\\n # Create a new hash_array_next\\r\\n hash_array_next = set_hash_array(hash_array, password)\\r\\n # Finally, now that hash_array is the old hash_array_next and a\\r\\n # few characters were used, remove those values\\r\\n hash_array = hash_array[next_array_len:]\\r\\n else:\\r\\n # Create the password array\\r\\n password_array = hash_array[:STRING_LENGTH]\\r\\n # Remove those used values from the hash_array\\r\\n hash_array = hash_array[STRING_LENGTH:]\\r\\n\\r\\n # Do the encrypt functions\\r\\n encrypted_string += set_encode(string_array, password_array)\\r\\n # Reset string_array to empty for the next pass\\r\\n string_array = []\\r\\n\\r\\n # This is for catching the last chunk of string that may not meet STRING_LENGTH requirements\\r\\n if string_array != []:\\r\\n # Calls function to pad out the last array to match STRING_LENGTH\\r\\n # Pass hash_array and hash_array_next as one big array to avoice\\r\\n # an array being too small\\r\\n string_array = set_string(string_array, (hash_array + hash_array_next))\\r\\n\\r\\n if len(hash_array) < STRING_LENGTH:\\r\\n # If not, find how many character from the hash_array_next to use\\r\\n next_array_len = STRING_LENGTH - len(hash_array)\\r\\n # Set password_array\\r\\n password_array = hash_array + hash_array_next[:next_array_len]\\r\\n else:\\r\\n # Create the password array padded with the hash_array\\r\\n # password_array = password + hash_array[len(password) : STRING_LENGTH]\\r\\n password_array = hash_array[:STRING_LENGTH]\\r\\n\\r\\n # Build out the encrypted_string\\r\\n encrypted_string += set_encode(string_array, password_array)\\r\\n\\r\\n return encrypted_string\",\n \"def preprocess_hashes(tex):\\n blocks = catlist()\\n rx = hash_rx\\n m = rx.search(tex)\\n while m:\\n if len(m.group(2)) > 40:\\n tex2htm.warn(\\\"Possible runaway hash: {}\\\".format(text_sample(m.group(2))))\\n raise(None)\\n blocks.append(tex[:m.start()])\\n blocks.append(re.sub(r'(^|[^\\\\\\\\])%', r'\\\\1\\\\%', m.group(0)))\\n tex = tex[m.end():]\\n m = rx.search(tex)\\n blocks.append(tex)\\n return \\\"\\\".join(blocks)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.670117","0.57371354","0.55651414","0.5493191","0.54896253","0.5443566","0.543582","0.5407759","0.5404549","0.53830826","0.5371627","0.53708583","0.5342098","0.5332482","0.53251714","0.5275193","0.5273674","0.5261942","0.52594906","0.52541286","0.524208","0.5233858","0.52014154","0.5135421","0.51333714","0.5121332","0.5106996","0.5095457","0.509263","0.50896275","0.5074858","0.50430274","0.5042276","0.5033524","0.50187445","0.4998779","0.49948576","0.4967318","0.4950119","0.4949575","0.49036378","0.4900988","0.48929408","0.48906195","0.48900166","0.4888579","0.48760024","0.48717317","0.48699537","0.48631737","0.4857766","0.48527563","0.4842035","0.4838864","0.48338854","0.4830531","0.4822358","0.48138347","0.48137948","0.48137948","0.48133698","0.48115203","0.480819","0.4795652","0.47953096","0.47902945","0.4788902","0.47882095","0.4785929","0.47823992","0.47794837","0.47789517","0.47787675","0.4778018","0.4775429","0.47629791","0.47626692","0.4762453","0.47622123","0.475503","0.47468993","0.47462657","0.4742451","0.4739444","0.47371328","0.47366294","0.47356993","0.47342983","0.47319892","0.4729336","0.47270766","0.47268984","0.4726522","0.4724092","0.47220233","0.4721911","0.47142923","0.4712408","0.4708115","0.47049123","0.47045097"],"string":"[\n \"0.670117\",\n \"0.57371354\",\n \"0.55651414\",\n \"0.5493191\",\n \"0.54896253\",\n \"0.5443566\",\n \"0.543582\",\n \"0.5407759\",\n \"0.5404549\",\n \"0.53830826\",\n \"0.5371627\",\n \"0.53708583\",\n \"0.5342098\",\n \"0.5332482\",\n \"0.53251714\",\n \"0.5275193\",\n \"0.5273674\",\n \"0.5261942\",\n \"0.52594906\",\n \"0.52541286\",\n \"0.524208\",\n \"0.5233858\",\n \"0.52014154\",\n \"0.5135421\",\n \"0.51333714\",\n \"0.5121332\",\n \"0.5106996\",\n \"0.5095457\",\n \"0.509263\",\n \"0.50896275\",\n \"0.5074858\",\n \"0.50430274\",\n \"0.5042276\",\n \"0.5033524\",\n \"0.50187445\",\n \"0.4998779\",\n \"0.49948576\",\n \"0.4967318\",\n \"0.4950119\",\n \"0.4949575\",\n \"0.49036378\",\n \"0.4900988\",\n \"0.48929408\",\n \"0.48906195\",\n \"0.48900166\",\n \"0.4888579\",\n \"0.48760024\",\n \"0.48717317\",\n \"0.48699537\",\n \"0.48631737\",\n \"0.4857766\",\n \"0.48527563\",\n \"0.4842035\",\n \"0.4838864\",\n \"0.48338854\",\n \"0.4830531\",\n \"0.4822358\",\n \"0.48138347\",\n \"0.48137948\",\n \"0.48137948\",\n \"0.48133698\",\n \"0.48115203\",\n \"0.480819\",\n \"0.4795652\",\n \"0.47953096\",\n \"0.47902945\",\n \"0.4788902\",\n \"0.47882095\",\n \"0.4785929\",\n \"0.47823992\",\n \"0.47794837\",\n \"0.47789517\",\n \"0.47787675\",\n \"0.4778018\",\n \"0.4775429\",\n \"0.47629791\",\n \"0.47626692\",\n \"0.4762453\",\n \"0.47622123\",\n \"0.475503\",\n \"0.47468993\",\n \"0.47462657\",\n \"0.4742451\",\n \"0.4739444\",\n \"0.47371328\",\n \"0.47366294\",\n \"0.47356993\",\n \"0.47342983\",\n \"0.47319892\",\n \"0.4729336\",\n \"0.47270766\",\n \"0.47268984\",\n \"0.4726522\",\n \"0.4724092\",\n \"0.47220233\",\n \"0.4721911\",\n \"0.47142923\",\n \"0.4712408\",\n \"0.4708115\",\n \"0.47049123\",\n \"0.47045097\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13284,"cells":{"query":{"kind":"string","value":"r\"\"\"Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for linear models with L1 + L2 regularization. As global optimization objective is stronglyconvex, the optimizer optimizes the dual objective at each step. The optimizer applies each update one example at a time. Examples are sampled uniformly, and the optimizer is learning rate free and enjoys linear convergence rate. Proximal Stochastic Dual Coordinate Ascent, ShalevShwartz, Shai; Zhang, Tong."},"document":{"kind":"string","value":"def _sdca_optimizer(sparse_example_indices, sparse_feature_indices,\n sparse_feature_values, dense_features, example_weights,\n example_labels, sparse_indices, sparse_weights,\n dense_weights, example_state_data, loss_type, l1, l2,\n num_loss_partitions, num_inner_iterations,\n adaptative=None, name=None):\n result = _op_def_lib.apply_op(\"SdcaOptimizer\",\n sparse_example_indices=sparse_example_indices,\n sparse_feature_indices=sparse_feature_indices,\n sparse_feature_values=sparse_feature_values,\n dense_features=dense_features,\n example_weights=example_weights,\n example_labels=example_labels,\n sparse_indices=sparse_indices,\n sparse_weights=sparse_weights,\n dense_weights=dense_weights,\n example_state_data=example_state_data,\n loss_type=loss_type, l1=l1, l2=l2,\n num_loss_partitions=num_loss_partitions,\n num_inner_iterations=num_inner_iterations,\n adaptative=adaptative, name=name)\n return _SdcaOptimizerOutput._make(result)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def optimize_sgd(beta, X, y, num_iterations, step_size):\n \n N = X.shape[0]\n P = X.shape[1]\n costs = []\n #variable step size\n if step_size == 'rm': #Robbins–Monro rule\n t0 = 2\n C = 1\n alpha = 0.5\n for i in range(num_iterations): \n j = random.randint(0,N-1) #Randomly sample a datapoint with replacement\n \n # Here I only pick a slice of X and an entry of y\n # To reuse our codes for standard GD, \n dbeta, cost = propagate(beta, X[j,:].reshape(1,P), y[j,:].reshape(1,1)) \n \n beta -= dbeta * C * ((num_iterations + t0)**(-alpha)) \n \n if i%1000 == 0:\n _, cost = propagate(beta, X, y) \n costs.append(cost.flatten())\n \n else: # constant step size\n step_size = float(step_size)\n for i in range(num_iterations):\n j = random.randint(0,N-1) #Randomly sample a datapoint with replacement\n \n # Here I only pick a slice of X and an entry of y\n # To reuse our codes for standard GD, \n dbeta, cost = propagate(beta, X[j,:].reshape(1,P), y[j,:].reshape(1,1)) \n \n beta -= dbeta * step_size\n \n if i%1000 == 0:\n _, cost = propagate(beta, X, y) \n costs.append(cost.flatten())\n \n \n return beta, costs","def _make_spsa_optimizer(self):\n def optimize(maxiter: int = 1000,\n tol = None,\n save_steps: int = 1,\n c0: float = 0.62,\n c1: float = 0.1,\n c2: float = 0.602,\n c3: float = 0.101,\n c4: float = 0):\n \"\"\"\n This method is heavily based on qiskits optimizers.spsa method, \n adapted here to worth with on quibs tn's without exact gradients \n\n Parameters\n ----------\n maxiter: Maximum number of iterations to perform.\n tol : None or float stops optim if tol is reached (default none - completes all steps)\n save_steps: Save intermediate info every save_steps step. It has a min. value of 1.\n last_avg: Averaged parameters over the last_avg iterations.\n If last_avg = 1, only the last iteration is considered. It has a min. value of 1.\n c0: The initial a. Step size to update parameters.\n c1: The initial c. The step size used to approximate gradient.\n c2: The alpha in the paper, and it is used to adjust a (c0) at each iteration.\n c3: The gamma in the paper, and it is used to adjust c (c1) at each iteration.\n c4: The parameter used to control a as well.\n \n Returns\n -------\n TYPE : updated object? (same return as TNOptimize)\n \"\"\"\n _spsa_vars = [c0, c1, c2, c3, c4]\n theta = self.vectorizer.vector\n nb_params = len(theta)\n use_exact_grads = 'grads' in self._method\n \n if save_steps:\n theta_vec = [theta]\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\n \n \n pbar = tqdm(total=maxiter, disable=not self.progbar)\n def callback(_):\n pbar.clear()\n pbar.update()\n val = round(self.loss, 5)\n pbar.set_description(str(val))\n\n if self.loss_target is not None:\n if self.loss < self.loss_target:\n # returning True doesn't terminate optimization\n pbar.close()\n raise KeyboardInterrupt\n \n for ii in range(maxiter):\n \n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\n delta = 2 * randint(0, 2, size=nb_params) - 1\n # plus and minus directions\n \n if use_exact_grads:\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\n else:\n theta_plus = theta + c_spsa * delta\n theta_minus = theta - c_spsa * delta\n\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\n # derivative estimate\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\n # updated theta\n theta = theta - a_spsa * g_spsa\n \n callback(ii)\n \n if tol is not None:\n if (cost_plus + cost_minus)/2 < tol:\n pbar.close()\n break\n \n if save_steps:\n theta_vec.append(theta)\n cost_vec.append(cost_plus/2+cost_minus/2)\n \n \n result_dict = {'hyper_parameters':_spsa_vars,\n 'maxiter':maxiter,\n 'theta_opt':theta,\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\n if save_steps:\n result_dict['theta_history'] = theta_vec\n result_dict['cost_history'] = cost_vec\n self.result_dict = result_dict\n pbar.close()\n\n return self.inject_res_vector_and_return_tn()\n return optimize","def optimizer(self):\n return 'sgd'","def sgd(cost, params, lr=1.0, alpha=0.1):\n grads = T.grad(cost=cost, wrt=params)\n updates = []\n for p, g in zip(params, grads):\n v = shared(p.get_value() * 0.)\n v_new = v * (1.0 - alpha) - alpha * lr * g\n updates.append((v, v_new))\n updates.append((p, p + v_new )) #+ T.sqrt(lr) / 600.0 * srnd.normal(v.shape, dtype=theano.config.floatX)\n \n return updates, norm_gs(params, grads)","def DistributedOptimizer(optimizer, name=None,\n device_dense='', device_sparse='',\n compression=Compression.none,\n sparse_as_dense=False):\n return _impl.create_distributed_optimizer(keras, optimizer, name,\n device_dense, device_sparse, compression,\n sparse_as_dense)","def dist_optimizer(config, optimizer):\n build_strategy, exec_strategy = create_strategy(config)\n\n dist_strategy = DistributedStrategy()\n dist_strategy.execution_strategy = exec_strategy\n dist_strategy.build_strategy = build_strategy\n\n dist_strategy.nccl_comm_num = 1\n dist_strategy.fuse_all_reduce_ops = True\n dist_strategy.fuse_grad_size_in_MB = 16\n optimizer = fleet.distributed_optimizer(optimizer, strategy=dist_strategy)\n\n return optimizer","def deep_slda_core50(override_args=None):\n args = create_default_args({'cuda': 0, 'feature_size': 512, 'batch_size': 512,\n 'shrinkage': 1e-4, 'plastic_cov': True, 'seed': None}, override_args)\n set_seed(args.seed)\n device = torch.device(f\"cuda:{args.cuda}\"\n if torch.cuda.is_available() and\n args.cuda >= 0 else \"cpu\")\n\n _mu = [0.485, 0.456, 0.406] # imagenet normalization\n _std = [0.229, 0.224, 0.225]\n transform = transforms.Compose([\n transforms.Resize((224, 224)),\n transforms.ToTensor(),\n transforms.Normalize(mean=_mu,\n std=_std)\n ])\n\n benchmark = avl.benchmarks.CORe50(scenario='nc', train_transform=transform, eval_transform=transform)\n\n eval_plugin = avl.training.plugins.EvaluationPlugin(\n loss_metrics(epoch=True, experience=True, stream=True),\n accuracy_metrics(epoch=True, experience=True, stream=True),\n forgetting_metrics(experience=True, stream=True),\n loggers=[InteractiveLogger()]\n )\n\n criterion = torch.nn.CrossEntropyLoss()\n model = avl.models.SLDAResNetModel(device=device, arch='resnet18',\n imagenet_pretrained=True)\n\n cl_strategy = avl.training.StreamingLDA(model, criterion,\n args.feature_size, num_classes=50,\n eval_mb_size=args.batch_size,\n train_mb_size=args.batch_size,\n train_epochs=1,\n shrinkage_param=args.shrinkage,\n streaming_update_sigma=args.plastic_cov,\n device=device, evaluator=eval_plugin)\n\n warnings.warn(\n \"The Deep SLDA example is not perfectly aligned with \"\n \"the paper implementation since it does not use a base \"\n \"initialization phase and instead starts streming from \"\n \"pre-trained weights. Performance should still match.\")\n\n res = None\n for i, exp in enumerate(benchmark.train_stream):\n cl_strategy.train(exp)\n res = cl_strategy.eval(benchmark.test_stream)\n\n return res","def AdaGrad(score_list, closure, batch_size, D, labels,\n max_epoch=100, init_step_size=None, linesearch_option=0, \n adaptive_termination=0, threshold_at=0.5,\n c=0.5, beta=0.7,\n x0=None, verbose=True, D_test=None, labels_test=None):\n n = D.shape[0]\n d = D.shape[1]\n \n m = int(n/batch_size)\n\n if x0 is None:\n x = np.zeros(d)\n x0 = np.zeros(d)\n elif isinstance(x0, np.ndarray) and x0.shape == (d,):\n x = x0.copy()\n else:\n raise ValueError('x0 must be a numpy array of size (d, )')\n\n num_grad_evals = 0\n Gk2 = 0\n \n if linesearch_option in [0]:\n step_size = init_step_size\n if linesearch_option in [1]:\n step_size = init_step_size / 2**(batch_size/n) \n \n condition_checked = False\n \n if adaptive_termination == 1:\n Gk2_list = np.zeros(max_epoch * m)\n iteration_counter = 0\n warmup_time = int(n / (batch_size))\n ratio_max = 0\n print(threshold_at, warmup_time)\n\n \n\n for k in range(max_epoch): \n # if num_grad_evals >= 2 * n * max_epoch:\n # # exceeds the number of standard SVRG gradient evaluations (only for batch-size = 1)\n # print('End of budget for gradient evaluations')\n # break\n t_start = time.time()\n\n\n\n loss, full_grad = closure(x, D, labels)\n \n if verbose:\n output = 'Epoch.: %d, Grad. norm: %.2e' % \\\n (k, np.linalg.norm(full_grad))\n output += ', Func. value: %e' % loss\n output += ', Step size: %e' % step_size\n output += ', Num gradient evaluations/n: %f' % (num_grad_evals / n) \n print(output) \n\n \n\n score_dict = {\"epoch\": k}\n score_dict[\"optimizer\"] = 0\n score_dict[\"n_grad_evals\"] = num_grad_evals\n score_dict[\"n_grad_evals_normalized\"] = num_grad_evals / n\n score_dict[\"train_loss\"] = loss\n score_dict[\"grad_norm\"] = np.linalg.norm(full_grad)\n score_dict[\"train_accuracy\"] = accuracy(x, D, labels)\n score_dict[\"train_loss_log\"] = np.log(loss)\n score_dict[\"grad_norm_log\"] = np.log(score_dict[\"grad_norm\"])\n # score_dict[\"train_accuracy_log\"] = np.log(score_dict[\"train_accuracy\"])\n if D_test is not None:\n test_loss = closure(x, D_test, labels_test, backwards=False)\n score_dict[\"test_loss\"] = test_loss\n score_dict[\"test_accuracy\"] = accuracy(x, D_test, labels_test)\n score_dict[\"test_loss_log\"] = np.log(test_loss)\n # score_dict[\"test_accuracy_log\"] = np.log(score_dict[\"test_accuracy\"])\n\n score_list += [score_dict]\n \n if np.linalg.norm(full_grad) <= 1e-10:\n break\n if np.linalg.norm(full_grad) >= 1e10:\n break\n if np.isnan(full_grad).any():\n break\n \n # Create Minibatches:\n minibatches = make_minibatches(n, m, batch_size)\n for i in range(m):\n # get the minibatch for this iteration\n indices = minibatches[i]\n Di, labels_i = D[indices, :], labels[indices]\n\n # compute the loss, gradients\n loss, x_grad = closure(x, Di, labels_i) \n gk = x_grad\n num_grad_evals = num_grad_evals + batch_size\n \n Gk2 = Gk2 + (np.linalg.norm(gk) ** 2)\n \n if linesearch_option == 0:\n step_size = init_step_size\n\n \n elif linesearch_option == 1:\n step_size, armijo_iter = armijo_ls(closure, Di, labels_i, x, loss,\n x_grad, x_grad, 2**(batch_size/n) * step_size, c=c, beta=beta,\n precond = 1)\n num_grad_evals += batch_size * armijo_iter\n \n if \"armijo_iter\" in score_list[len(score_list) - 1].keys(): \n score_list[len(score_list) - 1][\"armijo_iter\"] += armijo_iter\n else:\n score_list[len(score_list) - 1][\"armijo_iter\"] = armijo_iter\n \n if adaptive_termination == 1: \n if iteration_counter >= warmup_time:\n Gk2_list[iteration_counter] = Gk2\n if iteration_counter % 2 == 0: \n if iteration_counter/2 >= warmup_time:\n Gk2_last = Gk2_list[int(iteration_counter/2)] \n ratio = (Gk2 - Gk2_last) / Gk2_last\n #print(ratio)\n if ratio > ratio_max:\n ratio_max = ratio\n if ratio > threshold_at:\n x -= (step_size / np.sqrt(Gk2)) * gk\n print('Breaking out of inner loop at iteration', iteration_counter)\n condition_checked = True\n break\n iteration_counter += 1\n \n \n \n x -= (step_size / np.sqrt(Gk2)) * gk\n \n \n\n \n \n t_end = time.time()\n time_epoch = t_end - t_start\n score_list[len(score_list) - 1][\"time\"] = time_epoch \n if condition_checked:\n break\n \n return score_list, x, num_grad_evals, k","def fit(zs, ys, L, lam_1, lam_2, rho=10, maxiter=100, verbose=True, warm_start=None,\n eps_abs = 1e-5, eps_rel = 1e-5):\n K = int(zs.max() + 1)\n N, n = ys.shape\n Ys, cts = [], []\n for i in range(K):\n idx = zs == i\n cts.append(idx.sum()) #N_i, number of samples per z\n ys_i = ys[idx]\n Ys.append(ys_i.T @ ys_i)\n \n if verbose:\n print (\"Fitting covariance stratified model.\")\n print (\"%d stratification values, %d data points, %d dimensions\" % (K, N, n))\n print (\"%d\" % (K * n * n), \"optimization variables\")\n print (\"lam_1 = %3.3e, lam_2 = %3.3e, rho = %3.3e, maxiter=%d\" % (lam_1, lam_2, rho, maxiter))\n print (\"count per stratification value:\", cts)\n print (Ys[0].shape)\n\n shape = (K, n, n)\n if warm_start is None:\n warm_start = []\n for _ in range(5):\n warm_start.append(np.zeros(shape))\n inv_covs_loss, inv_covs_reg, inv_covs_lapl, U_1, U_2 = warm_start\n \n solve = factorized(L.tocsc() + rho * sparse.eye(K, format='csc'))\n \n for _ in range(maxiter):\n # inv_covs_loss\n for i in range(K):\n if cts[i] == 0:\n inv_covs_loss[i] = (inv_covs_lapl[i] - U_1[i])\n continue\n w, v = np.linalg.eigh((rho/cts[i]) * (inv_covs_lapl[i] - U_1[i]) - Ys[i]/cts[i])\n w_new = (w*cts[i]/rho + np.sqrt((w*cts[i]/rho)**2 + 4*cts[i]/rho))/2\n inv_covs_loss[i] = v @ np.diag(w_new) @ v.T \n \n # inv_covs_reg\n for i in range(K):\n inv_covs_reg[i][np.arange(n), np.arange(n)] = np.diag(inv_covs_lapl[i] - U_2[i] - lam_1/rho) #diagonal elements\n \n st2 = soft_threshold(inv_covs_lapl[i] - U_2[i], lam_2 / rho)\n od_idx = np.where(~np.eye(n,dtype=bool)) #gets off_diags\n inv_covs_reg[i][od_idx] = st2[od_idx] \n \n # inv_covs_lapl\n rhs = (inv_covs_loss + inv_covs_reg) / 2 + (U_1 + U_2) / 2\n rhs *= rho\n inv_covs_lapl_new = solve(rhs.reshape(K, n*n)).reshape(shape)\n S = rho * np.repeat(inv_covs_lapl_new - inv_covs_lapl, 2, axis=0)\n inv_covs_lapl = inv_covs_lapl_new.copy()\n\n # U_1\n R_1 = inv_covs_loss - inv_covs_lapl\n U_1 += R_1\n \n # U_2\n R_2 = inv_covs_reg - inv_covs_lapl\n U_2 += R_2\n \n R = np.concatenate([R_1, R_2], axis=0)\n \n # stopping criterion\n eps_pri = np.sqrt(2 * K * n * n) * eps_abs + eps_rel * max(np.linalg.norm(np.concatenate([inv_covs_loss, inv_covs_reg], axis=0)),\n np.linalg.norm(np.repeat(inv_covs_lapl, 2, axis=0)))\n eps_dual = np.sqrt(K * n * n) * eps_abs + eps_rel * np.linalg.norm(np.concatenate([U_1, U_2], axis=0))\n if verbose:\n print (np.linalg.norm(R), np.linalg.norm(S), eps_pri, eps_dual)\n \n return inv_covs_loss, inv_covs_reg, inv_covs_lapl","def ADMM_SGL(S, lambda1, Omega_0, Theta_0=np.array([]), X_0=np.array([]),\n rho=1., max_iter=1000, tol=1e-7, rtol=1e-4, stopping_criterion='boyd',\\\n update_rho=True, verbose=False, measure=False, latent=False, mu1=None):\n assert Omega_0.shape == S.shape\n assert S.shape[0] == S.shape[1]\n assert lambda1 > 0\n\n assert stopping_criterion in [\"boyd\", \"kkt\"]\n\n if latent:\n assert mu1 is not None\n assert mu1 > 0\n\n (p, p) = S.shape\n\n assert rho > 0, \"ADMM penalization parameter must be positive.\"\n\n # initialize\n Omega_t = Omega_0.copy()\n\n if len(Theta_0) == 0:\n Theta_0 = Omega_0.copy()\n if len(X_0) == 0:\n X_0 = np.zeros((p, p))\n\n Theta_t = Theta_0.copy()\n L_t = np.zeros((p, p))\n X_t = X_0.copy()\n\n runtime = np.zeros(max_iter)\n residual = np.zeros(max_iter)\n status = ''\n\n\n if verbose:\n print(\"------------ADMM Algorithm for Single Graphical Lasso----------------\")\n\n if stopping_criterion == 'boyd':\n hdr_fmt = \"%4s\\t%10s\\t%10s\\t%10s\\t%10s\"\n out_fmt = \"%4d\\t%10.4g\\t%10.4g\\t%10.4g\\t%10.4g\"\n print(hdr_fmt % (\"iter\", \"r_t\", \"s_t\", \"eps_pri\", \"eps_dual\"))\n elif stopping_criterion == 'kkt':\n hdr_fmt = \"%4s\\t%10s\"\n out_fmt = \"%4d\\t%10.4g\"\n print(hdr_fmt % (\"iter\", \"kkt residual\"))\n\n ##################################################################\n ### MAIN LOOP STARTS\n ##################################################################\n for iter_t in np.arange(max_iter):\n if measure:\n start = time.time()\n\n\n # Omega Update\n W_t = Theta_t - L_t - X_t - (1 / rho) * S\n eigD, eigQ = np.linalg.eigh(W_t)\n Omega_t_1 = Omega_t.copy()\n Omega_t = phiplus(beta=1 / rho, D=eigD, Q=eigQ)\n\n # Theta Update\n Theta_t = prox_od_1norm(Omega_t + L_t + X_t, (1 / rho) * lambda1)\n\n # L Update\n if latent:\n C_t = Theta_t - X_t - Omega_t\n # C_t = (C_t.T + C_t)/2\n eigD1, eigQ1 = np.linalg.eigh(C_t)\n L_t = prox_rank_norm(C_t, mu1/rho, D=eigD1, Q=eigQ1)\n\n # X Update\n X_t = X_t + Omega_t - Theta_t + L_t\n\n \n \n if measure:\n end = time.time()\n runtime[iter_t] = end - start\n\n # Stopping criterion\n if stopping_criterion == 'boyd':\n r_t,s_t,e_pri,e_dual = ADMM_stopping_criterion(Omega_t, Omega_t_1, Theta_t, L_t, X_t,\\\n S, rho, tol, rtol, latent)\n \n # update rho\n if update_rho:\n if r_t >= 10*s_t:\n rho_new = 2*rho\n elif s_t >= 10*r_t:\n rho_new = 0.5*rho\n else:\n rho_new = 1.*rho\n \n # rescale dual variables\n X_t = (rho/rho_new)*X_t\n rho = rho_new\n \n \n residual[iter_t] = max(r_t,s_t)\n\n if verbose:\n print(out_fmt % (iter_t,r_t,s_t,e_pri,e_dual))\n if (r_t <= e_pri) and (s_t <= e_dual):\n status = 'optimal'\n break\n\n elif stopping_criterion == 'kkt':\n eta_A = kkt_stopping_criterion(Omega_t, Theta_t, L_t, rho * X_t, S, lambda1, latent, mu1)\n residual[iter_t] = eta_A\n\n if verbose:\n print(out_fmt % (iter_t,eta_A))\n if eta_A <= tol:\n status = 'optimal'\n break\n\n\n ##################################################################\n ### MAIN LOOP FINISHED\n ##################################################################\n\n # retrieve status (partially optimal or max iter)\n if status != 'optimal':\n if stopping_criterion == 'boyd':\n if (r_t <= e_pri):\n status = 'primal optimal'\n elif (s_t <= e_dual):\n status = 'dual optimal'\n else:\n status = 'max iterations reached'\n else:\n status = 'max iterations reached'\n\n print(f\"ADMM terminated after {iter_t+1} iterations with status: {status}.\")\n\n ### CHECK FOR SYMMETRY\n if abs((Omega_t).T - Omega_t).max() > 1e-5:\n warnings.warn(f\"Omega variable is not symmetric, largest deviation is {abs((Omega_t).T - Omega_t).max()}.\")\n \n if abs((Theta_t).T - Theta_t).max() > 1e-5:\n warnings.warn(f\"Theta variable is not symmetric, largest deviation is {abs((Theta_t).T - Theta_t).max()}.\")\n \n if abs((L_t).T - L_t).max() > 1e-5:\n warnings.warn(f\"L variable is not symmetric, largest deviation is {abs((L_t).T - L_t).max()}.\")\n\n ### CHECK FOR POSDEF\n D = np.linalg.eigvalsh(Theta_t - L_t)\n if D.min() <= 0:\n print(\n f\"WARNING: Theta (Theta - L resp.) is not positive definite. Solve to higher accuracy! (min EV is {D.min()})\")\n\n if latent:\n D = np.linalg.eigvalsh(L_t)\n if D.min() < -1e-8:\n print(f\"WARNING: L is not positive semidefinite. Solve to higher accuracy! (min EV is {D.min()})\")\n\n if latent:\n sol = {'Omega': Omega_t, 'Theta': Theta_t, 'L': L_t, 'X': X_t}\n else:\n sol = {'Omega': Omega_t, 'Theta': Theta_t, 'X': X_t}\n\n if measure:\n info = {'status': status, 'runtime': runtime[:iter_t+1], 'residual': residual[:iter_t+1]}\n else:\n info = {'status': status}\n\n return sol, info","def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\r\n\r\n\t\r\n\tif grad == 'NO':\r\n\t\tif method == 'Powell' :\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'Nelder-Mead':\r\n\t\t\tres = opt.minimize(Ulike,init_par, method = method,\r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t options = {'ftol': 0.0001})\r\n\t\t\treturn res.x, res.nit\r\n\t\telif method == 'default':\r\n\t\t\tres = opt.minimize(Ulike,init_par, \r\n\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\r\n\t\t\treturn res.x, res.nit\r\n\r\n\telif grad == 'YES':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \r\n \t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\r\n\t\treturn res.x, res.nit \r\n\t\t\t\r\n\t\t\r\n\telif grad == 'HESS':\r\n\t\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\r\n\t\t\t\t\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\r\n\t\t\t\t\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \r\n\t\treturn res.x, res.nit","def __init__(\n self,\n params,\n lr=required,\n momentum=0,\n dampening=0,\n weight_decay=0,\n nesterov=False,\n scale=1,\n clip_norm=0,\n ):\n if lr is not required and lr < 0.:\n raise ValueError('Invalid learning rate: {}'.format(lr))\n if momentum < 0.:\n raise ValueError('Invalid momentum value: {}'.format(momentum))\n defaults = dict(lr=lr, momentum=momentum, dampening=dampening,\n nesterov=nesterov, weight_decay=weight_decay,\n scale=scale, clip_norm=clip_norm)\n if nesterov and (momentum <= 0. or dampening != 0.):\n raise ValueError('Nesterov momentum requires a momentum and zero dampening.')\n super(SGD, self).__init__(params, defaults)\n self._op_type = ('Nesterov' if nesterov else 'SGD') + 'Update'\n self._hyper = {\n 'lr': ('lr', collections.defaultdict(str)),\n 'momentum': ('momentum', collections.defaultdict(str)),\n 'weight_decay': ('weight_decay', collections.defaultdict(str)),\n 'scale': ('scale', collections.defaultdict(str)),\n 'clip_norm': ('clip_norm', collections.defaultdict(str)),\n }","def calc_dense2(self):\n # Local copies of instance attributes for faster access\n b = self.b\n qs = self.q_sim\n qo = self.q_obs\n maxlead = self.max_lead\n maxlag = self.max_lag\n measure = self.measure\n time = self.time\n n = len(self.q_obs)\n\n if self.calc_rays:\n warnings.warn('Not possible to calculate connecting rays when using HMA.calc_dense2')\n if self.keep_internals:\n warnings.warn('Not possible to keep internals when using HMA.calc_dense2')\n\n for i_o in range(n):\n # Cycle cw arrays\n if i_o > 0:\n cw0_prev = cw0_cur\n cw1_prev = cw1_cur\n cw0_cur = np.full(n, np.inf, dtype=np.float64)\n cw1_cur = np.full(n, np.inf, dtype=np.float64)\n\n iss = max(0, i_o - maxlead) # sim index start\n ise = min(n, i_o + maxlag + 1) # sim index end\n isv = np.arange(iss, ise) # sim index as vector\n if time is not None:\n dt = time[isv] - time[i_o]\n # Heavily penalize sim-obs combinations outside allowed window\n # so that they are not selected\n dt[(dt < -maxlag) | (dt > maxlead)] = np.inf\n else:\n dt = isv - i_o\n if measure in ('nse', 'square'):\n e = (qs[iss:ise] - qo[i_o]) ** 2 + b ** 2 * dt ** 2\n elif measure in ('mae', 'abs'):\n e = np.abs(qs[iss:ise] - qo[i_o]) + b * np.abs(dt)\n\n if i_o == 0:\n # Only populate first column of cw0 and move to i_o = 1\n cw0_cur[iss:ise] = e\n continue\n\n # Repeat the same simulation point\n d = cw0_prev[iss:ise]\n cw1_cur[iss:ise] = e + d\n\n # Find the 'cheapest' available preceding sim point\n points = np.full((len(isv), 4), np.inf)\n # Use the previous simulation point\n st = max(0, iss-1)\n end = min(n + 1, ise - 1)\n l = end - st\n points[-l:, 0] = cw0_prev[st:end]\n points[-l:, 1] = cw1_prev[st:end]\n # Skip a simulation point\n st = max(0, iss - 2)\n end = min(n + 1, ise - 2)\n l = end - st\n points[-l:, 2] = cw0_prev[st:end]\n points[-l:, 3] = cw1_prev[st:end]\n cw0_cur[iss:ise] = (e + np.min(points, axis=1))\n\n # Find the cheapest point in the last column, i.e. end of cheapest path, i.e. optimum score\n self.opt_score = min(np.min(cw0_cur), np.min(cw1_cur))\n self.of = 1 - self.opt_score / self.fbench\n\n return self.of","def sgdmgc(cost, params, lr=1.0, alpha=0.1, max_magnitude=5.0, infDecay=0.1):\n grads = T.grad(cost=cost, wrt=params)\n updates = []\n\n norm = norm_gs(params, grads)\n sqrtnorm = T.sqrt(norm)\n not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\n\n for p, g in zip(params, grads):\n v = shared(p.get_value() * 0.)\n g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\n v_new = v * (1.0 - alpha) - alpha * lr * g\n updates.append((v, v_new))\n updates.append((p, p + v_new ))\n \n return updates, norm","def optimize(maxiter: int = 1000,\n tol = None,\n save_steps: int = 1,\n c0: float = 0.62,\n c1: float = 0.1,\n c2: float = 0.602,\n c3: float = 0.101,\n c4: float = 0):\n _spsa_vars = [c0, c1, c2, c3, c4]\n theta = self.vectorizer.vector\n nb_params = len(theta)\n use_exact_grads = 'grads' in self._method\n \n if save_steps:\n theta_vec = [theta]\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\n \n \n pbar = tqdm(total=maxiter, disable=not self.progbar)\n def callback(_):\n pbar.clear()\n pbar.update()\n val = round(self.loss, 5)\n pbar.set_description(str(val))\n\n if self.loss_target is not None:\n if self.loss < self.loss_target:\n # returning True doesn't terminate optimization\n pbar.close()\n raise KeyboardInterrupt\n \n for ii in range(maxiter):\n \n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\n delta = 2 * randint(0, 2, size=nb_params) - 1\n # plus and minus directions\n \n if use_exact_grads:\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\n else:\n theta_plus = theta + c_spsa * delta\n theta_minus = theta - c_spsa * delta\n\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\n # derivative estimate\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\n # updated theta\n theta = theta - a_spsa * g_spsa\n \n callback(ii)\n \n if tol is not None:\n if (cost_plus + cost_minus)/2 < tol:\n pbar.close()\n break\n \n if save_steps:\n theta_vec.append(theta)\n cost_vec.append(cost_plus/2+cost_minus/2)\n \n \n result_dict = {'hyper_parameters':_spsa_vars,\n 'maxiter':maxiter,\n 'theta_opt':theta,\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\n if save_steps:\n result_dict['theta_history'] = theta_vec\n result_dict['cost_history'] = cost_vec\n self.result_dict = result_dict\n pbar.close()\n\n return self.inject_res_vector_and_return_tn()","def solve_SVM_dual_SMO(x_train, y_train, x_test, C=1):\n n, d = x_train.shape[0], x_train.shape[1]\n alpha = np.zeros((n))\n count = 0\n while True:\n count += 1\n alpha_prev = np.copy(alpha)\n for j in range(0, n):\n # Getting random int i!=j\n i = j\n cnt=0\n while i == j and cnt<1000:\n i = rnd.randint(0,n-1)\n cnt=cnt+1\n x_i, x_j, y_i, y_j = x_train[i,:], x_train[j,:], y_train[i], y_train[j]\n k_ij = (np.dot(x_i, x_i.T)) + (np.dot(x_j, x_j.T) ) - (2 * np.dot(x_i, x_j.T))\n if k_ij <= 0:\n continue\n alpha_prime_j, alpha_prime_i = alpha[j], alpha[i]\n if(y_i != y_j):\n (L,H) = (max(0, alpha_prime_j - alpha_prime_i), min(C, C - alpha_prime_i + alpha_prime_j))\n else:\n (L,H) = (max(0, alpha_prime_i + alpha_prime_j - C), min(C, alpha_prime_i + alpha_prime_j))\n if(L==H):\n continue\n # Computing model parameters\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\n b = np.mean(y_train - np.dot(w.T, x_train.T))\n E_i = np.sign(np.dot(w.T, x_i.T) + b).astype(int) - y_i\n E_j = np.sign(np.dot(w.T, x_j.T) + b).astype(int) - y_j\n # Setting new alpha values(Lagrange multipliers)\n alpha[j] = alpha_prime_j + float(y_j * (E_i - E_j))/k_ij\n alpha[j] = max(alpha[j], L)\n alpha[j] = min(alpha[j], H)\n alpha[i] = alpha_prime_i + y_i*y_j * (alpha_prime_j - alpha[j])\n # Checking for convergence\n diff = np.linalg.norm(alpha - alpha_prev)\n if diff < 0.000000001:\n break\n # Computing weights and bias\n b = np.mean(y_train-np.dot(w.T,x_train.T))\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\n y_pred_test = (np.sign(np.dot(w.T, x_test.T) + b).astype(int))\n return (y_pred_test,alpha)","def solve(self):\n \n # Check if cost is available for both estimators\n if not self.est0.cost_avail or not self.est1.cost_avail:\n self.comp_cost = False\n \n # Initial estimate from the input node\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\n else:\n z0, zvar0 = self.est0.est_init(return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0\n \n # Initialize other variables\n self.var_cost0 = 0\n self.var_cost1 = 0\n self.cost = 0\n self.s = np.zeros(self.shape1)\n \n for it in range(self.nit):\n \n # Forward transform to est1\n t0 = time.time()\n rvar1_new = self.A.var_dot(self.zvar0)\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\n self.var_axes1,rep=False)\n z1_mult = self.A.dot(self.z0)\n r1_new = z1_mult - rvar1_rep*self.s\n \n # Damping\n if it > 0: \n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\n else:\n self.r1 = r1_new\n self.rvar1 = rvar1_new\n\n # Estimator 1 \n if self.comp_cost: \n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \n if not self.map_est:\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\n self.shape1,self.var_axes1)\n else:\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \n cost1 = 0\n self.z1 = z1\n self.zvar1 = zvar1\n self.cost1 = cost1 \n con_new = np.mean(np.abs(z1-z1_mult)**2) \n \n # Reverse nonlinear transform to est 0\n self.s = (self.z1-self.r1)/rvar1_rep\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\n t1 = time.time()\n self.time_est1 = t1-t0\n \n # Reverse linear transform to est 0 \n rvar0_new = 1/self.A.var_dotH(self.sprec)\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\n self.var_axes0,rep=False)\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\n \n # Damping\n if it > 0:\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\n else:\n self.r0 = r0_new\n self.rvar0 = rvar0_new\n \n \n # Estimator 0\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\n if not self.map_est:\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\n self.shape0,self.var_axes0)\n \n else:\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0 \n\n \n # Compute total cost and constraint \n cost_new = self.cost0 + self.cost1 \n if not self.map_est:\n cost_new += self.cost_gauss()\n \n # Step size adaptation\n if (self.step_adapt) and (it > 0):\n if (con_new < self.con):\n self.step = np.minimum(1,self.step_inc*self.step)\n else:\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\n self.cost=cost_new\n self.con=con_new\n \n t2 = time.time()\n self.time_est0 = t2-t1\n self.time_iter = t2-t0\n \n # Print progress\n if self.prt_period > 0:\n if (it % self.prt_period == 0):\n if self.comp_cost:\n print(\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\".format(\\\n it, self.cost, self.con, self.step))\n else:\n print(\"it={0:4d} con={1:12.4e}\".format(\\\n it, self.con))\n \n # Save history\n self.save_hist()","def loss_sparse_dist(model, inputs_a, inputs_b, inputs_pairinfo, **kwargs):\n device = next(model.parameters()).device\n batch_size = len(inputs_a)\n\n scores = model.run(inputs_a, inputs_b)\n\n r_size = model.r_size\n\n # Generate sparse distribution for input batch\n sparse = torch.zeros(batch_size, r_size, device=device).detach()\n # FIXME: assertion that score is 0~5 range\n MAX_SCORE = 5\n for i, score in enumerate(inputs_pairinfo):\n score = score['sts']\n if score == MAX_SCORE:\n sparse[i, -1] = 1\n else:\n floor = int(score / MAX_SCORE * (r_size-1)) \n ceil = floor + 1\n weight = score / MAX_SCORE * (r_size-1) - floor\n if weight < 1e-4:\n # On the grid\n sparse[i, floor] = 1\n else:\n # Between the grid\n sparse[i, ceil] = weight\n sparse[i, floor] = 1 - weight\n\n # Calculate Kullback-Liebler Divergence loss for sparce distribution\n # Note that KLDivLoss does not support batch-first shaping.\n loss = nn.KLDivLoss(reduction='batchmean')(scores, sparse)\n\n return loss","def optimization_step(self):\n \n if \"CSS\" in self.algorithm:\n \n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\n \n var_list = [self.x_tilda, self.minibatch_set]\n \n if (self.num_samples > 0) and (not self.mixture):\n \n if ((self.mf_steps > 0) and self.alpha >0) or\\\n self.gibbs_steps > 0: \n \n var_list.append(self.sampler_theta)\n \n elif \"CD\" in self.algorithm:\n \n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \n \n var_list = [self.minibatch_set]\n \n var_list.append(self.learning_rate)\n \n if self.use_momentum:\n \n var_list.append(self.momentum)\n \n output_vars = [self.pseudo_cost]\n \n if self.report_p_tilda:\n \n output_vars.append(self.p_tilda)\n \n else:\n \n output_vars.append(theano.shared(0))\n \n opt_step = theano.function(inputs = var_list,\n outputs = output_vars,\n updates = self.updates,\n givens = input_dict,\n on_unused_input='warn')\n \n return opt_step","def test_determinism_2():\n\n def run_sgd(mode):\n # Must be seeded the same both times run_sgd is called\n disturb_mem.disturb_mem()\n rng = np.random.RandomState([2012, 11, 27])\n\n batch_size = 5\n train_batches = 3\n valid_batches = 4\n num_features = 2\n\n # Synthesize dataset with a linear decision boundary\n w = rng.randn(num_features)\n\n def make_dataset(num_batches):\n disturb_mem.disturb_mem()\n m = num_batches*batch_size\n X = rng.randn(m, num_features)\n y = np.zeros((m, 1))\n y[:, 0] = np.dot(X, w) > 0.\n\n rval = DenseDesignMatrix(X=X, y=y)\n\n rval.yaml_src = \"\" # suppress no yaml_src warning\n\n X = rval.get_batch_design(batch_size)\n assert X.shape == (batch_size, num_features)\n\n return rval\n\n train = make_dataset(train_batches)\n valid = make_dataset(valid_batches)\n\n num_chunks = 10\n chunk_width = 2\n\n class ManyParamsModel(Model):\n \"\"\"\n Make a model with lots of parameters, so that there are many\n opportunities for their updates to get accidentally re-ordered\n non-deterministically. This makes non-determinism bugs manifest\n more frequently.\n \"\"\"\n\n def __init__(self):\n super(ManyParamsModel, self).__init__()\n self.W1 = [sharedX(rng.randn(num_features, chunk_width)) for i\n in xrange(num_chunks)]\n disturb_mem.disturb_mem()\n self.W2 = [sharedX(rng.randn(chunk_width))\n for i in xrange(num_chunks)]\n self._params = safe_union(self.W1, self.W2)\n self.input_space = VectorSpace(num_features)\n self.output_space = VectorSpace(1)\n\n disturb_mem.disturb_mem()\n model = ManyParamsModel()\n disturb_mem.disturb_mem()\n\n class LotsOfSummingCost(Cost):\n \"\"\"\n Make a cost whose gradient on the parameters involves summing many\n terms together, so that T.grad is more likely to sum things in a\n random order.\n \"\"\"\n\n supervised = True\n\n def expr(self, model, data, **kwargs):\n self.get_data_specs(model)[0].validate(data)\n X, Y = data\n disturb_mem.disturb_mem()\n\n def mlp_pred(non_linearity):\n Z = [T.dot(X, W) for W in model.W1]\n H = [non_linearity(z) for z in Z]\n Z = [T.dot(h, W) for h, W in safe_izip(H, model.W2)]\n pred = sum(Z)\n return pred\n\n nonlinearity_predictions = map(mlp_pred,\n [T.nnet.sigmoid,\n T.nnet.softplus,\n T.sqr,\n T.sin])\n pred = sum(nonlinearity_predictions)\n disturb_mem.disturb_mem()\n\n return abs(pred-Y[:, 0]).sum()\n\n def get_data_specs(self, model):\n data = CompositeSpace((model.get_input_space(),\n model.get_output_space()))\n source = (model.get_input_source(), model.get_target_source())\n return (data, source)\n\n cost = LotsOfSummingCost()\n\n disturb_mem.disturb_mem()\n\n algorithm = SGD(cost=cost,\n batch_size=batch_size,\n learning_rule=Momentum(.5),\n learning_rate=1e-3,\n monitoring_dataset={'train': train, 'valid': valid},\n update_callbacks=[ExponentialDecay(decay_factor=2.,\n min_lr=.0001)],\n termination_criterion=EpochCounter(max_epochs=5))\n\n disturb_mem.disturb_mem()\n\n train_object = Train(dataset=train,\n model=model,\n algorithm=algorithm,\n extensions=[PolyakAveraging(start=0),\n MomentumAdjustor(final_momentum=.9,\n start=1,\n saturate=5), ],\n save_freq=0)\n\n disturb_mem.disturb_mem()\n\n train_object.main_loop()\n\n output = cStringIO()\n record = Record(file_object=output, replay=False)\n record_mode = RecordMode(record)\n\n run_sgd(record_mode)\n\n output = cStringIO(output.getvalue())\n playback = Record(file_object=output, replay=True)\n playback_mode = RecordMode(playback)\n\n run_sgd(playback_mode)","def sgd_optim(config = None, global_step = None):\n learning_rate = config[\"learning_rate\"]\n \n train_step = tf.train.GradientDescentOptimizer(learning_rate)\n #train_step = tf.train.GradientDescentOptimizer(learning_rate)\n return train_step","def td_sarsa(env, iterations=1000, gamma=0.9, alpha=0.1):\n\n nS = env.nS # number of states\n nA = env.nA # number of actions\n Q_value = np.zeros((nS, nA))\n policy = np.ones((env.nS,env.nA))/env.nA\n epsilon = 1\n s_t1 = env.reset() # reset the environment and place the agent in the start square\n a_t1 = sample_action(policy, s_t1)\n ############################\n # YOUR IMPLEMENTATION HERE #\n # HINT: Don't forget to decay epsilon according to GLIE\n \n curr_state = s_t1\n curr_action = a_t1\n \n start = time.time() # to time how long convergence takes\n print(\"---TD SARSA---\\nTraining Started.\")\n \n for k in range (1, iterations):\n # if (k%10000) == 0:\n # print(\"Now playing iteration: \", k)\n epsilon = 1/k\n curr_action, reward, new_state, done = take_one_step(env, policy, curr_state)\n new_action = sample_action(policy, new_state)\n Q_value[curr_state, curr_action] = Q_value[curr_state, curr_action] + alpha * (reward + gamma * Q_value[new_state, new_action] - Q_value[curr_state, curr_action])\n \n # epsilon-greedy policy update\n Q_list = np.argwhere(Q_value[curr_state] == np.amax(Q_value[curr_state])).flatten() # get a list of all indices where Q is maximum, (argmax(Q))\n max_Q = np.random.choice(Q_list.flatten()) # randomly pick from those indices. Picking each index is equally likely.\n for a in range (nA):\n if a == max_Q:\n policy[curr_state][a] = epsilon/nA + (1 - epsilon) # for the chosen maximal index of Q, set the policy to epsilon/m + 1 - epsilon\n else:\n policy[curr_state][a] = epsilon/nA # epsilon / 3\n \n # print(\"Q_value = {0}\".format(Q_value))\n # print(\"policy = {0}\".format(policy))\n \n if done:\n curr_state = env.reset() # reset the environment and place the agent in the start square\n curr_action = sample_action(policy, curr_state)\n else:\n curr_state = new_state\n curr_action = new_action\n \n stop = time.time()\n print(\"Training Completed.\")\n print(\"It took: {0} iterations and {1} minutes\".format(k,(stop-start)/60))\n \n ############################\n det_policy = np.argmax(Q_value, axis=1)\n return Q_value, det_policy","def sgd_optimization(dataset, learning_rate, n_epochs, batch_size):\n datasets = load_data(dataset)\n train_set_x, train_set_y = datasets[0]\n valid_set_x, valid_set_y = datasets[1]\n test_set_x, test_set_y = datasets[2]\n\n #number of minibatches\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\n n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size\n n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size\n\n #build the model\n print \"... building the model\"\n\n index = T.lscalar()\n x = T.matrix('x') #data for the rasterized images\n y = T.ivector('y') # labels (int)\n\n # logistic regression Class\n classifierLR = LogisticRegression(input=x, n_in=28*28, n_out=10)\n cost = classifierLR.negative_log_likelihood(y)\n\n # test model (no updates)\n test_model = theano.function(\n inputs=[index],\n outputs=classifierLR.errors(y),\n givens={\n x: test_set_x[index * batch_size: (index + 1) * batch_size],\n y: test_set_y[index * batch_size: (index + 1) * batch_size]\n }\n )\n\n #validate model (no updates)\n validate_model = theano.function(\n inputs=[index],\n outputs=classifierLR.errors(y),\n givens={\n x: valid_set_x[index * batch_size: (index + 1) * batch_size],\n y: valid_set_y[index * batch_size: (index + 1) * batch_size]\n }\n )\n\n #compute the gradient of cost wrt W, b\n g_W = T.grad(cost=cost, wrt=classifierLR.W)\n g_b = T.grad(cost=cost, wrt=classifierLR.b)\n\n #updating expression\n updates = [(classifierLR.W, classifierLR.W - learning_rate * g_W),\n (classifierLR.b, classifierLR.b - learning_rate * g_b)]\n\n # Train model (theano function); updates\n train_model = theano.function(\n inputs=[index],\n outputs=cost,\n updates=updates,\n givens={\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\n y: train_set_y[index * batch_size: (index + 1) * batch_size]\n\n }\n )\n\n # Training model (early stopping with validation examples)\n print \"... training the model\"\n patience = 5000\n patience_inc = 2 # wait this much\n improved_threshold = 0.995 # relative improvement (significant)\n validation_frequency = min(n_train_batches, patience / 2)\n best_validation_loss = numpy.inf\n test_score = 0.\n start_time = timeit.default_timer()\n\n done_looping = False\n epoch = 0\n while (epoch < n_epochs) and (not done_looping):\n epoch += 1\n for minibatch_index in xrange(n_train_batches):\n minibatch_avg_cost = train_model(minibatch_index)\n iter = (epoch - 1) * n_train_batches + minibatch_index\n\n if (iter + 1) % validation_frequency == 0:\n # compute loss on validation set\n validation_losses = [validate_model(i) for i in xrange(n_valid_batches)]\n this_validation_loss = numpy.mean(validation_losses)\n\n print(\n \"Epoch: %i, minibatch: %i/%i, validation_error: %f %%\" %\n (\n epoch,\n minibatch_index + 1,\n n_train_batches,\n this_validation_loss * 100.\n )\n )\n\n if this_validation_loss < best_validation_loss:\n #improve patience if good improvement\n if this_validation_loss < best_validation_loss * improved_threshold:\n patience = max(patience, iter * patience_inc)\n\n best_validation_loss = this_validation_loss\n\n #testing on test_set\n test_losses = [test_model(i) for i in xrange(n_test_batches)]\n test_score = numpy.mean(test_losses)\n\n print(\n (\n \"Epoch : %i, minibatch %i/%i,\"\n \" test error of best model %f %%\"\n ) % (\n epoch,\n minibatch_index,\n n_train_batches,\n test_score * 100.\n )\n )\n\n #save the best model\n print \"New best model found; saving ...\"\n with open('best_model.pkl', \"w\") as f:\n cPickle.dump(classifierLR, f)\n\n if patience <= iter:\n done_looping = True\n break\n\n\n end_time = timeit.default_timer()\n print(\n (\n \"Optimization Complete: best validation score : %f %%,\"\n \" test performance : %f %%\"\n )\n % (best_validation_loss * 100., test_score * 100.)\n )\n print \"The code run for %d epochs, with %f epochs/sec\" %(epoch, 1. * epoch / (end_time - start_time))\n print >> sys.stderr, (\"The code for file \" + os.path.split(__file__)[1] + \" ran for %.1fs\" % ((end_time - start_time)))","def cs_grad_estimator(self, test_batch_size=None):\n\n # Get a session.\n sess = self.sess\n # Initialize variables.\n try:\n tf.global_variables_initializer().run()\n except:\n tf.initialize_all_variables().run()\n\n # Set CS example batch size.\n if test_batch_size is not None:\n self.cs_bsize = test_batch_size\n else:\n if not self.cs_m_and_orig:\n self.cs_bsize = FLAGS.cs_batch_size\n else:\n self.cs_bsize = FLAGS.cs_batch_size + FLAGS.batch_size # When original images are used.\n\n # Create the generator.\n if self.contrastive_learning:\n self.cs_input_labels = tf.placeholder(tf.int32, shape=(self.cs_bsize), name='cs_input_labels')\n\n # The z latent variable.\n self.z_batch = tf.Variable(tf.random_normal([self.cs_bsize * FLAGS.cs_num_random_restarts, self.z_dim]),\n name='z_batch')\n\n # Regularizer.\n self.zp_loss_batch = tf.reduce_mean(self.z_batch ** 2, 1)\n\n # Placeholder for initializing z.\n self.z_init_pl = tf.placeholder(tf.float32, [self.cs_bsize * FLAGS.cs_num_random_restarts, self.z_dim])\n self.z_init_op = tf.assign(self.z_batch, self.z_init_pl)\n\n cs_batch_size = self.cs_bsize * FLAGS.cs_num_random_restarts\n self.cs_batch_size = cs_batch_size\n\n # CS loss (The same function is used for encoder input).\n self.cs_loss(self.z_batch, cs_batch_size=cs_batch_size)\n\n # Set up gradient descent optimizer.\n global_step = tf.Variable(0, trainable=False)\n self.cs_learning_rate = get_cs_learning_rate(global_step)\n with tf.variable_scope(tf.get_variable_scope(), reuse=False):\n opt = tf.train.AdamOptimizer(self.cs_learning_rate)\n self.cs_update_op = opt.minimize(self.cs_total_loss, var_list=[self.z_batch], global_step=global_step,\n name='update_op')\n\n # Get optimizer variables to re-initialize before each estimator call.\n uninitialized_vars = []\n for var in tf.global_variables():\n try:\n sess.run(var)\n except tf.errors.FailedPreconditionError:\n print '[WARNING] UNINIT {}'.format(var.op.name)\n uninitialized_vars.append(var)\n self.cs_initialize_op = tf.variables_initializer(uninitialized_vars)","def getCsnnOptimizerOp(self, global_step):\n # Define loss and optimizer\n csnn_optimizer, _ = self.__csnn.applySomLearning(global_step, self.__num_gpus)\n return csnn_optimizer","def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\n\n # Raise('NotImplementedError: only adjusted the arguments.')\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\n #precompute the expensive operation:\n lin_penalties = 1/np.sqrt(2*eta_lin)\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\n #!!!!\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\n #!!!!\n u_prev = u_init + 1\n u = u_init\n count = 0\n obj_history = []\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\n start = time.time()\n \n u_prev = np.copy(u)\n w_0 = w_0_update(eta_0, u, T, alpha, B) \n w = w_update(u, H, gamma, D, C) \n w_lin = w_lin_update(u, L_lhs, L_rhs)\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\n #!!!!\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\n #!!!!\n count += 1 \n if count == 10:\n u_inf = np.copy(u)\n w_0_inf = w_0[:]\n w_inf = w[:]\n w_lin_inf = w_lin[:]\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\n \n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\n obj_history.append(cur_obj)\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\n relaxed_obj_history.append(cur_relaxed_obj) \n \n stop = time.time()\n duration = stop-start\n \n if count%1 == 0 and verbose: \n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\n print(' This iteration took: {}'.format(duration))\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history","def __init__(self, optimizer):\n super(ShardedOptimizer, self).__init__(optimizer, name=\"ShardedOptimizer\")","def __init__(self,\n weight_decay,\n global_step,\n max_matrix_size=768,\n gbar_decay=0.0,\n gbar_weight=1.0,\n mat_gbar_decay=1.0,\n mat_gbar_weight=1.0,\n learning_rate=1.0,\n svd_interval=1,\n precond_update_interval=1,\n epsilon=1e-4,\n alpha=0.5,\n use_iterative_root=False,\n use_locking=False,\n name=\"ShampooW\"):\n super(ShampooWOptimizer, self).__init__(\n weight_decay,\n global_step=global_step,\n max_matrix_size=max_matrix_size,\n gbar_decay=gbar_decay,\n gbar_weight=gbar_weight,\n mat_gbar_decay=mat_gbar_weight,\n learning_rate=learning_rate,\n svd_interval=svd_interval,\n precond_update_interval=precond_update_interval,\n epsilon=epsilon,\n alpha=alpha,\n use_iterative_root=use_iterative_root,\n use_locking=use_locking,\n name=name)","def _batch_descent_on_samples(self, positivity_state_samples_all,\n derivative_state_samples_all, optimizer,\n positivity_state_repeatition,\n derivative_state_repeatition,\n options: AdversarialTrainingOptions):\n derivative_state_samples_next_all =\\\n self.lyapunov_hybrid_system.system.step_forward(\n derivative_state_samples_all)\n positivity_sample_initial_loss, derivative_sample_initial_loss = \\\n self.sample_loss(\n positivity_state_samples_all,\n derivative_state_samples_all,\n derivative_state_samples_next_all,\n self.lyapunov_positivity_sample_cost_weight,\n self.lyapunov_derivative_sample_cost_weight,\n positivity_state_repeatition,\n derivative_state_repeatition)\n best_loss = positivity_sample_initial_loss +\\\n derivative_sample_initial_loss\n best_training_params = self._get_current_training_params()\n if self.output_flag:\n print(\"Before training, positivity_sample_loss \" +\n f\"{positivity_sample_initial_loss.item()}, \" +\n \"derivative_sample_loss \" +\n f\"{derivative_sample_initial_loss.item()}\")\n positivity_dataset = torch.utils.data.TensorDataset(\n positivity_state_samples_all, positivity_state_repeatition)\n derivative_dataset = torch.utils.data.TensorDataset(\n derivative_state_samples_all, derivative_state_repeatition)\n # TODO(hongkai.dai): currently by using batch_size, I don't guarantee\n # to get options.num_batches batches in the dataset. Write a customized\n # loader later.\n positivity_loader = torch.utils.data.DataLoader(\n positivity_dataset,\n batch_size=int(\n np.ceil(len(positivity_dataset) / options.num_batches)),\n shuffle=True)\n derivative_loader = torch.utils.data.DataLoader(\n derivative_dataset,\n batch_size=int(\n np.ceil(len(derivative_dataset) / options.num_batches)),\n shuffle=True)\n for epoch in range(options.num_epochs_per_mip):\n it_positivity_samples = iter(positivity_loader)\n it_derivative_samples = iter(derivative_loader)\n for i in range(\n np.min((len(positivity_loader), len(derivative_loader)))):\n optimizer.zero_grad()\n positivity_state_batch, positivity_state_repeatition_batch =\\\n next(it_positivity_samples)\n derivative_state_batch, derivative_state_repeatition_batch =\\\n next(it_derivative_samples)\n derivative_state_next_batch = \\\n self.lyapunov_hybrid_system.system.step_forward(\n derivative_state_batch)\n positivity_sample_loss, derivative_sample_loss = \\\n self.sample_loss(\n positivity_state_batch, derivative_state_batch,\n derivative_state_next_batch,\n self.lyapunov_positivity_sample_cost_weight,\n self.lyapunov_derivative_sample_cost_weight,\n positivity_state_repeatition_batch,\n derivative_state_repeatition_batch)\n batch_loss = positivity_sample_loss +\\\n derivative_sample_loss\n batch_loss.backward()\n optimizer.step()\n\n derivative_state_samples_next_all =\\\n self.lyapunov_hybrid_system.system.step_forward(\n derivative_state_samples_all)\n positivity_sample_epoch_loss, derivative_sample_epoch_loss = \\\n self.sample_loss(\n positivity_state_samples_all,\n derivative_state_samples_all,\n derivative_state_samples_next_all,\n self.lyapunov_positivity_sample_cost_weight,\n self.lyapunov_derivative_sample_cost_weight,\n positivity_state_repeatition,\n derivative_state_repeatition)\n if self.output_flag:\n print(f\"epoch {epoch}, positivity_sample_loss \" +\n f\"{positivity_sample_epoch_loss.item()}, \" +\n \"derivative_sample_loss \" +\n f\"{derivative_sample_epoch_loss.item()}\")\n if positivity_sample_epoch_loss == 0. and\\\n derivative_sample_epoch_loss == 0.:\n return\n if positivity_sample_epoch_loss + derivative_sample_epoch_loss <\\\n best_loss:\n best_training_params = self._get_current_training_params()\n best_loss = positivity_sample_epoch_loss +\\\n derivative_sample_epoch_loss\n # End of training, set the training parameters to the one\n # corresponding to the best loss\n self._set_training_params(best_training_params)\n pass","def testSecondDerivatives(self):\n problem = problems.simple()\n optimizer = meta.MetaOptimizer(net=dict(\n net=\"CoordinateWiseDeepLSTM\",\n net_options={\"layers\": ()}))\n minimize_ops = optimizer.meta_minimize(problem, 3,\n second_derivatives=True)\n with self.test_session() as sess:\n sess.run(tf.global_variables_initializer())\n train(sess, minimize_ops, 1, 2)","def _sa1():\n The.optimize.early=4\n sa(ZDT1)","def set_optimizer_sgd(self):\n sgd = optimizers.SGD(lr=self.lr, momentum=self.momentum, decay=0.0, nesterov=False)\n self.optimizer = sgd","def train_adversarial(self, positivity_state_samples_init: torch.Tensor,\n derivative_state_samples_init: torch.Tensor,\n options: AdversarialTrainingOptions):\n assert (self.add_derivative_adversarial_state)\n assert (self.add_positivity_adversarial_state)\n if self.output_flag:\n self.print()\n if self.enable_wandb:\n options.wandb_config()\n\n train_start_time = time.time()\n positivity_state_samples_all = positivity_state_samples_init.clone()\n derivative_state_samples_all = derivative_state_samples_init.clone()\n positivity_state_repeatition = torch.ones(\n (positivity_state_samples_all.shape[0], ),\n dtype=positivity_state_samples_all.dtype)\n derivative_state_repeatition = torch.ones(\n (derivative_state_samples_all.shape[0], ),\n dtype=derivative_state_samples_all.dtype)\n iter_count = 0\n training_params = self._training_params()\n while iter_count < self.max_iterations:\n # Now solve MIP to find adversarial states.\n lyapunov_positivity_mip, lyapunov_positivity_mip_obj,\\\n positivity_mip_adversarial = self.solve_positivity_mip()\n lyapunov_derivative_mip, lyapunov_derivative_mip_obj,\\\n derivative_mip_adversarial, _ = self.solve_derivative_mip()\n if not np.isinf(options.adversarial_cluster_radius):\n positivity_mip_adversarial,\\\n positivity_mip_adversarial_repeatition =\\\n _cluster_adversarial_states(\n positivity_mip_adversarial,\n options.adversarial_cluster_radius)\n derivative_mip_adversarial,\\\n derivative_mip_adversarial_repeatition =\\\n _cluster_adversarial_states(\n derivative_mip_adversarial,\n options.adversarial_cluster_radius)\n # else:\n # positivity_mip_adversarial_repeatition = torch.ones(\n # (positivity_mip_adversarial.shape[0], ),\n # dtype=positivity_mip_adversarial.dtype)\n # derivative_mip_adversarial_repeatition = torch.ones(\n # (derivative_mip_adversarial.shape[0], ),\n # dtype=derivative_mip_adversarial.dtype)\n positivity_state_samples_all = torch.cat(\n (positivity_state_samples_all, positivity_mip_adversarial),\n dim=0)\n derivative_state_samples_all = torch.cat(\n (derivative_state_samples_all, derivative_mip_adversarial),\n dim=0)\n # positivity_state_repeatition = torch.cat(\n # (positivity_state_repeatition,\n # positivity_mip_adversarial_repeatition),\n # dim=0)\n positivity_state_repeatition = torch.ones((\n positivity_state_samples_all.shape[0],),\n dtype=positivity_state_samples_all.dtype)\n # derivative_state_repeatition = torch.cat(\n # (derivative_state_repeatition,\n # derivative_mip_adversarial_repeatition),\n # dim=0)\n derivative_state_repeatition = torch.ones((\n derivative_state_samples_all.shape[0],),\n dtype=derivative_state_samples_all.dtype)\n if positivity_state_samples_all.shape[\n 0] > options.positivity_samples_pool_size:\n positivity_state_samples_all = positivity_state_samples_all[\n -options.positivity_samples_pool_size:, :]\n positivity_state_repeatition = positivity_state_repeatition[\n -options.positivity_samples_pool_size:]\n if derivative_state_samples_all.shape[\n 0] > options.derivative_samples_pool_size:\n derivative_state_samples_all = derivative_state_samples_all[\n -options.derivative_samples_pool_size:, :]\n derivative_state_repeatition = derivative_state_repeatition[\n -options.derivative_samples_pool_size:]\n if self.output_flag:\n print(f\"Iter {iter_count}, positivity cost \" +\n f\"{lyapunov_positivity_mip_obj}, \" + \"derivative_cost \" +\n f\"{lyapunov_derivative_mip_obj}\")\n if self.enable_wandb:\n wandb.log({\n \"positivity MIP cost\": lyapunov_positivity_mip_obj,\n \"derivative MIP cost\": lyapunov_derivative_mip_obj,\n \"time\": time.time() - train_start_time\n })\n if lyapunov_positivity_mip_obj < \\\n self.lyapunov_positivity_convergence_tol and\\\n lyapunov_derivative_mip_obj < \\\n self.lyapunov_derivative_convergence_tol:\n return True, positivity_state_samples_all,\\\n derivative_state_samples_all\n # Now do gradient descent on the adversarial states.\n if self.optimizer == \"Adam\":\n optimizer = torch.optim.Adam(training_params,\n lr=self.learning_rate)\n elif self.optimizer == \"SGD\":\n optimizer = torch.optim.SGD(training_params,\n lr=self.learning_rate,\n momentum=self.momentum)\n self._batch_descent_on_samples(positivity_state_samples_all,\n derivative_state_samples_all,\n optimizer,\n positivity_state_repeatition,\n derivative_state_repeatition,\n options)\n iter_count += 1\n return False, positivity_state_samples_all,\\\n derivative_state_samples_all, positivity_state_repeatition,\\\n derivative_state_repeatition","def sgd_updates_adadelta(params,cost,rho=0.95,epsilon=1e-6,norm_lim=9,word_vec_name='Words'):\n updates = OrderedDict({})\n exp_sqr_grads = OrderedDict({})\n exp_sqr_ups = OrderedDict({})\n gparams = []\n for param in params:\n empty = np.zeros_like(param.get_value())\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),name=\"exp_grad_%s\" % param.name)\n gp = T.grad(cost, param)\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty), name=\"exp_grad_%s\" % param.name)\n gparams.append(gp)\n for param, gp in zip(params, gparams):\n exp_sg = exp_sqr_grads[param]\n exp_su = exp_sqr_ups[param]\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\n updates[exp_sg] = up_exp_sg\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\n stepped_param = param + step\n if (param.get_value(borrow=True).ndim == 2) and (param.name != 'Words') and (param.name != 'Topics'):\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\n scale = desired_norms / (1e-7 + col_norms)\n updates[param] = stepped_param * scale\n else:\n updates[param] = stepped_param \n return updates","def sac(args):\n device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n torch.manual_seed(args.seed)\n torch.cuda.manual_seed(args.seed)\n np.random.seed(args.seed)\n # initialization\n env = gym.make(args.game)\n s_space = env.observation_space\n a_space = env.action_space\n print(s_space.shape, ' ', a_space.shape)\n ac = ActorCritic(s_space, a_space, orth_norm=False)\n optimizer_pi = torch.optim.Adam(ac.pi.parameters(), lr=args.lr_pi)\n optimizer_q1 = torch.optim.Adam(ac.q1.parameters(), lr=args.lr_q)\n optimizer_q2 = torch.optim.Adam(ac.q2.parameters(), lr=args.lr_q)\n ac_target = deepcopy(ac) # initialize target Q1 and Q2\n for p in ac_target.parameters(): # freeze target networks' parameters\n p.requires_grad = False\n q_params = itertools.chain(ac.q1.parameters(), ac.q2.parameters()) # q1 and q2 params getheter\n alpha = args.alpha\n entropy_target = -np.prod(a_space.shape)\n\n def update_q(s, a):\n # compute Q loss, and update\n q1 = ac.q1(s, a)\n q2 = ac.q2(s, a)\n with torch.no_grad(): # notice here!\n an, logp_an = ac.pi(sn) # target actions come from current policy\n q1_hat = ac_target.q1(sn, an)\n q2_hat = ac_target.q2(sn, an)\n q_target = r + args.gamma * d * (torch.min(q1_hat, q2_hat) - alpha * logp_an)\n for p in q_params:\n p.requires_grad = True\n loss_q1 = ((q1 - q_target) ** 2).mean()\n loss_q2 = ((q2 - q_target) ** 2).mean()\n loss_q = loss_q1 + loss_q2\n optimizer_q1.zero_grad()\n optimizer_q2.zero_grad()\n loss_q.backward()\n optimizer_q1.step()\n optimizer_q2.step()\n\n def update_pi(s):\n # compute pi loss, and update\n a_new, logp_a_new = ac.pi(s)\n q1_pi = ac.q1(s, a_new)\n q2_pi = ac.q2(s, a_new)\n q_pi = torch.min(q1_pi, q2_pi)\n loss_pi = (alpha * logp_a_new - q_pi).mean()\n optimizer_pi.zero_grad()\n loss_pi.backward()\n optimizer_pi.step()\n\n # Main loop\n ep_r_mean = []\n returns = 0 # compute an episode's total reward\n s = env.reset()\n\n replay_buffer = ReplayBuffer(args.buf_size, s_space, a_space)\n for epoch in range(args.epochs): # times of getting replay buffer\n \"\"\"\n for example:\n every epoch sample step(s,a,r,d,sn) 2000 times\n then get minibatch and train and update 200 times\n \"\"\"\n\n episode_ret = [] # collect every episode's total reward\n\n for step in range(args.pre_epoch_steps):\n if replay_buffer.pointer < 10000: # increase exploration\n a = env.action_space.sample()\n else:\n a = ac.step(torch.as_tensor(s, dtype=torch.float32))\n sn, r, done, _ = env.step(a)\n returns += r\n d = 0 if done else 1\n replay_buffer.store(s, a, r, d, sn)\n if done:\n s = env.reset()\n episode_ret.append(returns)\n returns = 0\n else:\n s = sn\n # record mean episode's total return in every epoch\n ep_r_mean.append({'epochs': epoch+1, 'traj_nums': len(episode_ret), 'mean_ep_r': np.mean(episode_ret)})\n print('epoch:', epoch+1, ' --- tarj_nums:', len(episode_ret), ' --- mean_ep_r:', np.mean(episode_ret))\n # now we have completed to collect a replay_buffer\n # sample mini batch from buffer and update pi\\q networks\n if replay_buffer.pointer > 3000:\n for update in range(args.update_time):\n # prepare\n ac.to(device)\n ac_target.to(device)\n mini_batch = replay_buffer.sample_minibatch(args.batch_size)\n s_gpu, a, r, d, sn = mini_batch['s'].to(device),\\\n mini_batch['a'].to(device),\\\n mini_batch['r'].to(device),\\\n mini_batch['d'].to(device),\\\n mini_batch['sn'].to(device)\n # compute Q loss, and update\n update_q(s_gpu, a)\n # Freeze Q networks, so don't waste computational effort\n for p in q_params:\n p.requires_grad = False\n # compute pi loss, and update\n update_pi(s_gpu)\n # Unfreeze Q networks\n for p in q_params:\n p.requires_grad = True\n # compute alpha loss, and update\n with torch.no_grad():\n a_new, logp_a_new = ac.pi(s_gpu)\n alpha = alpha * (1 + args.lr_alpha * ((logp_a_new + entropy_target).mean()))\n if alpha > 1 or alpha < 0:\n print(\"Warning: alpha's value is error! \", alpha)\n # Update ac_target.q1\\2\n with torch.no_grad():\n for p, p_target in zip(ac.parameters(), ac_target.parameters()):\n p_target.data.copy_(args.tau * p.data + (1.0-args.tau) * p_target.data)\n ac.cpu()\n ac_target.cpu()\n return ac, ac_target, ep_r_mean","def compile_update_svdd(nnet, inputs, targets):\n\n floatX = Cfg.floatX\n B = Cfg.B\n C = Cfg.C\n nu = Cfg.nu\n\n # initialize R\n if nnet.R_init > 0:\n nnet.Rvar = shared(floatX(nnet.R_init), name=\"R\")\n else:\n nnet.Rvar = shared(floatX(1), name=\"R\") # initialization with R=1\n\n # Loss\n feature_layer = nnet.all_layers[-1]\n rep = lasagne.layers.get_output(feature_layer, inputs=inputs,\n deterministic=False)\n\n # initialize c (0.5 in every feature representation dimension)\n rep_dim = feature_layer.num_units\n # nnet.cvar = shared(floatX(np.ones(rep_dim) * (1. / (rep_dim ** 0.5))),\n # name=\"c\")\n nnet.cvar = shared(floatX(np.ones(rep_dim) * 0.5), name=\"c\")\n\n dist = T.sum(((rep - nnet.cvar.dimshuffle('x', 0)) ** 2),\n axis=1, dtype='floatX')\n scores = dist - nnet.Rvar\n stack = T.stack([T.zeros_like(scores), scores], axis=1)\n loss = T.cast(T.sum(T.max(stack, axis=1)) / (inputs.shape[0] * nu),\n dtype='floatX')\n\n y_pred = T.argmax(stack, axis=1)\n acc = T.cast((T.sum(T.eq(y_pred.flatten(), targets), dtype='int32')\n * 1. / targets.shape[0]), 'floatX')\n\n # Network weight decay\n if Cfg.weight_decay:\n l2_penalty = (1/C) * get_l2_penalty(nnet,\n include_bias=Cfg.include_bias,\n pow=Cfg.pow)\n else:\n l2_penalty = T.cast(0, dtype='floatX')\n\n # Network activation sparsity regularization\n if Cfg.sparsity_penalty:\n sparsity_penalty = (1/B) * get_sparsity_penalty(nnet, inputs,\n Cfg.sparsity,\n mode=Cfg.sparsity_mode,\n deterministic=False)\n else:\n sparsity_penalty = T.cast(0, dtype='floatX')\n\n # Backpropagation (hard-margin: only minimizing everything to a ball\n # centered at c)\n trainable_params = lasagne.layers.get_all_params(feature_layer,\n trainable=True)\n if Cfg.gaussian_blob:\n avg_dist = T.mean(1-T.exp(-dist), dtype=\"floatX\")\n else:\n avg_dist = T.mean(dist, dtype=\"floatX\")\n obj_ball = T.cast(floatX(0.5) * l2_penalty + avg_dist + sparsity_penalty,\n dtype='floatX')\n updates_ball = get_updates(nnet, obj_ball, trainable_params,\n solver=nnet.solver)\n nnet.backprop_ball = theano.function([inputs, targets], [obj_ball, acc],\n updates=updates_ball)\n\n # Backpropagation (without training R)\n obj = T.cast(floatX(0.5) * l2_penalty + nnet.Rvar + loss + sparsity_penalty,\n dtype='floatX')\n updates = get_updates(nnet, obj, trainable_params, solver=nnet.solver)\n nnet.backprop_without_R = theano.function([inputs, targets], [obj, acc],\n updates=updates)\n\n # Backpropagation (with training R)\n trainable_params.append(nnet.Rvar) # add radius R to trainable parameters\n updates = get_updates(nnet, obj, trainable_params, solver=nnet.solver)\n nnet.backprop = theano.function([inputs, targets], [obj, acc],\n updates=updates)\n\n\n # Forwardpropagation\n test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,\n deterministic=True)\n test_rep_norm = test_rep.norm(L=2, axis=1)\n\n test_dist = T.sum(((test_rep - nnet.cvar.dimshuffle('x', 0)) ** 2),\n axis=1, dtype='floatX')\n\n test_scores = test_dist - nnet.Rvar\n test_stack = T.stack([T.zeros_like(test_scores), test_scores], axis=1)\n test_loss = T.cast(T.sum(T.max(test_stack, axis=1)) / (inputs.shape[0]*nu),\n dtype='floatX')\n\n test_y_pred = T.argmax(test_stack, axis=1)\n test_acc = T.cast((T.sum(T.eq(test_y_pred.flatten(), targets),\n dtype='int32')\n * 1. / targets.shape[0]), dtype='floatX')\n\n # Network activation sparsity regularization (with determinisitc=True)\n if Cfg.sparsity_penalty:\n test_sparsity_penalty = ((1 / B) *\n get_sparsity_penalty(nnet, inputs,\n Cfg.sparsity,\n mode=Cfg.sparsity_mode,\n deterministic=True))\n else:\n test_sparsity_penalty = T.cast(0, dtype='floatX')\n\n test_obj = T.cast(floatX(0.5) * l2_penalty + nnet.Rvar + test_loss\n + test_sparsity_penalty, dtype='floatX')\n nnet.forward = theano.function([inputs, targets],\n [test_obj, test_acc, test_scores,\n floatX(0.5) * l2_penalty,\n test_sparsity_penalty, test_rep,\n test_rep_norm, test_loss, nnet.Rvar])","def sgd_updates_adadelta(params,cost,rho=0.95,epsilon=1e-6,norm_lim=9,word_vec_name='Words'):\n updates = OrderedDict({})\n exp_sqr_grads = OrderedDict({})\n exp_sqr_ups = OrderedDict({})\n gparams = []\n for param in params:\n empty = np.zeros_like(param.get_value())\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),name=\"exp_grad_%s\" % param.name)\n gp = T.grad(cost, param)\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty), name=\"exp_grad_%s\" % param.name)\n gparams.append(gp)\n for param, gp in zip(params, gparams):\n exp_sg = exp_sqr_grads[param]\n exp_su = exp_sqr_ups[param]\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\n updates[exp_sg] = up_exp_sg\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\n stepped_param = param + step\n if (param.get_value(borrow=True).ndim == 2) and (param.name!='Words'):\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\n scale = desired_norms / (1e-7 + col_norms)\n updates[param] = stepped_param * scale\n else:\n updates[param] = stepped_param \n return updates","def sgd_updates_adadelta(params,cost,rho=0.95,epsilon=1e-6,norm_lim=9,word_vec_name='Words'):\n updates = OrderedDict({})\n exp_sqr_grads = OrderedDict({})\n exp_sqr_ups = OrderedDict({})\n gparams = []\n for param in params:\n empty = np.zeros_like(param.get_value())\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),name=\"exp_grad_%s\" % param.name)\n gp = T.grad(cost, param)\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty), name=\"exp_grad_%s\" % param.name)\n gparams.append(gp)\n for param, gp in zip(params, gparams):\n exp_sg = exp_sqr_grads[param]\n exp_su = exp_sqr_ups[param]\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\n updates[exp_sg] = up_exp_sg\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\n stepped_param = param + step\n if (param.get_value(borrow=True).ndim == 2) and (param.name!='Words'):\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\n scale = desired_norms / (1e-7 + col_norms)\n updates[param] = stepped_param * scale\n else:\n updates[param] = stepped_param \n return updates","def adaptive_step(self):\n\n s = self\n \n # adaptive line search parameters\n down_adjustment_frequency = 1\n up_adjustment_frequency = 50\n alpha=0.3 # acceptable fraction of predicted decrease\n beta=0.8 # how much to shrink when violation\n gamma=1.05 # how much to grow when too conservative\n report_frequency = 1\n \n\n s.model.advance_batch()\n s.update_stats() # update cov matrices and svds\n\n s.grad.update() # gradient (ptodo, already updated in stats)\n s.grad2.update() # gradient from synth labels (don't need?)\n s.grad_new.update() # corrected gradient\n\n # TODO: decide on s vs s.\n s.run(s.param_save_op) # TODO: insert lr somewhere\n lr0, loss0 = s.run(s.lr, s.model.loss)\n\n s.run(s.param_update_op)\n loss1 = s.run(s.model.loss)\n \n target_slope = -s.run(s.grad_dot_grad_new_op)\n target_delta = lr0*target_slope\n actual_delta = loss1 - loss0\n actual_slope = actual_delta/lr0\n slope_ratio = actual_slope/target_slope # between 0 and 1.01\n \n s.record('loss', loss0)\n s.record('step_length', lr0)\n s.record('grad_norm', s.run(s.grad_norm_op))\n s.record('grad_new_norm', s.run(s.grad_new_norm_op))\n s.record('target_delta', target_delta)\n\n if step_rejection and actual_delta > 0:\n print('Observed increase in loss %.2f, rejecting step'%(actual_delta,))\n s.run(s.param_restore_op)\n\n if s.step_counter % report_frequency == 0:\n print('NStep %d loss %.2f, target decrease %.3f, actual decrease, %.3f ratio %.2f'%(self.step_counter, loss0, target_delta, actual_delta, slope_ratio))\n\n if (adaptive_step and s.step_counter % down_adjustment_frequency == 0 and\n slope_ratio < alpha and abs(target_delta)>eps):\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\n print('Slope optimality %.2f, shrinking learning rate to %.2f'%(slope_ratio, lr0*beta,))\n s.lr.set(lr0*beta)\n elif (adaptive_step and s.step_counter % up_adjustment_frequency == 0 and\n slope_ratio>0.90):\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\n print('Growing learning rate to %.2f'%(lr0*gamma))\n s.lr.set(lr0*gamma)\n \n s.step_counter+=1","def test_sag_adaptive():\n np.random.seed(0)\n X = sparse.rand(100, 10, density=.5, random_state=0).tocsr()\n y = np.random.randint(0, high=2, size=100)\n for alpha in np.logspace(-3, 1, 5):\n clf_adaptive = SAGClassifier(\n eta='line-search', random_state=0, alpha=alpha)\n clf_adaptive.fit(X, y)\n clf = SAGClassifier(\n eta='auto', random_state=0, alpha=alpha)\n clf.fit(X, y)\n assert_almost_equal(clf_adaptive.score(X, y), clf.score(X, y), 1)\n\n clf_adaptive = SAGAClassifier(\n eta='line-search', loss='log', random_state=0, alpha=alpha, max_iter=20)\n clf_adaptive.fit(X, y)\n assert np.isnan(clf_adaptive.coef_.sum()) == False\n clf = SAGAClassifier(\n eta='auto', loss='log', random_state=0, alpha=alpha, max_iter=20)\n clf.fit(X, y)\n assert_almost_equal(clf_adaptive.score(X, y), clf.score(X, y), 1)","def SPSA(y, t0, a, c, delta, constraint=identity):\n theta = t0\n\n # Pull off the ak and ck values forever\n for ak, ck in izip(a, c):\n # Get estimated gradient\n gk = estimate_gk(y, theta, delta, ck)\n\n # Adjust theta estimate using SA\n theta = [t - ak * gkk for t, gkk in izip(theta, gk)]\n\n # Constrain\n theta = constraint(theta)\n\n yield theta # This makes this function become an iterator","def SGD(self, tr_d, va_d, epochs, lr, relz=\"\", lmbda=0.0, mu=0.0,perc=1.0):\n print \"Training the network with SGD......\"\n trlen = len(tr_d)\n batch_size = 10\n j = 0\n accuracy = []\n while j < epochs:\n random.shuffle(tr_d)\n batches = [tr_d[k:k+batch_size] for k in xrange(0,trlen,batch_size)]\n for tr_batch in batches:\n if(relz[0:2] != \"DP\"):\n self.update_network(tr_batch,lr, relz, lmbda, mu)\n else:\n self.update_network_dp(tr_batch,lr,relz[2:], lmbda,perc, mu)\n acy = self.Evaluate(va_d)\n accuracy.append(acy)\n if (va_d):\n print \"Epoch {0}: {1}/{2}\".format(j, acy, len(va_d))\n else:\n print \"Epoch {0}:\".format(j)\n j += 1\n np.save(\"test_acy_%s_qinit_1.npy\"%(relz), accuracy)","def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\n\n\n obj_lss = np.zeros(max_iter)\n x_zs = np.zeros(max_iter)\n u_norms = np.zeros(max_iter)\n times = np.zeros(max_iter)\n\n ATy = AT_fun(y)\n x_shape = ATy.shape\n d = np.prod(x_shape)\n\n def A_cgs_fun(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x)) + alpha * x\n return vec(y)\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\n\n def compute_p_inv_A(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n\n def A_cgs_fun_init(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x))\n return vec(y)\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\n\n def compute_init(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n # initialize z and u\n z = compute_init(ATy, ATy)\n u = np.zeros(x_shape)\n\n\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\n\n\n start_time = timeit.default_timer()\n\n for iter in range(max_iter):\n\n # x-update\n net_input = z+u\n Wzu, wbook = wavelet_transform(net_input)\n q = soft_threshold(Wzu, lambda_l1/alpha)\n x = inverse_wavelet_transform(q, wbook, x_shape)\n x = np.reshape(x, x_shape)\n\n # z-update\n b = ATy + alpha * (x - u)\n z = compute_p_inv_A(b, z)\n\n # u-update\n u += z - x;\n\n if show_img_progress == True:\n\n fig = plt.figure('current_sol')\n plt.gcf().clear()\n fig.canvas.set_window_title('iter %d' % iter)\n plt.subplot(1,3,1)\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('x')\n plt.subplot(1,3,2)\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('z')\n plt.subplot(1,3,3)\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('netin')\n plt.pause(0.00001)\n\n\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\n x_z = np.sqrt(np.mean(np.square(x-z)))\n u_norm = np.sqrt(np.mean(np.square(u)))\n\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\n\n\n obj_lss[iter] = obj_ls\n x_zs[iter] = x_z\n u_norms[iter] = u_norm\n times[iter] = timeit.default_timer() - start_time\n\n if x_z < solver_tol:\n break\n\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\n 'max_iter':max_iter, 'solver_tol':solver_tol}\n\n\n return (x, z, u, infos)","def _apply_dense(self, grad, var):\n\n assignments = []\n\n param_name = self._get_variable_name(var.name)\n\n m = self.get_slot(var, \"m\")\n v = self.get_slot(var, \"v\")\n\n # Standard Adam update.\n next_m = (\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\n next_v = (\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\n tf.square(grad)))\n\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\n\n # Just adding the square of the weights to the loss function is *not*\n # the correct way of using L2 regularization/weight decay with Adam,\n # since that will interact with the m and v parameters in strange ways.\n #\n # Instead we want ot decay the weights in a manner that doesn't interact\n # with the m/v parameters. This is equivalent to adding the square\n # of the weights to the loss with plain (non-momentum) SGD.\n if self._do_use_weight_decay(param_name):\n update += self.weight_decay_rate * var\n\n ratio = 1.0\n if self._do_layer_adaptation(param_name):\n w_norm = linalg_ops.norm(var, ord=2)\n g_norm = linalg_ops.norm(update, ord=2)\n ratio = array_ops.where(math_ops.greater(w_norm, 0), array_ops.where(\n math_ops.greater(g_norm, 0), (w_norm / g_norm), 1.0), 1.0)\n\n update_with_lr = ratio * self.learning_rate * update\n\n next_param = var - update_with_lr\n\n assignments.extend(\n [var.assign(next_param, use_locking=self._use_locking),\n m.assign(next_m),\n v.assign(next_v)])\n return tf.group(*assignments)","def adam_optim(config = None, global_step = None):\n learning_rate = config[\"learning_rate\"]\n\n beta1 = config.get('beta1', 0.9)\n beta2 = config.get('beta2', 0.999)\n epsilon = config.get('epsilon', 1e-8)\n \n train_step = tf.train.AdamOptimizer(learning_rate, beta1, beta2, epsilon)\n\n return train_step","def optimizer_creator(model, config):\n return torch.optim.SGD(model.parameters(), lr=config.get(\"lr\", 1e-4))","def sgd_optimize(self, train_set, test_set, n_epochs, learning_rate, batch_size):\n\n train_set_x, train_set_y, train_set_c = train_set\n assert train_set_x.shape == (60000, 784)\n assert train_set_y.shape == (60000,)\n assert train_set_c.shape == (60000, 10)\n\n test_set_x, test_set_y, test_set_c = test_set\n assert test_set_x.shape == (10000, 784)\n assert test_set_y.shape == (10000,)\n assert test_set_c.shape == (10000, 10)\n\n from toolbox import make_shared_data\n\n train_set_x = make_shared_data(train_set_x)\n train_set_c = make_shared_data(train_set_c)\n train_set_y = T.cast(make_shared_data(train_set_y), 'int32')\n\n test_set_x = make_shared_data(test_set_x)\n test_set_c = make_shared_data(test_set_c)\n test_set_y = T.cast(make_shared_data(test_set_y), 'int32')\n\n print '... building the model'\n\n index = T.lscalar()\n\n cost = self.MSE\n\n gparams = [T.grad(cost, param) for param in self.params]\n\n train_model = theano.function(\n inputs=[index],\n outputs=cost,\n updates=[\n (param, param - learning_rate * gparam)\n for param, gparam in zip(self.params, gparams)\n ],\n givens={\n self.input: train_set_x[index * batch_size: (index + 1) * batch_size],\n self.cost_vector: train_set_c[index * batch_size: (index + 1) * batch_size]\n },\n name='train_model'\n )\n\n in_sample_result = theano.function(\n inputs=[],\n outputs=[self.error, self.future_cost],\n givens={\n self.input: train_set_x,\n self.y: train_set_y,\n self.cost_vector: train_set_c\n },\n name='in_sample_result'\n )\n\n out_sample_result = theano.function(\n inputs=[],\n outputs=[self.error, self.future_cost],\n givens={\n self.input: test_set_x,\n self.y: test_set_y,\n self.cost_vector: test_set_c\n },\n name='out_sample_result'\n )\n\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\n\n print '... training the model'\n\n best_Cout = np.inf\n corresponding_Eout = np.inf\n for epoch in xrange(n_epochs):\n print 'epoch #%d' % (epoch + 1)\n for batch_index in xrange(n_train_batches):\n batch_cost = train_model(batch_index)\n Ein, Cin = in_sample_result()\n Eout, Cout = out_sample_result()\n if Cout < best_Cout:\n best_Cout = Cout\n corresponding_Eout = Eout\n print ' better performance achieved ... best_Cout = %f' % best_Cout\n\n print 'after training %d epochs, best_Cout = %f, and corresponding_Eout = %f' \\\n % (n_epochs, best_Cout, corresponding_Eout)","def cem_optimize(init_mean, cost_func, init_variance=1., samples=20, precision=1.0e-3,\n steps=20, nelite=5, contraint_mean=None, constraint_variance=(-999999, 999999), device=\"cpu\"):\n mean = init_mean\n variance = torch.tensor([init_variance], device=device).repeat(mean.shape).float()\n # print(mean.type(), variance.type())\n step = 1\n diff = 9999999\n while diff > precision and step < steps:\n dists = [distributions.MultivariateNormal(m, torch.diagflat(v+precision/10), device=device) for m, v in zip(mean, variance)]\n candidates = [d.sample_n(samples) for d in dists]\n candidates = torch.stack(candidates, dim=1)\n costs = cost_func(candidates)\n # we sort descending because we want a maximum reward\n sorted_idx = torch.argsort(costs, dim=0, descending=True)\n candidates = candidates[sorted_idx]\n elite = candidates[:nelite]\n new_mean = torch.mean(elite, dim=0)\n variance = torch.var(elite, dim=0)\n diff = torch.mean(torch.abs(mean - new_mean))\n mean = new_mean\n # print(mean, variance)\n if not contraint_mean is None:\n mean = clip(mean, contraint_mean[0], contraint_mean[1])\n step += 1\n\n return mean","def tsne(X = Math.array([]), no_dims = 2, initial_dims = 50, perplexity = 30.0):\n \n # Check inputs\n if X.dtype != \"float64\":\n raise ValueError(\"array X should have type float64.\")\n #if no_dims.__class__ != \"<type 'int'>\": # doesn't work yet!\n # print \"Error: number of dimensions should be an integer.\";\n # return -1;\n \n # Initialize variables\n if X.shape[1] > initial_dims:\n print \"Reducing the dimensionality to %d\" %initial_dims\n X = pca(X, initial_dims);\n (n, d) = X.shape;\n max_iter = 1000;\n initial_momentum = 0.5;\n final_momentum = 0.8;\n eta = 500;\n min_gain = 0.01;\n Y = Math.random.randn(n, no_dims);\n dY = Math.zeros((n, no_dims));\n iY = Math.zeros((n, no_dims));\n gains = Math.ones((n, no_dims));\n \n # Compute P-values\n P = x2p(X, 1e-5, perplexity);\n P = P + Math.transpose(P);\n P = P / Math.sum(P);\n P = P * 4; # early exaggeration\n P = Math.maximum(P, 1e-12);\n \n # Run iterations\n for iter in range(max_iter):\n \n # Compute pairwise affinities\n sum_Y = Math.sum(Math.square(Y), 1); \n num = 1 / (1 + Math.add(Math.add(-2 * Math.dot(Y, Y.T), sum_Y).T, sum_Y));\n num[range(n), range(n)] = 0;\n Q = num / Math.sum(num);\n Q = Math.maximum(Q, 1e-12);\n \n # Compute gradient\n PQ = P - Q;\n for i in range(n):\n dY[i,:] = Math.sum(Math.tile(PQ[:,i] * num[:,i], (no_dims, 1)).T * (Y[i,:] - Y), 0);\n \n # Perform the update\n if iter < 20:\n momentum = initial_momentum\n else:\n momentum = final_momentum\n gains = (gains + 0.2) * ((dY > 0) != (iY > 0)) + (gains * 0.8) * ((dY > 0) == (iY > 0));\n gains[gains < min_gain] = min_gain;\n iY = momentum * iY - eta * (gains * dY);\n Y = Y + iY;\n Y = Y - Math.tile(Math.mean(Y, 0), (n, 1));\n \n # Compute current value of cost function\n if (iter + 1) % 10 == 0:\n C = Math.sum(P * Math.log(P / Q));\n print \"Iteration \", (iter + 1), \": error is \", C\n \n # Stop lying about P-values\n if iter == 100:\n P = P / 4;\n \n # Return solution\n return Y;","def adversarial_update(model, optimiser, loss_fn, x, y, epoch, eps, step, k, norm, **kwargs):\n model.train()\n\n # Adversial perturbation\n if norm == 'inf':\n x_adv = iterated_fgsm(model, x, y, loss_fn, k=k, step=step, eps=eps, norm='inf', random=args.random_start)\n elif norm == 2:\n x_adv = pgd(model, x, y, loss_fn, k=k, step=step, eps=eps, norm=2, random=args.random_start)\n else:\n raise ValueError('Unsupported norm')\n\n optimiser.zero_grad()\n y_pred = model(x_adv)\n loss = loss_fn(y_pred, y)\n loss.backward()\n optimiser.step()\n\n return loss, y_pred","def __optimizers(self, Gen_loss, D_A_loss, D_B_loss):\n def make_optimizer(loss, variables, name='Adam'):\n \"\"\" Adam optimizer with learning rate 0.0002 for the first 100k steps (~100 epochs)\n and a linearly decaying rate that goes to zero over the next 100k steps\n \"\"\"\n global_step = tf.Variable(0, trainable=False, name='global_step')\n starter_learning_rate = self.opt.lr\n end_learning_rate = 0.0\n start_decay_step = self.opt.niter\n decay_steps = self.opt.niter_decay\n beta1 = self.opt.beta1\n learning_rate = (tf.where(tf.greater_equal(global_step, start_decay_step),\n tf.train.polynomial_decay(starter_learning_rate,\n global_step-start_decay_step,\n decay_steps, end_learning_rate,\n power=1.0),\n starter_learning_rate))\n\n learning_step = (tf.train.AdamOptimizer(learning_rate, beta1=beta1, name=name)\n .minimize(loss, global_step=global_step, var_list=variables))\n\n return learning_step\n\n Gen_optimizer = make_optimizer(Gen_loss, self.G.variables + self.F.variables, name='Adam_Gen')\n D_A_optimizer = make_optimizer(D_A_loss, self.D_A.variables, name='Adam_D_A')\n D_B_optimizer = make_optimizer(D_B_loss, self.D_B.variables, name='Adam_D_B')\n\n with tf.control_dependencies([Gen_optimizer, D_A_optimizer, D_B_optimizer]):\n return tf.no_op(name='optimizers')","def tsd_alpha(s_1, s_2, p_1, p_2, w_1, w_2, alpha_concurrency):\n\n def calculate_cost(s1_idx, s2_idx):\n t_1 = p_1[s1_idx] + w_1[s1_idx]\n if t_1 > 0:\n b_1 = (p_1[s1_idx]/t_1)\n cost = ((b_1*np.abs(p_2[s2_idx]-p_1[s1_idx])) +\n ((1 - b_1)*np.abs(w_2[s2_idx]-w_1[s1_idx])))\n else:\n cost = 0\n return cost\n\n dist = {}\n lenstr1 = len(s_1)\n lenstr2 = len(s_2)\n for i in range(-1, lenstr1+1):\n dist[(i, -1)] = i+1\n for j in range(-1, lenstr2+1):\n dist[(-1, j)] = j+1\n for i in range(0, lenstr1):\n for j in range(0, lenstr2):\n if s_1[i] == s_2[j]:\n cost = calculate_cost(i, j)\n else:\n cost = 1\n dist[(i, j)] = min(\n dist[(i-1, j)] + 1, # deletion\n dist[(i, j-1)] + 1, # insertion\n dist[(i-1, j-1)] + cost # substitution\n )\n if i and j and s_1[i] == s_2[j-1] and s_1[i-1] == s_2[j]:\n if alpha_concurrency[(s_1[i], s_2[j])] == Rel.PARALLEL:\n cost = calculate_cost(i, j-1)\n dist[(i, j)] = min(dist[(i, j)], dist[i-2, j-2] + cost) # transposition\n return dist[lenstr1-1, lenstr2-1]","def dcca_objective(pred1, pred2, reg):\n\n H1 = torch.Tensor(pred1).t()\n H2 = torch.Tensor(pred2).t()\n\n o = H1.shape[0] # latent dimension\n m = H1.shape[1] # number of training samples\n ones = torch.ones(m, m)\n I = torch.eye(o, o) # identity matrix\n\n # centered data matrices\n H1_hat = H1.sub(torch.mul(H1.mm(ones), (1.0 / m)))\n H2_hat = H2.sub(torch.mul(H2.mm(ones), (1.0 / m)))\n\n SigmaHat12 = torch.mul(H1_hat.mm(torch.t(H2_hat)), 1.0 / (m - 1))\n SigmaHat11 = torch.add(torch.mul(H1_hat.mm(torch.t(H1_hat)), 1.0 / (m - 1)), torch.mul(reg, I))\n SigmaHat22 = torch.add(torch.mul(H2_hat.mm(torch.t(H2_hat)), 1.0 / (m - 1)), torch.mul(reg, I))\n\n # SVD decomposition for square root calculation\n U1, D1, V1 = torch.svd(SigmaHat11)\n U2, D2, V2 = torch.svd(SigmaHat22)\n # D1, V1 = torch.symeig(SigmaHat11, eigenvectors=True)\n # epsilon = 1e-12\n # D1_indices = torch.nonzero(D1.squeeze() > epsilon)\n # D1 = D1[D1_indices].squeeze()\n # V1 = V1[D1_indices].squeeze()\n #\n # D2, V2 = torch.symeig(SigmaHat22, eigenvectors=True)\n # D2_indices = torch.nonzero(D2.squeeze() > epsilon)\n # D2 = D2[D2_indices].squeeze()\n # V2 = V2[D2_indices].squeeze()\n #\n # # calculate root inverse of correlation matrices\n # SigmaHat11RootInv = V1.mm(torch.diag(torch.pow(D1, -0.5))).mm(torch.t(V1))\n # SigmaHat22RootInv = V2.mm(torch.diag(torch.pow(D2, -0.5))).mm(torch.t(V2))\n\n SigmaHat11RootInv = U1.mm(torch.diag(torch.pow(D1, -0.5))).mm(torch.t(V1))\n SigmaHat22RootInv = U2.mm(torch.diag(torch.pow(D2, -0.5))).mm(torch.t(V2))\n\n # Total correlation\n T = SigmaHat11RootInv.mm(SigmaHat12).mm(SigmaHat22RootInv)\n corr = torch.sqrt(torch.trace(torch.t(T).mm(T)))\n # corr = torch.trace(torch.sqrt(torch.t(T).mm(T)))\n\n # Gradient calculations\n U, D, V = torch.svd(T)\n\n Delta12 = SigmaHat11RootInv.mm(U).mm(torch.t(V)).mm(SigmaHat22RootInv)\n Delta11 = torch.mul(SigmaHat11RootInv.mm(U).mm(torch.diag(D)).mm(U.t()).mm(SigmaHat11RootInv), -0.5)\n Delta22 = torch.mul(SigmaHat22RootInv.mm(U).mm(torch.diag(D)).mm(U.t()).mm(SigmaHat22RootInv), -0.5)\n\n # dcorr(H1, H2) / dH1 and dcorr(H1, H2) / dH2\n dH1 = torch.mul(torch.mul(Delta11.mm(H1_hat), 2.0) + Delta12.mm(H2_hat), 1.0 / (m - 1))\n dH2 = torch.mul(torch.mul(Delta22.mm(H2_hat), 2.0) + Delta12.mm(H1_hat), 1.0 / (m - 1))\n\n return -corr, dH1.t(), dH2.t(), SigmaHat11RootInv.mm(U), SigmaHat22RootInv.mm(V)","def adam_optimizer(loss, initial_lr, decay_step, decay_rate):\n global_step = tf.train.get_or_create_global_step()\n lr = tf.train.exponential_decay(initial_lr, global_step, decay_step,\n decay_rate, staircase=True)\n\n optim = tf.train.AdamOptimizer(learning_rate=lr)\n global_step = tf.train.get_or_create_global_step()\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n\n with tf.control_dependencies(update_ops):\n train_op = optim.minimize(loss, global_step=global_step)\n\n return train_op","def run(self):\n is_spsa = True\n is_steep_descent = False\n is_rprop = False\n\n k = 0\n theta = self.theta0\n\n while True:\n k = k + 1\n\n self.iter = k\n print(f'starting iter {k} ...')\n\n if self.constraints is not None:\n theta = self.constraints(theta)\n\n print('current param:')\n for name, value in utils.true_param(theta).items():\n print(f' {name}: {value[\"value\"]}')\n\n c_k = self.c / (k ** self.gamma)\n a_k = self.a / ((k + self.A) ** self.alpha)\n\n # print(f' ck: {c_k:0.5f}')\n # print(f' ak: {a_k:0.5f}')\n\n # Run the engine match here to get the gradient\n print('Run engine match ...')\n gradient = self.approximate_gradient(theta, c_k, k)\n\n # For SPSA we update with a small step (theta = theta - a_k * gradient)\n if is_spsa:\n theta = utils.linear_combinaison(1.0, theta, -a_k, gradient)\n logging.info(f'{__file__} > theta from spsa: {theta}')\n # print(f'new param after application of gradient:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # For steepest descent we update via a constant small step in the gradient direction\n elif is_steep_descent:\n mu = -0.01 / max(1.0, utils.norm2(gradient))\n theta = utils.linear_combinaison(1.0, theta, mu, gradient)\n\n # For RPROP, we update with information about the sign of the gradients\n elif is_rprop:\n theta = utils.linear_combinaison(1.0, theta, -0.01, self.rprop(theta, gradient))\n\n # Apply parameter limits\n theta = utils.apply_limits(theta)\n logging.info(f'{__file__} > theta with limits: {theta}')\n # print(f'new param after application of limits:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # We then move to the point which gives the best average of goal\n (avg_goal, avg_theta) = self.average_best_evals(30)\n logging.info(f'{__file__} > avg_theta from average_best_evals: {avg_theta}')\n\n theta = utils.linear_combinaison(0.98, theta, 0.02, avg_theta)\n logging.info(f'{__file__} > theta with avg_theta: {theta}')\n # print(f'new param after application of best average param:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # Apply parameter limits\n theta = utils.apply_limits(theta) # This is the best param.\n logging.info(f'{__file__} > best param: {theta}')\n # print(f'new param after application of limits:')\n # for n, v in theta.items():\n # print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n # Log best param values\n for kv, vv in theta.items():\n logging.info(f'<best> iter: {k}, param: {kv}, value: {int(vv[\"value\"]*vv[\"factor\"])}')\n print('best param:')\n for n, v in theta.items():\n print(f' {n}: {int(v[\"value\"] * v[\"factor\"])}')\n\n mean_all_goal, _ = self.average_evaluations(30)\n print(f'mean all goal: {mean_all_goal}')\n\n mean_best_goal, _ = self.average_best_evals(30)\n print(f'mean best goal: {mean_best_goal}')\n\n # Save data in csv for plotting.\n plot_data = {}\n plot_data.update({'iter': k})\n plot_data.update({'meanbestgoal': mean_best_goal})\n plot_data.update({'meanallgoal': mean_all_goal})\n plot_theta = utils.true_param(theta)\n for name, value in plot_theta.items():\n plot_data.update({name: value[\"value\"]})\n\n with open(self.plot_data_file, 'a') as f:\n cnt = 0\n for name, value in plot_data.items():\n cnt += 1\n if cnt == len(plot_data):\n f.write(f'{value}\\n')\n else:\n f.write(f'{value},')\n\n print(f'done iter {k} / {self.max_iter}')\n logging.info(f'{__file__} > done iter {k} / {self.max_iter}')\n print('=========================================')\n\n # Stopping rule 1: Average goal and iteration meet the\n # stop_all_mean_goal and stop_min_iter criteria.\n if k >= self.stop_min_iter and mean_all_goal <= self.stop_all_mean_goal:\n print('Stop opimization due to good average all goal!')\n break\n\n # Stopping rule 2: Average best goal and iteration meet the\n # stop_best_mean_goal and stop_min_iter criteria.\n if k >= self.stop_min_iter and mean_best_goal <= self.stop_best_mean_goal:\n print('Stop opimization due to good average best goal!')\n break\n\n # Stopping rule 3: Max iteration is reached.\n if k >= self.max_iter:\n print('Stop opimization due to max iteration!')\n break\n\n return utils.true_param(theta)","def optimizer(self):\n \n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\n # I believe this is a work around to get keras to learn **given a gradient**\n # As opposed to bunch of x_train, y_trains?\n \n #Inputs\n state_pl = self.model.input\n action_grads_pl = K.placeholder(shape=(None,1)) \n \n #Find grad_(pars) mu(state)\n mu_pl = self.model.output\n pars = self.model.trainable_weights\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\n \n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\n\n # The gradients as defined above work on my mac, but not ubuntu.\n # Below I am trying a workaround. I changed the keras source code \n # To get this working. Specifically, I make the optimizer.get_updates()\n # function accept custom gradients. It was easy to do.\n \n opt = Adam(self.lr)\n loss = pars_grad_mu #placeholder, I won't use it\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\n\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])","def fit(self, X, y, X_validate, y_validate):\n \n iterate = 800\n \n self.SGD_theta_list = [0]*len(X[0])\n self.SGD_bias = 0\n\n SGD_cost_history = []\n SGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\n temp_X = []\n temp_X.append(X[selection])\n temp_y = []\n temp_y.append(y[selection])\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\n SGD_cost_history.append(SGD_cost)\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\n SGD_validate_cost_history.append(SGD_validate_cost)\n\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), SGD_cost_history)\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss SGD\")\n plt.show()\n \n \n self.BGD_theta_list = [0]*len(X[0])\n self.BGD_bias = 0\n\n BGD_cost_history = []\n BGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1)\n \n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\n\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\n BGD_cost_history.append(BGD_cost)\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\n BGD_validate_cost_history.append(BGD_validate_cost)\n\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), BGD_cost_history)\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss BGD\")\n plt.show()\n\n print(\"FINAL_SGD_TRAIN_LOSS\\n\",self.FINAL_SGD_TRAIN_LOSS)\n print(\"FINAL_SGD_VALIDATE_LOSS\\n\",self.FINAL_SGD_VALIDATE_LOSS)\n print(\"FINAL_BGD_TRAIN_LOSS\\n\",self.FINAL_BGD_TRAIN_LOSS)\n print(\"FINAL_BGD_VALIDATE_LOSS\\n\",self.FINAL_BGD_VALIDATE_LOSS)\n\n \n return self","def stochastic_gradient_descent(example: pd.Series,\n matrices: Matrices,\n word2onehot: Dict[str, int],\n learn_rate: float\n ) -> Matrices:\n \n # Get hidden layer (projection vector), positive context word, and \n # list of negative context words, all as vectors.\n proj_vector, c_positive, w_negative = (\n matrices.embedding[word2onehot[example['centre_word']]],\n matrices.context[word2onehot[example['context_word']]],\n [matrices.context[word2onehot[sample]]\n for sample in example['negative_samples']] \n )\n \n # Obtain vectors for updating gradients. \n embedding_gradient = (\n cost_derivation(proj_vector, c_positive, 1) + \n sum(cost_derivation(proj_vector, c_negative, 0)\n for c_negative in w_negative)\n )\n pos_context_gradient = cost_derivation(c_positive, proj_vector, 1)\n neg_context_gradients = (\n (c_negative, cost_derivation(c_negative, proj_vector, 0))\n for c_negative in w_negative \n )\n \n # Update parameters.\n proj_vector[:] = proj_vector - learn_rate*embedding_gradient \n c_positive[:] = c_positive - learn_rate*pos_context_gradient\n for c_negative, neg_context_gradient in neg_context_gradients:\n c_negative[:] = c_negative - learn_rate*neg_context_gradient \n \n return matrices","def compile(self, optimizer=tf.keras.optimizers.RMSprop,\n loss='mse',\n metrics=pearson_correlation_first,\n learning_rate=1e-3, **kwargs):\n if callable(optimizer):\n optimizer = optimizer(learning_rate=learning_rate)\n super(BrainModelLinearRegression, self).compile(\n optimizer=optimizer, loss=loss, metrics=metrics, **kwargs)","def test_sdp(self):\n a = sp.rand(100, 100, .1, random_state=1)\n a = a.todense()\n X = Variable(100, 100)\n obj = at.norm(X, \"nuc\") + at.norm(X-a, 'fro')\n p = Problem(Minimize(obj))\n p.solve(solver=\"SCS\")","def _resource_apply_dense(self, grad, var):\n\n assignments = []\n\n param_name = self._get_variable_name(var.name)\n\n m = self.get_slot(var, \"m\")\n v = self.get_slot(var, \"v\")\n\n # m = m.handle\n # v = v.handle\n # var = var.handle\n\n # Standard Adam update.\n next_m = (\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\n next_v = (\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\n tf.square(grad)))\n\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\n\n # Just adding the square of the weights to the loss function is *not*\n # the correct way of using L2 regularization/weight decay with Adam,\n # since that will interact with the m and v parameters in strange ways.\n #\n # Instead we want ot decay the weights in a manner that doesn't interact\n # with the m/v parameters. This is equivalent to adding the square\n # of the weights to the loss with plain (non-momentum) SGD.\n if self._do_use_weight_decay(param_name):\n update += self.weight_decay_rate * var\n\n ratio = 1.0\n if self._do_layer_adaptation(param_name):\n w_norm = linalg_ops.norm(var, ord=2)\n g_norm = linalg_ops.norm(update, ord=2)\n ratio = array_ops.where(math_ops.greater(w_norm, 0), array_ops.where(\n math_ops.greater(g_norm, 0), (w_norm / g_norm), 1.0), 1.0)\n\n update_with_lr = ratio * self.learning_rate * update\n\n next_param = var - update_with_lr\n\n assignments.extend(\n [var.assign(next_param, use_locking=self._use_locking),\n m.assign(next_m),\n v.assign(next_v)])\n return tf.group(*assignments)","def optimizer(\n optimizer,\n named_parameters,\n reduction: str = \"sum\",\n compression: str = \"none\",\n accumulate: int = 1,\n rank: int = 0,\n):\n\n optimizer = hvd.DistributedOptimizer(\n optimizer,\n named_parameters,\n _compression(compression),\n backward_passes_per_step=accumulate,\n op=_reduction(reduction),\n )\n\n hvd.broadcast_optimizer_state(optimizer, root_rank=rank)\n return optimizer","def experiment_linear_conv_ls(_):\n # Min dft1-norm solution found (norm=1.9895)\n adv_norm_type = 'dftinf'\n dual_norm_type = 'dft1'\n attack_step_dir = 'dftinf_sd' # 'dftinf'\n\n module_name = 'train'\n # log_dir = 'runs_linear_conv_ls_%s' % adv_norm_type\n log_dir = 'runs_linear_conv_ls_normfix_%s' % adv_norm_type\n exclude = '*'\n\n d_over_n = [1, 2, 4, 8, 16, 32] # separable >= 1\n dim = 100\n num_train = [int(dim / p) for p in d_over_n]\n\n # Config params\n shared_params = []\n shared_params += [\n ('config', './config.py'),\n ('seed', list(range(3))),\n ]\n\n # Data hyper-parameters\n shared_params += [\n ('temperature', 0.0001),\n ('num_test', 1), # 500\n ('dim', dim),\n ('num_train', num_train),\n ]\n\n # Adversarial configuration: test\n shared_params += nameit('adv', [\n ('norm_type', adv_norm_type),\n # ('lr', 0.1),\n ('niters', 1), # 10\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\n ('pre_normalize', True), # multi attacks\n ('post_normalize', True),\n ('eps_from_cvxpy', True),\n ('step_dir', attack_step_dir),\n ])\n\n # Logging to standard output\n shared_params += [\n ('log_interval', 10000), # 1000),\n ('log_keys', '\\'(\"%s\")\\'' % ('\",\"'.join([\n 'risk/train/zero_one',\n 'risk/train/adv/%s' % adv_norm_type,\n 'weight/linear/norm/%s' % dual_norm_type,\n 'margin/%s' % dual_norm_type,\n ]))),\n # Compare with cvxpy\n ('enable_cvxpy', True),\n ]\n\n # Model hyper-parameters\n conv_linear_params = nameit('model', [\n ('arch', 'conv_linear'),\n ('nlayers', 2),\n ('regularizer', 'none'),\n ])\n\n params = []\n\n # GD line search implicit bias\n gd_ls = nameit('optim', [\n ('name', 'gd_ls'),\n ('niters', 100000),\n ('bound_step', True),\n ])\n params += [OrderedDict(shared_params+conv_linear_params+gd_ls)]\n\n return params, log_dir, module_name, exclude","def test_SLearner(self):\n # Test constant treatment effect with multi output Y\n # Test heterogeneous treatment effect\n # Need interactions between T and features\n Y, T, X, _ = ihdp_surface_B()\n est = AutomatedSLearner(overall_model=automl_model_reg())\n\n est.fit(Y, T, X=X)\n _ = est.effect(X)\n\n # Test heterogeneous treatment effect with multi output Y","def DistributedOptimizer(optimizer, name=None, use_locking=False, device_dense='',\n device_sparse='', compression=Compression.none,\n sparse_as_dense=False, backward_passes_per_step=1,\n op=Average):\n if isinstance(optimizer, _LegacyOptimizer):\n if op == Adasum:\n raise ValueError('op == Adasum is not supported yet with ')\n else:\n if backward_passes_per_step > 1:\n raise ValueError('backward_passes_per_step>1 is not supported yet with '\n 'op != Adasum')\n return _DistributedOptimizer(optimizer, name, use_locking, device_dense,\n device_sparse, compression, sparse_as_dense, op)\n elif isinstance(optimizer, tf.keras.optimizers.Optimizer):\n if op == Adasum:\n raise ValueError('op == Adasum is not supported yet with Keras')\n if backward_passes_per_step > 1:\n raise ValueError('backward_passes_per_step > 1 is not supported yet with Keras')\n import byteps.tensorflow.keras as bps_k\n return bps_k.DistributedOptimizer(optimizer, name, device_dense, device_sparse,\n compression, sparse_as_dense)\n else:\n raise ValueError('Provided optimizer doesn\\'t inherit from either legacy '\n 'TensorFlow or Keras optimizer: %s' % optimizer)","def optimize_library_descent(self, target, direction='max', steps=100,\n multiprocessing=False, ret_info=False,\n args=None):\n # get the target function to call\n target_function = getattr(self, target)\n if args is not None:\n target_function = functools.partial(target_function, **args)\n\n # initialize the optimizer\n value = target_function()\n value_best, state_best = value, self.sens_mat.copy()\n \n if ret_info:\n # store extra information\n start_time = time.time()\n info = {'values': {}}\n values_count = self.parameters['optimizer_values_count']\n values_step = max(1, steps // values_count)\n \n if multiprocessing:\n # run the calculations in multiple processes\n pool_size = self.get_number_of_cores()\n pool = mp.Pool(processes=pool_size)\n if ret_info:\n values_step = max(1, values_step // pool_size)\n \n # iterate for given number of steps\n for step in range(int(steps) // pool_size):\n joblist = []\n init_arguments = self.init_arguments\n for _ in range(pool_size):\n # modify the current state and add it to the job list\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n params = init_arguments['parameters'] \n params['sensitivity_matrix'] = self.sens_mat\n params['initialize_state']['sensitivity'] = 'exact'\n \n joblist.append((copy.deepcopy(init_arguments), target))\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # run all the jobs\n results = pool.map(_run_job, joblist)\n \n # find the best result \n if direction == 'max':\n res_best = np.argmax(results)\n if results[res_best] > value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n elif direction == 'min':\n res_best = np.argmin(results)\n if results[res_best] < value_best:\n value_best = results[res_best]\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\n # use the best state as a basis for the next iteration\n self.sens_mat = state_best\n \n else:\n raise ValueError('Unsupported direction `%s`' % direction)\n \n if ret_info and step % values_step == 0:\n info['values'][step * pool_size] = results[res_best]\n \n else:\n # run the calculations in this process\n for step in range(int(steps)):\n # modify the current state\n i = random.randrange(self.sens_mat.size)\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n # get the value of the new state\n value = target_function()\n \n improved = ((direction == 'max' and value > value_best) or\n (direction == 'min' and value < value_best))\n if improved:\n # save the state as the new best value\n value_best, state_best = value, self.sens_mat.copy()\n else:\n # undo last change\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\n \n if ret_info and step % values_step == 0:\n info['values'][step] = value_best\n\n # sort the best state and store it in the current object\n state_best = self.sort_sensitivity_matrix(state_best)\n self.sens_mat = state_best.copy()\n\n if ret_info:\n info['total_time'] = time.time() - start_time \n info['states_considered'] = steps\n info['performance'] = steps / info['total_time']\n return value_best, state_best, info\n else:\n return value_best, state_best","def learn2_sgd():\n\n sgd.fit(vector_training,sentiment_training) ##fits the training data of vector tweets and sentiments using SGDClassifier\n correct = 0\n for i in range(vector_testing.shape[0]): ##using the testing, data see how accurate SGDC is\n prediction = sgd.predict(vector_testing[i])\n sentiment = sentiment_testing[i]\n if prediction[0] == sentiment:\n correct +=1\n \n accuracy = correct/vector_testing.shape[0]\n print('Stochastic Gradient Descent Classifier Testing Accuracy: {:.2f}'.format(accuracy)) ##prints the accuracy of the algorithm","def experiment_linear_conv(_):\n # Min dft1-norm solution found (norm=1.9895)\n adv_norm_type = 'dftinf'\n dual_norm_type = 'dft1'\n baseline_norm_types = ['l1', 'linf']\n attack_step_dir = 'dftinf_sd' # 'dftinf'\n\n module_name = 'train'\n log_dir = 'runs_linear_conv_%s' % adv_norm_type\n exclude = '*'\n\n d_over_n = [1, 2, 4, 8, 16, 32] # separable >= 1\n dim = 100\n num_train = [int(dim / p) for p in d_over_n]\n\n # Config params\n shared_params = []\n shared_params += [\n ('config', './config.py'),\n ('seed', list(range(3))),\n ]\n\n # Data hyper-parameters\n shared_params += [\n ('temperature', 0.0001),\n ('num_test', 1), # 500\n ('dim', dim),\n ('num_train', num_train),\n ]\n\n # Adversarial configuration: test\n shared_params += nameit('adv', [\n ('norm_type', adv_norm_type),\n # ('lr', 0.1),\n ('niters', 1), # 10\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\n ('pre_normalize', True), # multi attacks\n ('post_normalize', True),\n ('eps_from_cvxpy', True),\n ('step_dir', attack_step_dir),\n ])\n\n # Logging to standard output\n shared_params += [\n ('log_interval', 10000), # 1000),\n ('log_keys', '\\'(\"%s\")\\'' % ('\",\"'.join([\n 'risk/train/zero_one',\n 'risk/train/adv/%s' % adv_norm_type,\n 'weight/linear/norm/%s' % dual_norm_type,\n 'margin/%s' % dual_norm_type,\n ]))),\n # Compare with cvxpy\n ('enable_cvxpy', True),\n ]\n\n # No 0 regularization coefficient\n reg_coeff = [1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1]\n\n # Model hyper-parameters\n linear_noreg_model_params = nameit('model', [\n ('arch', 'linear'),\n ('regularizer', 'none'),\n ])\n linear_reg_model_params = nameit('model', [\n ('arch', 'linear'),\n ('regularizer', ['w_%s' % b for b in baseline_norm_types] +\n ['w_%s' % dual_norm_type]),\n ('reg_coeff', reg_coeff),\n ])\n deep_linear_params = nameit('model', [\n ('arch', 'deep_linear'),\n ('nlayers', 2),\n ('regularizer', 'none'),\n ])\n conv_linear_params = nameit('model', [\n ('arch', 'conv_linear'),\n ('nlayers', 2),\n ('regularizer', 'none'),\n ])\n\n params = []\n\n # cvxpy solution\n cvxpy_params = nameit('optim', [\n ('name', 'cvxpy'),\n ('norm', dual_norm_type),\n ('niters', 10000),\n ('lr', 0), # keep cvxpy sol fixed\n ])\n params += [OrderedDict(shared_params+linear_noreg_model_params+cvxpy_params)]\n\n # GD line search implicit bias\n gd_ls = nameit('optim', [\n ('name', 'gd_ls'),\n ('niters', 10000),\n ('bound_step', True),\n ])\n params += [OrderedDict(shared_params+deep_linear_params+gd_ls)]\n params += [OrderedDict(shared_params+conv_linear_params+gd_ls)]\n\n # CD, SignGD implicit bias\n cd_fixed_lr = nameit('optim', [\n ('name', ['cd', 'signgd']),\n ('niters', 10000),\n ('lr', [\n 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1,\n 3e-1, 1, 2, 3, 6, 9, 10, 20, 30, 50\n ]),\n ])\n params += [OrderedDict(shared_params+linear_noreg_model_params+cd_fixed_lr)]\n\n # Explicit regularization with line search\n explicit_reg = nameit('optim', [\n ('name', 'fista'),\n ('niters', 10000),\n ('bound_step', True),\n ('step_size', [1, 10, 100, 1000]),\n ])\n params += [OrderedDict(shared_params+linear_reg_model_params+explicit_reg)]\n\n # Adversarial training with line search\n adv_train_params = nameit('optim', [\n ('name', 'gd_ls'),\n ('niters', 10000),\n ('bound_step', True),\n ])\n adv_train_params += nameit('optim', nameit('adv_train', [\n ('enable', True),\n ('norm_type', adv_norm_type),\n # ('lr', 0.1),\n ('niters', 1), # niters, 1000\n ('pre_normalize', True),\n ('post_normalize', True),\n ('step_dir', attack_step_dir),\n ('eps_from_cvxpy', True),\n ]))\n params += [OrderedDict(\n shared_params+linear_noreg_model_params+adv_train_params)]\n\n return params, log_dir, module_name, exclude","def dcsolver(initial=\"dog\", goal=\"cat\", cost='steps'):\n problem = DC(initial, goal, cost)\n start = time.time()\n solution = astar_search(problem)\n elapsed = time.time() - start\n if solution:\n solution_path = path = ' '.join([node.state for node in solution.path()])\n solution_cost = solution.path_cost\n # show how much h() underestimated H-star. Should all be <= 0\n deltas = [rnd(node.path_cost + problem.h(node) - solution_cost) for node in solution.path()][:-1]\n else:\n solution_path = \"NO SOLUTION\"\n deltas = []\n solution_cost = -1\n print(f\"{problem} cost:{solution_cost:.2f}; time:{elapsed:.3f}; solution:{solution_path}; deltas:{deltas}\")","def sgdgc(cost, params, lr=1.0, max_magnitude=5.0, infDecay=0.1):\n grads = T.grad(cost=cost, wrt=params)\n updates = []\n\n norm = norm_gs(params, grads)\n sqrtnorm = T.sqrt(norm)\n #not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\n\n for p, g in zip(params, grads):\n #g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\n updates.append((p, p - lr * g * adj_norm_gs)) \n \n return updates, norm","def optimize(self):\n print(colored('starting optimization with ADAM...', 'cyan'))\n self.optimizer = torch.optim.Adam(self.net.parameters(), lr=self.args.lr)\n scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, mode='min',\n factor=self.args.lr_factor,\n threshold=self.args.lr_thresh,\n patience=self.args.lr_patience)\n # stop after no improvements greater than a certain percentage of the previous loss\n stopper = u.EarlyStopping(patience=self.args.earlystop_patience,\n min_delta=self.args.earlystop_min_delta,\n percentage=True)\n start = time()\n for j in range(self.args.epochs):\n self.optimizer.zero_grad()\n loss = self.optimization_loop()\n self.optimizer.step()\n if self.args.reduce_lr:\n scheduler.step(loss)\n if stopper.step(loss): # stopper is computed on loss, as we don't have any validation metrics\n break\n \n self.elapsed = time() - start\n print(colored(u.sec2time(self.elapsed), 'yellow'))","def experiment_linear_conv_constant_lr(_):\n # Min dft1-norm solution found (norm=1.9895)\n adv_norm_type = 'dftinf'\n dual_norm_type = 'dft1'\n attack_step_dir = 'dftinf_sd' # 'dftinf'\n\n module_name = 'train'\n # log_dir = 'runs_linear_conv_constant_lr_%s' % adv_norm_type\n log_dir = 'runs_linear_conv_constant_lr_normfix_%s' % adv_norm_type\n exclude = '*'\n\n # d_over_n = [1, 2, 4, 8, 16, 32] # separable >= 1\n d_over_n = [16, 32] # separable >= 1\n dim = 100\n num_train = [int(dim / p) for p in d_over_n]\n\n # Config params\n shared_params = []\n shared_params += [\n ('config', './config.py'),\n ('seed', list(range(3))),\n ]\n\n # Data hyper-parameters\n shared_params += [\n ('temperature', 0.0001),\n ('num_test', 1), # 500\n ('dim', dim),\n ('num_train', num_train),\n ]\n\n # Adversarial configuration: test\n shared_params += nameit('adv', [\n ('norm_type', adv_norm_type),\n # ('lr', 0.1),\n ('niters', 1), # 10\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\n ('pre_normalize', True), # multi attacks\n ('post_normalize', True),\n ('eps_from_cvxpy', True),\n ('step_dir', attack_step_dir),\n ])\n\n # Logging to standard output\n shared_params += [\n ('log_interval', 10000), # 1000),\n ('log_keys', '\\'(\"%s\")\\'' % ('\",\"'.join([\n 'risk/train/zero_one',\n 'risk/train/adv/%s' % adv_norm_type,\n 'weight/linear/norm/%s' % dual_norm_type,\n 'margin/%s' % dual_norm_type,\n ]))),\n # Compare with cvxpy\n ('enable_cvxpy', True),\n ]\n\n # Model hyper-parameters\n conv_linear_params = nameit('model', [\n ('arch', 'conv_linear'),\n ('nlayers', 2),\n ('regularizer', 'none'),\n ])\n\n params = []\n\n # Conv linear constant lr\n cd_fixed_lr = nameit('optim', [\n ('name', ['gd']),\n ('niters', 100000),\n ('lr', [\n 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1,\n 3e-1, 1, 2, 3, 6, 9, 10, 20, 30, 50\n ]),\n ])\n params += [OrderedDict(shared_params+conv_linear_params+cd_fixed_lr)]\n\n return params, log_dir, module_name, exclude","def tune(runner, kernel_options, device_options, tuning_options):\n\n #Bayesian Optimization strategy seems to need some hyper parameter tuning to\n #become better than random sampling for auto-tuning GPU kernels.\n\n #alpha, normalize_y, and n_restarts_optimizer are options to\n #https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessRegressor.html\n #defaults used by Baysian Optimization are:\n # alpha=1e-6, #1e-3 recommended for very noisy or discrete search spaces\n # n_restarts_optimizer=5,\n # normalize_y=True,\n\n #several exploration friendly settings are: (default is acq=\"ucb\", kappa=2.576)\n # acq=\"poi\", xi=1e-1\n # acq=\"ei\", xi=1e-1\n # acq=\"ucb\", kappa=10\n\n if not bayes_opt_present:\n raise ImportError(\"Error: optional dependency Bayesian Optimization not installed\")\n\n #defaults as used by Bayesian Optimization Python package\n acq = tuning_options.strategy_options.get(\"method\", \"poi\")\n kappa = tuning_options.strategy_options.get(\"kappa\", 2.576)\n xi = tuning_options.strategy_options.get(\"xi\", 0.0)\n init_points = tuning_options.strategy_options.get(\"popsize\", 5)\n n_iter = tuning_options.strategy_options.get(\"maxiter\", 25)\n\n tuning_options[\"scaling\"] = True\n\n results = []\n\n #function to pass to the optimizer\n def func(**kwargs):\n args = [kwargs[key] for key in tuning_options.tune_params.keys()]\n return -1.0 * minimize._cost_func(args, kernel_options, tuning_options, runner, results)\n\n bounds, _, _ = minimize.get_bounds_x0_eps(tuning_options)\n pbounds = OrderedDict(zip(tuning_options.tune_params.keys(),bounds))\n\n verbose=0\n if tuning_options.verbose:\n verbose=2\n\n optimizer = BayesianOptimization(f=func, pbounds=pbounds, verbose=verbose)\n\n optimizer.maximize(init_points=init_points, n_iter=n_iter, acq=acq, kappa=kappa, xi=xi)\n\n if tuning_options.verbose:\n print(optimizer.max)\n\n return results, runner.dev.get_environment()","def sdot_asgd(y, nu, C, x_sample, W = None):\n # if W == None: W = np.zeros(y.shape[0]) else: assert(W.shape[0] == y.shape[0])\n W = np.zeros(y.shape[0]) # (500, 0)\n W_tmp = np.copy(W)\n #source_density = dp.get_density_by_name(name_source) # Density of source distribution\n h_save = np.empty_like(0)\n # Print iteration status\n niter = np.shape(x_sample)[0]\n for t in range(niter):\n if (t+1) % 10000 == 0:\n print(\"Iteration: {}\".format(t+1))\n \n # Sample from source distribution\n #x = source_density.sample_from(1).numpy()\n x = x_sample[t]\n\n # Gradient Step\n r = np.sum(np.square(x-y) , axis=1) - W_tmp # |x-y|^2 - W_tmp (900, )\n indx_min = np.argmin(r)\n grad = np.copy(nu)\n grad[indx_min] = grad[indx_min] - 1 # (900, )\n\n # Evaluate empirical Reward\n r2 = np.sum(np.square(x-y) , axis=1) - W # |x-y|^2 - W_tmp (900, )\n h = np.min(r2) + np.dot(W,nu) \n h_save = np.hstack((h_save,h))\n\n # Gradient Ascent \n W_tmp = W_tmp + C/np.sqrt(t+1) *grad # t+1 because it starts from 0\n W = t/(t+1) *W + 1/(t+1)*W_tmp # t+1 because it starts from 0\n # W = W / np.max(np.abs(W)) \n\n return W, h_save","def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\n TrainingTarget, TestData, ValData):\n # Gradient Descent Solution for Linear Regression\n La = 2\n # learningRate = 0.01\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\n\n for i in range(0, 400):\n\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\n Delta_E_D = -np.dot(\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\n TRAINING_PHI[i])\n La_Delta_E_W = np.dot(La, W_Now)\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\n Delta_W = -np.dot(learningRate, Delta_E)\n W_T_Next = W_Now + Delta_W\n W_Now = W_T_Next\n\n #-----------------TrainingData Accuracy---------------------#\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\n\n #-----------------ValidationData Accuracy---------------------#\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\n\n #-----------------TestingData Accuracy---------------------#\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\n\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])","def __call__(self, input_or_adv, label=None, unpack=True):\n\n a = input_or_adv\n del input_or_adv\n del label\n del unpack\n\n x = a.unperturbed\n dtype = a.unperturbed.dtype\n min_, max_ = a.bounds()\n\n # flatten the input (and remember the shape)\n shape = x.shape\n n = x.size\n x = x.flatten()\n\n x0 = nprng.uniform(min_, max_, size=x.shape)\n bounds = [(min_, max_)] * n\n options = {\"maxiter\": 500}\n\n def fun(x, *args):\n \"\"\"Objective function with derivative\"\"\"\n distance = a.normalized_distance(x.reshape(shape))\n return distance.value, distance.gradient.reshape(-1)\n\n def eq_constraint(x, *args):\n \"\"\"Equality constraint\"\"\"\n _, is_adv = a.forward_one(x.reshape(shape).astype(dtype))\n if is_adv:\n return 0.0\n else:\n return 1.0\n\n constraints = [{\"type\": \"eq\", \"fun\": eq_constraint}]\n\n result = so.minimize(\n fun,\n x0,\n method=\"SLSQP\",\n jac=True,\n bounds=bounds,\n constraints=constraints,\n options=options,\n )\n\n a.forward_one(result.x.reshape(shape).astype(dtype))","def sgd_updates_adadelta(self, cost, rho=0.95, epsilon=1e-6, norm_lim=9,\n word_vec_name='Words'):\n updates = OrderedDict({})\n exp_sqr_grads = OrderedDict({})\n exp_sqr_ups = OrderedDict({})\n gparams = []\n for param in self.params:\n empty = np.zeros_like(param.get_value())\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),\n name=\"exp_grad_%s\" % param.name)\n gp = T.grad(cost, param)\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty),\n name=\"exp_grad_%s\" % param.name)\n gparams.append(gp)\n for param, gp in zip(self.params, gparams):\n exp_sg = exp_sqr_grads[param]\n exp_su = exp_sqr_ups[param]\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\n updates[exp_sg] = up_exp_sg\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\n stepped_param = param + step\n if (param.get_value(borrow=True).ndim == 2) and (param.name != 'Words'):\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\n scale = desired_norms / (1e-7 + col_norms)\n updates[param] = stepped_param * scale\n else:\n updates[param] = stepped_param \n return updates","def SP_init(train_data, test_data, n_cols, n_proxim_con, perm_thresh, perm_inc, perm_dec, min_overlap, n_winners, beta_boost, T_boost_speed, verbose, pixel_size):\n\n if(pixel_size == None):\n pixel_size = 28\n\n # Load MNIST data input_size (aka nn) of 256 or 1024\n input_size = len(train_data[1])\n # print(len(train_data[1]))\n\n # Initialize synapses and permanence arrays\n syn_index = np.random.randint(0, input_size, (n_cols, n_proxim_con))\n syn_array = np.zeros((n_cols, input_size), dtype=int)\n # syn_array[syn_index] = 1\n\n # Synapses array\n for i in range(n_cols):\n syn_array[i, syn_index[i]] = 1\n\n # syn_array = np.random.randint(0, 2, (n_cols, input_size))\n perm_array = np.random.uniform(0, 1, (n_cols, input_size))\n perm_array = syn_array * perm_array\n\n # Initialize empty SDR array\n # overlap_scores = np.zeros([1, n_cols])\n sdr_train_array = np.zeros((len(train_data), n_cols), dtype=int)\n sdr_test_array = np.zeros((len(test_data), n_cols), dtype=int)\n\n # Initialize empty boosting arrays; time-averaged activation level\n time_avg_act = np.zeros([1, n_cols])\n prev_time_avg_act = np.zeros([1, n_cols])\n boosting = np.ones([1, n_cols])\n\n # Initialize metric arrays\n sparse_train_array = np.zeros(([len(train_data), 1]))\n sparse_test_array = np.zeros(([len(test_data), 1]))\n\n # Main code\n train_en = True\n for epoch in range(0, 2):\n input_set = train_data\n if train_en == False:\n input_set = test_data\n\n for iter in range(0, len(input_set)):\n # Calculate overlap scores\n overlap_scores = np.dot((syn_array * (perm_array >= perm_thresh)), input_set[iter, :].transpose()) \\\n * boosting\n\n # Initialize SDR (activations of cols)\n sdr = np.zeros(([1, n_cols]), dtype=int)\n\n # Select the winners\n for i in range(n_winners):\n win_val = np.max(overlap_scores)\n win_index = np.argmax(overlap_scores)\n if(win_val >= min_overlap):\n sdr[0, win_index] = 1\n overlap_scores[0, win_index] = 0\n\n #num_wins = sum(sdr)\n #print('This is num_wins')\n #print(num_wins)\n\n # Calculating activation level current and then previous, a_bar(t) and a_bar(t-1)\n if iter >= T_boost_speed:\n time_avg_act = ((T_boost_speed - 1) * prev_time_avg_act + sdr) / T_boost_speed\n prev_time_avg_act = time_avg_act\n\n # Calculating mini column neighborhood\n recent_act = (1/abs(n_cols)) * np.sum(time_avg_act)\n\n # Calculate boosting for next time\n boosting = np.exp(-beta_boost * (time_avg_act - recent_act))\n\n if(train_en == True):\n # Update permanence values for learning -> Hebbian learning\n z = sdr.transpose() * syn_array\n polar_input = np.copy(input_set[iter, :])\n polar_input[polar_input == 1] = perm_inc\n polar_input[polar_input == 0] = perm_dec\n delta_perm = polar_input * z\n perm_array = perm_array + delta_perm\n perm_array[perm_array > 1] = 1\n perm_array[perm_array < 0] = 0\n\n # Add SDR to array and calculate metrics\n # Metrics include: sparseness\n if train_en == False:\n sdr_test_array[iter, :] = sdr\n sparse_test_array[iter, 0] = sparseness(n_cols, sdr)\n else:\n sdr_train_array[iter, :] = sdr\n sparse_train_array[iter, 0] = sparseness(n_cols, sdr)\n\n # You are set!!!\n\n if(verbose):\n pixel_sdr = int(n_cols**(0.5))\n # Plot the image\n sdr_image = np.reshape(sdr, (pixel_sdr, pixel_sdr))\n\n # Plot the image\n image = np.reshape(train_data[iter, :], (pixel_size, pixel_size))\n plt.figure(1)\n plt.subplot(211)\n plt.imshow(image, cmap='gray_r')\n plt.title('Train')\n\n # Plot the sdr\n plt.subplot(212)\n plt.imshow(sdr_image, cmap='gray_r')\n plt.title('SDR')\n plt.tight_layout()\n plt.show()\n if(iter % 10 == 0):\n print(iter)\n\n train_en = False\n return sdr_train_array, sdr_test_array, sparse_train_array, sparse_test_array","def sgd(self, training_data, epochs, batch_size, eta=0.01, lambda_r=0.2, verbose=False, test_data=None):\n stagnation_epochs = 5\n eta_divide_factor = 4\n eta_decrease_available = 4\n\n self.accuracies = np.zeros(epochs)\n self.costs = np.zeros(epochs)\n self.eta = eta\n self.lambda_r = lambda_r\n\n n = len(training_data)\n curr_stagnation = stagnation_epochs\n min_cost = float('inf')\n\n for idx, e in enumerate(range(epochs)):\n np.random.shuffle(training_data)\n batches = [np.array(training_data[k:k + batch_size], dtype=object)\n for k in range(0, len(training_data), batch_size)]\n\n for batch in batches:\n self.gradient_descent_step(batch, eta, lambda_r, n)\n\n self.costs[idx] = self.cost_func.prediction_cost(self.feed_forward([x_ for x_, y_ in training_data])[2],\n np.array([y_ for x_, y_ in training_data])) + \\\n self.weights_cost(n, self.lambda_r)\n\n if verbose:\n print('Epoch {} ended with cost {:.3f}'.format(e + 1, self.costs[idx]))\n\n min_cost = min(min_cost, self.costs[idx])\n\n if idx != 0:\n curr_stagnation = curr_stagnation - 1 if self.costs[idx] != min_cost else stagnation_epochs\n\n if curr_stagnation == 0:\n curr_stagnation = stagnation_epochs\n eta /= eta_divide_factor\n eta_decrease_available -= 1\n min_cost = float('inf')\n\n if eta_decrease_available < 0:\n if verbose:\n print('Eta decreased maximum available times, terminating')\n break\n\n if verbose:\n print('Decreasing eta to {:.5f}'.format(eta))\n\n if test_data:\n self.accuracies[idx] = self.metric.metric_value(self.predict([x_ for x_, y_ in test_data]),\n [y_ for x_, y_ in test_data])\n\n if verbose:\n self.plot_costs()\n\n if test_data:\n self.plot_metric_values()","def test_dc_lcsmodel_class():\n\n # Set the problem size.\n n = 1000\n p = 3\n\n # Define the test model\n TM = test.Model1(n,p)\n\n # Note: diff_A/diff_b do not require A/b as an input in this case,\n # but in the more general case they might.\n\n # Check the basic model calculations.\n theta = numpy.array((1., 0.1, 0.2, 0.1))\n A = TM.eval_A(theta)\n B = TM.eval_b(theta)\n\n dA_1 = TM.diff_A(A, theta, 0).todense()\n dA_2 = TM.diff_A(A, theta, 1).todense()\n dA_3 = TM.diff_A(A, theta, 2).todense()\n dA_4 = TM.diff_A(A, theta, 3).todense()\n Z = numpy.zeros_like(dA_1)\n \n dB_1 = TM.diff_b(B, theta, 0)\n dB_2 = TM.diff_b(B, theta, 1)\n dB_3 = TM.diff_b(B, theta, 2)\n dB_4 = TM.diff_b(B, theta, 3)\n z = numpy.zeros_like(dB_1)\n \n print \"dA/dtheta_1 check:\", numpy.allclose(dA_1, TM.A1.todense())\n print \"dA/dtheta_2 check:\", numpy.allclose(dA_2, TM.A2.todense())\n print \"dA/dtheta_3 check:\", numpy.allclose(dA_3, Z)\n print \"dA/dtheta_4 check:\", numpy.allclose(dA_4, Z)\n\n print \"db/dtheta_1 check:\", numpy.allclose(dB_1, z)\n print \"db/dtheta_2 check:\", numpy.allclose(dB_2, z)\n print \"db/dtheta_3 check:\", numpy.allclose(dB_3, TM.B1)\n print \"db/dtheta_4 check:\", numpy.allclose(dB_4, TM.B2)\n\n\n #\n # Test the lcs model class\n #\n\n gLCS = DC_LCSModel()\n gLCS.eval_A = TM.eval_A\n gLCS.eval_b = TM.eval_b\n gLCS.diff_A = TM.diff_A\n gLCS.diff_b = TM.diff_b\n \n gLCS.quiet=True\n gLCS.A_params_mask = numpy.array([True, True, False, False])\n gLCS.b_params_mask = numpy.array([False, False, True, True])\n\n x = gLCS.eval(theta)\n #print x.shape\n\n for k in range(p):\n print \"Primal solution for x_{}, matches spsolve calculation: {}\".\\\n format(k, numpy.allclose(x[:,k], spla.spsolve(A,B[:,k])))\n\n\n D = gLCS.jacobian(theta)\n\n # -- If theta[1]=0, and theta[2:3] are fixed, then there is an analytical\n # calculation for x(theta[0]), and in this case we can check the first\n # column of D.\n\n theta = numpy.array((5.1, 0, 1.2, 2.1))\n A = TM.eval_A(theta)\n B = TM.eval_b(theta)\n D = gLCS.jacobian(theta)\n\n for k in range(p):\n D_col_1 = -(1./theta[0]**2) * B[:,k]\n print \"First column of D_{} all close: {}\".\\\n format(k, numpy.allclose(D[k,:,0], D_col_1))\n\n\n # -- We'll use a numerical approximation to check the second column of D\n\n h = 0.000001\n theta = numpy.array((5.1, 1.1, 1.2, 2.1))\n dtheta = numpy.array((0., h, 0., 0.))\n A = TM.eval_A(theta)\n B = TM.eval_b(theta)\n x = gLCS.eval(theta)\n D = gLCS.jacobian(theta)\n\n A_dt = TM.eval_A(theta + dtheta)\n B_dt = TM.eval_b(theta + dtheta)\n\n for k in range(p):\n x_dt = spla.spsolve(A_dt, B_dt[:,k])\n D_col_2_num_approx = (x_dt - x[:,k])/h\n max_abs_err = numpy.max(numpy.abs(D[k,:,1] - D_col_2_num_approx))\n\n print \"Second column of D_{} all close: {}\".\\\n format(k, numpy.allclose(D[k,:,1], D_col_2_num_approx))\n \n print \"Max abs error in second column of D_{}: {}\".\\\n format(k, max_abs_err)\n \n\n # -- If theta[0] and theta[1] are fixed, A(theta) is determined, and A^{-1}\n # is fixed. With a little math you can analytically calculate the third\n # and fourth columns of D. In fact x(theta) is linear in theta[2] and\n # theta[3], but not in theta[0] and theta[1].\n\n theta = numpy.array((1., 0.1, 0.2, 0.1))\n A = TM.eval_A(theta)\n D = gLCS.jacobian(theta);\n\n for k in range(p):\n D_col_3 = spla.spsolve(A, TM.B1[:,k])\n\n print \"Third column of D_{} all close: {}\".\\\n format(k, numpy.allclose(D[k,:,2], D_col_3))\n\n\n for k in range(p):\n D_col_4 = spla.spsolve(A, TM.B2[:,k])\n \n print \"Fourth column of D_{} all close: {}\".\\\n format(k, numpy.allclose(D[k,:,3], D_col_4))","def _apply_dense(self, grad, var):\n\n assignments = []\n\n param_name = self._get_variable_name(var.name)\n\n m = self.get_slot(var, \"m\")\n v = self.get_slot(var, \"v\")\n\n # Standard Adam update.\n next_m = (\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\n next_v = (\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\n tf.square(grad)))\n\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\n\n # Just adding the square of the weights to the loss function is *not*\n # the correct way of using L2 regularization/weight decay with Adam,\n # since that will interact with the m and v parameters in strange ways.\n #\n # Instead we want ot decay the weights in a manner that doesn't interact\n # with the m/v parameters. This is equivalent to adding the square\n # of the weights to the loss with plain (non-momentum) SGD.\n if self._do_use_weight_decay(param_name):\n update += self.weight_decay_rate * var\n\n update_with_lr = self.learning_rate * update\n\n next_param = var - update_with_lr\n\n assignments.extend([var.assign(next_param, use_locking=self._use_locking),\n m.assign(next_m),\n v.assign(next_v)])\n return tf.group(*assignments)","def C2ST_NN_fit(S,y,N1,x_in,H,x_out,learning_rate_C2ST,N_epoch,batch_size,device,dtype):\r\n N = S.shape[0]\r\n if is_cuda:\r\n model_C2ST = ModelLatentF(x_in, H, x_out).cuda()\r\n else:\r\n model_C2ST = ModelLatentF(x_in, H, x_out)\r\n w_C2ST = torch.randn([x_out, 2]).to(device, dtype)\r\n b_C2ST = torch.randn([1, 2]).to(device, dtype)\r\n w_C2ST.requires_grad = True\r\n b_C2ST.requires_grad = True\r\n optimizer_C2ST = torch.optim.Adam(list(model_C2ST.parameters()) + [w_C2ST] + [b_C2ST], lr=learning_rate_C2ST)\r\n criterion = torch.nn.CrossEntropyLoss()\r\n f = torch.nn.Softmax()\r\n ind = np.random.choice(N, N, replace=False)\r\n tr_ind = ind[:np.int(np.ceil(N * 1))]\r\n te_ind = tr_ind\r\n dataset = torch.utils.data.TensorDataset(S[tr_ind, :], y[tr_ind])\r\n dataloader_C2ST = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)\r\n len_dataloader = len(dataloader_C2ST)\r\n for epoch in range(N_epoch):\r\n data_iter = iter(dataloader_C2ST)\r\n tt = 0\r\n while tt < len_dataloader:\r\n # training model using source data\r\n data_source = data_iter.next()\r\n S_b, y_b = data_source\r\n output_b = model_C2ST(S_b).mm(w_C2ST) + b_C2ST\r\n loss_C2ST = criterion(output_b, y_b)\r\n optimizer_C2ST.zero_grad()\r\n loss_C2ST.backward(retain_graph=True)\r\n # Update sigma0 using gradient descent\r\n optimizer_C2ST.step()\r\n tt = tt + 1\r\n if epoch % 100 == 0:\r\n print(criterion(model_C2ST(S).mm(w_C2ST) + b_C2ST, y).item())\r\n\r\n output = f(model_C2ST(S[te_ind, :]).mm(w_C2ST) + b_C2ST)\r\n pred = output.max(1, keepdim=True)[1]\r\n STAT_C2ST = abs(pred[:N1].type(torch.FloatTensor).mean() - pred[N1:].type(torch.FloatTensor).mean())\r\n return pred, STAT_C2ST, model_C2ST, w_C2ST, b_C2ST","def DynamicsCo(x, t, T0, alpha, cost_co, cost_ch, K_co, K_ch, n, r):\n y=np.zeros([np.size(x)])\n D=np.zeros([2]) \n #define fitnss\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \n #degradation\n deg=fmax*x[1]/(x[1]+Kd) \n #ODE of eco-evo dynamics\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r*(1-cost_co)*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\n y[2]=x[2]*(r*(1-cost_ch)*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\n \n return y","def get_cost_updates(self,learning_rate, beta=0.9):\n max_x = T.max(self.x)\n min_x = T.min(self.x)\n self.x = (self.x - min_x) / (max_x - min_x)\n y = self.get_hidden_values(self.x)\n z = self.get_reconstructed_input(y)\n # note : we sum over the size of a datapoint; if we are using\n # minibatches, L will be a vector, with one entry per\n # example in minibatch\n # L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)\n L_prime = T.sum(T.square(z - self.x), axis=1)\n # note : L is now a vector, where each element is the\n # cross-entropy cost of the reconstruction of the\n # corresponding example of the minibatch. We need to\n # compute the average of all these to get the cost of\n # the minibatch\n cost = T.mean(L_prime)\n\n # compute the gradients of the cost of the `dA` with respect\n # to its parameters\n gparams = T.grad(cost, self.params)\n # generate the list of updates\n updates = []\n for momen, gparm1 in zip(self.mom, gparams):\n updates.append((momen, momen * beta + (1 - beta) * gparm1))\n for param, momen in zip(self.params, self.mom):\n updates.append((param, param - learning_rate * momen))\n\n return (cost, updates)","def run_sgd(self, inputs, step_size=0.01, momentum=0.9, num_epoch=200,\r\n minibatch_size=100, l2_coef=1e-5, test_inputs=None,\r\n display=False):\r\n train_loss = []\r\n train_grad = []\r\n test_loss = []\r\n test_grad = []\r\n max_inputs = np.max(inputs) + 1.0\r\n max_test_inputs = np.max(test_inputs) + 1.0\r\n inputs = inputs / max_inputs\r\n test_inputs = test_inputs / max_test_inputs\r\n w = np.random.normal(loc=0.0, scale=0.2, size=self.net.params_number)\r\n self.net.set_weights(w)\r\n for i in range(num_epoch):\r\n first = 0\r\n dw = 0\r\n while first < inputs.shape[1]:\r\n step_input = inputs[:, first: first + minibatch_size]\r\n first += minibatch_size\r\n step_output = self.net.compute_outputs(step_input)\r\n loss = np.sum(np.abs(step_output - step_input), axis=0).mean()\r\n dz = np.sign(step_output - step_input)\r\n loss_grad = self.net.compute_loss_grad(dz)\r\n w = self.net.get_weights()\r\n l2_loss_grad = loss_grad + 2.0 * l2_coef * w\r\n learning_rate = step_size / (i + 1) ** 0.25\r\n dw = momentum * dw - learning_rate * l2_loss_grad\r\n w = w + dw\r\n self.net.set_weights(w)\r\n if first >= inputs.shape[1]:\r\n loss_grad_norm = math.sqrt(np.sum(l2_loss_grad ** 2))\r\n train_loss.append(loss)\r\n train_grad.append(loss_grad_norm)\r\n\r\n test_outputs = self.net.compute_outputs(test_inputs)\r\n loss2 = np.sum(np.abs(test_outputs - test_inputs),\r\n axis=0).mean()\r\n dz = np.sign(test_outputs - test_inputs)\r\n test_loss_grad = self.net.compute_loss_grad(dz)\r\n test_loss_grad_norm = math.sqrt(np.sum(test_loss_grad ** 2))\r\n test_loss.append(loss2)\r\n test_grad.append(test_loss_grad_norm)\r\n\r\n if display is True:\r\n print(loss)\r\n\r\n return {'train_loss': train_loss, 'train_grad': train_grad,\r\n 'test_loss': test_loss, 'test_grad': test_grad}","def update(self, dLds, alpha, beta):\n T = len(self.x)\n self.nodes.reset_error()\n self.igate.reset_error()\n self.fgate.reset_error()\n self.ogate.reset_error()\n dLdx = np.zeros((T, self.input_size))\n dLdc = np.zeros(self.hidden_size)\n for t in xrange(T-1, -1, -1):\n dLdpo = dLds[t] * self.h[t] * self.gatefun.derivate(self.o[t])\n # parameters for output gate\n self.ogate.dLdu += np.outer(dLdpo, self.x[t])\n self.ogate.dLdw += np.outer(dLdpo, self.s[t-1])\n self.ogate.dLdv += np.outer(dLdpo, self.c[t-1])\n dLds[t-1] += np.dot(self.ogate.w.T, dLdpo)\n dLdx[t] += np.dot(self.ogate.u.T, dLdpo)\n dLdc += np.dot(self.ogate.v.T, dLdpo)\n\n dLdc += dLds[t] * self.o[t] * self.acfun.derivate(self.h[t])\n dLdpi = dLdc * self.g[t] * self.gatefun.derivate(self.i[t])\n dLdpf = dLdc * self.c[t-1] * self.gatefun.derivate(self.f[t])\n dLdpg = dLdc * self.i[t] * self.acfun.derivate(self.g[t])\n dLdc = dLdc * self.f[t]\n # parameters for nodes in hidden layer\n self.nodes.dLdu += np.outer(dLdpg, self.x[t])\n self.nodes.dLdw += np.outer(dLdpg, self.s[t-1])\n dLds[t-1] += np.dot(self.nodes.w.T, dLdpg)\n dLdx[t] += np.dot(self.nodes.u.T, dLdpg)\n # parameters for input gate\n self.igate.dLdu += np.outer(dLdpi, self.x[t])\n self.igate.dLdw += np.outer(dLdpi, self.s[t-1])\n self.igate.dLdv += np.outer(dLdpi, self.c[t-1])\n dLds[t-1] += np.dot(self.igate.w.T, dLdpi)\n dLdx[t] += np.dot(self.igate.u.T, dLdpi)\n dLdc += np.dot(self.igate.v.T, dLdpi)\n # parameters for forget gate\n self.fgate.dLdu += np.outer(dLdpf, self.x[t])\n self.fgate.dLdw += np.outer(dLdpf, self.s[t-1])\n self.fgate.dLdv += np.outer(dLdpf, self.c[t-1])\n dLds[t-1] += np.dot(self.fgate.w.T, dLdpf)\n dLdx[t] += np.dot(self.fgate.u.T, dLdpf)\n dLdc += np.dot(self.fgate.v.T, dLdpf)\n if self.en_bias:\n self.nodes.dLdb += dLdpg\n self.igate.dLdb += dLdpi\n self.fgate.dLdb += dLdpf\n self.ogate.dLdb += dLdpo\n # update weight matrix of current hidden node\n self.nodes.update(alpha, beta)\n self.igate.update(alpha, beta)\n self.fgate.update(alpha, beta)\n self.ogate.update(alpha, beta)\n return dLdx","def CA_Algorithm(self, states, actions, rewards, next_states, terminals):\n states = states.reshape(-1, self.input_width)\n next_states = next_states.reshape(-1, self.input_width)\n update_rule = self.update_rule\n terminals = terminals.astype(np.float32)\n if (self.freeze_interval > 0 and\n self.update_counter % self.freeze_interval == 0):\n self.reset_q_hat()\n p_vals, next_p_vals = self.sess.run([self.p_vals, self.next_p_vals],{self.S: states, self.A: actions, self.R: rewards, self.S_: next_states, self.T: terminals})\n\n p_target = p_vals.copy()\n BestAct = np.argmax(np.sum(np.multiply(self.Z, next_p_vals),axis =2), axis = 1)\n terminals_false = np.ones_like(terminals)-terminals\n\n for batchIndex, r in enumerate(rewards):\n m = np.zeros(self.atoms)\n for j in range(self.atoms):\n Tau_z_j = np.clip(r + terminals_false[batchIndex][0]*self.discount * self.Z[j], self.Vmin, self.Vmax)\n b_j = float(Tau_z_j-self.Vmin)/self.delta_z\n l = math.floor(b_j)\n u = math.ceil(b_j)\n l_int = int(l)\n u_int = int(u)\n m[l_int] = m[l_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(u - b_j)\n m[u_int] = m[u_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(b_j - l)\n p_target[batchIndex,BestAct[batchIndex],:] = m\n\n _,loss = self.sess.run([self._train,self.loss], feed_dict={self.S: states, self.p_target: p_target})\n self.update_counter += 1\n return loss","def learn(self, lr_a, lr_l, lr_lag, lr_c, batch):\n\n # Adjust optimizer learning rates (decay)\n self._set_learning_rates(\n lr_a=lr_a, lr_alpha=lr_a, lr_l=lr_l, lr_labda=lr_lag, lr_c=lr_c\n )\n\n ################################################\n # Optimize (Lyapunov/Q) critic #################\n ################################################\n if self.use_lyapunov:\n # Get target Lyapunov value (Bellman-backup)\n a2_, _ = self.ga_(\n batch[\"s_\"]\n ) # NOTE (rickstaa): Target actions come from *current* *target* policy\n l_pi_targ = self.lc_(batch[\"s_\"], a2_)\n l_backup = (\n batch[\"r\"] + self._gamma * (1 - batch[\"terminal\"]) * l_pi_targ\n ) # The Lyapunov candidate\n\n # Compute Lyapunov Critic error gradients\n with tf.GradientTape() as l_tape:\n\n # Get current Lyapunov value\n l1 = self.lc(batch[\"s\"], batch[\"a\"])\n\n # Calculate Lyapunov *CRITIC* error\n # NOTE (rickstaa): The 0.5 multiplication factor was added to make the\n # derivation cleaner and can be safely removed without influencing the\n # minimization. We kept it here for consistency.\n l_error = 0.5 * tf.reduce_mean((l1 - l_backup) ** 2) # See eq. 7\n\n # Perform one gradient descent step for the Lyapunov critic\n l_grads = l_tape.gradient(l_error, self.lc.trainable_variables)\n self._l_train.apply_gradients(zip(l_grads, self.lc.trainable_variables))\n else:\n\n # Get target Q values (Bellman-backup)\n # NOTE (rickstaa): Here we use max-clipping instead of min-clipping used\n # in the SAC algorithm since we want to minimize the return.\n a2, logp_a2 = self.ga(\n batch[\"s_\"]\n ) # NOTE (rickstaa): Target actions come from *current* policy\n q1_pi_targ = self.q_1_(batch[\"s_\"], a2)\n q2_pi_targ = self.q_2_(batch[\"s_\"], a2)\n q_pi_targ = tf.maximum(\n q1_pi_targ, q2_pi_targ\n ) # Use max clipping to prevent overestimation bias.\n q_backup = batch[\"r\"] + self._gamma * (1 - batch[\"terminal\"]) * (\n q_pi_targ - self.alpha * logp_a2\n )\n\n # Compute the Q-Critic loss gradients\n with tf.GradientTape() as q_tape:\n # Get the current Q values\n q1 = self.q_1(batch[\"s\"], batch[\"a\"])\n q2 = self.q_2(batch[\"s\"], batch[\"a\"])\n\n # Calculate Q-critic loss\n loss_q1 = 0.5 * tf.reduce_mean(\n (q1 - q_backup) ** 2\n ) # See Haarnoja eq. 5\n loss_q2 = 0.5 * tf.reduce_mean((q2 - q_backup) ** 2)\n loss_q = loss_q1 + loss_q2\n\n # Perform one gradient descent step for the Q-critic\n q_grads = q_tape.gradient(loss_q, self._main_q_vars)\n self._q_train.apply_gradients(zip(q_grads, self._main_q_vars))\n\n ################################################\n # Optimize Gaussian actor ######################\n ################################################\n\n # Compute actor loss gradients\n with tf.GradientTape() as a_tape:\n\n # Retrieve log probabilities of batch observations based on *current*\n # policy\n pi, log_pis = self.ga(batch[\"s\"])\n\n # Compute actor loss\n if self.use_lyapunov:\n # Calculate the target Lyapunov value\n a2, _ = self.ga(\n batch[\"s_\"]\n ) # NOTE (rickstaa): Target actions come from *current* policy\n lya_l_ = self.lc(batch[\"s_\"], a2)\n\n # Compute Lyapunov Actor error\n self.l_delta = tf.reduce_mean(\n lya_l_ - tf.stop_gradient(l1) + self._alpha_3 * batch[\"r\"]\n ) # See eq. 11\n\n # Calculate actor loss\n a_loss = tf.stop_gradient(self.labda) * self.l_delta + tf.stop_gradient(\n self.alpha\n ) * tf.reduce_mean(\n log_pis\n ) # See eq. 12\n else:\n\n # Retrieve the current Q values\n q1_pi = self.q_1(\n batch[\"s\"], pi\n ) # NOTE (rickstaa): Actions come from *current* policy\n q2_pi = self.q_2(\n batch[\"s\"], pi\n ) # NOTE (rickstaa): Actions come from *current* policy\n q_pi = tf.maximum(q1_pi, q2_pi)\n\n # Calculate actor loss\n a_loss = tf.reduce_mean(\n tf.stop_gradient(self.alpha) * log_pis - q_pi\n ) # See Haarnoja eq. 7\n\n # Perform one gradient descent step for the Gaussian Actor\n a_grads = a_tape.gradient(a_loss, self.ga.trainable_variables)\n self._a_train.apply_gradients(zip(a_grads, self.ga.trainable_variables))\n\n ################################################\n # Optimize alpha (Entropy temperature) #########\n ################################################\n\n # Compute alpha loss gradients\n with tf.GradientTape() as alpha_tape:\n\n # Calculate alpha loss\n alpha_loss = -tf.reduce_mean(\n self.alpha * tf.stop_gradient(log_pis + self.target_entropy)\n ) # See Haarnoja eq. 17\n\n # Perform one gradient descent step for alpha\n alpha_grads = alpha_tape.gradient(alpha_loss, [self.log_alpha])\n self._alpha_train.apply_gradients(zip(alpha_grads, [self.log_alpha]))\n\n ################################################\n # Optimize labda (Lyapunov temperature) ########\n ################################################\n if self.use_lyapunov:\n\n # Compute labda loss gradients\n with tf.GradientTape() as lambda_tape:\n\n # Calculate labda loss\n # NOTE (rickstaa): Log_labda was used in the lambda_loss function\n # because using lambda caused the gradients to vanish. This is caused\n # since we restrict lambda within a 0-1.0 range using the clamp function\n # (see #38). Using log_lambda also is more numerically stable.\n labda_loss = -tf.reduce_mean(\n self.log_labda * tf.stop_gradient(self.l_delta)\n ) # See formulas under eq. 14\n\n # Perform one gradient descent step for labda\n lambda_grads = lambda_tape.gradient(labda_loss, [self.log_labda])\n self._lambda_train.apply_gradients(zip(lambda_grads, [self.log_labda]))\n\n ################################################\n # Update target networks and return ############\n # diagnostics. #################################\n ################################################\n\n # Update target networks\n self._update_targets()\n\n # Return diagnostics\n if self.use_lyapunov:\n return (\n self.labda,\n self.alpha,\n l_error,\n tf.reduce_mean(tf.stop_gradient(-log_pis)),\n a_loss,\n alpha_loss,\n labda_loss,\n )\n else:\n return (\n self.alpha,\n loss_q,\n tf.reduce_mean(tf.stop_gradient(-log_pis)),\n a_loss,\n alpha_loss,\n )","def sgd(self, data, iterations, learning_rate, initial_momentum, final_momentum, minibatch=10, \\\n\t\tannealing=None, max_epoch_without_improvement=30, early_stop=True, corruption=None):\n\t\t\n\t\tm = data.shape[1]\n\t\tdata = data.T\n\t\t\n\t\t###########################################################################################\n\t\t# Initialisation of the weights and bias\n\t\t\n\t\t# Copy the weights and biases into a state vector theta\n\t\tweights = []\n\t\tbiases = []\n\t\tfor jj in range(self.mid * 2):\n\t\t\tweights.append(copy.copy(self.layers[jj].weights))\n\t\t\tbiases.append(self.layers[jj].hidden_biases) \n\t\t\t\n\t\ttheta, indices, weights_shape, biases_shape = self._roll(weights, biases)\n\t\tdel weights, biases\n\t\t\n\t\t###########################################################################################\n\t\tv_mom = 0\n\t\tbest_cost = 1e8\n\t\t\n\t\tbatch_indices = np.arange(m)\n\t\tn_minibatches = np.int(np.ceil(m/minibatch))\n\t\t\n\t\tgamma = initial_momentum\n\t\t\n\t\tfor epoch in range(iterations):\n\t\t\tnp.random.shuffle(batch_indices)\t\t\t\n\t\t\tfor ibatch in range(n_minibatches+1):\n\t\t\t\tids = batch_indices[ibatch*minibatch:(ibatch+1)*minibatch]\n\t\t\t\tbatch = data[:,ids]\n\t\t\t\t\n\t\t\t\t_, thetan = self.cost(theta, indices, weights_shape, biases_shape,\n\t\t\t\t0, 0, 0, batch, corruption=corruption, cost_fct='cross-entropy', log_cost=False)\n\t\t\t\tv_mom = gamma * v_mom + learning_rate * thetan\n\t\t\t\ttheta -= v_mom\n\t\t\t\n\t\t\tactual = self.feedforward(data.T)\n\t\t\tcost = utils.cross_entropy(data.T, actual)\n\t\t\tprint 'Epoch %4d/%4d:\\t%e' % (epoch+1, iterations, cost)\n\n\t\t\tself.train_history.append(cost)\n\t\t\t\n\t\t\tif cost <= best_cost :\n\t\t\t\tbest_cost = cost\n\t\t\t\titer_best = epoch\n\t\t\t\t\n\t\t\tif epoch - iter_best > max_epoch_without_improvement :\n\t\t\t\tprint 'STOP: %d epoches without improvment' % max_epoch_without_improvement\n\t\t\t\tbreak\n\t\t\t\n\t\t\t\n\t\t\tif annealing is not None:\n\t\t\t\tlearning_rate /= (1. + float(epoch) / annealing)\n\t\t\t\t\n\t\t\tif epoch > 100:\n\t\t\t\tgamma = final_momentum\n\t\t\telse:\n\t\t\t\tgamma = initial_momentum + (final_momentum - initial_momentum) * utils.sigmoid(epoch - 50)\n\t\t\tprint learning_rate, gamma\n\t\t\t\n\t\t###########################################################################################\n\t\t# Unroll the state vector and saves it to self.\t\n\t\tfor jj in range(self.mid * 2):\n\t\t\tw, b = self._unroll(theta, jj, indices, weights_shape, biases_shape)\n\t\t\t\n\t\t\tself.layers[jj].weights = w\n\t\t\tself.layers[jj].hidden_biases = b\n\t\t\t\n\t\t# We're done !\n\t\tself.is_trained = True","def update_critics(self, s, a, r, t, s_):\n q1_loss, q2_loss = self.cal_critic_loss(s, a, r, t, s_)\n\n self.critic1_optimiser.zero_grad()\n q1_loss.backward()\n self.critic1_optimiser.step()\n\n self.critic2_optimiser.zero_grad()\n q2_loss.backward()\n self.critic2_optimiser.step()","def _stochastic_gradient_descent(self, X, y, lr, epochs, sample_rate):\n\n # Initialize the bias and weights.\n m, n = X.shape\n self.bias = 0\n self.weights = np.random.normal(size=n)\n\n n_sample = int(m * sample_rate)\n for i in range(epochs):\n for idx in choice(range(m), n_sample, replace=False):\n # Calculate the gradient delta of each sample\n grad_bias, grad_weights = self._get_gradient(X[idx], y[idx])\n\n # Update the bias and weight by gradient of current sample\n self.bias += lr * grad_bias\n self.weights += lr * grad_weights\n\n # Show the gradient of each epoch.\n grad_bias, grad_weights = self._get_gradient(X, y)\n grad = (grad_bias + grad_weights.mean()) / 2\n print(\"Epochs %d gradient %.3f\" % (i + 1, grad), flush=True)","def sorm(func, dist_list, init_search_point, alg): \n def SLSQP(func, dist_list, init_search_point):\n \n dim = len(dist_list)\n current_beta = 0\n new_beta = 1\n sig = np.empty((1, dim))\n mu = np.empty((1, dim))\n new_search_point = np.array(init_search_point).reshape((1, dim))\n \n def f_l(x_l):\n return(func([x_l[i,:]*sig[0,i] + mu[0,i] for i in range(0, dim)]))\n \n while abs(current_beta-new_beta) > 0.001:\n current_search_point = new_search_point\n current_beta = new_beta\n for i in range(0, dim):\n if dist_list[i][1] != 'norm':\n mu[0,i], sig[0, i] = Rosenblatt_Transform(dist_list[i][0], current_search_point[0,i])\n else:\n mu[0,i], sig[0, i] = dist_list[i][0].mean(), dist_list[i][0].std()\n \n dist_fun = lambda u: np.linalg.norm(u) \n \n alg = 'SLSQP'\n \n H = lambda u: f_l(u)\n cons = ({'type': 'eq', 'fun': lambda u: -(H(u.reshape(-1,1)))})\n \n result = scipy.optimize.minimize(dist_fun, x0 = current_search_point, constraints = cons, method=alg)\n \n new_beta = result.fun\n u = np.array(result.x).reshape((1,dim))\n \n new_search_point = np.empty((1, dim))\n for i in range(0, dim):\n new_search_point[0,i] = mu[0,i] + u[0,i]*sig[0,i]\n \n beta_value = new_beta \n p_f = sst.norm.cdf(-beta_value)\n iterations = result.nit\n u = result.x\n x = u[:]*sig[0,:] + mu[0,:]\n grad_val = scipy.optimize.approx_fprime(x, func, 0.00000001)\n grad_val = grad_val.reshape((1, dim))\n \n sum1 = np.sum((grad_val[0,:]**2)*(sig[0,:]**2))\n cosines = np.empty((1, dim))\n \n for i in range(0, dim):\n cosines[0,i] = grad_val[0,i]*sig[0,i]/np.sqrt(sum1) \n \n return(beta_value, p_f, x, u, mu, sig, cosines, iterations) \n \n def HL_R(func, dist_list, init_search_point):\n \n iterations = 0\n cur_beta = 3\n new_beta = 0\n dim = len(dist_list)\n global_mean_arr = np.empty((1, dim))\n global_std_arr = np.empty((1, dim))\n new_search_point = np.array(init_search_point).reshape((1, dim))\n \n while abs(cur_beta - new_beta) > 0.001:\n cur_beta = new_beta\n cur_cosines = np.zeros((1, dim))\n new_cosines = np.ones((1, dim))\n \n while max((abs(cur_cosines - new_cosines))[0]) > 0.005:\n \n cur_cosines = new_cosines\n \n cur_search_point = new_search_point\n \n for i in range(0, dim):\n if dist_list[i][1] != 'norm':\n global_mean_arr[0, i], global_std_arr[0, i] = Rosenblatt_Transform(dist_list[i][0], cur_search_point[0,i])\n else:\n global_mean_arr[0, i], global_std_arr[0, i] = dist_list[i][0].mean(), dist_list[i][0].std()\n \n \n grad_val = scipy.optimize.approx_fprime(cur_search_point[0], func, 0.00000001)\n grad_val = grad_val.reshape((1, dim))\n \n sum1 = np.sum((grad_val[0,:]**2)*(global_std_arr[0,:]**2))\n cosines = np.empty((1, dim))\n \n for i in range(0, dim):\n cosines[0,i] = grad_val[0,i]*global_std_arr[0,i]/np.sqrt(sum1)\n \n new_cosines = cosines\n new_search_point = np.empty((1, dim))\n for i in range(0, dim):\n new_search_point[0,i] = global_mean_arr[0,i] - new_cosines[0,i]*global_std_arr[0,i]*cur_beta\n \n iterations = iterations + 1\n \n \n B = Symbol('B')\n coordinates = []\n for i in range(0, dim):\n coordinates.append(global_mean_arr[0, i] - new_cosines[0,i]*global_std_arr[0, i]*B)\n new_beta = float(solve(func(coordinates), B)[0])\n \n cosines = new_cosines \n beta_value = new_beta\n p_f = sst.norm.cdf(-new_beta)\n x = new_search_point\n u = (x[0,:] - global_mean_arr[0,:])/global_std_arr\n \n return(beta_value, p_f, x, u, global_mean_arr, global_std_arr, cosines, iterations)\n \n def HL_RF(func, dist_list, init_search_point):\n\n cur_beta = 3\n new_beta = 0\n dim = len(dist_list)\n\n new_search_point = np.array(init_search_point).reshape((1, dim))\n iterations = 0\n while abs(cur_beta - new_beta) > 0.001 and abs(func(new_search_point[0])) > 0.001:\n global_mean_arr = np.empty((1, dim))\n global_std_arr = np.empty((1, dim))\n cur_beta = new_beta\n cur_search_point = new_search_point\n \n for i in range(0, dim):\n if dist_list[i][1] != 'norm':\n global_mean_arr[0,i], global_std_arr[0, i] = Rosenblatt_Transform(dist_list[i][0], cur_search_point[0,i])\n else:\n global_mean_arr[0,i], global_std_arr[0, i] = dist_list[i][0].mean(), dist_list[i][0].std()\n \n f_val = func(cur_search_point[0])\n \n x_ast = np.empty((1, dim))\n for i in range(0, dim):\n x_ast[0,i] =(cur_search_point[0,i] - global_mean_arr[0,i])/global_std_arr[0,i]\n\n grad_val = scipy.optimize.approx_fprime(cur_search_point[0], func, 0.000001)\n grad_val = grad_val.reshape((1, dim)) \n \n grad_val_ast = np.empty(grad_val.shape)\n for i in range(0, dim):\n grad_val_ast[0,i] = grad_val[0,i]*global_std_arr[0,i]\n \n t1 = 1/np.sum(grad_val_ast[0,:]**2)\n\n t2 = sum(grad_val_ast[0,:]*x_ast[0,:]) - f_val\n \n t3 = t1*t2\n \n new_x_ast = np.empty(x_ast.shape)\n for i in range(0, dim):\n new_x_ast[0,i] = t3*grad_val_ast[0,i]\n u = new_x_ast\n new_beta = np.linalg.norm(new_x_ast)\n \n new_search_point = np.empty((1, dim))\n for i in range(0, dim):\n new_search_point[0,i] = new_x_ast[0,i]*global_std_arr[0,i] + global_mean_arr[0,i]\n iterations = iterations + 1\n \n grad_val_ast_sum = sum(grad_val_ast[0,:]**2)\n cosines = grad_val_ast/(grad_val_ast_sum**0.5)\n beta_value = new_beta\n x = new_search_point\n p_f = sst.norm.cdf(-beta_value)\n \n return(beta_value, p_f, x, u, global_mean_arr, global_std_arr, cosines, iterations)\n \n if alg == 'slsqp':\n beta_value, p_f, x, u, mu, sig, cosines, iterations = SLSQP(func, dist_list, init_search_point)\n elif alg == 'HL-R':\n beta_value, p_f, x, u, mu, sig, cosines, iterations = HL_R(func, dist_list, init_search_point)\n elif alg == 'HL-RF':\n beta_value, p_f, x, u, mu, sig, cosines, iterations = HL_RF(func, dist_list, init_search_point)\n \n d = len(dist_list)\n\n R0 = np.eye(d)\n \n for i in range(0, d):\n R0[-1,i] = cosines[0,i]\n \n Q, R = scipy.linalg.rq(R0)\n \n def f_l(x_l):\n return(func([x_l[i]*sig[0,i] + mu[0,i] for i in range(0, d)]))\n \n x = np.array(x).reshape((1, -1))\n u = x[0,:]*sig[0,:] + mu[0,:]\n \n H = nd.Hessian(f_l)(u)\n \n grad_val_standard = (scipy.optimize.approx_fprime(x[0], func, 0.00000001)[:])*(sig[0,:])\n \n dist_standard = np.linalg.norm(grad_val_standard)\n \n A_1 = 1/dist_standard\n R_transp = np.transpose(R)\n A_2 = R.dot(H)\n A_3 = A_2.dot(R_transp)\n \n A = A_3.dot(A_1)\n \n A = A[0:-1, 0:-1]\n \n k = np.linalg.eig(A)[0]\n \n prod_arr = np.empty((1, len(k)))\n for i in range(0, len(k)):\n prod_arr[0,i] = (1 + beta_value*k[i])**-0.5\n \n p_f_sorm = p_f*np.prod(prod_arr)\n beta_sorm = -1*scipy.stats.norm.ppf(p_f_sorm)\n \n print('-------------------------')\n print('Second-Order Reliability Analysis')\n print('Algorithm:',alg,'solver')\n print('Iterations: {}\\nReliability index = {}\\nProbability of failure = {}'.format(iterations, beta_sorm, p_f_sorm))\n print('-------------------------')\n \n return(beta_sorm, p_f_sorm)","def _resource_apply_dense(self, grad, var):\n\n assignments = []\n\n param_name = self._get_variable_name(var.name)\n\n m = self.get_slot(var, \"m\")\n v = self.get_slot(var, \"v\")\n\n # Standard Adam update.\n next_m = (\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\n next_v = (\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\n tf.square(grad)))\n\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\n\n # Just adding the square of the weights to the loss function is *not*\n # the correct way of using L2 regularization/weight decay with Adam,\n # since that will interact with the m and v parameters in strange ways.\n #\n # Instead we want ot decay the weights in a manner that doesn't interact\n # with the m/v parameters. This is equivalent to adding the square\n # of the weights to the loss with plain (non-momentum) SGD.\n if self._do_use_weight_decay(param_name):\n update += self.weight_decay_rate * var\n\n update_with_lr = self.learning_rate * update\n\n next_param = var - update_with_lr\n\n assignments.extend([var.assign(next_param, use_locking=self._use_locking),\n m.assign(next_m),\n v.assign(next_v)])\n return tf.group(*assignments)","def least_squares_SGD(y, tx, initial_w, max_iters, gamma, batch_size=10, verbose=False):\n return stochastic_gradient_descent(y, tx, initial_w, max_iters, gamma, compute_mse, \n compute_mse_gradient, batch_size=batch_size, verbose=verbose)","def SSC_test():\n \n # generating data\n\n D = 40 # Dimension of ambient space\n k = 4 # Number of subspaces\n d = 1\n N = 90 # Number of points in subspaces\n # Generating N points in d dim. subspaces\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\n for _ in range(k)]\n X = np.concatenate(Xi, axis=1)\n\n # Generating the ground-truth for evaluating clustering results\n lbls = [i * np.ones([1, N]) for i in range(k)]\n s = np.concatenate(lbls, axis=1)\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\n K = 0 #max(d1, d2)\n if Cst == 1:\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\n\n Xp = DataProjection(X, r, 'NormalProj')\n \n # testing clustering\n \n '''\n # using wrapper function\n Grps, sc = sparseSubspaceClustering(\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n '''\n \n '''\n # calling internal tools\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\n # Make small values 0\n eps = np.finfo(float).eps\n CMat[np.abs(CMat) < eps] = 0\n\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\n\n if Fail == False:\n CKSym = BuildAdjacency(CMatC, K)\n Grps = SpectralClustering(CKSym, n)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n else:\n print(\"Something failed\")\n '''\n \n labels, _, __ = KSubspaces(Xp.T, k, d)\n labels = BestMap(s, labels)\n Missrate = float(np.sum(s != labels)) / s.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))","def SynchronousSGDOptimizer(optimizer,\n nccl=False,\n nccl_fusion=False,\n hierarchical_nccl=False,\n monitor=False,\n name=None,\n use_locking=False,\n with_keras=False):\n sync_sgd_algo = _SynchronousSGD(nccl=nccl,\n nccl_fusion=nccl_fusion,\n hierarchical_nccl=hierarchical_nccl,\n monitor=monitor)\n if with_keras:\n return _create_kungfu_keras_optimizer(optimizer, sync_sgd_algo)\n else:\n return _create_kungfu_optimizer(optimizer, sync_sgd_algo, name,\n use_locking)","def test_ccsd_doubles(parthole_drudge):\n\n dr = parthole_drudge\n p = dr.names\n\n a, b, c, d = p.V_dumms[:4]\n i, j = p.O_dumms[:2]\n u = dr.two_body\n t = IndexedBase('t')\n dr.set_dbbar_base(t, 2)\n\n tensor = dr.define_einst(\n IndexedBase('r')[a, b, i, j],\n t[c, d, i, j] * u[a, b, c, d] + u[a, b, c, d] * t[c, i] * t[d, j]\n )\n targets = [tensor]\n\n all_eval_seq = optimize(\n targets, substs={p.nv: p.no * 10},\n strategy=Strategy.ALL | Strategy.SUM | Strategy.COMMON\n )\n\n assert verify_eval_seq(all_eval_seq, targets)\n assert len(all_eval_seq) == 2\n all_cost = get_flop_cost(all_eval_seq)\n\n best_eval_seq = optimize(\n targets, substs={p.nv: p.no * 10},\n strategy=Strategy.BEST | Strategy.SUM | Strategy.COMMON\n )\n assert verify_eval_seq(best_eval_seq, targets)\n assert len(best_eval_seq) == 2\n best_cost = get_flop_cost(best_eval_seq)\n\n assert (best_cost - all_cost).xreplace({p.no: 1, p.nv: 10}) > 0","def adam_optimizer() -> mt.HyperparameterConfig:\n # Create a dict of hyperparameters and their feasible ranges\n hyperparam_dict = {\n # ADAM optimization hyperparameters\n # Ref: Kingma, Diederik P., and Jimmy Ba.\n # \"Adam: A method for stochastic optimization.\" (2014).\n # log10 of alpha1 := 1 - beta1\n 'log_alpha1': -1.5,\n # log10 of alpha2 := 1 - beta2\n 'log_alpha2': -2.1,\n # log10 of epsilon\n 'log_epsilon': -7.,\n # Other hyperparameters\n # Minimum value for the voxel weights in the summed xentropy op\n 'weight_floor': 0.01,\n\n # Exponential learning rate decay hyperparams\n # log10 of the learning rate\n 'log_learning_rate': -3.,\n # log10 of the number of Decay steps\n 'log_decay_steps': 3.4,\n # Exponential decay rate\n 'exponential_decay_rate': 0.75\n }\n\n return mt.HyperparameterConfig(hyperparam_dict)","def run_sda(datasets=None, batch_size=100,\n window_size=7, n_principle=4,\n pretraining_epochs=2000, pretrain_lr=0.02,\n training_epochs=10000, finetune_lr=0.008, \n hidden_layers_sizes=[310, 100], corruption_levels = [0., 0.]):\n \n print 'finetuning learning rate=', finetune_lr\n print 'pretraining learning rate=', pretrain_lr\n print 'pretraining epoches=', pretraining_epochs\n print 'fine tuning epoches=', training_epochs\n print 'batch size=', batch_size\n print 'hidden layers sizes=', hidden_layers_sizes\n print 'corruption levels=', corruption_levels\n\n # compute number of minibatches for training, validation and testing\n n_train_batches = datasets[0][0].get_value(borrow=True).shape[0]\n n_train_batches /= batch_size\n\n # numpy random generator\n numpy_rng = numpy.random.RandomState(89677)\n print '... building the model'\n # construct the stacked denoising autoencoder class\n sda = SdA(numpy_rng=numpy_rng, n_ins=datasets[0][0].get_value(borrow=True).shape[1],\n hidden_layers_sizes=hidden_layers_sizes,\n n_outs=gnd_img.max())\n\n ################################################################################\n # PRETRAINING THE MODEL #\n #########################\n\n print '... getting the pretraining functions'\n pretraining_fns = sda.pretraining_functions(train_set_x=datasets[0][0],\n batch_size=batch_size)\n\n print '... pre-training the model'\n start_time = time.clock()\n ## Pre-train layer-wise\n for i in xrange(sda.n_layers):\n # go through pretraining epochs\n for epoch in xrange(pretraining_epochs):\n # go through the training set\n c = []\n for batch_index in xrange(n_train_batches):\n c.append(pretraining_fns[i](index=batch_index,\n corruption=corruption_levels[i],\n lr=pretrain_lr))\n \n if epoch % 100 == 0:\n print 'Pre-training layer %i, epoch %d, cost ' % (i, epoch),\n print numpy.mean(c)\n\n end_time = time.clock()\n\n print >> sys.stderr, ('The pretraining code for file ' +\n os.path.split(__file__)[1] +\n ' ran for %.2fm' % ((end_time - start_time) / 60.))\n\n ################################################################################\n # FINETUNING THE MODEL #\n ########################\n\n # get the training, validation and testing function for the model\n print '... getting the finetuning functions'\n train_fn, validate_model, test_model = sda.build_finetune_functions(\n datasets=datasets, batch_size=batch_size,\n learning_rate=finetune_lr)\n\n print '... finetunning the model'\n # early-stopping parameters\n patience = 100 * n_train_batches # look as this many examples regardless\n patience_increase = 2. # wait this much longer when a new best is\n # found\n improvement_threshold = 0.995 # a relative improvement of this much is\n # considered significant\n validation_frequency = min(10 * n_train_batches, patience / 2)\n # go through this many\n # minibatche before checking the network\n # on the validation set; in this case we\n # check every epoch\n\n best_params = None\n best_validation_loss = numpy.inf\n test_score = 0.\n start_time = time.clock()\n\n done_looping = False\n epoch = 0\n\n while (epoch < training_epochs) and (not done_looping):\n epoch = epoch + 1\n for minibatch_index in xrange(n_train_batches):\n minibatch_avg_cost = train_fn(minibatch_index)\n iter = (epoch - 1) * n_train_batches + minibatch_index\n\n if (iter + 1) % validation_frequency == 0:\n validation_losses = validate_model()\n this_validation_loss = numpy.mean(validation_losses)\n print('epoch %i, minibatch %i/%i, validation error %f %%' %\n (epoch, minibatch_index + 1, n_train_batches,\n this_validation_loss * 100.))\n\n # if we got the best validation score until now\n if this_validation_loss < best_validation_loss:\n # improve patience if loss improvement is good enough\n if (this_validation_loss < best_validation_loss *\n improvement_threshold):\n patience = max(patience, iter * patience_increase)\n\n # save best validation score and iteration number\n best_validation_loss = this_validation_loss\n best_iter = iter\n\n # test it on the test set\n test_losses = test_model()\n test_score = numpy.mean(test_losses)\n print((' epoch %i, minibatch %i/%i, test error of '\n 'best model %f %%') %\n (epoch, minibatch_index + 1, n_train_batches,\n test_score * 100.))\n\n end_time = time.clock()\n print(('Optimization complete with best validation score of %f %%,'\n 'with test performance %f %%') %\n (best_validation_loss * 100., test_score * 100.))\n print >> sys.stdout, ('The training code for file ' +\n os.path.split(__file__)[1] +\n ' ran for %.2fm' % ((end_time - start_time) / 60.))\n\n # keep the following line consistent with line 227, function \"prepare_data\"\n filename = 'ksc_l1sda_pt%d_ft%d_lrp%.4f_f%.4f_bs%d_pca%d_ws%d' % \\\n (pretraining_epochs, training_epochs, pretrain_lr, finetune_lr, \n batch_size, n_principle, window_size) \n\n print '... classifying test set with learnt model:'\n pred_func = theano.function(inputs=[sda.x], outputs=sda.logLayer.y_pred)\n pred_test = pred_func(datasets[2][0].get_value(borrow=True))\n true_test = datasets[2][1].get_value(borrow=True)\n true_valid = datasets[1][1].get_value(borrow=True)\n true_train = datasets[0][1].get_value(borrow=True)\n result_analysis(pred_test, true_train, true_valid, true_test)\n\n print '... classifying the whole image with learnt model:'\n print '...... extracting data'\n data_spectral, data_spatial, _, _ = \\\n T_pca_constructor(hsi_img=img, gnd_img=gnd_img, n_principle=n_principle, \n window_size=window_size, flag='unsupervised', \n merge=True)\n \n start_time = time.clock()\n print '...... begin '\n y = pred_func(data_spectral) + 1\n print '...... done '\n end_time = time.clock()\n print 'finished, running time:%fs' % (end_time - start_time)\n\n y_rgb = cmap[y, :]\n margin = (window_size / 2) * 2 # floor it to a multiple of 2\n y_image = y_rgb.reshape(width - margin, height - margin, 3)\n scipy.misc.imsave(filename + 'wholeimg.png' , y_image)\n print 'Saving classification results'\n sio.savemat(filename + 'wholeimg.mat', \n {'y': y.reshape(width - margin, height - margin)})\n\n ############################################################################\n print '... performing Student\\'s t-test'\n best_c = 10000.\n best_g = 10.\n svm_classifier = svm.SVC(C=best_c, gamma=best_g, kernel='rbf')\n svm_classifier.fit(datasets[0][0].get_value(), datasets[0][1].get_value())\n\n data = [numpy.vstack((datasets[1][0].get_value(),\n datasets[2][0].get_value())),\n numpy.hstack((datasets[1][1].get_value(),\n datasets[2][1].get_value()))]\n numpy_rng = numpy.random.RandomState(89677)\n num_test = 100\n print 'Total number of tests: %d' % num_test\n k_sae = []\n k_svm = []\n for i in xrange(num_test):\n [_, _], [_, _], [test_x, test_y], _ = \\\n train_valid_test(data, ratio=[0, 1, 1], batch_size=1, \n random_state=numpy_rng.random_integers(1e10))\n test_y = test_y + 1 # fix the label scale problem\n pred_y = pred_func(test_x)\n cm = confusion_matrix(test_y, pred_y)\n pr_a = cm.trace()*1.0 / test_y.size\n pr_e = ((cm.sum(axis=0)*1.0/test_y.size) * \\\n (cm.sum(axis=1)*1.0/test_y.size)).sum()\n k_sae.append( (pr_a - pr_e) / (1 - pr_e) )\n\n pred_y = svm_classifier.predict(test_x)\n cm = confusion_matrix(test_y, pred_y)\n pr_a = cm.trace()*1.0 / test_y.size\n pr_e = ((cm.sum(axis=0)*1.0/test_y.size) * \\\n (cm.sum(axis=1)*1.0/test_y.size)).sum()\n k_svm.append( (pr_a - pr_e) / (1 - pr_e) )\n\n std_k_sae = numpy.std(k_sae)\n std_k_svm = numpy.std(k_svm)\n mean_k_sae = numpy.mean(k_sae)\n mean_k_svm = numpy.mean(k_svm)\n left = ( (mean_k_sae - mean_k_svm) * numpy.sqrt(num_test*2-2)) \\\n / ( numpy.sqrt(2./num_test) * num_test * (std_k_sae**2 + std_k_svm**2) )\n\n rv = t(num_test*2.0 - 2)\n right = rv.ppf(0.95)\n\n print '\\tstd\\t\\tmean'\n print 'k_sae\\t%f\\t%f' % (std_k_sae, mean_k_sae)\n print 'k_svm\\t%f\\t%f' % (std_k_svm, mean_k_svm)\n if left > right:\n print 'left = %f, right = %f, test PASSED.' % (left, right)\n else:\n print 'left = %f, right = %f, test FAILED.' % (left, right)\n\n return test_score","def mt10_sac(ctxt=None, seed=1):\n runner = LocalRunner(ctxt)\n MT10_envs_by_id = {}\n MT10_envs_test = {}\n for (task, env) in EASY_MODE_CLS_DICT.items():\n MT10_envs_by_id[task] = MetaRLEnv(env(*EASY_MODE_ARGS_KWARGS[task]['args'],\n **EASY_MODE_ARGS_KWARGS[task]['kwargs']))\n # python 3.6 dicts are ordered\n MT10_envs_test[task] = MetaRLEnv(env(*EASY_MODE_ARGS_KWARGS[task]['args'],\n **EASY_MODE_ARGS_KWARGS[task]['kwargs']))\n\n env = IgnoreDoneWrapper(MTMetaWorldWrapper(MT10_envs_by_id))\n\n policy = TanhGaussianMLPPolicy2(env_spec=env.spec,\n hidden_sizes=[400, 400, 400],\n hidden_nonlinearity=nn.ReLU,\n output_nonlinearity=None,\n min_std=np.exp(-20.),\n max_std=np.exp(2.),)\n\n qf1 = ContinuousMLPQFunction(env_spec=env.spec,\n hidden_sizes=[400, 400, 400],\n hidden_nonlinearity=F.relu)\n\n qf2 = ContinuousMLPQFunction(env_spec=env.spec,\n hidden_sizes=[400, 400, 400],\n hidden_nonlinearity=F.relu)\n\n replay_buffer = SACReplayBuffer(env_spec=env.spec,\n max_size=int(1e6))\n sampler_args = {'agent': policy, 'max_path_length': 150}\n\n timesteps = 20000000\n batch_size = int(150 * env.num_tasks)\n num_evaluation_points = 500\n epochs = timesteps // batch_size\n epoch_cycles = epochs // num_evaluation_points\n epochs = epochs // epoch_cycles\n sac = MTSAC(env=env,\n eval_env_dict=MT10_envs_test,\n env_spec=env.spec,\n policy=policy,\n qf1=qf1,\n qf2=qf2,\n gradient_steps_per_itr=150,\n epoch_cycles=epoch_cycles,\n use_automatic_entropy_tuning=True,\n replay_buffer=replay_buffer,\n min_buffer_size=1500,\n target_update_tau=5e-3,\n discount=0.99,\n buffer_batch_size=1280)\n tu.set_gpu_mode(True)\n sac.to('cuda:0')\n\n runner.setup(algo=sac, env=env, sampler_cls=SimpleSampler, sampler_args=sampler_args)\n\n runner.train(n_epochs=epochs, batch_size=batch_size)"],"string":"[\n \"def optimize_sgd(beta, X, y, num_iterations, step_size):\\n \\n N = X.shape[0]\\n P = X.shape[1]\\n costs = []\\n #variable step size\\n if step_size == 'rm': #Robbins–Monro rule\\n t0 = 2\\n C = 1\\n alpha = 0.5\\n for i in range(num_iterations): \\n j = random.randint(0,N-1) #Randomly sample a datapoint with replacement\\n \\n # Here I only pick a slice of X and an entry of y\\n # To reuse our codes for standard GD, \\n dbeta, cost = propagate(beta, X[j,:].reshape(1,P), y[j,:].reshape(1,1)) \\n \\n beta -= dbeta * C * ((num_iterations + t0)**(-alpha)) \\n \\n if i%1000 == 0:\\n _, cost = propagate(beta, X, y) \\n costs.append(cost.flatten())\\n \\n else: # constant step size\\n step_size = float(step_size)\\n for i in range(num_iterations):\\n j = random.randint(0,N-1) #Randomly sample a datapoint with replacement\\n \\n # Here I only pick a slice of X and an entry of y\\n # To reuse our codes for standard GD, \\n dbeta, cost = propagate(beta, X[j,:].reshape(1,P), y[j,:].reshape(1,1)) \\n \\n beta -= dbeta * step_size\\n \\n if i%1000 == 0:\\n _, cost = propagate(beta, X, y) \\n costs.append(cost.flatten())\\n \\n \\n return beta, costs\",\n \"def _make_spsa_optimizer(self):\\n def optimize(maxiter: int = 1000,\\n tol = None,\\n save_steps: int = 1,\\n c0: float = 0.62,\\n c1: float = 0.1,\\n c2: float = 0.602,\\n c3: float = 0.101,\\n c4: float = 0):\\n \\\"\\\"\\\"\\n This method is heavily based on qiskits optimizers.spsa method, \\n adapted here to worth with on quibs tn's without exact gradients \\n\\n Parameters\\n ----------\\n maxiter: Maximum number of iterations to perform.\\n tol : None or float stops optim if tol is reached (default none - completes all steps)\\n save_steps: Save intermediate info every save_steps step. It has a min. value of 1.\\n last_avg: Averaged parameters over the last_avg iterations.\\n If last_avg = 1, only the last iteration is considered. It has a min. value of 1.\\n c0: The initial a. Step size to update parameters.\\n c1: The initial c. The step size used to approximate gradient.\\n c2: The alpha in the paper, and it is used to adjust a (c0) at each iteration.\\n c3: The gamma in the paper, and it is used to adjust c (c1) at each iteration.\\n c4: The parameter used to control a as well.\\n \\n Returns\\n -------\\n TYPE : updated object? (same return as TNOptimize)\\n \\\"\\\"\\\"\\n _spsa_vars = [c0, c1, c2, c3, c4]\\n theta = self.vectorizer.vector\\n nb_params = len(theta)\\n use_exact_grads = 'grads' in self._method\\n \\n if save_steps:\\n theta_vec = [theta]\\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\\n \\n \\n pbar = tqdm(total=maxiter, disable=not self.progbar)\\n def callback(_):\\n pbar.clear()\\n pbar.update()\\n val = round(self.loss, 5)\\n pbar.set_description(str(val))\\n\\n if self.loss_target is not None:\\n if self.loss < self.loss_target:\\n # returning True doesn't terminate optimization\\n pbar.close()\\n raise KeyboardInterrupt\\n \\n for ii in range(maxiter):\\n \\n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\\n delta = 2 * randint(0, 2, size=nb_params) - 1\\n # plus and minus directions\\n \\n if use_exact_grads:\\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\\n else:\\n theta_plus = theta + c_spsa * delta\\n theta_minus = theta - c_spsa * delta\\n\\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\\n # derivative estimate\\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\\n # updated theta\\n theta = theta - a_spsa * g_spsa\\n \\n callback(ii)\\n \\n if tol is not None:\\n if (cost_plus + cost_minus)/2 < tol:\\n pbar.close()\\n break\\n \\n if save_steps:\\n theta_vec.append(theta)\\n cost_vec.append(cost_plus/2+cost_minus/2)\\n \\n \\n result_dict = {'hyper_parameters':_spsa_vars,\\n 'maxiter':maxiter,\\n 'theta_opt':theta,\\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\\n if save_steps:\\n result_dict['theta_history'] = theta_vec\\n result_dict['cost_history'] = cost_vec\\n self.result_dict = result_dict\\n pbar.close()\\n\\n return self.inject_res_vector_and_return_tn()\\n return optimize\",\n \"def optimizer(self):\\n return 'sgd'\",\n \"def sgd(cost, params, lr=1.0, alpha=0.1):\\n grads = T.grad(cost=cost, wrt=params)\\n updates = []\\n for p, g in zip(params, grads):\\n v = shared(p.get_value() * 0.)\\n v_new = v * (1.0 - alpha) - alpha * lr * g\\n updates.append((v, v_new))\\n updates.append((p, p + v_new )) #+ T.sqrt(lr) / 600.0 * srnd.normal(v.shape, dtype=theano.config.floatX)\\n \\n return updates, norm_gs(params, grads)\",\n \"def DistributedOptimizer(optimizer, name=None,\\n device_dense='', device_sparse='',\\n compression=Compression.none,\\n sparse_as_dense=False):\\n return _impl.create_distributed_optimizer(keras, optimizer, name,\\n device_dense, device_sparse, compression,\\n sparse_as_dense)\",\n \"def dist_optimizer(config, optimizer):\\n build_strategy, exec_strategy = create_strategy(config)\\n\\n dist_strategy = DistributedStrategy()\\n dist_strategy.execution_strategy = exec_strategy\\n dist_strategy.build_strategy = build_strategy\\n\\n dist_strategy.nccl_comm_num = 1\\n dist_strategy.fuse_all_reduce_ops = True\\n dist_strategy.fuse_grad_size_in_MB = 16\\n optimizer = fleet.distributed_optimizer(optimizer, strategy=dist_strategy)\\n\\n return optimizer\",\n \"def deep_slda_core50(override_args=None):\\n args = create_default_args({'cuda': 0, 'feature_size': 512, 'batch_size': 512,\\n 'shrinkage': 1e-4, 'plastic_cov': True, 'seed': None}, override_args)\\n set_seed(args.seed)\\n device = torch.device(f\\\"cuda:{args.cuda}\\\"\\n if torch.cuda.is_available() and\\n args.cuda >= 0 else \\\"cpu\\\")\\n\\n _mu = [0.485, 0.456, 0.406] # imagenet normalization\\n _std = [0.229, 0.224, 0.225]\\n transform = transforms.Compose([\\n transforms.Resize((224, 224)),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=_mu,\\n std=_std)\\n ])\\n\\n benchmark = avl.benchmarks.CORe50(scenario='nc', train_transform=transform, eval_transform=transform)\\n\\n eval_plugin = avl.training.plugins.EvaluationPlugin(\\n loss_metrics(epoch=True, experience=True, stream=True),\\n accuracy_metrics(epoch=True, experience=True, stream=True),\\n forgetting_metrics(experience=True, stream=True),\\n loggers=[InteractiveLogger()]\\n )\\n\\n criterion = torch.nn.CrossEntropyLoss()\\n model = avl.models.SLDAResNetModel(device=device, arch='resnet18',\\n imagenet_pretrained=True)\\n\\n cl_strategy = avl.training.StreamingLDA(model, criterion,\\n args.feature_size, num_classes=50,\\n eval_mb_size=args.batch_size,\\n train_mb_size=args.batch_size,\\n train_epochs=1,\\n shrinkage_param=args.shrinkage,\\n streaming_update_sigma=args.plastic_cov,\\n device=device, evaluator=eval_plugin)\\n\\n warnings.warn(\\n \\\"The Deep SLDA example is not perfectly aligned with \\\"\\n \\\"the paper implementation since it does not use a base \\\"\\n \\\"initialization phase and instead starts streming from \\\"\\n \\\"pre-trained weights. Performance should still match.\\\")\\n\\n res = None\\n for i, exp in enumerate(benchmark.train_stream):\\n cl_strategy.train(exp)\\n res = cl_strategy.eval(benchmark.test_stream)\\n\\n return res\",\n \"def AdaGrad(score_list, closure, batch_size, D, labels,\\n max_epoch=100, init_step_size=None, linesearch_option=0, \\n adaptive_termination=0, threshold_at=0.5,\\n c=0.5, beta=0.7,\\n x0=None, verbose=True, D_test=None, labels_test=None):\\n n = D.shape[0]\\n d = D.shape[1]\\n \\n m = int(n/batch_size)\\n\\n if x0 is None:\\n x = np.zeros(d)\\n x0 = np.zeros(d)\\n elif isinstance(x0, np.ndarray) and x0.shape == (d,):\\n x = x0.copy()\\n else:\\n raise ValueError('x0 must be a numpy array of size (d, )')\\n\\n num_grad_evals = 0\\n Gk2 = 0\\n \\n if linesearch_option in [0]:\\n step_size = init_step_size\\n if linesearch_option in [1]:\\n step_size = init_step_size / 2**(batch_size/n) \\n \\n condition_checked = False\\n \\n if adaptive_termination == 1:\\n Gk2_list = np.zeros(max_epoch * m)\\n iteration_counter = 0\\n warmup_time = int(n / (batch_size))\\n ratio_max = 0\\n print(threshold_at, warmup_time)\\n\\n \\n\\n for k in range(max_epoch): \\n # if num_grad_evals >= 2 * n * max_epoch:\\n # # exceeds the number of standard SVRG gradient evaluations (only for batch-size = 1)\\n # print('End of budget for gradient evaluations')\\n # break\\n t_start = time.time()\\n\\n\\n\\n loss, full_grad = closure(x, D, labels)\\n \\n if verbose:\\n output = 'Epoch.: %d, Grad. norm: %.2e' % \\\\\\n (k, np.linalg.norm(full_grad))\\n output += ', Func. value: %e' % loss\\n output += ', Step size: %e' % step_size\\n output += ', Num gradient evaluations/n: %f' % (num_grad_evals / n) \\n print(output) \\n\\n \\n\\n score_dict = {\\\"epoch\\\": k}\\n score_dict[\\\"optimizer\\\"] = 0\\n score_dict[\\\"n_grad_evals\\\"] = num_grad_evals\\n score_dict[\\\"n_grad_evals_normalized\\\"] = num_grad_evals / n\\n score_dict[\\\"train_loss\\\"] = loss\\n score_dict[\\\"grad_norm\\\"] = np.linalg.norm(full_grad)\\n score_dict[\\\"train_accuracy\\\"] = accuracy(x, D, labels)\\n score_dict[\\\"train_loss_log\\\"] = np.log(loss)\\n score_dict[\\\"grad_norm_log\\\"] = np.log(score_dict[\\\"grad_norm\\\"])\\n # score_dict[\\\"train_accuracy_log\\\"] = np.log(score_dict[\\\"train_accuracy\\\"])\\n if D_test is not None:\\n test_loss = closure(x, D_test, labels_test, backwards=False)\\n score_dict[\\\"test_loss\\\"] = test_loss\\n score_dict[\\\"test_accuracy\\\"] = accuracy(x, D_test, labels_test)\\n score_dict[\\\"test_loss_log\\\"] = np.log(test_loss)\\n # score_dict[\\\"test_accuracy_log\\\"] = np.log(score_dict[\\\"test_accuracy\\\"])\\n\\n score_list += [score_dict]\\n \\n if np.linalg.norm(full_grad) <= 1e-10:\\n break\\n if np.linalg.norm(full_grad) >= 1e10:\\n break\\n if np.isnan(full_grad).any():\\n break\\n \\n # Create Minibatches:\\n minibatches = make_minibatches(n, m, batch_size)\\n for i in range(m):\\n # get the minibatch for this iteration\\n indices = minibatches[i]\\n Di, labels_i = D[indices, :], labels[indices]\\n\\n # compute the loss, gradients\\n loss, x_grad = closure(x, Di, labels_i) \\n gk = x_grad\\n num_grad_evals = num_grad_evals + batch_size\\n \\n Gk2 = Gk2 + (np.linalg.norm(gk) ** 2)\\n \\n if linesearch_option == 0:\\n step_size = init_step_size\\n\\n \\n elif linesearch_option == 1:\\n step_size, armijo_iter = armijo_ls(closure, Di, labels_i, x, loss,\\n x_grad, x_grad, 2**(batch_size/n) * step_size, c=c, beta=beta,\\n precond = 1)\\n num_grad_evals += batch_size * armijo_iter\\n \\n if \\\"armijo_iter\\\" in score_list[len(score_list) - 1].keys(): \\n score_list[len(score_list) - 1][\\\"armijo_iter\\\"] += armijo_iter\\n else:\\n score_list[len(score_list) - 1][\\\"armijo_iter\\\"] = armijo_iter\\n \\n if adaptive_termination == 1: \\n if iteration_counter >= warmup_time:\\n Gk2_list[iteration_counter] = Gk2\\n if iteration_counter % 2 == 0: \\n if iteration_counter/2 >= warmup_time:\\n Gk2_last = Gk2_list[int(iteration_counter/2)] \\n ratio = (Gk2 - Gk2_last) / Gk2_last\\n #print(ratio)\\n if ratio > ratio_max:\\n ratio_max = ratio\\n if ratio > threshold_at:\\n x -= (step_size / np.sqrt(Gk2)) * gk\\n print('Breaking out of inner loop at iteration', iteration_counter)\\n condition_checked = True\\n break\\n iteration_counter += 1\\n \\n \\n \\n x -= (step_size / np.sqrt(Gk2)) * gk\\n \\n \\n\\n \\n \\n t_end = time.time()\\n time_epoch = t_end - t_start\\n score_list[len(score_list) - 1][\\\"time\\\"] = time_epoch \\n if condition_checked:\\n break\\n \\n return score_list, x, num_grad_evals, k\",\n \"def fit(zs, ys, L, lam_1, lam_2, rho=10, maxiter=100, verbose=True, warm_start=None,\\n eps_abs = 1e-5, eps_rel = 1e-5):\\n K = int(zs.max() + 1)\\n N, n = ys.shape\\n Ys, cts = [], []\\n for i in range(K):\\n idx = zs == i\\n cts.append(idx.sum()) #N_i, number of samples per z\\n ys_i = ys[idx]\\n Ys.append(ys_i.T @ ys_i)\\n \\n if verbose:\\n print (\\\"Fitting covariance stratified model.\\\")\\n print (\\\"%d stratification values, %d data points, %d dimensions\\\" % (K, N, n))\\n print (\\\"%d\\\" % (K * n * n), \\\"optimization variables\\\")\\n print (\\\"lam_1 = %3.3e, lam_2 = %3.3e, rho = %3.3e, maxiter=%d\\\" % (lam_1, lam_2, rho, maxiter))\\n print (\\\"count per stratification value:\\\", cts)\\n print (Ys[0].shape)\\n\\n shape = (K, n, n)\\n if warm_start is None:\\n warm_start = []\\n for _ in range(5):\\n warm_start.append(np.zeros(shape))\\n inv_covs_loss, inv_covs_reg, inv_covs_lapl, U_1, U_2 = warm_start\\n \\n solve = factorized(L.tocsc() + rho * sparse.eye(K, format='csc'))\\n \\n for _ in range(maxiter):\\n # inv_covs_loss\\n for i in range(K):\\n if cts[i] == 0:\\n inv_covs_loss[i] = (inv_covs_lapl[i] - U_1[i])\\n continue\\n w, v = np.linalg.eigh((rho/cts[i]) * (inv_covs_lapl[i] - U_1[i]) - Ys[i]/cts[i])\\n w_new = (w*cts[i]/rho + np.sqrt((w*cts[i]/rho)**2 + 4*cts[i]/rho))/2\\n inv_covs_loss[i] = v @ np.diag(w_new) @ v.T \\n \\n # inv_covs_reg\\n for i in range(K):\\n inv_covs_reg[i][np.arange(n), np.arange(n)] = np.diag(inv_covs_lapl[i] - U_2[i] - lam_1/rho) #diagonal elements\\n \\n st2 = soft_threshold(inv_covs_lapl[i] - U_2[i], lam_2 / rho)\\n od_idx = np.where(~np.eye(n,dtype=bool)) #gets off_diags\\n inv_covs_reg[i][od_idx] = st2[od_idx] \\n \\n # inv_covs_lapl\\n rhs = (inv_covs_loss + inv_covs_reg) / 2 + (U_1 + U_2) / 2\\n rhs *= rho\\n inv_covs_lapl_new = solve(rhs.reshape(K, n*n)).reshape(shape)\\n S = rho * np.repeat(inv_covs_lapl_new - inv_covs_lapl, 2, axis=0)\\n inv_covs_lapl = inv_covs_lapl_new.copy()\\n\\n # U_1\\n R_1 = inv_covs_loss - inv_covs_lapl\\n U_1 += R_1\\n \\n # U_2\\n R_2 = inv_covs_reg - inv_covs_lapl\\n U_2 += R_2\\n \\n R = np.concatenate([R_1, R_2], axis=0)\\n \\n # stopping criterion\\n eps_pri = np.sqrt(2 * K * n * n) * eps_abs + eps_rel * max(np.linalg.norm(np.concatenate([inv_covs_loss, inv_covs_reg], axis=0)),\\n np.linalg.norm(np.repeat(inv_covs_lapl, 2, axis=0)))\\n eps_dual = np.sqrt(K * n * n) * eps_abs + eps_rel * np.linalg.norm(np.concatenate([U_1, U_2], axis=0))\\n if verbose:\\n print (np.linalg.norm(R), np.linalg.norm(S), eps_pri, eps_dual)\\n \\n return inv_covs_loss, inv_covs_reg, inv_covs_lapl\",\n \"def ADMM_SGL(S, lambda1, Omega_0, Theta_0=np.array([]), X_0=np.array([]),\\n rho=1., max_iter=1000, tol=1e-7, rtol=1e-4, stopping_criterion='boyd',\\\\\\n update_rho=True, verbose=False, measure=False, latent=False, mu1=None):\\n assert Omega_0.shape == S.shape\\n assert S.shape[0] == S.shape[1]\\n assert lambda1 > 0\\n\\n assert stopping_criterion in [\\\"boyd\\\", \\\"kkt\\\"]\\n\\n if latent:\\n assert mu1 is not None\\n assert mu1 > 0\\n\\n (p, p) = S.shape\\n\\n assert rho > 0, \\\"ADMM penalization parameter must be positive.\\\"\\n\\n # initialize\\n Omega_t = Omega_0.copy()\\n\\n if len(Theta_0) == 0:\\n Theta_0 = Omega_0.copy()\\n if len(X_0) == 0:\\n X_0 = np.zeros((p, p))\\n\\n Theta_t = Theta_0.copy()\\n L_t = np.zeros((p, p))\\n X_t = X_0.copy()\\n\\n runtime = np.zeros(max_iter)\\n residual = np.zeros(max_iter)\\n status = ''\\n\\n\\n if verbose:\\n print(\\\"------------ADMM Algorithm for Single Graphical Lasso----------------\\\")\\n\\n if stopping_criterion == 'boyd':\\n hdr_fmt = \\\"%4s\\\\t%10s\\\\t%10s\\\\t%10s\\\\t%10s\\\"\\n out_fmt = \\\"%4d\\\\t%10.4g\\\\t%10.4g\\\\t%10.4g\\\\t%10.4g\\\"\\n print(hdr_fmt % (\\\"iter\\\", \\\"r_t\\\", \\\"s_t\\\", \\\"eps_pri\\\", \\\"eps_dual\\\"))\\n elif stopping_criterion == 'kkt':\\n hdr_fmt = \\\"%4s\\\\t%10s\\\"\\n out_fmt = \\\"%4d\\\\t%10.4g\\\"\\n print(hdr_fmt % (\\\"iter\\\", \\\"kkt residual\\\"))\\n\\n ##################################################################\\n ### MAIN LOOP STARTS\\n ##################################################################\\n for iter_t in np.arange(max_iter):\\n if measure:\\n start = time.time()\\n\\n\\n # Omega Update\\n W_t = Theta_t - L_t - X_t - (1 / rho) * S\\n eigD, eigQ = np.linalg.eigh(W_t)\\n Omega_t_1 = Omega_t.copy()\\n Omega_t = phiplus(beta=1 / rho, D=eigD, Q=eigQ)\\n\\n # Theta Update\\n Theta_t = prox_od_1norm(Omega_t + L_t + X_t, (1 / rho) * lambda1)\\n\\n # L Update\\n if latent:\\n C_t = Theta_t - X_t - Omega_t\\n # C_t = (C_t.T + C_t)/2\\n eigD1, eigQ1 = np.linalg.eigh(C_t)\\n L_t = prox_rank_norm(C_t, mu1/rho, D=eigD1, Q=eigQ1)\\n\\n # X Update\\n X_t = X_t + Omega_t - Theta_t + L_t\\n\\n \\n \\n if measure:\\n end = time.time()\\n runtime[iter_t] = end - start\\n\\n # Stopping criterion\\n if stopping_criterion == 'boyd':\\n r_t,s_t,e_pri,e_dual = ADMM_stopping_criterion(Omega_t, Omega_t_1, Theta_t, L_t, X_t,\\\\\\n S, rho, tol, rtol, latent)\\n \\n # update rho\\n if update_rho:\\n if r_t >= 10*s_t:\\n rho_new = 2*rho\\n elif s_t >= 10*r_t:\\n rho_new = 0.5*rho\\n else:\\n rho_new = 1.*rho\\n \\n # rescale dual variables\\n X_t = (rho/rho_new)*X_t\\n rho = rho_new\\n \\n \\n residual[iter_t] = max(r_t,s_t)\\n\\n if verbose:\\n print(out_fmt % (iter_t,r_t,s_t,e_pri,e_dual))\\n if (r_t <= e_pri) and (s_t <= e_dual):\\n status = 'optimal'\\n break\\n\\n elif stopping_criterion == 'kkt':\\n eta_A = kkt_stopping_criterion(Omega_t, Theta_t, L_t, rho * X_t, S, lambda1, latent, mu1)\\n residual[iter_t] = eta_A\\n\\n if verbose:\\n print(out_fmt % (iter_t,eta_A))\\n if eta_A <= tol:\\n status = 'optimal'\\n break\\n\\n\\n ##################################################################\\n ### MAIN LOOP FINISHED\\n ##################################################################\\n\\n # retrieve status (partially optimal or max iter)\\n if status != 'optimal':\\n if stopping_criterion == 'boyd':\\n if (r_t <= e_pri):\\n status = 'primal optimal'\\n elif (s_t <= e_dual):\\n status = 'dual optimal'\\n else:\\n status = 'max iterations reached'\\n else:\\n status = 'max iterations reached'\\n\\n print(f\\\"ADMM terminated after {iter_t+1} iterations with status: {status}.\\\")\\n\\n ### CHECK FOR SYMMETRY\\n if abs((Omega_t).T - Omega_t).max() > 1e-5:\\n warnings.warn(f\\\"Omega variable is not symmetric, largest deviation is {abs((Omega_t).T - Omega_t).max()}.\\\")\\n \\n if abs((Theta_t).T - Theta_t).max() > 1e-5:\\n warnings.warn(f\\\"Theta variable is not symmetric, largest deviation is {abs((Theta_t).T - Theta_t).max()}.\\\")\\n \\n if abs((L_t).T - L_t).max() > 1e-5:\\n warnings.warn(f\\\"L variable is not symmetric, largest deviation is {abs((L_t).T - L_t).max()}.\\\")\\n\\n ### CHECK FOR POSDEF\\n D = np.linalg.eigvalsh(Theta_t - L_t)\\n if D.min() <= 0:\\n print(\\n f\\\"WARNING: Theta (Theta - L resp.) is not positive definite. Solve to higher accuracy! (min EV is {D.min()})\\\")\\n\\n if latent:\\n D = np.linalg.eigvalsh(L_t)\\n if D.min() < -1e-8:\\n print(f\\\"WARNING: L is not positive semidefinite. Solve to higher accuracy! (min EV is {D.min()})\\\")\\n\\n if latent:\\n sol = {'Omega': Omega_t, 'Theta': Theta_t, 'L': L_t, 'X': X_t}\\n else:\\n sol = {'Omega': Omega_t, 'Theta': Theta_t, 'X': X_t}\\n\\n if measure:\\n info = {'status': status, 'runtime': runtime[:iter_t+1], 'residual': residual[:iter_t+1]}\\n else:\\n info = {'status': status}\\n\\n return sol, info\",\n \"def optimizer(grad, method, init_par, alpha, delta, plx_obs, mualpha_obs, mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N):\\r\\n\\r\\n\\t\\r\\n\\tif grad == 'NO':\\r\\n\\t\\tif method == 'Powell' :\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'Nelder-Mead':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, method = method,\\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t options = {'ftol': 0.0001})\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\t\\telif method == 'default':\\r\\n\\t\\t\\tres = opt.minimize(Ulike,init_par, \\r\\n\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N))\\r\\n\\t\\t\\treturn res.x, res.nit\\r\\n\\r\\n\\telif grad == 'YES':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, \\r\\n \\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t options={'disp': True, 'maxiter': 4000, 'xtol': 1e-4})\\r\\n\\t\\treturn res.x, res.nit \\r\\n\\t\\t\\t\\r\\n\\t\\t\\r\\n\\telif grad == 'HESS':\\r\\n\\t\\tres = opt.minimize(Ulike, init_par, method = method, jac = stella_grad_full, hess = stella_hessian,\\r\\n\\t\\t\\t\\t\\t args = (alpha, delta, plx_obs, mualpha_obs,mudelta_obs, vrad_obs, sigma_obs, sigma_vrad, ccoeff, N),\\r\\n\\t\\t\\t\\t\\t options = {'disp': True, 'maxiter': 4000, 'xtol': 1.e-06}) \\r\\n\\t\\treturn res.x, res.nit\",\n \"def __init__(\\n self,\\n params,\\n lr=required,\\n momentum=0,\\n dampening=0,\\n weight_decay=0,\\n nesterov=False,\\n scale=1,\\n clip_norm=0,\\n ):\\n if lr is not required and lr < 0.:\\n raise ValueError('Invalid learning rate: {}'.format(lr))\\n if momentum < 0.:\\n raise ValueError('Invalid momentum value: {}'.format(momentum))\\n defaults = dict(lr=lr, momentum=momentum, dampening=dampening,\\n nesterov=nesterov, weight_decay=weight_decay,\\n scale=scale, clip_norm=clip_norm)\\n if nesterov and (momentum <= 0. or dampening != 0.):\\n raise ValueError('Nesterov momentum requires a momentum and zero dampening.')\\n super(SGD, self).__init__(params, defaults)\\n self._op_type = ('Nesterov' if nesterov else 'SGD') + 'Update'\\n self._hyper = {\\n 'lr': ('lr', collections.defaultdict(str)),\\n 'momentum': ('momentum', collections.defaultdict(str)),\\n 'weight_decay': ('weight_decay', collections.defaultdict(str)),\\n 'scale': ('scale', collections.defaultdict(str)),\\n 'clip_norm': ('clip_norm', collections.defaultdict(str)),\\n }\",\n \"def calc_dense2(self):\\n # Local copies of instance attributes for faster access\\n b = self.b\\n qs = self.q_sim\\n qo = self.q_obs\\n maxlead = self.max_lead\\n maxlag = self.max_lag\\n measure = self.measure\\n time = self.time\\n n = len(self.q_obs)\\n\\n if self.calc_rays:\\n warnings.warn('Not possible to calculate connecting rays when using HMA.calc_dense2')\\n if self.keep_internals:\\n warnings.warn('Not possible to keep internals when using HMA.calc_dense2')\\n\\n for i_o in range(n):\\n # Cycle cw arrays\\n if i_o > 0:\\n cw0_prev = cw0_cur\\n cw1_prev = cw1_cur\\n cw0_cur = np.full(n, np.inf, dtype=np.float64)\\n cw1_cur = np.full(n, np.inf, dtype=np.float64)\\n\\n iss = max(0, i_o - maxlead) # sim index start\\n ise = min(n, i_o + maxlag + 1) # sim index end\\n isv = np.arange(iss, ise) # sim index as vector\\n if time is not None:\\n dt = time[isv] - time[i_o]\\n # Heavily penalize sim-obs combinations outside allowed window\\n # so that they are not selected\\n dt[(dt < -maxlag) | (dt > maxlead)] = np.inf\\n else:\\n dt = isv - i_o\\n if measure in ('nse', 'square'):\\n e = (qs[iss:ise] - qo[i_o]) ** 2 + b ** 2 * dt ** 2\\n elif measure in ('mae', 'abs'):\\n e = np.abs(qs[iss:ise] - qo[i_o]) + b * np.abs(dt)\\n\\n if i_o == 0:\\n # Only populate first column of cw0 and move to i_o = 1\\n cw0_cur[iss:ise] = e\\n continue\\n\\n # Repeat the same simulation point\\n d = cw0_prev[iss:ise]\\n cw1_cur[iss:ise] = e + d\\n\\n # Find the 'cheapest' available preceding sim point\\n points = np.full((len(isv), 4), np.inf)\\n # Use the previous simulation point\\n st = max(0, iss-1)\\n end = min(n + 1, ise - 1)\\n l = end - st\\n points[-l:, 0] = cw0_prev[st:end]\\n points[-l:, 1] = cw1_prev[st:end]\\n # Skip a simulation point\\n st = max(0, iss - 2)\\n end = min(n + 1, ise - 2)\\n l = end - st\\n points[-l:, 2] = cw0_prev[st:end]\\n points[-l:, 3] = cw1_prev[st:end]\\n cw0_cur[iss:ise] = (e + np.min(points, axis=1))\\n\\n # Find the cheapest point in the last column, i.e. end of cheapest path, i.e. optimum score\\n self.opt_score = min(np.min(cw0_cur), np.min(cw1_cur))\\n self.of = 1 - self.opt_score / self.fbench\\n\\n return self.of\",\n \"def sgdmgc(cost, params, lr=1.0, alpha=0.1, max_magnitude=5.0, infDecay=0.1):\\n grads = T.grad(cost=cost, wrt=params)\\n updates = []\\n\\n norm = norm_gs(params, grads)\\n sqrtnorm = T.sqrt(norm)\\n not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\\n\\n for p, g in zip(params, grads):\\n v = shared(p.get_value() * 0.)\\n g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\\n v_new = v * (1.0 - alpha) - alpha * lr * g\\n updates.append((v, v_new))\\n updates.append((p, p + v_new ))\\n \\n return updates, norm\",\n \"def optimize(maxiter: int = 1000,\\n tol = None,\\n save_steps: int = 1,\\n c0: float = 0.62,\\n c1: float = 0.1,\\n c2: float = 0.602,\\n c3: float = 0.101,\\n c4: float = 0):\\n _spsa_vars = [c0, c1, c2, c3, c4]\\n theta = self.vectorizer.vector\\n nb_params = len(theta)\\n use_exact_grads = 'grads' in self._method\\n \\n if save_steps:\\n theta_vec = [theta]\\n cost_vec = [self.vectorized_value_and_grad(theta)[0]]\\n \\n \\n pbar = tqdm(total=maxiter, disable=not self.progbar)\\n def callback(_):\\n pbar.clear()\\n pbar.update()\\n val = round(self.loss, 5)\\n pbar.set_description(str(val))\\n\\n if self.loss_target is not None:\\n if self.loss < self.loss_target:\\n # returning True doesn't terminate optimization\\n pbar.close()\\n raise KeyboardInterrupt\\n \\n for ii in range(maxiter):\\n \\n a_spsa = float(_spsa_vars[0]) / ((ii + 1 + _spsa_vars[4])**_spsa_vars[2])\\n c_spsa = float(_spsa_vars[1]) / ((ii + 1)**_spsa_vars[3])\\n delta = 2 * randint(0, 2, size=nb_params) - 1\\n # plus and minus directions\\n \\n if use_exact_grads:\\n raise NotImplementedError('Will use grad calc to project on to SP-direction')\\n else:\\n theta_plus = theta + c_spsa * delta\\n theta_minus = theta - c_spsa * delta\\n\\n cost_plus = self.vectorized_value_and_grad(theta_plus)[0]\\n cost_minus = self.vectorized_value_and_grad(theta_minus)[0]\\n # derivative estimate\\n g_spsa = (cost_plus - cost_minus) * delta / (2.0 * c_spsa)\\n # updated theta\\n theta = theta - a_spsa * g_spsa\\n \\n callback(ii)\\n \\n if tol is not None:\\n if (cost_plus + cost_minus)/2 < tol:\\n pbar.close()\\n break\\n \\n if save_steps:\\n theta_vec.append(theta)\\n cost_vec.append(cost_plus/2+cost_minus/2)\\n \\n \\n result_dict = {'hyper_parameters':_spsa_vars,\\n 'maxiter':maxiter,\\n 'theta_opt':theta,\\n 'cost_opt':self.vectorized_value_and_grad(theta)[0],\\n 'grad_opt':self.vectorized_value_and_grad(theta)[1]}\\n if save_steps:\\n result_dict['theta_history'] = theta_vec\\n result_dict['cost_history'] = cost_vec\\n self.result_dict = result_dict\\n pbar.close()\\n\\n return self.inject_res_vector_and_return_tn()\",\n \"def solve_SVM_dual_SMO(x_train, y_train, x_test, C=1):\\n n, d = x_train.shape[0], x_train.shape[1]\\n alpha = np.zeros((n))\\n count = 0\\n while True:\\n count += 1\\n alpha_prev = np.copy(alpha)\\n for j in range(0, n):\\n # Getting random int i!=j\\n i = j\\n cnt=0\\n while i == j and cnt<1000:\\n i = rnd.randint(0,n-1)\\n cnt=cnt+1\\n x_i, x_j, y_i, y_j = x_train[i,:], x_train[j,:], y_train[i], y_train[j]\\n k_ij = (np.dot(x_i, x_i.T)) + (np.dot(x_j, x_j.T) ) - (2 * np.dot(x_i, x_j.T))\\n if k_ij <= 0:\\n continue\\n alpha_prime_j, alpha_prime_i = alpha[j], alpha[i]\\n if(y_i != y_j):\\n (L,H) = (max(0, alpha_prime_j - alpha_prime_i), min(C, C - alpha_prime_i + alpha_prime_j))\\n else:\\n (L,H) = (max(0, alpha_prime_i + alpha_prime_j - C), min(C, alpha_prime_i + alpha_prime_j))\\n if(L==H):\\n continue\\n # Computing model parameters\\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\\n b = np.mean(y_train - np.dot(w.T, x_train.T))\\n E_i = np.sign(np.dot(w.T, x_i.T) + b).astype(int) - y_i\\n E_j = np.sign(np.dot(w.T, x_j.T) + b).astype(int) - y_j\\n # Setting new alpha values(Lagrange multipliers)\\n alpha[j] = alpha_prime_j + float(y_j * (E_i - E_j))/k_ij\\n alpha[j] = max(alpha[j], L)\\n alpha[j] = min(alpha[j], H)\\n alpha[i] = alpha_prime_i + y_i*y_j * (alpha_prime_j - alpha[j])\\n # Checking for convergence\\n diff = np.linalg.norm(alpha - alpha_prev)\\n if diff < 0.000000001:\\n break\\n # Computing weights and bias\\n b = np.mean(y_train-np.dot(w.T,x_train.T))\\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\\n y_pred_test = (np.sign(np.dot(w.T, x_test.T) + b).astype(int))\\n return (y_pred_test,alpha)\",\n \"def solve(self):\\n \\n # Check if cost is available for both estimators\\n if not self.est0.cost_avail or not self.est1.cost_avail:\\n self.comp_cost = False\\n \\n # Initial estimate from the input node\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\\n else:\\n z0, zvar0 = self.est0.est_init(return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0\\n \\n # Initialize other variables\\n self.var_cost0 = 0\\n self.var_cost1 = 0\\n self.cost = 0\\n self.s = np.zeros(self.shape1)\\n \\n for it in range(self.nit):\\n \\n # Forward transform to est1\\n t0 = time.time()\\n rvar1_new = self.A.var_dot(self.zvar0)\\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\\\\n self.var_axes1,rep=False)\\n z1_mult = self.A.dot(self.z0)\\n r1_new = z1_mult - rvar1_rep*self.s\\n \\n # Damping\\n if it > 0: \\n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\\n else:\\n self.r1 = r1_new\\n self.rvar1 = rvar1_new\\n\\n # Estimator 1 \\n if self.comp_cost: \\n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \\n if not self.map_est:\\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\\\\n self.shape1,self.var_axes1)\\n else:\\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \\n cost1 = 0\\n self.z1 = z1\\n self.zvar1 = zvar1\\n self.cost1 = cost1 \\n con_new = np.mean(np.abs(z1-z1_mult)**2) \\n \\n # Reverse nonlinear transform to est 0\\n self.s = (self.z1-self.r1)/rvar1_rep\\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\\n t1 = time.time()\\n self.time_est1 = t1-t0\\n \\n # Reverse linear transform to est 0 \\n rvar0_new = 1/self.A.var_dotH(self.sprec)\\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\\\\n self.var_axes0,rep=False)\\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\\n \\n # Damping\\n if it > 0:\\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\\n else:\\n self.r0 = r0_new\\n self.rvar0 = rvar0_new\\n \\n \\n # Estimator 0\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\\n if not self.map_est:\\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\\\\n self.shape0,self.var_axes0)\\n \\n else:\\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0 \\n\\n \\n # Compute total cost and constraint \\n cost_new = self.cost0 + self.cost1 \\n if not self.map_est:\\n cost_new += self.cost_gauss()\\n \\n # Step size adaptation\\n if (self.step_adapt) and (it > 0):\\n if (con_new < self.con):\\n self.step = np.minimum(1,self.step_inc*self.step)\\n else:\\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\\n self.cost=cost_new\\n self.con=con_new\\n \\n t2 = time.time()\\n self.time_est0 = t2-t1\\n self.time_iter = t2-t0\\n \\n # Print progress\\n if self.prt_period > 0:\\n if (it % self.prt_period == 0):\\n if self.comp_cost:\\n print(\\\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\\\".format(\\\\\\n it, self.cost, self.con, self.step))\\n else:\\n print(\\\"it={0:4d} con={1:12.4e}\\\".format(\\\\\\n it, self.con))\\n \\n # Save history\\n self.save_hist()\",\n \"def loss_sparse_dist(model, inputs_a, inputs_b, inputs_pairinfo, **kwargs):\\n device = next(model.parameters()).device\\n batch_size = len(inputs_a)\\n\\n scores = model.run(inputs_a, inputs_b)\\n\\n r_size = model.r_size\\n\\n # Generate sparse distribution for input batch\\n sparse = torch.zeros(batch_size, r_size, device=device).detach()\\n # FIXME: assertion that score is 0~5 range\\n MAX_SCORE = 5\\n for i, score in enumerate(inputs_pairinfo):\\n score = score['sts']\\n if score == MAX_SCORE:\\n sparse[i, -1] = 1\\n else:\\n floor = int(score / MAX_SCORE * (r_size-1)) \\n ceil = floor + 1\\n weight = score / MAX_SCORE * (r_size-1) - floor\\n if weight < 1e-4:\\n # On the grid\\n sparse[i, floor] = 1\\n else:\\n # Between the grid\\n sparse[i, ceil] = weight\\n sparse[i, floor] = 1 - weight\\n\\n # Calculate Kullback-Liebler Divergence loss for sparce distribution\\n # Note that KLDivLoss does not support batch-first shaping.\\n loss = nn.KLDivLoss(reduction='batchmean')(scores, sparse)\\n\\n return loss\",\n \"def optimization_step(self):\\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n input_dict = {self.x: self.train_inputs[self.minibatch_set,:]}\\n \\n var_list = [self.x_tilda, self.minibatch_set]\\n \\n if (self.num_samples > 0) and (not self.mixture):\\n \\n if ((self.mf_steps > 0) and self.alpha >0) or\\\\\\n self.gibbs_steps > 0: \\n \\n var_list.append(self.sampler_theta)\\n \\n elif \\\"CD\\\" in self.algorithm:\\n \\n input_dict = {self.x : self.train_inputs[self.minibatch_set,:]} \\n \\n var_list = [self.minibatch_set]\\n \\n var_list.append(self.learning_rate)\\n \\n if self.use_momentum:\\n \\n var_list.append(self.momentum)\\n \\n output_vars = [self.pseudo_cost]\\n \\n if self.report_p_tilda:\\n \\n output_vars.append(self.p_tilda)\\n \\n else:\\n \\n output_vars.append(theano.shared(0))\\n \\n opt_step = theano.function(inputs = var_list,\\n outputs = output_vars,\\n updates = self.updates,\\n givens = input_dict,\\n on_unused_input='warn')\\n \\n return opt_step\",\n \"def test_determinism_2():\\n\\n def run_sgd(mode):\\n # Must be seeded the same both times run_sgd is called\\n disturb_mem.disturb_mem()\\n rng = np.random.RandomState([2012, 11, 27])\\n\\n batch_size = 5\\n train_batches = 3\\n valid_batches = 4\\n num_features = 2\\n\\n # Synthesize dataset with a linear decision boundary\\n w = rng.randn(num_features)\\n\\n def make_dataset(num_batches):\\n disturb_mem.disturb_mem()\\n m = num_batches*batch_size\\n X = rng.randn(m, num_features)\\n y = np.zeros((m, 1))\\n y[:, 0] = np.dot(X, w) > 0.\\n\\n rval = DenseDesignMatrix(X=X, y=y)\\n\\n rval.yaml_src = \\\"\\\" # suppress no yaml_src warning\\n\\n X = rval.get_batch_design(batch_size)\\n assert X.shape == (batch_size, num_features)\\n\\n return rval\\n\\n train = make_dataset(train_batches)\\n valid = make_dataset(valid_batches)\\n\\n num_chunks = 10\\n chunk_width = 2\\n\\n class ManyParamsModel(Model):\\n \\\"\\\"\\\"\\n Make a model with lots of parameters, so that there are many\\n opportunities for their updates to get accidentally re-ordered\\n non-deterministically. This makes non-determinism bugs manifest\\n more frequently.\\n \\\"\\\"\\\"\\n\\n def __init__(self):\\n super(ManyParamsModel, self).__init__()\\n self.W1 = [sharedX(rng.randn(num_features, chunk_width)) for i\\n in xrange(num_chunks)]\\n disturb_mem.disturb_mem()\\n self.W2 = [sharedX(rng.randn(chunk_width))\\n for i in xrange(num_chunks)]\\n self._params = safe_union(self.W1, self.W2)\\n self.input_space = VectorSpace(num_features)\\n self.output_space = VectorSpace(1)\\n\\n disturb_mem.disturb_mem()\\n model = ManyParamsModel()\\n disturb_mem.disturb_mem()\\n\\n class LotsOfSummingCost(Cost):\\n \\\"\\\"\\\"\\n Make a cost whose gradient on the parameters involves summing many\\n terms together, so that T.grad is more likely to sum things in a\\n random order.\\n \\\"\\\"\\\"\\n\\n supervised = True\\n\\n def expr(self, model, data, **kwargs):\\n self.get_data_specs(model)[0].validate(data)\\n X, Y = data\\n disturb_mem.disturb_mem()\\n\\n def mlp_pred(non_linearity):\\n Z = [T.dot(X, W) for W in model.W1]\\n H = [non_linearity(z) for z in Z]\\n Z = [T.dot(h, W) for h, W in safe_izip(H, model.W2)]\\n pred = sum(Z)\\n return pred\\n\\n nonlinearity_predictions = map(mlp_pred,\\n [T.nnet.sigmoid,\\n T.nnet.softplus,\\n T.sqr,\\n T.sin])\\n pred = sum(nonlinearity_predictions)\\n disturb_mem.disturb_mem()\\n\\n return abs(pred-Y[:, 0]).sum()\\n\\n def get_data_specs(self, model):\\n data = CompositeSpace((model.get_input_space(),\\n model.get_output_space()))\\n source = (model.get_input_source(), model.get_target_source())\\n return (data, source)\\n\\n cost = LotsOfSummingCost()\\n\\n disturb_mem.disturb_mem()\\n\\n algorithm = SGD(cost=cost,\\n batch_size=batch_size,\\n learning_rule=Momentum(.5),\\n learning_rate=1e-3,\\n monitoring_dataset={'train': train, 'valid': valid},\\n update_callbacks=[ExponentialDecay(decay_factor=2.,\\n min_lr=.0001)],\\n termination_criterion=EpochCounter(max_epochs=5))\\n\\n disturb_mem.disturb_mem()\\n\\n train_object = Train(dataset=train,\\n model=model,\\n algorithm=algorithm,\\n extensions=[PolyakAveraging(start=0),\\n MomentumAdjustor(final_momentum=.9,\\n start=1,\\n saturate=5), ],\\n save_freq=0)\\n\\n disturb_mem.disturb_mem()\\n\\n train_object.main_loop()\\n\\n output = cStringIO()\\n record = Record(file_object=output, replay=False)\\n record_mode = RecordMode(record)\\n\\n run_sgd(record_mode)\\n\\n output = cStringIO(output.getvalue())\\n playback = Record(file_object=output, replay=True)\\n playback_mode = RecordMode(playback)\\n\\n run_sgd(playback_mode)\",\n \"def sgd_optim(config = None, global_step = None):\\n learning_rate = config[\\\"learning_rate\\\"]\\n \\n train_step = tf.train.GradientDescentOptimizer(learning_rate)\\n #train_step = tf.train.GradientDescentOptimizer(learning_rate)\\n return train_step\",\n \"def td_sarsa(env, iterations=1000, gamma=0.9, alpha=0.1):\\n\\n nS = env.nS # number of states\\n nA = env.nA # number of actions\\n Q_value = np.zeros((nS, nA))\\n policy = np.ones((env.nS,env.nA))/env.nA\\n epsilon = 1\\n s_t1 = env.reset() # reset the environment and place the agent in the start square\\n a_t1 = sample_action(policy, s_t1)\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n # HINT: Don't forget to decay epsilon according to GLIE\\n \\n curr_state = s_t1\\n curr_action = a_t1\\n \\n start = time.time() # to time how long convergence takes\\n print(\\\"---TD SARSA---\\\\nTraining Started.\\\")\\n \\n for k in range (1, iterations):\\n # if (k%10000) == 0:\\n # print(\\\"Now playing iteration: \\\", k)\\n epsilon = 1/k\\n curr_action, reward, new_state, done = take_one_step(env, policy, curr_state)\\n new_action = sample_action(policy, new_state)\\n Q_value[curr_state, curr_action] = Q_value[curr_state, curr_action] + alpha * (reward + gamma * Q_value[new_state, new_action] - Q_value[curr_state, curr_action])\\n \\n # epsilon-greedy policy update\\n Q_list = np.argwhere(Q_value[curr_state] == np.amax(Q_value[curr_state])).flatten() # get a list of all indices where Q is maximum, (argmax(Q))\\n max_Q = np.random.choice(Q_list.flatten()) # randomly pick from those indices. Picking each index is equally likely.\\n for a in range (nA):\\n if a == max_Q:\\n policy[curr_state][a] = epsilon/nA + (1 - epsilon) # for the chosen maximal index of Q, set the policy to epsilon/m + 1 - epsilon\\n else:\\n policy[curr_state][a] = epsilon/nA # epsilon / 3\\n \\n # print(\\\"Q_value = {0}\\\".format(Q_value))\\n # print(\\\"policy = {0}\\\".format(policy))\\n \\n if done:\\n curr_state = env.reset() # reset the environment and place the agent in the start square\\n curr_action = sample_action(policy, curr_state)\\n else:\\n curr_state = new_state\\n curr_action = new_action\\n \\n stop = time.time()\\n print(\\\"Training Completed.\\\")\\n print(\\\"It took: {0} iterations and {1} minutes\\\".format(k,(stop-start)/60))\\n \\n ############################\\n det_policy = np.argmax(Q_value, axis=1)\\n return Q_value, det_policy\",\n \"def sgd_optimization(dataset, learning_rate, n_epochs, batch_size):\\n datasets = load_data(dataset)\\n train_set_x, train_set_y = datasets[0]\\n valid_set_x, valid_set_y = datasets[1]\\n test_set_x, test_set_y = datasets[2]\\n\\n #number of minibatches\\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\\n n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size\\n n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size\\n\\n #build the model\\n print \\\"... building the model\\\"\\n\\n index = T.lscalar()\\n x = T.matrix('x') #data for the rasterized images\\n y = T.ivector('y') # labels (int)\\n\\n # logistic regression Class\\n classifierLR = LogisticRegression(input=x, n_in=28*28, n_out=10)\\n cost = classifierLR.negative_log_likelihood(y)\\n\\n # test model (no updates)\\n test_model = theano.function(\\n inputs=[index],\\n outputs=classifierLR.errors(y),\\n givens={\\n x: test_set_x[index * batch_size: (index + 1) * batch_size],\\n y: test_set_y[index * batch_size: (index + 1) * batch_size]\\n }\\n )\\n\\n #validate model (no updates)\\n validate_model = theano.function(\\n inputs=[index],\\n outputs=classifierLR.errors(y),\\n givens={\\n x: valid_set_x[index * batch_size: (index + 1) * batch_size],\\n y: valid_set_y[index * batch_size: (index + 1) * batch_size]\\n }\\n )\\n\\n #compute the gradient of cost wrt W, b\\n g_W = T.grad(cost=cost, wrt=classifierLR.W)\\n g_b = T.grad(cost=cost, wrt=classifierLR.b)\\n\\n #updating expression\\n updates = [(classifierLR.W, classifierLR.W - learning_rate * g_W),\\n (classifierLR.b, classifierLR.b - learning_rate * g_b)]\\n\\n # Train model (theano function); updates\\n train_model = theano.function(\\n inputs=[index],\\n outputs=cost,\\n updates=updates,\\n givens={\\n x: train_set_x[index * batch_size: (index + 1) * batch_size],\\n y: train_set_y[index * batch_size: (index + 1) * batch_size]\\n\\n }\\n )\\n\\n # Training model (early stopping with validation examples)\\n print \\\"... training the model\\\"\\n patience = 5000\\n patience_inc = 2 # wait this much\\n improved_threshold = 0.995 # relative improvement (significant)\\n validation_frequency = min(n_train_batches, patience / 2)\\n best_validation_loss = numpy.inf\\n test_score = 0.\\n start_time = timeit.default_timer()\\n\\n done_looping = False\\n epoch = 0\\n while (epoch < n_epochs) and (not done_looping):\\n epoch += 1\\n for minibatch_index in xrange(n_train_batches):\\n minibatch_avg_cost = train_model(minibatch_index)\\n iter = (epoch - 1) * n_train_batches + minibatch_index\\n\\n if (iter + 1) % validation_frequency == 0:\\n # compute loss on validation set\\n validation_losses = [validate_model(i) for i in xrange(n_valid_batches)]\\n this_validation_loss = numpy.mean(validation_losses)\\n\\n print(\\n \\\"Epoch: %i, minibatch: %i/%i, validation_error: %f %%\\\" %\\n (\\n epoch,\\n minibatch_index + 1,\\n n_train_batches,\\n this_validation_loss * 100.\\n )\\n )\\n\\n if this_validation_loss < best_validation_loss:\\n #improve patience if good improvement\\n if this_validation_loss < best_validation_loss * improved_threshold:\\n patience = max(patience, iter * patience_inc)\\n\\n best_validation_loss = this_validation_loss\\n\\n #testing on test_set\\n test_losses = [test_model(i) for i in xrange(n_test_batches)]\\n test_score = numpy.mean(test_losses)\\n\\n print(\\n (\\n \\\"Epoch : %i, minibatch %i/%i,\\\"\\n \\\" test error of best model %f %%\\\"\\n ) % (\\n epoch,\\n minibatch_index,\\n n_train_batches,\\n test_score * 100.\\n )\\n )\\n\\n #save the best model\\n print \\\"New best model found; saving ...\\\"\\n with open('best_model.pkl', \\\"w\\\") as f:\\n cPickle.dump(classifierLR, f)\\n\\n if patience <= iter:\\n done_looping = True\\n break\\n\\n\\n end_time = timeit.default_timer()\\n print(\\n (\\n \\\"Optimization Complete: best validation score : %f %%,\\\"\\n \\\" test performance : %f %%\\\"\\n )\\n % (best_validation_loss * 100., test_score * 100.)\\n )\\n print \\\"The code run for %d epochs, with %f epochs/sec\\\" %(epoch, 1. * epoch / (end_time - start_time))\\n print >> sys.stderr, (\\\"The code for file \\\" + os.path.split(__file__)[1] + \\\" ran for %.1fs\\\" % ((end_time - start_time)))\",\n \"def cs_grad_estimator(self, test_batch_size=None):\\n\\n # Get a session.\\n sess = self.sess\\n # Initialize variables.\\n try:\\n tf.global_variables_initializer().run()\\n except:\\n tf.initialize_all_variables().run()\\n\\n # Set CS example batch size.\\n if test_batch_size is not None:\\n self.cs_bsize = test_batch_size\\n else:\\n if not self.cs_m_and_orig:\\n self.cs_bsize = FLAGS.cs_batch_size\\n else:\\n self.cs_bsize = FLAGS.cs_batch_size + FLAGS.batch_size # When original images are used.\\n\\n # Create the generator.\\n if self.contrastive_learning:\\n self.cs_input_labels = tf.placeholder(tf.int32, shape=(self.cs_bsize), name='cs_input_labels')\\n\\n # The z latent variable.\\n self.z_batch = tf.Variable(tf.random_normal([self.cs_bsize * FLAGS.cs_num_random_restarts, self.z_dim]),\\n name='z_batch')\\n\\n # Regularizer.\\n self.zp_loss_batch = tf.reduce_mean(self.z_batch ** 2, 1)\\n\\n # Placeholder for initializing z.\\n self.z_init_pl = tf.placeholder(tf.float32, [self.cs_bsize * FLAGS.cs_num_random_restarts, self.z_dim])\\n self.z_init_op = tf.assign(self.z_batch, self.z_init_pl)\\n\\n cs_batch_size = self.cs_bsize * FLAGS.cs_num_random_restarts\\n self.cs_batch_size = cs_batch_size\\n\\n # CS loss (The same function is used for encoder input).\\n self.cs_loss(self.z_batch, cs_batch_size=cs_batch_size)\\n\\n # Set up gradient descent optimizer.\\n global_step = tf.Variable(0, trainable=False)\\n self.cs_learning_rate = get_cs_learning_rate(global_step)\\n with tf.variable_scope(tf.get_variable_scope(), reuse=False):\\n opt = tf.train.AdamOptimizer(self.cs_learning_rate)\\n self.cs_update_op = opt.minimize(self.cs_total_loss, var_list=[self.z_batch], global_step=global_step,\\n name='update_op')\\n\\n # Get optimizer variables to re-initialize before each estimator call.\\n uninitialized_vars = []\\n for var in tf.global_variables():\\n try:\\n sess.run(var)\\n except tf.errors.FailedPreconditionError:\\n print '[WARNING] UNINIT {}'.format(var.op.name)\\n uninitialized_vars.append(var)\\n self.cs_initialize_op = tf.variables_initializer(uninitialized_vars)\",\n \"def getCsnnOptimizerOp(self, global_step):\\n # Define loss and optimizer\\n csnn_optimizer, _ = self.__csnn.applySomLearning(global_step, self.__num_gpus)\\n return csnn_optimizer\",\n \"def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\\n\\n # Raise('NotImplementedError: only adjusted the arguments.')\\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\\n #precompute the expensive operation:\\n lin_penalties = 1/np.sqrt(2*eta_lin)\\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\\n #!!!!\\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\\n #!!!!\\n u_prev = u_init + 1\\n u = u_init\\n count = 0\\n obj_history = []\\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\\n start = time.time()\\n \\n u_prev = np.copy(u)\\n w_0 = w_0_update(eta_0, u, T, alpha, B) \\n w = w_update(u, H, gamma, D, C) \\n w_lin = w_lin_update(u, L_lhs, L_rhs)\\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\\n #!!!!\\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\\n #!!!!\\n count += 1 \\n if count == 10:\\n u_inf = np.copy(u)\\n w_0_inf = w_0[:]\\n w_inf = w[:]\\n w_lin_inf = w_lin[:]\\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\\n \\n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\\n obj_history.append(cur_obj)\\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\\n relaxed_obj_history.append(cur_relaxed_obj) \\n \\n stop = time.time()\\n duration = stop-start\\n \\n if count%1 == 0 and verbose: \\n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\\n print(' This iteration took: {}'.format(duration))\\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history\",\n \"def __init__(self, optimizer):\\n super(ShardedOptimizer, self).__init__(optimizer, name=\\\"ShardedOptimizer\\\")\",\n \"def __init__(self,\\n weight_decay,\\n global_step,\\n max_matrix_size=768,\\n gbar_decay=0.0,\\n gbar_weight=1.0,\\n mat_gbar_decay=1.0,\\n mat_gbar_weight=1.0,\\n learning_rate=1.0,\\n svd_interval=1,\\n precond_update_interval=1,\\n epsilon=1e-4,\\n alpha=0.5,\\n use_iterative_root=False,\\n use_locking=False,\\n name=\\\"ShampooW\\\"):\\n super(ShampooWOptimizer, self).__init__(\\n weight_decay,\\n global_step=global_step,\\n max_matrix_size=max_matrix_size,\\n gbar_decay=gbar_decay,\\n gbar_weight=gbar_weight,\\n mat_gbar_decay=mat_gbar_weight,\\n learning_rate=learning_rate,\\n svd_interval=svd_interval,\\n precond_update_interval=precond_update_interval,\\n epsilon=epsilon,\\n alpha=alpha,\\n use_iterative_root=use_iterative_root,\\n use_locking=use_locking,\\n name=name)\",\n \"def _batch_descent_on_samples(self, positivity_state_samples_all,\\n derivative_state_samples_all, optimizer,\\n positivity_state_repeatition,\\n derivative_state_repeatition,\\n options: AdversarialTrainingOptions):\\n derivative_state_samples_next_all =\\\\\\n self.lyapunov_hybrid_system.system.step_forward(\\n derivative_state_samples_all)\\n positivity_sample_initial_loss, derivative_sample_initial_loss = \\\\\\n self.sample_loss(\\n positivity_state_samples_all,\\n derivative_state_samples_all,\\n derivative_state_samples_next_all,\\n self.lyapunov_positivity_sample_cost_weight,\\n self.lyapunov_derivative_sample_cost_weight,\\n positivity_state_repeatition,\\n derivative_state_repeatition)\\n best_loss = positivity_sample_initial_loss +\\\\\\n derivative_sample_initial_loss\\n best_training_params = self._get_current_training_params()\\n if self.output_flag:\\n print(\\\"Before training, positivity_sample_loss \\\" +\\n f\\\"{positivity_sample_initial_loss.item()}, \\\" +\\n \\\"derivative_sample_loss \\\" +\\n f\\\"{derivative_sample_initial_loss.item()}\\\")\\n positivity_dataset = torch.utils.data.TensorDataset(\\n positivity_state_samples_all, positivity_state_repeatition)\\n derivative_dataset = torch.utils.data.TensorDataset(\\n derivative_state_samples_all, derivative_state_repeatition)\\n # TODO(hongkai.dai): currently by using batch_size, I don't guarantee\\n # to get options.num_batches batches in the dataset. Write a customized\\n # loader later.\\n positivity_loader = torch.utils.data.DataLoader(\\n positivity_dataset,\\n batch_size=int(\\n np.ceil(len(positivity_dataset) / options.num_batches)),\\n shuffle=True)\\n derivative_loader = torch.utils.data.DataLoader(\\n derivative_dataset,\\n batch_size=int(\\n np.ceil(len(derivative_dataset) / options.num_batches)),\\n shuffle=True)\\n for epoch in range(options.num_epochs_per_mip):\\n it_positivity_samples = iter(positivity_loader)\\n it_derivative_samples = iter(derivative_loader)\\n for i in range(\\n np.min((len(positivity_loader), len(derivative_loader)))):\\n optimizer.zero_grad()\\n positivity_state_batch, positivity_state_repeatition_batch =\\\\\\n next(it_positivity_samples)\\n derivative_state_batch, derivative_state_repeatition_batch =\\\\\\n next(it_derivative_samples)\\n derivative_state_next_batch = \\\\\\n self.lyapunov_hybrid_system.system.step_forward(\\n derivative_state_batch)\\n positivity_sample_loss, derivative_sample_loss = \\\\\\n self.sample_loss(\\n positivity_state_batch, derivative_state_batch,\\n derivative_state_next_batch,\\n self.lyapunov_positivity_sample_cost_weight,\\n self.lyapunov_derivative_sample_cost_weight,\\n positivity_state_repeatition_batch,\\n derivative_state_repeatition_batch)\\n batch_loss = positivity_sample_loss +\\\\\\n derivative_sample_loss\\n batch_loss.backward()\\n optimizer.step()\\n\\n derivative_state_samples_next_all =\\\\\\n self.lyapunov_hybrid_system.system.step_forward(\\n derivative_state_samples_all)\\n positivity_sample_epoch_loss, derivative_sample_epoch_loss = \\\\\\n self.sample_loss(\\n positivity_state_samples_all,\\n derivative_state_samples_all,\\n derivative_state_samples_next_all,\\n self.lyapunov_positivity_sample_cost_weight,\\n self.lyapunov_derivative_sample_cost_weight,\\n positivity_state_repeatition,\\n derivative_state_repeatition)\\n if self.output_flag:\\n print(f\\\"epoch {epoch}, positivity_sample_loss \\\" +\\n f\\\"{positivity_sample_epoch_loss.item()}, \\\" +\\n \\\"derivative_sample_loss \\\" +\\n f\\\"{derivative_sample_epoch_loss.item()}\\\")\\n if positivity_sample_epoch_loss == 0. and\\\\\\n derivative_sample_epoch_loss == 0.:\\n return\\n if positivity_sample_epoch_loss + derivative_sample_epoch_loss <\\\\\\n best_loss:\\n best_training_params = self._get_current_training_params()\\n best_loss = positivity_sample_epoch_loss +\\\\\\n derivative_sample_epoch_loss\\n # End of training, set the training parameters to the one\\n # corresponding to the best loss\\n self._set_training_params(best_training_params)\\n pass\",\n \"def testSecondDerivatives(self):\\n problem = problems.simple()\\n optimizer = meta.MetaOptimizer(net=dict(\\n net=\\\"CoordinateWiseDeepLSTM\\\",\\n net_options={\\\"layers\\\": ()}))\\n minimize_ops = optimizer.meta_minimize(problem, 3,\\n second_derivatives=True)\\n with self.test_session() as sess:\\n sess.run(tf.global_variables_initializer())\\n train(sess, minimize_ops, 1, 2)\",\n \"def _sa1():\\n The.optimize.early=4\\n sa(ZDT1)\",\n \"def set_optimizer_sgd(self):\\n sgd = optimizers.SGD(lr=self.lr, momentum=self.momentum, decay=0.0, nesterov=False)\\n self.optimizer = sgd\",\n \"def train_adversarial(self, positivity_state_samples_init: torch.Tensor,\\n derivative_state_samples_init: torch.Tensor,\\n options: AdversarialTrainingOptions):\\n assert (self.add_derivative_adversarial_state)\\n assert (self.add_positivity_adversarial_state)\\n if self.output_flag:\\n self.print()\\n if self.enable_wandb:\\n options.wandb_config()\\n\\n train_start_time = time.time()\\n positivity_state_samples_all = positivity_state_samples_init.clone()\\n derivative_state_samples_all = derivative_state_samples_init.clone()\\n positivity_state_repeatition = torch.ones(\\n (positivity_state_samples_all.shape[0], ),\\n dtype=positivity_state_samples_all.dtype)\\n derivative_state_repeatition = torch.ones(\\n (derivative_state_samples_all.shape[0], ),\\n dtype=derivative_state_samples_all.dtype)\\n iter_count = 0\\n training_params = self._training_params()\\n while iter_count < self.max_iterations:\\n # Now solve MIP to find adversarial states.\\n lyapunov_positivity_mip, lyapunov_positivity_mip_obj,\\\\\\n positivity_mip_adversarial = self.solve_positivity_mip()\\n lyapunov_derivative_mip, lyapunov_derivative_mip_obj,\\\\\\n derivative_mip_adversarial, _ = self.solve_derivative_mip()\\n if not np.isinf(options.adversarial_cluster_radius):\\n positivity_mip_adversarial,\\\\\\n positivity_mip_adversarial_repeatition =\\\\\\n _cluster_adversarial_states(\\n positivity_mip_adversarial,\\n options.adversarial_cluster_radius)\\n derivative_mip_adversarial,\\\\\\n derivative_mip_adversarial_repeatition =\\\\\\n _cluster_adversarial_states(\\n derivative_mip_adversarial,\\n options.adversarial_cluster_radius)\\n # else:\\n # positivity_mip_adversarial_repeatition = torch.ones(\\n # (positivity_mip_adversarial.shape[0], ),\\n # dtype=positivity_mip_adversarial.dtype)\\n # derivative_mip_adversarial_repeatition = torch.ones(\\n # (derivative_mip_adversarial.shape[0], ),\\n # dtype=derivative_mip_adversarial.dtype)\\n positivity_state_samples_all = torch.cat(\\n (positivity_state_samples_all, positivity_mip_adversarial),\\n dim=0)\\n derivative_state_samples_all = torch.cat(\\n (derivative_state_samples_all, derivative_mip_adversarial),\\n dim=0)\\n # positivity_state_repeatition = torch.cat(\\n # (positivity_state_repeatition,\\n # positivity_mip_adversarial_repeatition),\\n # dim=0)\\n positivity_state_repeatition = torch.ones((\\n positivity_state_samples_all.shape[0],),\\n dtype=positivity_state_samples_all.dtype)\\n # derivative_state_repeatition = torch.cat(\\n # (derivative_state_repeatition,\\n # derivative_mip_adversarial_repeatition),\\n # dim=0)\\n derivative_state_repeatition = torch.ones((\\n derivative_state_samples_all.shape[0],),\\n dtype=derivative_state_samples_all.dtype)\\n if positivity_state_samples_all.shape[\\n 0] > options.positivity_samples_pool_size:\\n positivity_state_samples_all = positivity_state_samples_all[\\n -options.positivity_samples_pool_size:, :]\\n positivity_state_repeatition = positivity_state_repeatition[\\n -options.positivity_samples_pool_size:]\\n if derivative_state_samples_all.shape[\\n 0] > options.derivative_samples_pool_size:\\n derivative_state_samples_all = derivative_state_samples_all[\\n -options.derivative_samples_pool_size:, :]\\n derivative_state_repeatition = derivative_state_repeatition[\\n -options.derivative_samples_pool_size:]\\n if self.output_flag:\\n print(f\\\"Iter {iter_count}, positivity cost \\\" +\\n f\\\"{lyapunov_positivity_mip_obj}, \\\" + \\\"derivative_cost \\\" +\\n f\\\"{lyapunov_derivative_mip_obj}\\\")\\n if self.enable_wandb:\\n wandb.log({\\n \\\"positivity MIP cost\\\": lyapunov_positivity_mip_obj,\\n \\\"derivative MIP cost\\\": lyapunov_derivative_mip_obj,\\n \\\"time\\\": time.time() - train_start_time\\n })\\n if lyapunov_positivity_mip_obj < \\\\\\n self.lyapunov_positivity_convergence_tol and\\\\\\n lyapunov_derivative_mip_obj < \\\\\\n self.lyapunov_derivative_convergence_tol:\\n return True, positivity_state_samples_all,\\\\\\n derivative_state_samples_all\\n # Now do gradient descent on the adversarial states.\\n if self.optimizer == \\\"Adam\\\":\\n optimizer = torch.optim.Adam(training_params,\\n lr=self.learning_rate)\\n elif self.optimizer == \\\"SGD\\\":\\n optimizer = torch.optim.SGD(training_params,\\n lr=self.learning_rate,\\n momentum=self.momentum)\\n self._batch_descent_on_samples(positivity_state_samples_all,\\n derivative_state_samples_all,\\n optimizer,\\n positivity_state_repeatition,\\n derivative_state_repeatition,\\n options)\\n iter_count += 1\\n return False, positivity_state_samples_all,\\\\\\n derivative_state_samples_all, positivity_state_repeatition,\\\\\\n derivative_state_repeatition\",\n \"def sgd_updates_adadelta(params,cost,rho=0.95,epsilon=1e-6,norm_lim=9,word_vec_name='Words'):\\n updates = OrderedDict({})\\n exp_sqr_grads = OrderedDict({})\\n exp_sqr_ups = OrderedDict({})\\n gparams = []\\n for param in params:\\n empty = np.zeros_like(param.get_value())\\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),name=\\\"exp_grad_%s\\\" % param.name)\\n gp = T.grad(cost, param)\\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty), name=\\\"exp_grad_%s\\\" % param.name)\\n gparams.append(gp)\\n for param, gp in zip(params, gparams):\\n exp_sg = exp_sqr_grads[param]\\n exp_su = exp_sqr_ups[param]\\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\\n updates[exp_sg] = up_exp_sg\\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\\n stepped_param = param + step\\n if (param.get_value(borrow=True).ndim == 2) and (param.name != 'Words') and (param.name != 'Topics'):\\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\\n scale = desired_norms / (1e-7 + col_norms)\\n updates[param] = stepped_param * scale\\n else:\\n updates[param] = stepped_param \\n return updates\",\n \"def sac(args):\\n device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\\n torch.manual_seed(args.seed)\\n torch.cuda.manual_seed(args.seed)\\n np.random.seed(args.seed)\\n # initialization\\n env = gym.make(args.game)\\n s_space = env.observation_space\\n a_space = env.action_space\\n print(s_space.shape, ' ', a_space.shape)\\n ac = ActorCritic(s_space, a_space, orth_norm=False)\\n optimizer_pi = torch.optim.Adam(ac.pi.parameters(), lr=args.lr_pi)\\n optimizer_q1 = torch.optim.Adam(ac.q1.parameters(), lr=args.lr_q)\\n optimizer_q2 = torch.optim.Adam(ac.q2.parameters(), lr=args.lr_q)\\n ac_target = deepcopy(ac) # initialize target Q1 and Q2\\n for p in ac_target.parameters(): # freeze target networks' parameters\\n p.requires_grad = False\\n q_params = itertools.chain(ac.q1.parameters(), ac.q2.parameters()) # q1 and q2 params getheter\\n alpha = args.alpha\\n entropy_target = -np.prod(a_space.shape)\\n\\n def update_q(s, a):\\n # compute Q loss, and update\\n q1 = ac.q1(s, a)\\n q2 = ac.q2(s, a)\\n with torch.no_grad(): # notice here!\\n an, logp_an = ac.pi(sn) # target actions come from current policy\\n q1_hat = ac_target.q1(sn, an)\\n q2_hat = ac_target.q2(sn, an)\\n q_target = r + args.gamma * d * (torch.min(q1_hat, q2_hat) - alpha * logp_an)\\n for p in q_params:\\n p.requires_grad = True\\n loss_q1 = ((q1 - q_target) ** 2).mean()\\n loss_q2 = ((q2 - q_target) ** 2).mean()\\n loss_q = loss_q1 + loss_q2\\n optimizer_q1.zero_grad()\\n optimizer_q2.zero_grad()\\n loss_q.backward()\\n optimizer_q1.step()\\n optimizer_q2.step()\\n\\n def update_pi(s):\\n # compute pi loss, and update\\n a_new, logp_a_new = ac.pi(s)\\n q1_pi = ac.q1(s, a_new)\\n q2_pi = ac.q2(s, a_new)\\n q_pi = torch.min(q1_pi, q2_pi)\\n loss_pi = (alpha * logp_a_new - q_pi).mean()\\n optimizer_pi.zero_grad()\\n loss_pi.backward()\\n optimizer_pi.step()\\n\\n # Main loop\\n ep_r_mean = []\\n returns = 0 # compute an episode's total reward\\n s = env.reset()\\n\\n replay_buffer = ReplayBuffer(args.buf_size, s_space, a_space)\\n for epoch in range(args.epochs): # times of getting replay buffer\\n \\\"\\\"\\\"\\n for example:\\n every epoch sample step(s,a,r,d,sn) 2000 times\\n then get minibatch and train and update 200 times\\n \\\"\\\"\\\"\\n\\n episode_ret = [] # collect every episode's total reward\\n\\n for step in range(args.pre_epoch_steps):\\n if replay_buffer.pointer < 10000: # increase exploration\\n a = env.action_space.sample()\\n else:\\n a = ac.step(torch.as_tensor(s, dtype=torch.float32))\\n sn, r, done, _ = env.step(a)\\n returns += r\\n d = 0 if done else 1\\n replay_buffer.store(s, a, r, d, sn)\\n if done:\\n s = env.reset()\\n episode_ret.append(returns)\\n returns = 0\\n else:\\n s = sn\\n # record mean episode's total return in every epoch\\n ep_r_mean.append({'epochs': epoch+1, 'traj_nums': len(episode_ret), 'mean_ep_r': np.mean(episode_ret)})\\n print('epoch:', epoch+1, ' --- tarj_nums:', len(episode_ret), ' --- mean_ep_r:', np.mean(episode_ret))\\n # now we have completed to collect a replay_buffer\\n # sample mini batch from buffer and update pi\\\\q networks\\n if replay_buffer.pointer > 3000:\\n for update in range(args.update_time):\\n # prepare\\n ac.to(device)\\n ac_target.to(device)\\n mini_batch = replay_buffer.sample_minibatch(args.batch_size)\\n s_gpu, a, r, d, sn = mini_batch['s'].to(device),\\\\\\n mini_batch['a'].to(device),\\\\\\n mini_batch['r'].to(device),\\\\\\n mini_batch['d'].to(device),\\\\\\n mini_batch['sn'].to(device)\\n # compute Q loss, and update\\n update_q(s_gpu, a)\\n # Freeze Q networks, so don't waste computational effort\\n for p in q_params:\\n p.requires_grad = False\\n # compute pi loss, and update\\n update_pi(s_gpu)\\n # Unfreeze Q networks\\n for p in q_params:\\n p.requires_grad = True\\n # compute alpha loss, and update\\n with torch.no_grad():\\n a_new, logp_a_new = ac.pi(s_gpu)\\n alpha = alpha * (1 + args.lr_alpha * ((logp_a_new + entropy_target).mean()))\\n if alpha > 1 or alpha < 0:\\n print(\\\"Warning: alpha's value is error! \\\", alpha)\\n # Update ac_target.q1\\\\2\\n with torch.no_grad():\\n for p, p_target in zip(ac.parameters(), ac_target.parameters()):\\n p_target.data.copy_(args.tau * p.data + (1.0-args.tau) * p_target.data)\\n ac.cpu()\\n ac_target.cpu()\\n return ac, ac_target, ep_r_mean\",\n \"def compile_update_svdd(nnet, inputs, targets):\\n\\n floatX = Cfg.floatX\\n B = Cfg.B\\n C = Cfg.C\\n nu = Cfg.nu\\n\\n # initialize R\\n if nnet.R_init > 0:\\n nnet.Rvar = shared(floatX(nnet.R_init), name=\\\"R\\\")\\n else:\\n nnet.Rvar = shared(floatX(1), name=\\\"R\\\") # initialization with R=1\\n\\n # Loss\\n feature_layer = nnet.all_layers[-1]\\n rep = lasagne.layers.get_output(feature_layer, inputs=inputs,\\n deterministic=False)\\n\\n # initialize c (0.5 in every feature representation dimension)\\n rep_dim = feature_layer.num_units\\n # nnet.cvar = shared(floatX(np.ones(rep_dim) * (1. / (rep_dim ** 0.5))),\\n # name=\\\"c\\\")\\n nnet.cvar = shared(floatX(np.ones(rep_dim) * 0.5), name=\\\"c\\\")\\n\\n dist = T.sum(((rep - nnet.cvar.dimshuffle('x', 0)) ** 2),\\n axis=1, dtype='floatX')\\n scores = dist - nnet.Rvar\\n stack = T.stack([T.zeros_like(scores), scores], axis=1)\\n loss = T.cast(T.sum(T.max(stack, axis=1)) / (inputs.shape[0] * nu),\\n dtype='floatX')\\n\\n y_pred = T.argmax(stack, axis=1)\\n acc = T.cast((T.sum(T.eq(y_pred.flatten(), targets), dtype='int32')\\n * 1. / targets.shape[0]), 'floatX')\\n\\n # Network weight decay\\n if Cfg.weight_decay:\\n l2_penalty = (1/C) * get_l2_penalty(nnet,\\n include_bias=Cfg.include_bias,\\n pow=Cfg.pow)\\n else:\\n l2_penalty = T.cast(0, dtype='floatX')\\n\\n # Network activation sparsity regularization\\n if Cfg.sparsity_penalty:\\n sparsity_penalty = (1/B) * get_sparsity_penalty(nnet, inputs,\\n Cfg.sparsity,\\n mode=Cfg.sparsity_mode,\\n deterministic=False)\\n else:\\n sparsity_penalty = T.cast(0, dtype='floatX')\\n\\n # Backpropagation (hard-margin: only minimizing everything to a ball\\n # centered at c)\\n trainable_params = lasagne.layers.get_all_params(feature_layer,\\n trainable=True)\\n if Cfg.gaussian_blob:\\n avg_dist = T.mean(1-T.exp(-dist), dtype=\\\"floatX\\\")\\n else:\\n avg_dist = T.mean(dist, dtype=\\\"floatX\\\")\\n obj_ball = T.cast(floatX(0.5) * l2_penalty + avg_dist + sparsity_penalty,\\n dtype='floatX')\\n updates_ball = get_updates(nnet, obj_ball, trainable_params,\\n solver=nnet.solver)\\n nnet.backprop_ball = theano.function([inputs, targets], [obj_ball, acc],\\n updates=updates_ball)\\n\\n # Backpropagation (without training R)\\n obj = T.cast(floatX(0.5) * l2_penalty + nnet.Rvar + loss + sparsity_penalty,\\n dtype='floatX')\\n updates = get_updates(nnet, obj, trainable_params, solver=nnet.solver)\\n nnet.backprop_without_R = theano.function([inputs, targets], [obj, acc],\\n updates=updates)\\n\\n # Backpropagation (with training R)\\n trainable_params.append(nnet.Rvar) # add radius R to trainable parameters\\n updates = get_updates(nnet, obj, trainable_params, solver=nnet.solver)\\n nnet.backprop = theano.function([inputs, targets], [obj, acc],\\n updates=updates)\\n\\n\\n # Forwardpropagation\\n test_rep = lasagne.layers.get_output(feature_layer, inputs=inputs,\\n deterministic=True)\\n test_rep_norm = test_rep.norm(L=2, axis=1)\\n\\n test_dist = T.sum(((test_rep - nnet.cvar.dimshuffle('x', 0)) ** 2),\\n axis=1, dtype='floatX')\\n\\n test_scores = test_dist - nnet.Rvar\\n test_stack = T.stack([T.zeros_like(test_scores), test_scores], axis=1)\\n test_loss = T.cast(T.sum(T.max(test_stack, axis=1)) / (inputs.shape[0]*nu),\\n dtype='floatX')\\n\\n test_y_pred = T.argmax(test_stack, axis=1)\\n test_acc = T.cast((T.sum(T.eq(test_y_pred.flatten(), targets),\\n dtype='int32')\\n * 1. / targets.shape[0]), dtype='floatX')\\n\\n # Network activation sparsity regularization (with determinisitc=True)\\n if Cfg.sparsity_penalty:\\n test_sparsity_penalty = ((1 / B) *\\n get_sparsity_penalty(nnet, inputs,\\n Cfg.sparsity,\\n mode=Cfg.sparsity_mode,\\n deterministic=True))\\n else:\\n test_sparsity_penalty = T.cast(0, dtype='floatX')\\n\\n test_obj = T.cast(floatX(0.5) * l2_penalty + nnet.Rvar + test_loss\\n + test_sparsity_penalty, dtype='floatX')\\n nnet.forward = theano.function([inputs, targets],\\n [test_obj, test_acc, test_scores,\\n floatX(0.5) * l2_penalty,\\n test_sparsity_penalty, test_rep,\\n test_rep_norm, test_loss, nnet.Rvar])\",\n \"def sgd_updates_adadelta(params,cost,rho=0.95,epsilon=1e-6,norm_lim=9,word_vec_name='Words'):\\n updates = OrderedDict({})\\n exp_sqr_grads = OrderedDict({})\\n exp_sqr_ups = OrderedDict({})\\n gparams = []\\n for param in params:\\n empty = np.zeros_like(param.get_value())\\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),name=\\\"exp_grad_%s\\\" % param.name)\\n gp = T.grad(cost, param)\\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty), name=\\\"exp_grad_%s\\\" % param.name)\\n gparams.append(gp)\\n for param, gp in zip(params, gparams):\\n exp_sg = exp_sqr_grads[param]\\n exp_su = exp_sqr_ups[param]\\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\\n updates[exp_sg] = up_exp_sg\\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\\n stepped_param = param + step\\n if (param.get_value(borrow=True).ndim == 2) and (param.name!='Words'):\\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\\n scale = desired_norms / (1e-7 + col_norms)\\n updates[param] = stepped_param * scale\\n else:\\n updates[param] = stepped_param \\n return updates\",\n \"def sgd_updates_adadelta(params,cost,rho=0.95,epsilon=1e-6,norm_lim=9,word_vec_name='Words'):\\n updates = OrderedDict({})\\n exp_sqr_grads = OrderedDict({})\\n exp_sqr_ups = OrderedDict({})\\n gparams = []\\n for param in params:\\n empty = np.zeros_like(param.get_value())\\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),name=\\\"exp_grad_%s\\\" % param.name)\\n gp = T.grad(cost, param)\\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty), name=\\\"exp_grad_%s\\\" % param.name)\\n gparams.append(gp)\\n for param, gp in zip(params, gparams):\\n exp_sg = exp_sqr_grads[param]\\n exp_su = exp_sqr_ups[param]\\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\\n updates[exp_sg] = up_exp_sg\\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\\n stepped_param = param + step\\n if (param.get_value(borrow=True).ndim == 2) and (param.name!='Words'):\\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\\n scale = desired_norms / (1e-7 + col_norms)\\n updates[param] = stepped_param * scale\\n else:\\n updates[param] = stepped_param \\n return updates\",\n \"def adaptive_step(self):\\n\\n s = self\\n \\n # adaptive line search parameters\\n down_adjustment_frequency = 1\\n up_adjustment_frequency = 50\\n alpha=0.3 # acceptable fraction of predicted decrease\\n beta=0.8 # how much to shrink when violation\\n gamma=1.05 # how much to grow when too conservative\\n report_frequency = 1\\n \\n\\n s.model.advance_batch()\\n s.update_stats() # update cov matrices and svds\\n\\n s.grad.update() # gradient (ptodo, already updated in stats)\\n s.grad2.update() # gradient from synth labels (don't need?)\\n s.grad_new.update() # corrected gradient\\n\\n # TODO: decide on s vs s.\\n s.run(s.param_save_op) # TODO: insert lr somewhere\\n lr0, loss0 = s.run(s.lr, s.model.loss)\\n\\n s.run(s.param_update_op)\\n loss1 = s.run(s.model.loss)\\n \\n target_slope = -s.run(s.grad_dot_grad_new_op)\\n target_delta = lr0*target_slope\\n actual_delta = loss1 - loss0\\n actual_slope = actual_delta/lr0\\n slope_ratio = actual_slope/target_slope # between 0 and 1.01\\n \\n s.record('loss', loss0)\\n s.record('step_length', lr0)\\n s.record('grad_norm', s.run(s.grad_norm_op))\\n s.record('grad_new_norm', s.run(s.grad_new_norm_op))\\n s.record('target_delta', target_delta)\\n\\n if step_rejection and actual_delta > 0:\\n print('Observed increase in loss %.2f, rejecting step'%(actual_delta,))\\n s.run(s.param_restore_op)\\n\\n if s.step_counter % report_frequency == 0:\\n print('NStep %d loss %.2f, target decrease %.3f, actual decrease, %.3f ratio %.2f'%(self.step_counter, loss0, target_delta, actual_delta, slope_ratio))\\n\\n if (adaptive_step and s.step_counter % down_adjustment_frequency == 0 and\\n slope_ratio < alpha and abs(target_delta)>eps):\\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\\n print('Slope optimality %.2f, shrinking learning rate to %.2f'%(slope_ratio, lr0*beta,))\\n s.lr.set(lr0*beta)\\n elif (adaptive_step and s.step_counter % up_adjustment_frequency == 0 and\\n slope_ratio>0.90):\\n print('%.2f %.2f %.2f'%(loss0, loss1, slope_ratio))\\n print('Growing learning rate to %.2f'%(lr0*gamma))\\n s.lr.set(lr0*gamma)\\n \\n s.step_counter+=1\",\n \"def test_sag_adaptive():\\n np.random.seed(0)\\n X = sparse.rand(100, 10, density=.5, random_state=0).tocsr()\\n y = np.random.randint(0, high=2, size=100)\\n for alpha in np.logspace(-3, 1, 5):\\n clf_adaptive = SAGClassifier(\\n eta='line-search', random_state=0, alpha=alpha)\\n clf_adaptive.fit(X, y)\\n clf = SAGClassifier(\\n eta='auto', random_state=0, alpha=alpha)\\n clf.fit(X, y)\\n assert_almost_equal(clf_adaptive.score(X, y), clf.score(X, y), 1)\\n\\n clf_adaptive = SAGAClassifier(\\n eta='line-search', loss='log', random_state=0, alpha=alpha, max_iter=20)\\n clf_adaptive.fit(X, y)\\n assert np.isnan(clf_adaptive.coef_.sum()) == False\\n clf = SAGAClassifier(\\n eta='auto', loss='log', random_state=0, alpha=alpha, max_iter=20)\\n clf.fit(X, y)\\n assert_almost_equal(clf_adaptive.score(X, y), clf.score(X, y), 1)\",\n \"def SPSA(y, t0, a, c, delta, constraint=identity):\\n theta = t0\\n\\n # Pull off the ak and ck values forever\\n for ak, ck in izip(a, c):\\n # Get estimated gradient\\n gk = estimate_gk(y, theta, delta, ck)\\n\\n # Adjust theta estimate using SA\\n theta = [t - ak * gkk for t, gkk in izip(theta, gk)]\\n\\n # Constrain\\n theta = constraint(theta)\\n\\n yield theta # This makes this function become an iterator\",\n \"def SGD(self, tr_d, va_d, epochs, lr, relz=\\\"\\\", lmbda=0.0, mu=0.0,perc=1.0):\\n print \\\"Training the network with SGD......\\\"\\n trlen = len(tr_d)\\n batch_size = 10\\n j = 0\\n accuracy = []\\n while j < epochs:\\n random.shuffle(tr_d)\\n batches = [tr_d[k:k+batch_size] for k in xrange(0,trlen,batch_size)]\\n for tr_batch in batches:\\n if(relz[0:2] != \\\"DP\\\"):\\n self.update_network(tr_batch,lr, relz, lmbda, mu)\\n else:\\n self.update_network_dp(tr_batch,lr,relz[2:], lmbda,perc, mu)\\n acy = self.Evaluate(va_d)\\n accuracy.append(acy)\\n if (va_d):\\n print \\\"Epoch {0}: {1}/{2}\\\".format(j, acy, len(va_d))\\n else:\\n print \\\"Epoch {0}:\\\".format(j)\\n j += 1\\n np.save(\\\"test_acy_%s_qinit_1.npy\\\"%(relz), accuracy)\",\n \"def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\\n\\n\\n obj_lss = np.zeros(max_iter)\\n x_zs = np.zeros(max_iter)\\n u_norms = np.zeros(max_iter)\\n times = np.zeros(max_iter)\\n\\n ATy = AT_fun(y)\\n x_shape = ATy.shape\\n d = np.prod(x_shape)\\n\\n def A_cgs_fun(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x)) + alpha * x\\n return vec(y)\\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\\n\\n def compute_p_inv_A(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n\\n def A_cgs_fun_init(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x))\\n return vec(y)\\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\\n\\n def compute_init(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n # initialize z and u\\n z = compute_init(ATy, ATy)\\n u = np.zeros(x_shape)\\n\\n\\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\\n\\n\\n start_time = timeit.default_timer()\\n\\n for iter in range(max_iter):\\n\\n # x-update\\n net_input = z+u\\n Wzu, wbook = wavelet_transform(net_input)\\n q = soft_threshold(Wzu, lambda_l1/alpha)\\n x = inverse_wavelet_transform(q, wbook, x_shape)\\n x = np.reshape(x, x_shape)\\n\\n # z-update\\n b = ATy + alpha * (x - u)\\n z = compute_p_inv_A(b, z)\\n\\n # u-update\\n u += z - x;\\n\\n if show_img_progress == True:\\n\\n fig = plt.figure('current_sol')\\n plt.gcf().clear()\\n fig.canvas.set_window_title('iter %d' % iter)\\n plt.subplot(1,3,1)\\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('x')\\n plt.subplot(1,3,2)\\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('z')\\n plt.subplot(1,3,3)\\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('netin')\\n plt.pause(0.00001)\\n\\n\\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\\n x_z = np.sqrt(np.mean(np.square(x-z)))\\n u_norm = np.sqrt(np.mean(np.square(u)))\\n\\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\\n\\n\\n obj_lss[iter] = obj_ls\\n x_zs[iter] = x_z\\n u_norms[iter] = u_norm\\n times[iter] = timeit.default_timer() - start_time\\n\\n if x_z < solver_tol:\\n break\\n\\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\\n 'max_iter':max_iter, 'solver_tol':solver_tol}\\n\\n\\n return (x, z, u, infos)\",\n \"def _apply_dense(self, grad, var):\\n\\n assignments = []\\n\\n param_name = self._get_variable_name(var.name)\\n\\n m = self.get_slot(var, \\\"m\\\")\\n v = self.get_slot(var, \\\"v\\\")\\n\\n # Standard Adam update.\\n next_m = (\\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\\n next_v = (\\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\\n tf.square(grad)))\\n\\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\\n\\n # Just adding the square of the weights to the loss function is *not*\\n # the correct way of using L2 regularization/weight decay with Adam,\\n # since that will interact with the m and v parameters in strange ways.\\n #\\n # Instead we want ot decay the weights in a manner that doesn't interact\\n # with the m/v parameters. This is equivalent to adding the square\\n # of the weights to the loss with plain (non-momentum) SGD.\\n if self._do_use_weight_decay(param_name):\\n update += self.weight_decay_rate * var\\n\\n ratio = 1.0\\n if self._do_layer_adaptation(param_name):\\n w_norm = linalg_ops.norm(var, ord=2)\\n g_norm = linalg_ops.norm(update, ord=2)\\n ratio = array_ops.where(math_ops.greater(w_norm, 0), array_ops.where(\\n math_ops.greater(g_norm, 0), (w_norm / g_norm), 1.0), 1.0)\\n\\n update_with_lr = ratio * self.learning_rate * update\\n\\n next_param = var - update_with_lr\\n\\n assignments.extend(\\n [var.assign(next_param, use_locking=self._use_locking),\\n m.assign(next_m),\\n v.assign(next_v)])\\n return tf.group(*assignments)\",\n \"def adam_optim(config = None, global_step = None):\\n learning_rate = config[\\\"learning_rate\\\"]\\n\\n beta1 = config.get('beta1', 0.9)\\n beta2 = config.get('beta2', 0.999)\\n epsilon = config.get('epsilon', 1e-8)\\n \\n train_step = tf.train.AdamOptimizer(learning_rate, beta1, beta2, epsilon)\\n\\n return train_step\",\n \"def optimizer_creator(model, config):\\n return torch.optim.SGD(model.parameters(), lr=config.get(\\\"lr\\\", 1e-4))\",\n \"def sgd_optimize(self, train_set, test_set, n_epochs, learning_rate, batch_size):\\n\\n train_set_x, train_set_y, train_set_c = train_set\\n assert train_set_x.shape == (60000, 784)\\n assert train_set_y.shape == (60000,)\\n assert train_set_c.shape == (60000, 10)\\n\\n test_set_x, test_set_y, test_set_c = test_set\\n assert test_set_x.shape == (10000, 784)\\n assert test_set_y.shape == (10000,)\\n assert test_set_c.shape == (10000, 10)\\n\\n from toolbox import make_shared_data\\n\\n train_set_x = make_shared_data(train_set_x)\\n train_set_c = make_shared_data(train_set_c)\\n train_set_y = T.cast(make_shared_data(train_set_y), 'int32')\\n\\n test_set_x = make_shared_data(test_set_x)\\n test_set_c = make_shared_data(test_set_c)\\n test_set_y = T.cast(make_shared_data(test_set_y), 'int32')\\n\\n print '... building the model'\\n\\n index = T.lscalar()\\n\\n cost = self.MSE\\n\\n gparams = [T.grad(cost, param) for param in self.params]\\n\\n train_model = theano.function(\\n inputs=[index],\\n outputs=cost,\\n updates=[\\n (param, param - learning_rate * gparam)\\n for param, gparam in zip(self.params, gparams)\\n ],\\n givens={\\n self.input: train_set_x[index * batch_size: (index + 1) * batch_size],\\n self.cost_vector: train_set_c[index * batch_size: (index + 1) * batch_size]\\n },\\n name='train_model'\\n )\\n\\n in_sample_result = theano.function(\\n inputs=[],\\n outputs=[self.error, self.future_cost],\\n givens={\\n self.input: train_set_x,\\n self.y: train_set_y,\\n self.cost_vector: train_set_c\\n },\\n name='in_sample_result'\\n )\\n\\n out_sample_result = theano.function(\\n inputs=[],\\n outputs=[self.error, self.future_cost],\\n givens={\\n self.input: test_set_x,\\n self.y: test_set_y,\\n self.cost_vector: test_set_c\\n },\\n name='out_sample_result'\\n )\\n\\n n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size\\n\\n print '... training the model'\\n\\n best_Cout = np.inf\\n corresponding_Eout = np.inf\\n for epoch in xrange(n_epochs):\\n print 'epoch #%d' % (epoch + 1)\\n for batch_index in xrange(n_train_batches):\\n batch_cost = train_model(batch_index)\\n Ein, Cin = in_sample_result()\\n Eout, Cout = out_sample_result()\\n if Cout < best_Cout:\\n best_Cout = Cout\\n corresponding_Eout = Eout\\n print ' better performance achieved ... best_Cout = %f' % best_Cout\\n\\n print 'after training %d epochs, best_Cout = %f, and corresponding_Eout = %f' \\\\\\n % (n_epochs, best_Cout, corresponding_Eout)\",\n \"def cem_optimize(init_mean, cost_func, init_variance=1., samples=20, precision=1.0e-3,\\n steps=20, nelite=5, contraint_mean=None, constraint_variance=(-999999, 999999), device=\\\"cpu\\\"):\\n mean = init_mean\\n variance = torch.tensor([init_variance], device=device).repeat(mean.shape).float()\\n # print(mean.type(), variance.type())\\n step = 1\\n diff = 9999999\\n while diff > precision and step < steps:\\n dists = [distributions.MultivariateNormal(m, torch.diagflat(v+precision/10), device=device) for m, v in zip(mean, variance)]\\n candidates = [d.sample_n(samples) for d in dists]\\n candidates = torch.stack(candidates, dim=1)\\n costs = cost_func(candidates)\\n # we sort descending because we want a maximum reward\\n sorted_idx = torch.argsort(costs, dim=0, descending=True)\\n candidates = candidates[sorted_idx]\\n elite = candidates[:nelite]\\n new_mean = torch.mean(elite, dim=0)\\n variance = torch.var(elite, dim=0)\\n diff = torch.mean(torch.abs(mean - new_mean))\\n mean = new_mean\\n # print(mean, variance)\\n if not contraint_mean is None:\\n mean = clip(mean, contraint_mean[0], contraint_mean[1])\\n step += 1\\n\\n return mean\",\n \"def tsne(X = Math.array([]), no_dims = 2, initial_dims = 50, perplexity = 30.0):\\n \\n # Check inputs\\n if X.dtype != \\\"float64\\\":\\n raise ValueError(\\\"array X should have type float64.\\\")\\n #if no_dims.__class__ != \\\"<type 'int'>\\\": # doesn't work yet!\\n # print \\\"Error: number of dimensions should be an integer.\\\";\\n # return -1;\\n \\n # Initialize variables\\n if X.shape[1] > initial_dims:\\n print \\\"Reducing the dimensionality to %d\\\" %initial_dims\\n X = pca(X, initial_dims);\\n (n, d) = X.shape;\\n max_iter = 1000;\\n initial_momentum = 0.5;\\n final_momentum = 0.8;\\n eta = 500;\\n min_gain = 0.01;\\n Y = Math.random.randn(n, no_dims);\\n dY = Math.zeros((n, no_dims));\\n iY = Math.zeros((n, no_dims));\\n gains = Math.ones((n, no_dims));\\n \\n # Compute P-values\\n P = x2p(X, 1e-5, perplexity);\\n P = P + Math.transpose(P);\\n P = P / Math.sum(P);\\n P = P * 4; # early exaggeration\\n P = Math.maximum(P, 1e-12);\\n \\n # Run iterations\\n for iter in range(max_iter):\\n \\n # Compute pairwise affinities\\n sum_Y = Math.sum(Math.square(Y), 1); \\n num = 1 / (1 + Math.add(Math.add(-2 * Math.dot(Y, Y.T), sum_Y).T, sum_Y));\\n num[range(n), range(n)] = 0;\\n Q = num / Math.sum(num);\\n Q = Math.maximum(Q, 1e-12);\\n \\n # Compute gradient\\n PQ = P - Q;\\n for i in range(n):\\n dY[i,:] = Math.sum(Math.tile(PQ[:,i] * num[:,i], (no_dims, 1)).T * (Y[i,:] - Y), 0);\\n \\n # Perform the update\\n if iter < 20:\\n momentum = initial_momentum\\n else:\\n momentum = final_momentum\\n gains = (gains + 0.2) * ((dY > 0) != (iY > 0)) + (gains * 0.8) * ((dY > 0) == (iY > 0));\\n gains[gains < min_gain] = min_gain;\\n iY = momentum * iY - eta * (gains * dY);\\n Y = Y + iY;\\n Y = Y - Math.tile(Math.mean(Y, 0), (n, 1));\\n \\n # Compute current value of cost function\\n if (iter + 1) % 10 == 0:\\n C = Math.sum(P * Math.log(P / Q));\\n print \\\"Iteration \\\", (iter + 1), \\\": error is \\\", C\\n \\n # Stop lying about P-values\\n if iter == 100:\\n P = P / 4;\\n \\n # Return solution\\n return Y;\",\n \"def adversarial_update(model, optimiser, loss_fn, x, y, epoch, eps, step, k, norm, **kwargs):\\n model.train()\\n\\n # Adversial perturbation\\n if norm == 'inf':\\n x_adv = iterated_fgsm(model, x, y, loss_fn, k=k, step=step, eps=eps, norm='inf', random=args.random_start)\\n elif norm == 2:\\n x_adv = pgd(model, x, y, loss_fn, k=k, step=step, eps=eps, norm=2, random=args.random_start)\\n else:\\n raise ValueError('Unsupported norm')\\n\\n optimiser.zero_grad()\\n y_pred = model(x_adv)\\n loss = loss_fn(y_pred, y)\\n loss.backward()\\n optimiser.step()\\n\\n return loss, y_pred\",\n \"def __optimizers(self, Gen_loss, D_A_loss, D_B_loss):\\n def make_optimizer(loss, variables, name='Adam'):\\n \\\"\\\"\\\" Adam optimizer with learning rate 0.0002 for the first 100k steps (~100 epochs)\\n and a linearly decaying rate that goes to zero over the next 100k steps\\n \\\"\\\"\\\"\\n global_step = tf.Variable(0, trainable=False, name='global_step')\\n starter_learning_rate = self.opt.lr\\n end_learning_rate = 0.0\\n start_decay_step = self.opt.niter\\n decay_steps = self.opt.niter_decay\\n beta1 = self.opt.beta1\\n learning_rate = (tf.where(tf.greater_equal(global_step, start_decay_step),\\n tf.train.polynomial_decay(starter_learning_rate,\\n global_step-start_decay_step,\\n decay_steps, end_learning_rate,\\n power=1.0),\\n starter_learning_rate))\\n\\n learning_step = (tf.train.AdamOptimizer(learning_rate, beta1=beta1, name=name)\\n .minimize(loss, global_step=global_step, var_list=variables))\\n\\n return learning_step\\n\\n Gen_optimizer = make_optimizer(Gen_loss, self.G.variables + self.F.variables, name='Adam_Gen')\\n D_A_optimizer = make_optimizer(D_A_loss, self.D_A.variables, name='Adam_D_A')\\n D_B_optimizer = make_optimizer(D_B_loss, self.D_B.variables, name='Adam_D_B')\\n\\n with tf.control_dependencies([Gen_optimizer, D_A_optimizer, D_B_optimizer]):\\n return tf.no_op(name='optimizers')\",\n \"def tsd_alpha(s_1, s_2, p_1, p_2, w_1, w_2, alpha_concurrency):\\n\\n def calculate_cost(s1_idx, s2_idx):\\n t_1 = p_1[s1_idx] + w_1[s1_idx]\\n if t_1 > 0:\\n b_1 = (p_1[s1_idx]/t_1)\\n cost = ((b_1*np.abs(p_2[s2_idx]-p_1[s1_idx])) +\\n ((1 - b_1)*np.abs(w_2[s2_idx]-w_1[s1_idx])))\\n else:\\n cost = 0\\n return cost\\n\\n dist = {}\\n lenstr1 = len(s_1)\\n lenstr2 = len(s_2)\\n for i in range(-1, lenstr1+1):\\n dist[(i, -1)] = i+1\\n for j in range(-1, lenstr2+1):\\n dist[(-1, j)] = j+1\\n for i in range(0, lenstr1):\\n for j in range(0, lenstr2):\\n if s_1[i] == s_2[j]:\\n cost = calculate_cost(i, j)\\n else:\\n cost = 1\\n dist[(i, j)] = min(\\n dist[(i-1, j)] + 1, # deletion\\n dist[(i, j-1)] + 1, # insertion\\n dist[(i-1, j-1)] + cost # substitution\\n )\\n if i and j and s_1[i] == s_2[j-1] and s_1[i-1] == s_2[j]:\\n if alpha_concurrency[(s_1[i], s_2[j])] == Rel.PARALLEL:\\n cost = calculate_cost(i, j-1)\\n dist[(i, j)] = min(dist[(i, j)], dist[i-2, j-2] + cost) # transposition\\n return dist[lenstr1-1, lenstr2-1]\",\n \"def dcca_objective(pred1, pred2, reg):\\n\\n H1 = torch.Tensor(pred1).t()\\n H2 = torch.Tensor(pred2).t()\\n\\n o = H1.shape[0] # latent dimension\\n m = H1.shape[1] # number of training samples\\n ones = torch.ones(m, m)\\n I = torch.eye(o, o) # identity matrix\\n\\n # centered data matrices\\n H1_hat = H1.sub(torch.mul(H1.mm(ones), (1.0 / m)))\\n H2_hat = H2.sub(torch.mul(H2.mm(ones), (1.0 / m)))\\n\\n SigmaHat12 = torch.mul(H1_hat.mm(torch.t(H2_hat)), 1.0 / (m - 1))\\n SigmaHat11 = torch.add(torch.mul(H1_hat.mm(torch.t(H1_hat)), 1.0 / (m - 1)), torch.mul(reg, I))\\n SigmaHat22 = torch.add(torch.mul(H2_hat.mm(torch.t(H2_hat)), 1.0 / (m - 1)), torch.mul(reg, I))\\n\\n # SVD decomposition for square root calculation\\n U1, D1, V1 = torch.svd(SigmaHat11)\\n U2, D2, V2 = torch.svd(SigmaHat22)\\n # D1, V1 = torch.symeig(SigmaHat11, eigenvectors=True)\\n # epsilon = 1e-12\\n # D1_indices = torch.nonzero(D1.squeeze() > epsilon)\\n # D1 = D1[D1_indices].squeeze()\\n # V1 = V1[D1_indices].squeeze()\\n #\\n # D2, V2 = torch.symeig(SigmaHat22, eigenvectors=True)\\n # D2_indices = torch.nonzero(D2.squeeze() > epsilon)\\n # D2 = D2[D2_indices].squeeze()\\n # V2 = V2[D2_indices].squeeze()\\n #\\n # # calculate root inverse of correlation matrices\\n # SigmaHat11RootInv = V1.mm(torch.diag(torch.pow(D1, -0.5))).mm(torch.t(V1))\\n # SigmaHat22RootInv = V2.mm(torch.diag(torch.pow(D2, -0.5))).mm(torch.t(V2))\\n\\n SigmaHat11RootInv = U1.mm(torch.diag(torch.pow(D1, -0.5))).mm(torch.t(V1))\\n SigmaHat22RootInv = U2.mm(torch.diag(torch.pow(D2, -0.5))).mm(torch.t(V2))\\n\\n # Total correlation\\n T = SigmaHat11RootInv.mm(SigmaHat12).mm(SigmaHat22RootInv)\\n corr = torch.sqrt(torch.trace(torch.t(T).mm(T)))\\n # corr = torch.trace(torch.sqrt(torch.t(T).mm(T)))\\n\\n # Gradient calculations\\n U, D, V = torch.svd(T)\\n\\n Delta12 = SigmaHat11RootInv.mm(U).mm(torch.t(V)).mm(SigmaHat22RootInv)\\n Delta11 = torch.mul(SigmaHat11RootInv.mm(U).mm(torch.diag(D)).mm(U.t()).mm(SigmaHat11RootInv), -0.5)\\n Delta22 = torch.mul(SigmaHat22RootInv.mm(U).mm(torch.diag(D)).mm(U.t()).mm(SigmaHat22RootInv), -0.5)\\n\\n # dcorr(H1, H2) / dH1 and dcorr(H1, H2) / dH2\\n dH1 = torch.mul(torch.mul(Delta11.mm(H1_hat), 2.0) + Delta12.mm(H2_hat), 1.0 / (m - 1))\\n dH2 = torch.mul(torch.mul(Delta22.mm(H2_hat), 2.0) + Delta12.mm(H1_hat), 1.0 / (m - 1))\\n\\n return -corr, dH1.t(), dH2.t(), SigmaHat11RootInv.mm(U), SigmaHat22RootInv.mm(V)\",\n \"def adam_optimizer(loss, initial_lr, decay_step, decay_rate):\\n global_step = tf.train.get_or_create_global_step()\\n lr = tf.train.exponential_decay(initial_lr, global_step, decay_step,\\n decay_rate, staircase=True)\\n\\n optim = tf.train.AdamOptimizer(learning_rate=lr)\\n global_step = tf.train.get_or_create_global_step()\\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\\n\\n with tf.control_dependencies(update_ops):\\n train_op = optim.minimize(loss, global_step=global_step)\\n\\n return train_op\",\n \"def run(self):\\n is_spsa = True\\n is_steep_descent = False\\n is_rprop = False\\n\\n k = 0\\n theta = self.theta0\\n\\n while True:\\n k = k + 1\\n\\n self.iter = k\\n print(f'starting iter {k} ...')\\n\\n if self.constraints is not None:\\n theta = self.constraints(theta)\\n\\n print('current param:')\\n for name, value in utils.true_param(theta).items():\\n print(f' {name}: {value[\\\"value\\\"]}')\\n\\n c_k = self.c / (k ** self.gamma)\\n a_k = self.a / ((k + self.A) ** self.alpha)\\n\\n # print(f' ck: {c_k:0.5f}')\\n # print(f' ak: {a_k:0.5f}')\\n\\n # Run the engine match here to get the gradient\\n print('Run engine match ...')\\n gradient = self.approximate_gradient(theta, c_k, k)\\n\\n # For SPSA we update with a small step (theta = theta - a_k * gradient)\\n if is_spsa:\\n theta = utils.linear_combinaison(1.0, theta, -a_k, gradient)\\n logging.info(f'{__file__} > theta from spsa: {theta}')\\n # print(f'new param after application of gradient:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # For steepest descent we update via a constant small step in the gradient direction\\n elif is_steep_descent:\\n mu = -0.01 / max(1.0, utils.norm2(gradient))\\n theta = utils.linear_combinaison(1.0, theta, mu, gradient)\\n\\n # For RPROP, we update with information about the sign of the gradients\\n elif is_rprop:\\n theta = utils.linear_combinaison(1.0, theta, -0.01, self.rprop(theta, gradient))\\n\\n # Apply parameter limits\\n theta = utils.apply_limits(theta)\\n logging.info(f'{__file__} > theta with limits: {theta}')\\n # print(f'new param after application of limits:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # We then move to the point which gives the best average of goal\\n (avg_goal, avg_theta) = self.average_best_evals(30)\\n logging.info(f'{__file__} > avg_theta from average_best_evals: {avg_theta}')\\n\\n theta = utils.linear_combinaison(0.98, theta, 0.02, avg_theta)\\n logging.info(f'{__file__} > theta with avg_theta: {theta}')\\n # print(f'new param after application of best average param:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # Apply parameter limits\\n theta = utils.apply_limits(theta) # This is the best param.\\n logging.info(f'{__file__} > best param: {theta}')\\n # print(f'new param after application of limits:')\\n # for n, v in theta.items():\\n # print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n # Log best param values\\n for kv, vv in theta.items():\\n logging.info(f'<best> iter: {k}, param: {kv}, value: {int(vv[\\\"value\\\"]*vv[\\\"factor\\\"])}')\\n print('best param:')\\n for n, v in theta.items():\\n print(f' {n}: {int(v[\\\"value\\\"] * v[\\\"factor\\\"])}')\\n\\n mean_all_goal, _ = self.average_evaluations(30)\\n print(f'mean all goal: {mean_all_goal}')\\n\\n mean_best_goal, _ = self.average_best_evals(30)\\n print(f'mean best goal: {mean_best_goal}')\\n\\n # Save data in csv for plotting.\\n plot_data = {}\\n plot_data.update({'iter': k})\\n plot_data.update({'meanbestgoal': mean_best_goal})\\n plot_data.update({'meanallgoal': mean_all_goal})\\n plot_theta = utils.true_param(theta)\\n for name, value in plot_theta.items():\\n plot_data.update({name: value[\\\"value\\\"]})\\n\\n with open(self.plot_data_file, 'a') as f:\\n cnt = 0\\n for name, value in plot_data.items():\\n cnt += 1\\n if cnt == len(plot_data):\\n f.write(f'{value}\\\\n')\\n else:\\n f.write(f'{value},')\\n\\n print(f'done iter {k} / {self.max_iter}')\\n logging.info(f'{__file__} > done iter {k} / {self.max_iter}')\\n print('=========================================')\\n\\n # Stopping rule 1: Average goal and iteration meet the\\n # stop_all_mean_goal and stop_min_iter criteria.\\n if k >= self.stop_min_iter and mean_all_goal <= self.stop_all_mean_goal:\\n print('Stop opimization due to good average all goal!')\\n break\\n\\n # Stopping rule 2: Average best goal and iteration meet the\\n # stop_best_mean_goal and stop_min_iter criteria.\\n if k >= self.stop_min_iter and mean_best_goal <= self.stop_best_mean_goal:\\n print('Stop opimization due to good average best goal!')\\n break\\n\\n # Stopping rule 3: Max iteration is reached.\\n if k >= self.max_iter:\\n print('Stop opimization due to max iteration!')\\n break\\n\\n return utils.true_param(theta)\",\n \"def optimizer(self):\\n \\n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\\n # I believe this is a work around to get keras to learn **given a gradient**\\n # As opposed to bunch of x_train, y_trains?\\n \\n #Inputs\\n state_pl = self.model.input\\n action_grads_pl = K.placeholder(shape=(None,1)) \\n \\n #Find grad_(pars) mu(state)\\n mu_pl = self.model.output\\n pars = self.model.trainable_weights\\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\\n \\n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\\n\\n # The gradients as defined above work on my mac, but not ubuntu.\\n # Below I am trying a workaround. I changed the keras source code \\n # To get this working. Specifically, I make the optimizer.get_updates()\\n # function accept custom gradients. It was easy to do.\\n \\n opt = Adam(self.lr)\\n loss = pars_grad_mu #placeholder, I won't use it\\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\\n\\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])\",\n \"def fit(self, X, y, X_validate, y_validate):\\n \\n iterate = 800\\n \\n self.SGD_theta_list = [0]*len(X[0])\\n self.SGD_bias = 0\\n\\n SGD_cost_history = []\\n SGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\\n temp_X = []\\n temp_X.append(X[selection])\\n temp_y = []\\n temp_y.append(y[selection])\\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\\n SGD_cost_history.append(SGD_cost)\\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\\n SGD_validate_cost_history.append(SGD_validate_cost)\\n\\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), SGD_cost_history)\\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss SGD\\\")\\n plt.show()\\n \\n \\n self.BGD_theta_list = [0]*len(X[0])\\n self.BGD_bias = 0\\n\\n BGD_cost_history = []\\n BGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1)\\n \\n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\\n\\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\\n BGD_cost_history.append(BGD_cost)\\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\\n BGD_validate_cost_history.append(BGD_validate_cost)\\n\\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), BGD_cost_history)\\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss BGD\\\")\\n plt.show()\\n\\n print(\\\"FINAL_SGD_TRAIN_LOSS\\\\n\\\",self.FINAL_SGD_TRAIN_LOSS)\\n print(\\\"FINAL_SGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_SGD_VALIDATE_LOSS)\\n print(\\\"FINAL_BGD_TRAIN_LOSS\\\\n\\\",self.FINAL_BGD_TRAIN_LOSS)\\n print(\\\"FINAL_BGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_BGD_VALIDATE_LOSS)\\n\\n \\n return self\",\n \"def stochastic_gradient_descent(example: pd.Series,\\n matrices: Matrices,\\n word2onehot: Dict[str, int],\\n learn_rate: float\\n ) -> Matrices:\\n \\n # Get hidden layer (projection vector), positive context word, and \\n # list of negative context words, all as vectors.\\n proj_vector, c_positive, w_negative = (\\n matrices.embedding[word2onehot[example['centre_word']]],\\n matrices.context[word2onehot[example['context_word']]],\\n [matrices.context[word2onehot[sample]]\\n for sample in example['negative_samples']] \\n )\\n \\n # Obtain vectors for updating gradients. \\n embedding_gradient = (\\n cost_derivation(proj_vector, c_positive, 1) + \\n sum(cost_derivation(proj_vector, c_negative, 0)\\n for c_negative in w_negative)\\n )\\n pos_context_gradient = cost_derivation(c_positive, proj_vector, 1)\\n neg_context_gradients = (\\n (c_negative, cost_derivation(c_negative, proj_vector, 0))\\n for c_negative in w_negative \\n )\\n \\n # Update parameters.\\n proj_vector[:] = proj_vector - learn_rate*embedding_gradient \\n c_positive[:] = c_positive - learn_rate*pos_context_gradient\\n for c_negative, neg_context_gradient in neg_context_gradients:\\n c_negative[:] = c_negative - learn_rate*neg_context_gradient \\n \\n return matrices\",\n \"def compile(self, optimizer=tf.keras.optimizers.RMSprop,\\n loss='mse',\\n metrics=pearson_correlation_first,\\n learning_rate=1e-3, **kwargs):\\n if callable(optimizer):\\n optimizer = optimizer(learning_rate=learning_rate)\\n super(BrainModelLinearRegression, self).compile(\\n optimizer=optimizer, loss=loss, metrics=metrics, **kwargs)\",\n \"def test_sdp(self):\\n a = sp.rand(100, 100, .1, random_state=1)\\n a = a.todense()\\n X = Variable(100, 100)\\n obj = at.norm(X, \\\"nuc\\\") + at.norm(X-a, 'fro')\\n p = Problem(Minimize(obj))\\n p.solve(solver=\\\"SCS\\\")\",\n \"def _resource_apply_dense(self, grad, var):\\n\\n assignments = []\\n\\n param_name = self._get_variable_name(var.name)\\n\\n m = self.get_slot(var, \\\"m\\\")\\n v = self.get_slot(var, \\\"v\\\")\\n\\n # m = m.handle\\n # v = v.handle\\n # var = var.handle\\n\\n # Standard Adam update.\\n next_m = (\\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\\n next_v = (\\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\\n tf.square(grad)))\\n\\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\\n\\n # Just adding the square of the weights to the loss function is *not*\\n # the correct way of using L2 regularization/weight decay with Adam,\\n # since that will interact with the m and v parameters in strange ways.\\n #\\n # Instead we want ot decay the weights in a manner that doesn't interact\\n # with the m/v parameters. This is equivalent to adding the square\\n # of the weights to the loss with plain (non-momentum) SGD.\\n if self._do_use_weight_decay(param_name):\\n update += self.weight_decay_rate * var\\n\\n ratio = 1.0\\n if self._do_layer_adaptation(param_name):\\n w_norm = linalg_ops.norm(var, ord=2)\\n g_norm = linalg_ops.norm(update, ord=2)\\n ratio = array_ops.where(math_ops.greater(w_norm, 0), array_ops.where(\\n math_ops.greater(g_norm, 0), (w_norm / g_norm), 1.0), 1.0)\\n\\n update_with_lr = ratio * self.learning_rate * update\\n\\n next_param = var - update_with_lr\\n\\n assignments.extend(\\n [var.assign(next_param, use_locking=self._use_locking),\\n m.assign(next_m),\\n v.assign(next_v)])\\n return tf.group(*assignments)\",\n \"def optimizer(\\n optimizer,\\n named_parameters,\\n reduction: str = \\\"sum\\\",\\n compression: str = \\\"none\\\",\\n accumulate: int = 1,\\n rank: int = 0,\\n):\\n\\n optimizer = hvd.DistributedOptimizer(\\n optimizer,\\n named_parameters,\\n _compression(compression),\\n backward_passes_per_step=accumulate,\\n op=_reduction(reduction),\\n )\\n\\n hvd.broadcast_optimizer_state(optimizer, root_rank=rank)\\n return optimizer\",\n \"def experiment_linear_conv_ls(_):\\n # Min dft1-norm solution found (norm=1.9895)\\n adv_norm_type = 'dftinf'\\n dual_norm_type = 'dft1'\\n attack_step_dir = 'dftinf_sd' # 'dftinf'\\n\\n module_name = 'train'\\n # log_dir = 'runs_linear_conv_ls_%s' % adv_norm_type\\n log_dir = 'runs_linear_conv_ls_normfix_%s' % adv_norm_type\\n exclude = '*'\\n\\n d_over_n = [1, 2, 4, 8, 16, 32] # separable >= 1\\n dim = 100\\n num_train = [int(dim / p) for p in d_over_n]\\n\\n # Config params\\n shared_params = []\\n shared_params += [\\n ('config', './config.py'),\\n ('seed', list(range(3))),\\n ]\\n\\n # Data hyper-parameters\\n shared_params += [\\n ('temperature', 0.0001),\\n ('num_test', 1), # 500\\n ('dim', dim),\\n ('num_train', num_train),\\n ]\\n\\n # Adversarial configuration: test\\n shared_params += nameit('adv', [\\n ('norm_type', adv_norm_type),\\n # ('lr', 0.1),\\n ('niters', 1), # 10\\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\\n ('pre_normalize', True), # multi attacks\\n ('post_normalize', True),\\n ('eps_from_cvxpy', True),\\n ('step_dir', attack_step_dir),\\n ])\\n\\n # Logging to standard output\\n shared_params += [\\n ('log_interval', 10000), # 1000),\\n ('log_keys', '\\\\'(\\\"%s\\\")\\\\'' % ('\\\",\\\"'.join([\\n 'risk/train/zero_one',\\n 'risk/train/adv/%s' % adv_norm_type,\\n 'weight/linear/norm/%s' % dual_norm_type,\\n 'margin/%s' % dual_norm_type,\\n ]))),\\n # Compare with cvxpy\\n ('enable_cvxpy', True),\\n ]\\n\\n # Model hyper-parameters\\n conv_linear_params = nameit('model', [\\n ('arch', 'conv_linear'),\\n ('nlayers', 2),\\n ('regularizer', 'none'),\\n ])\\n\\n params = []\\n\\n # GD line search implicit bias\\n gd_ls = nameit('optim', [\\n ('name', 'gd_ls'),\\n ('niters', 100000),\\n ('bound_step', True),\\n ])\\n params += [OrderedDict(shared_params+conv_linear_params+gd_ls)]\\n\\n return params, log_dir, module_name, exclude\",\n \"def test_SLearner(self):\\n # Test constant treatment effect with multi output Y\\n # Test heterogeneous treatment effect\\n # Need interactions between T and features\\n Y, T, X, _ = ihdp_surface_B()\\n est = AutomatedSLearner(overall_model=automl_model_reg())\\n\\n est.fit(Y, T, X=X)\\n _ = est.effect(X)\\n\\n # Test heterogeneous treatment effect with multi output Y\",\n \"def DistributedOptimizer(optimizer, name=None, use_locking=False, device_dense='',\\n device_sparse='', compression=Compression.none,\\n sparse_as_dense=False, backward_passes_per_step=1,\\n op=Average):\\n if isinstance(optimizer, _LegacyOptimizer):\\n if op == Adasum:\\n raise ValueError('op == Adasum is not supported yet with ')\\n else:\\n if backward_passes_per_step > 1:\\n raise ValueError('backward_passes_per_step>1 is not supported yet with '\\n 'op != Adasum')\\n return _DistributedOptimizer(optimizer, name, use_locking, device_dense,\\n device_sparse, compression, sparse_as_dense, op)\\n elif isinstance(optimizer, tf.keras.optimizers.Optimizer):\\n if op == Adasum:\\n raise ValueError('op == Adasum is not supported yet with Keras')\\n if backward_passes_per_step > 1:\\n raise ValueError('backward_passes_per_step > 1 is not supported yet with Keras')\\n import byteps.tensorflow.keras as bps_k\\n return bps_k.DistributedOptimizer(optimizer, name, device_dense, device_sparse,\\n compression, sparse_as_dense)\\n else:\\n raise ValueError('Provided optimizer doesn\\\\'t inherit from either legacy '\\n 'TensorFlow or Keras optimizer: %s' % optimizer)\",\n \"def optimize_library_descent(self, target, direction='max', steps=100,\\n multiprocessing=False, ret_info=False,\\n args=None):\\n # get the target function to call\\n target_function = getattr(self, target)\\n if args is not None:\\n target_function = functools.partial(target_function, **args)\\n\\n # initialize the optimizer\\n value = target_function()\\n value_best, state_best = value, self.sens_mat.copy()\\n \\n if ret_info:\\n # store extra information\\n start_time = time.time()\\n info = {'values': {}}\\n values_count = self.parameters['optimizer_values_count']\\n values_step = max(1, steps // values_count)\\n \\n if multiprocessing:\\n # run the calculations in multiple processes\\n pool_size = self.get_number_of_cores()\\n pool = mp.Pool(processes=pool_size)\\n if ret_info:\\n values_step = max(1, values_step // pool_size)\\n \\n # iterate for given number of steps\\n for step in range(int(steps) // pool_size):\\n joblist = []\\n init_arguments = self.init_arguments\\n for _ in range(pool_size):\\n # modify the current state and add it to the job list\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n params = init_arguments['parameters'] \\n params['sensitivity_matrix'] = self.sens_mat\\n params['initialize_state']['sensitivity'] = 'exact'\\n \\n joblist.append((copy.deepcopy(init_arguments), target))\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # run all the jobs\\n results = pool.map(_run_job, joblist)\\n \\n # find the best result \\n if direction == 'max':\\n res_best = np.argmax(results)\\n if results[res_best] > value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n elif direction == 'min':\\n res_best = np.argmin(results)\\n if results[res_best] < value_best:\\n value_best = results[res_best]\\n state_best = joblist[res_best][0]['parameters']['sensitivity_matrix']\\n # use the best state as a basis for the next iteration\\n self.sens_mat = state_best\\n \\n else:\\n raise ValueError('Unsupported direction `%s`' % direction)\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step * pool_size] = results[res_best]\\n \\n else:\\n # run the calculations in this process\\n for step in range(int(steps)):\\n # modify the current state\\n i = random.randrange(self.sens_mat.size)\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n # get the value of the new state\\n value = target_function()\\n \\n improved = ((direction == 'max' and value > value_best) or\\n (direction == 'min' and value < value_best))\\n if improved:\\n # save the state as the new best value\\n value_best, state_best = value, self.sens_mat.copy()\\n else:\\n # undo last change\\n self.sens_mat.flat[i] = 1 - self.sens_mat.flat[i]\\n \\n if ret_info and step % values_step == 0:\\n info['values'][step] = value_best\\n\\n # sort the best state and store it in the current object\\n state_best = self.sort_sensitivity_matrix(state_best)\\n self.sens_mat = state_best.copy()\\n\\n if ret_info:\\n info['total_time'] = time.time() - start_time \\n info['states_considered'] = steps\\n info['performance'] = steps / info['total_time']\\n return value_best, state_best, info\\n else:\\n return value_best, state_best\",\n \"def learn2_sgd():\\n\\n sgd.fit(vector_training,sentiment_training) ##fits the training data of vector tweets and sentiments using SGDClassifier\\n correct = 0\\n for i in range(vector_testing.shape[0]): ##using the testing, data see how accurate SGDC is\\n prediction = sgd.predict(vector_testing[i])\\n sentiment = sentiment_testing[i]\\n if prediction[0] == sentiment:\\n correct +=1\\n \\n accuracy = correct/vector_testing.shape[0]\\n print('Stochastic Gradient Descent Classifier Testing Accuracy: {:.2f}'.format(accuracy)) ##prints the accuracy of the algorithm\",\n \"def experiment_linear_conv(_):\\n # Min dft1-norm solution found (norm=1.9895)\\n adv_norm_type = 'dftinf'\\n dual_norm_type = 'dft1'\\n baseline_norm_types = ['l1', 'linf']\\n attack_step_dir = 'dftinf_sd' # 'dftinf'\\n\\n module_name = 'train'\\n log_dir = 'runs_linear_conv_%s' % adv_norm_type\\n exclude = '*'\\n\\n d_over_n = [1, 2, 4, 8, 16, 32] # separable >= 1\\n dim = 100\\n num_train = [int(dim / p) for p in d_over_n]\\n\\n # Config params\\n shared_params = []\\n shared_params += [\\n ('config', './config.py'),\\n ('seed', list(range(3))),\\n ]\\n\\n # Data hyper-parameters\\n shared_params += [\\n ('temperature', 0.0001),\\n ('num_test', 1), # 500\\n ('dim', dim),\\n ('num_train', num_train),\\n ]\\n\\n # Adversarial configuration: test\\n shared_params += nameit('adv', [\\n ('norm_type', adv_norm_type),\\n # ('lr', 0.1),\\n ('niters', 1), # 10\\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\\n ('pre_normalize', True), # multi attacks\\n ('post_normalize', True),\\n ('eps_from_cvxpy', True),\\n ('step_dir', attack_step_dir),\\n ])\\n\\n # Logging to standard output\\n shared_params += [\\n ('log_interval', 10000), # 1000),\\n ('log_keys', '\\\\'(\\\"%s\\\")\\\\'' % ('\\\",\\\"'.join([\\n 'risk/train/zero_one',\\n 'risk/train/adv/%s' % adv_norm_type,\\n 'weight/linear/norm/%s' % dual_norm_type,\\n 'margin/%s' % dual_norm_type,\\n ]))),\\n # Compare with cvxpy\\n ('enable_cvxpy', True),\\n ]\\n\\n # No 0 regularization coefficient\\n reg_coeff = [1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1]\\n\\n # Model hyper-parameters\\n linear_noreg_model_params = nameit('model', [\\n ('arch', 'linear'),\\n ('regularizer', 'none'),\\n ])\\n linear_reg_model_params = nameit('model', [\\n ('arch', 'linear'),\\n ('regularizer', ['w_%s' % b for b in baseline_norm_types] +\\n ['w_%s' % dual_norm_type]),\\n ('reg_coeff', reg_coeff),\\n ])\\n deep_linear_params = nameit('model', [\\n ('arch', 'deep_linear'),\\n ('nlayers', 2),\\n ('regularizer', 'none'),\\n ])\\n conv_linear_params = nameit('model', [\\n ('arch', 'conv_linear'),\\n ('nlayers', 2),\\n ('regularizer', 'none'),\\n ])\\n\\n params = []\\n\\n # cvxpy solution\\n cvxpy_params = nameit('optim', [\\n ('name', 'cvxpy'),\\n ('norm', dual_norm_type),\\n ('niters', 10000),\\n ('lr', 0), # keep cvxpy sol fixed\\n ])\\n params += [OrderedDict(shared_params+linear_noreg_model_params+cvxpy_params)]\\n\\n # GD line search implicit bias\\n gd_ls = nameit('optim', [\\n ('name', 'gd_ls'),\\n ('niters', 10000),\\n ('bound_step', True),\\n ])\\n params += [OrderedDict(shared_params+deep_linear_params+gd_ls)]\\n params += [OrderedDict(shared_params+conv_linear_params+gd_ls)]\\n\\n # CD, SignGD implicit bias\\n cd_fixed_lr = nameit('optim', [\\n ('name', ['cd', 'signgd']),\\n ('niters', 10000),\\n ('lr', [\\n 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1,\\n 3e-1, 1, 2, 3, 6, 9, 10, 20, 30, 50\\n ]),\\n ])\\n params += [OrderedDict(shared_params+linear_noreg_model_params+cd_fixed_lr)]\\n\\n # Explicit regularization with line search\\n explicit_reg = nameit('optim', [\\n ('name', 'fista'),\\n ('niters', 10000),\\n ('bound_step', True),\\n ('step_size', [1, 10, 100, 1000]),\\n ])\\n params += [OrderedDict(shared_params+linear_reg_model_params+explicit_reg)]\\n\\n # Adversarial training with line search\\n adv_train_params = nameit('optim', [\\n ('name', 'gd_ls'),\\n ('niters', 10000),\\n ('bound_step', True),\\n ])\\n adv_train_params += nameit('optim', nameit('adv_train', [\\n ('enable', True),\\n ('norm_type', adv_norm_type),\\n # ('lr', 0.1),\\n ('niters', 1), # niters, 1000\\n ('pre_normalize', True),\\n ('post_normalize', True),\\n ('step_dir', attack_step_dir),\\n ('eps_from_cvxpy', True),\\n ]))\\n params += [OrderedDict(\\n shared_params+linear_noreg_model_params+adv_train_params)]\\n\\n return params, log_dir, module_name, exclude\",\n \"def dcsolver(initial=\\\"dog\\\", goal=\\\"cat\\\", cost='steps'):\\n problem = DC(initial, goal, cost)\\n start = time.time()\\n solution = astar_search(problem)\\n elapsed = time.time() - start\\n if solution:\\n solution_path = path = ' '.join([node.state for node in solution.path()])\\n solution_cost = solution.path_cost\\n # show how much h() underestimated H-star. Should all be <= 0\\n deltas = [rnd(node.path_cost + problem.h(node) - solution_cost) for node in solution.path()][:-1]\\n else:\\n solution_path = \\\"NO SOLUTION\\\"\\n deltas = []\\n solution_cost = -1\\n print(f\\\"{problem} cost:{solution_cost:.2f}; time:{elapsed:.3f}; solution:{solution_path}; deltas:{deltas}\\\")\",\n \"def sgdgc(cost, params, lr=1.0, max_magnitude=5.0, infDecay=0.1):\\n grads = T.grad(cost=cost, wrt=params)\\n updates = []\\n\\n norm = norm_gs(params, grads)\\n sqrtnorm = T.sqrt(norm)\\n #not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\\n\\n for p, g in zip(params, grads):\\n #g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\\n updates.append((p, p - lr * g * adj_norm_gs)) \\n \\n return updates, norm\",\n \"def optimize(self):\\n print(colored('starting optimization with ADAM...', 'cyan'))\\n self.optimizer = torch.optim.Adam(self.net.parameters(), lr=self.args.lr)\\n scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, mode='min',\\n factor=self.args.lr_factor,\\n threshold=self.args.lr_thresh,\\n patience=self.args.lr_patience)\\n # stop after no improvements greater than a certain percentage of the previous loss\\n stopper = u.EarlyStopping(patience=self.args.earlystop_patience,\\n min_delta=self.args.earlystop_min_delta,\\n percentage=True)\\n start = time()\\n for j in range(self.args.epochs):\\n self.optimizer.zero_grad()\\n loss = self.optimization_loop()\\n self.optimizer.step()\\n if self.args.reduce_lr:\\n scheduler.step(loss)\\n if stopper.step(loss): # stopper is computed on loss, as we don't have any validation metrics\\n break\\n \\n self.elapsed = time() - start\\n print(colored(u.sec2time(self.elapsed), 'yellow'))\",\n \"def experiment_linear_conv_constant_lr(_):\\n # Min dft1-norm solution found (norm=1.9895)\\n adv_norm_type = 'dftinf'\\n dual_norm_type = 'dft1'\\n attack_step_dir = 'dftinf_sd' # 'dftinf'\\n\\n module_name = 'train'\\n # log_dir = 'runs_linear_conv_constant_lr_%s' % adv_norm_type\\n log_dir = 'runs_linear_conv_constant_lr_normfix_%s' % adv_norm_type\\n exclude = '*'\\n\\n # d_over_n = [1, 2, 4, 8, 16, 32] # separable >= 1\\n d_over_n = [16, 32] # separable >= 1\\n dim = 100\\n num_train = [int(dim / p) for p in d_over_n]\\n\\n # Config params\\n shared_params = []\\n shared_params += [\\n ('config', './config.py'),\\n ('seed', list(range(3))),\\n ]\\n\\n # Data hyper-parameters\\n shared_params += [\\n ('temperature', 0.0001),\\n ('num_test', 1), # 500\\n ('dim', dim),\\n ('num_train', num_train),\\n ]\\n\\n # Adversarial configuration: test\\n shared_params += nameit('adv', [\\n ('norm_type', adv_norm_type),\\n # ('lr', 0.1),\\n ('niters', 1), # 10\\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\\n ('pre_normalize', True), # multi attacks\\n ('post_normalize', True),\\n ('eps_from_cvxpy', True),\\n ('step_dir', attack_step_dir),\\n ])\\n\\n # Logging to standard output\\n shared_params += [\\n ('log_interval', 10000), # 1000),\\n ('log_keys', '\\\\'(\\\"%s\\\")\\\\'' % ('\\\",\\\"'.join([\\n 'risk/train/zero_one',\\n 'risk/train/adv/%s' % adv_norm_type,\\n 'weight/linear/norm/%s' % dual_norm_type,\\n 'margin/%s' % dual_norm_type,\\n ]))),\\n # Compare with cvxpy\\n ('enable_cvxpy', True),\\n ]\\n\\n # Model hyper-parameters\\n conv_linear_params = nameit('model', [\\n ('arch', 'conv_linear'),\\n ('nlayers', 2),\\n ('regularizer', 'none'),\\n ])\\n\\n params = []\\n\\n # Conv linear constant lr\\n cd_fixed_lr = nameit('optim', [\\n ('name', ['gd']),\\n ('niters', 100000),\\n ('lr', [\\n 1e-5, 3e-5, 1e-4, 3e-4, 1e-3, 3e-3, 1e-2, 3e-2, 1e-1,\\n 3e-1, 1, 2, 3, 6, 9, 10, 20, 30, 50\\n ]),\\n ])\\n params += [OrderedDict(shared_params+conv_linear_params+cd_fixed_lr)]\\n\\n return params, log_dir, module_name, exclude\",\n \"def tune(runner, kernel_options, device_options, tuning_options):\\n\\n #Bayesian Optimization strategy seems to need some hyper parameter tuning to\\n #become better than random sampling for auto-tuning GPU kernels.\\n\\n #alpha, normalize_y, and n_restarts_optimizer are options to\\n #https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessRegressor.html\\n #defaults used by Baysian Optimization are:\\n # alpha=1e-6, #1e-3 recommended for very noisy or discrete search spaces\\n # n_restarts_optimizer=5,\\n # normalize_y=True,\\n\\n #several exploration friendly settings are: (default is acq=\\\"ucb\\\", kappa=2.576)\\n # acq=\\\"poi\\\", xi=1e-1\\n # acq=\\\"ei\\\", xi=1e-1\\n # acq=\\\"ucb\\\", kappa=10\\n\\n if not bayes_opt_present:\\n raise ImportError(\\\"Error: optional dependency Bayesian Optimization not installed\\\")\\n\\n #defaults as used by Bayesian Optimization Python package\\n acq = tuning_options.strategy_options.get(\\\"method\\\", \\\"poi\\\")\\n kappa = tuning_options.strategy_options.get(\\\"kappa\\\", 2.576)\\n xi = tuning_options.strategy_options.get(\\\"xi\\\", 0.0)\\n init_points = tuning_options.strategy_options.get(\\\"popsize\\\", 5)\\n n_iter = tuning_options.strategy_options.get(\\\"maxiter\\\", 25)\\n\\n tuning_options[\\\"scaling\\\"] = True\\n\\n results = []\\n\\n #function to pass to the optimizer\\n def func(**kwargs):\\n args = [kwargs[key] for key in tuning_options.tune_params.keys()]\\n return -1.0 * minimize._cost_func(args, kernel_options, tuning_options, runner, results)\\n\\n bounds, _, _ = minimize.get_bounds_x0_eps(tuning_options)\\n pbounds = OrderedDict(zip(tuning_options.tune_params.keys(),bounds))\\n\\n verbose=0\\n if tuning_options.verbose:\\n verbose=2\\n\\n optimizer = BayesianOptimization(f=func, pbounds=pbounds, verbose=verbose)\\n\\n optimizer.maximize(init_points=init_points, n_iter=n_iter, acq=acq, kappa=kappa, xi=xi)\\n\\n if tuning_options.verbose:\\n print(optimizer.max)\\n\\n return results, runner.dev.get_environment()\",\n \"def sdot_asgd(y, nu, C, x_sample, W = None):\\n # if W == None: W = np.zeros(y.shape[0]) else: assert(W.shape[0] == y.shape[0])\\n W = np.zeros(y.shape[0]) # (500, 0)\\n W_tmp = np.copy(W)\\n #source_density = dp.get_density_by_name(name_source) # Density of source distribution\\n h_save = np.empty_like(0)\\n # Print iteration status\\n niter = np.shape(x_sample)[0]\\n for t in range(niter):\\n if (t+1) % 10000 == 0:\\n print(\\\"Iteration: {}\\\".format(t+1))\\n \\n # Sample from source distribution\\n #x = source_density.sample_from(1).numpy()\\n x = x_sample[t]\\n\\n # Gradient Step\\n r = np.sum(np.square(x-y) , axis=1) - W_tmp # |x-y|^2 - W_tmp (900, )\\n indx_min = np.argmin(r)\\n grad = np.copy(nu)\\n grad[indx_min] = grad[indx_min] - 1 # (900, )\\n\\n # Evaluate empirical Reward\\n r2 = np.sum(np.square(x-y) , axis=1) - W # |x-y|^2 - W_tmp (900, )\\n h = np.min(r2) + np.dot(W,nu) \\n h_save = np.hstack((h_save,h))\\n\\n # Gradient Ascent \\n W_tmp = W_tmp + C/np.sqrt(t+1) *grad # t+1 because it starts from 0\\n W = t/(t+1) *W + 1/(t+1)*W_tmp # t+1 because it starts from 0\\n # W = W / np.max(np.abs(W)) \\n\\n return W, h_save\",\n \"def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\\n TrainingTarget, TestData, ValData):\\n # Gradient Descent Solution for Linear Regression\\n La = 2\\n # learningRate = 0.01\\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\\n\\n for i in range(0, 400):\\n\\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\\n Delta_E_D = -np.dot(\\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\\n TRAINING_PHI[i])\\n La_Delta_E_W = np.dot(La, W_Now)\\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\\n Delta_W = -np.dot(learningRate, Delta_E)\\n W_T_Next = W_Now + Delta_W\\n W_Now = W_T_Next\\n\\n #-----------------TrainingData Accuracy---------------------#\\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\\n\\n #-----------------ValidationData Accuracy---------------------#\\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\\n\\n #-----------------TestingData Accuracy---------------------#\\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\\n\\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])\",\n \"def __call__(self, input_or_adv, label=None, unpack=True):\\n\\n a = input_or_adv\\n del input_or_adv\\n del label\\n del unpack\\n\\n x = a.unperturbed\\n dtype = a.unperturbed.dtype\\n min_, max_ = a.bounds()\\n\\n # flatten the input (and remember the shape)\\n shape = x.shape\\n n = x.size\\n x = x.flatten()\\n\\n x0 = nprng.uniform(min_, max_, size=x.shape)\\n bounds = [(min_, max_)] * n\\n options = {\\\"maxiter\\\": 500}\\n\\n def fun(x, *args):\\n \\\"\\\"\\\"Objective function with derivative\\\"\\\"\\\"\\n distance = a.normalized_distance(x.reshape(shape))\\n return distance.value, distance.gradient.reshape(-1)\\n\\n def eq_constraint(x, *args):\\n \\\"\\\"\\\"Equality constraint\\\"\\\"\\\"\\n _, is_adv = a.forward_one(x.reshape(shape).astype(dtype))\\n if is_adv:\\n return 0.0\\n else:\\n return 1.0\\n\\n constraints = [{\\\"type\\\": \\\"eq\\\", \\\"fun\\\": eq_constraint}]\\n\\n result = so.minimize(\\n fun,\\n x0,\\n method=\\\"SLSQP\\\",\\n jac=True,\\n bounds=bounds,\\n constraints=constraints,\\n options=options,\\n )\\n\\n a.forward_one(result.x.reshape(shape).astype(dtype))\",\n \"def sgd_updates_adadelta(self, cost, rho=0.95, epsilon=1e-6, norm_lim=9,\\n word_vec_name='Words'):\\n updates = OrderedDict({})\\n exp_sqr_grads = OrderedDict({})\\n exp_sqr_ups = OrderedDict({})\\n gparams = []\\n for param in self.params:\\n empty = np.zeros_like(param.get_value())\\n exp_sqr_grads[param] = theano.shared(value=as_floatX(empty),\\n name=\\\"exp_grad_%s\\\" % param.name)\\n gp = T.grad(cost, param)\\n exp_sqr_ups[param] = theano.shared(value=as_floatX(empty),\\n name=\\\"exp_grad_%s\\\" % param.name)\\n gparams.append(gp)\\n for param, gp in zip(self.params, gparams):\\n exp_sg = exp_sqr_grads[param]\\n exp_su = exp_sqr_ups[param]\\n up_exp_sg = rho * exp_sg + (1 - rho) * T.sqr(gp)\\n updates[exp_sg] = up_exp_sg\\n step = -(T.sqrt(exp_su + epsilon) / T.sqrt(up_exp_sg + epsilon)) * gp\\n updates[exp_su] = rho * exp_su + (1 - rho) * T.sqr(step)\\n stepped_param = param + step\\n if (param.get_value(borrow=True).ndim == 2) and (param.name != 'Words'):\\n col_norms = T.sqrt(T.sum(T.sqr(stepped_param), axis=0))\\n desired_norms = T.clip(col_norms, 0, T.sqrt(norm_lim))\\n scale = desired_norms / (1e-7 + col_norms)\\n updates[param] = stepped_param * scale\\n else:\\n updates[param] = stepped_param \\n return updates\",\n \"def SP_init(train_data, test_data, n_cols, n_proxim_con, perm_thresh, perm_inc, perm_dec, min_overlap, n_winners, beta_boost, T_boost_speed, verbose, pixel_size):\\n\\n if(pixel_size == None):\\n pixel_size = 28\\n\\n # Load MNIST data input_size (aka nn) of 256 or 1024\\n input_size = len(train_data[1])\\n # print(len(train_data[1]))\\n\\n # Initialize synapses and permanence arrays\\n syn_index = np.random.randint(0, input_size, (n_cols, n_proxim_con))\\n syn_array = np.zeros((n_cols, input_size), dtype=int)\\n # syn_array[syn_index] = 1\\n\\n # Synapses array\\n for i in range(n_cols):\\n syn_array[i, syn_index[i]] = 1\\n\\n # syn_array = np.random.randint(0, 2, (n_cols, input_size))\\n perm_array = np.random.uniform(0, 1, (n_cols, input_size))\\n perm_array = syn_array * perm_array\\n\\n # Initialize empty SDR array\\n # overlap_scores = np.zeros([1, n_cols])\\n sdr_train_array = np.zeros((len(train_data), n_cols), dtype=int)\\n sdr_test_array = np.zeros((len(test_data), n_cols), dtype=int)\\n\\n # Initialize empty boosting arrays; time-averaged activation level\\n time_avg_act = np.zeros([1, n_cols])\\n prev_time_avg_act = np.zeros([1, n_cols])\\n boosting = np.ones([1, n_cols])\\n\\n # Initialize metric arrays\\n sparse_train_array = np.zeros(([len(train_data), 1]))\\n sparse_test_array = np.zeros(([len(test_data), 1]))\\n\\n # Main code\\n train_en = True\\n for epoch in range(0, 2):\\n input_set = train_data\\n if train_en == False:\\n input_set = test_data\\n\\n for iter in range(0, len(input_set)):\\n # Calculate overlap scores\\n overlap_scores = np.dot((syn_array * (perm_array >= perm_thresh)), input_set[iter, :].transpose()) \\\\\\n * boosting\\n\\n # Initialize SDR (activations of cols)\\n sdr = np.zeros(([1, n_cols]), dtype=int)\\n\\n # Select the winners\\n for i in range(n_winners):\\n win_val = np.max(overlap_scores)\\n win_index = np.argmax(overlap_scores)\\n if(win_val >= min_overlap):\\n sdr[0, win_index] = 1\\n overlap_scores[0, win_index] = 0\\n\\n #num_wins = sum(sdr)\\n #print('This is num_wins')\\n #print(num_wins)\\n\\n # Calculating activation level current and then previous, a_bar(t) and a_bar(t-1)\\n if iter >= T_boost_speed:\\n time_avg_act = ((T_boost_speed - 1) * prev_time_avg_act + sdr) / T_boost_speed\\n prev_time_avg_act = time_avg_act\\n\\n # Calculating mini column neighborhood\\n recent_act = (1/abs(n_cols)) * np.sum(time_avg_act)\\n\\n # Calculate boosting for next time\\n boosting = np.exp(-beta_boost * (time_avg_act - recent_act))\\n\\n if(train_en == True):\\n # Update permanence values for learning -> Hebbian learning\\n z = sdr.transpose() * syn_array\\n polar_input = np.copy(input_set[iter, :])\\n polar_input[polar_input == 1] = perm_inc\\n polar_input[polar_input == 0] = perm_dec\\n delta_perm = polar_input * z\\n perm_array = perm_array + delta_perm\\n perm_array[perm_array > 1] = 1\\n perm_array[perm_array < 0] = 0\\n\\n # Add SDR to array and calculate metrics\\n # Metrics include: sparseness\\n if train_en == False:\\n sdr_test_array[iter, :] = sdr\\n sparse_test_array[iter, 0] = sparseness(n_cols, sdr)\\n else:\\n sdr_train_array[iter, :] = sdr\\n sparse_train_array[iter, 0] = sparseness(n_cols, sdr)\\n\\n # You are set!!!\\n\\n if(verbose):\\n pixel_sdr = int(n_cols**(0.5))\\n # Plot the image\\n sdr_image = np.reshape(sdr, (pixel_sdr, pixel_sdr))\\n\\n # Plot the image\\n image = np.reshape(train_data[iter, :], (pixel_size, pixel_size))\\n plt.figure(1)\\n plt.subplot(211)\\n plt.imshow(image, cmap='gray_r')\\n plt.title('Train')\\n\\n # Plot the sdr\\n plt.subplot(212)\\n plt.imshow(sdr_image, cmap='gray_r')\\n plt.title('SDR')\\n plt.tight_layout()\\n plt.show()\\n if(iter % 10 == 0):\\n print(iter)\\n\\n train_en = False\\n return sdr_train_array, sdr_test_array, sparse_train_array, sparse_test_array\",\n \"def sgd(self, training_data, epochs, batch_size, eta=0.01, lambda_r=0.2, verbose=False, test_data=None):\\n stagnation_epochs = 5\\n eta_divide_factor = 4\\n eta_decrease_available = 4\\n\\n self.accuracies = np.zeros(epochs)\\n self.costs = np.zeros(epochs)\\n self.eta = eta\\n self.lambda_r = lambda_r\\n\\n n = len(training_data)\\n curr_stagnation = stagnation_epochs\\n min_cost = float('inf')\\n\\n for idx, e in enumerate(range(epochs)):\\n np.random.shuffle(training_data)\\n batches = [np.array(training_data[k:k + batch_size], dtype=object)\\n for k in range(0, len(training_data), batch_size)]\\n\\n for batch in batches:\\n self.gradient_descent_step(batch, eta, lambda_r, n)\\n\\n self.costs[idx] = self.cost_func.prediction_cost(self.feed_forward([x_ for x_, y_ in training_data])[2],\\n np.array([y_ for x_, y_ in training_data])) + \\\\\\n self.weights_cost(n, self.lambda_r)\\n\\n if verbose:\\n print('Epoch {} ended with cost {:.3f}'.format(e + 1, self.costs[idx]))\\n\\n min_cost = min(min_cost, self.costs[idx])\\n\\n if idx != 0:\\n curr_stagnation = curr_stagnation - 1 if self.costs[idx] != min_cost else stagnation_epochs\\n\\n if curr_stagnation == 0:\\n curr_stagnation = stagnation_epochs\\n eta /= eta_divide_factor\\n eta_decrease_available -= 1\\n min_cost = float('inf')\\n\\n if eta_decrease_available < 0:\\n if verbose:\\n print('Eta decreased maximum available times, terminating')\\n break\\n\\n if verbose:\\n print('Decreasing eta to {:.5f}'.format(eta))\\n\\n if test_data:\\n self.accuracies[idx] = self.metric.metric_value(self.predict([x_ for x_, y_ in test_data]),\\n [y_ for x_, y_ in test_data])\\n\\n if verbose:\\n self.plot_costs()\\n\\n if test_data:\\n self.plot_metric_values()\",\n \"def test_dc_lcsmodel_class():\\n\\n # Set the problem size.\\n n = 1000\\n p = 3\\n\\n # Define the test model\\n TM = test.Model1(n,p)\\n\\n # Note: diff_A/diff_b do not require A/b as an input in this case,\\n # but in the more general case they might.\\n\\n # Check the basic model calculations.\\n theta = numpy.array((1., 0.1, 0.2, 0.1))\\n A = TM.eval_A(theta)\\n B = TM.eval_b(theta)\\n\\n dA_1 = TM.diff_A(A, theta, 0).todense()\\n dA_2 = TM.diff_A(A, theta, 1).todense()\\n dA_3 = TM.diff_A(A, theta, 2).todense()\\n dA_4 = TM.diff_A(A, theta, 3).todense()\\n Z = numpy.zeros_like(dA_1)\\n \\n dB_1 = TM.diff_b(B, theta, 0)\\n dB_2 = TM.diff_b(B, theta, 1)\\n dB_3 = TM.diff_b(B, theta, 2)\\n dB_4 = TM.diff_b(B, theta, 3)\\n z = numpy.zeros_like(dB_1)\\n \\n print \\\"dA/dtheta_1 check:\\\", numpy.allclose(dA_1, TM.A1.todense())\\n print \\\"dA/dtheta_2 check:\\\", numpy.allclose(dA_2, TM.A2.todense())\\n print \\\"dA/dtheta_3 check:\\\", numpy.allclose(dA_3, Z)\\n print \\\"dA/dtheta_4 check:\\\", numpy.allclose(dA_4, Z)\\n\\n print \\\"db/dtheta_1 check:\\\", numpy.allclose(dB_1, z)\\n print \\\"db/dtheta_2 check:\\\", numpy.allclose(dB_2, z)\\n print \\\"db/dtheta_3 check:\\\", numpy.allclose(dB_3, TM.B1)\\n print \\\"db/dtheta_4 check:\\\", numpy.allclose(dB_4, TM.B2)\\n\\n\\n #\\n # Test the lcs model class\\n #\\n\\n gLCS = DC_LCSModel()\\n gLCS.eval_A = TM.eval_A\\n gLCS.eval_b = TM.eval_b\\n gLCS.diff_A = TM.diff_A\\n gLCS.diff_b = TM.diff_b\\n \\n gLCS.quiet=True\\n gLCS.A_params_mask = numpy.array([True, True, False, False])\\n gLCS.b_params_mask = numpy.array([False, False, True, True])\\n\\n x = gLCS.eval(theta)\\n #print x.shape\\n\\n for k in range(p):\\n print \\\"Primal solution for x_{}, matches spsolve calculation: {}\\\".\\\\\\n format(k, numpy.allclose(x[:,k], spla.spsolve(A,B[:,k])))\\n\\n\\n D = gLCS.jacobian(theta)\\n\\n # -- If theta[1]=0, and theta[2:3] are fixed, then there is an analytical\\n # calculation for x(theta[0]), and in this case we can check the first\\n # column of D.\\n\\n theta = numpy.array((5.1, 0, 1.2, 2.1))\\n A = TM.eval_A(theta)\\n B = TM.eval_b(theta)\\n D = gLCS.jacobian(theta)\\n\\n for k in range(p):\\n D_col_1 = -(1./theta[0]**2) * B[:,k]\\n print \\\"First column of D_{} all close: {}\\\".\\\\\\n format(k, numpy.allclose(D[k,:,0], D_col_1))\\n\\n\\n # -- We'll use a numerical approximation to check the second column of D\\n\\n h = 0.000001\\n theta = numpy.array((5.1, 1.1, 1.2, 2.1))\\n dtheta = numpy.array((0., h, 0., 0.))\\n A = TM.eval_A(theta)\\n B = TM.eval_b(theta)\\n x = gLCS.eval(theta)\\n D = gLCS.jacobian(theta)\\n\\n A_dt = TM.eval_A(theta + dtheta)\\n B_dt = TM.eval_b(theta + dtheta)\\n\\n for k in range(p):\\n x_dt = spla.spsolve(A_dt, B_dt[:,k])\\n D_col_2_num_approx = (x_dt - x[:,k])/h\\n max_abs_err = numpy.max(numpy.abs(D[k,:,1] - D_col_2_num_approx))\\n\\n print \\\"Second column of D_{} all close: {}\\\".\\\\\\n format(k, numpy.allclose(D[k,:,1], D_col_2_num_approx))\\n \\n print \\\"Max abs error in second column of D_{}: {}\\\".\\\\\\n format(k, max_abs_err)\\n \\n\\n # -- If theta[0] and theta[1] are fixed, A(theta) is determined, and A^{-1}\\n # is fixed. With a little math you can analytically calculate the third\\n # and fourth columns of D. In fact x(theta) is linear in theta[2] and\\n # theta[3], but not in theta[0] and theta[1].\\n\\n theta = numpy.array((1., 0.1, 0.2, 0.1))\\n A = TM.eval_A(theta)\\n D = gLCS.jacobian(theta);\\n\\n for k in range(p):\\n D_col_3 = spla.spsolve(A, TM.B1[:,k])\\n\\n print \\\"Third column of D_{} all close: {}\\\".\\\\\\n format(k, numpy.allclose(D[k,:,2], D_col_3))\\n\\n\\n for k in range(p):\\n D_col_4 = spla.spsolve(A, TM.B2[:,k])\\n \\n print \\\"Fourth column of D_{} all close: {}\\\".\\\\\\n format(k, numpy.allclose(D[k,:,3], D_col_4))\",\n \"def _apply_dense(self, grad, var):\\n\\n assignments = []\\n\\n param_name = self._get_variable_name(var.name)\\n\\n m = self.get_slot(var, \\\"m\\\")\\n v = self.get_slot(var, \\\"v\\\")\\n\\n # Standard Adam update.\\n next_m = (\\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\\n next_v = (\\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\\n tf.square(grad)))\\n\\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\\n\\n # Just adding the square of the weights to the loss function is *not*\\n # the correct way of using L2 regularization/weight decay with Adam,\\n # since that will interact with the m and v parameters in strange ways.\\n #\\n # Instead we want ot decay the weights in a manner that doesn't interact\\n # with the m/v parameters. This is equivalent to adding the square\\n # of the weights to the loss with plain (non-momentum) SGD.\\n if self._do_use_weight_decay(param_name):\\n update += self.weight_decay_rate * var\\n\\n update_with_lr = self.learning_rate * update\\n\\n next_param = var - update_with_lr\\n\\n assignments.extend([var.assign(next_param, use_locking=self._use_locking),\\n m.assign(next_m),\\n v.assign(next_v)])\\n return tf.group(*assignments)\",\n \"def C2ST_NN_fit(S,y,N1,x_in,H,x_out,learning_rate_C2ST,N_epoch,batch_size,device,dtype):\\r\\n N = S.shape[0]\\r\\n if is_cuda:\\r\\n model_C2ST = ModelLatentF(x_in, H, x_out).cuda()\\r\\n else:\\r\\n model_C2ST = ModelLatentF(x_in, H, x_out)\\r\\n w_C2ST = torch.randn([x_out, 2]).to(device, dtype)\\r\\n b_C2ST = torch.randn([1, 2]).to(device, dtype)\\r\\n w_C2ST.requires_grad = True\\r\\n b_C2ST.requires_grad = True\\r\\n optimizer_C2ST = torch.optim.Adam(list(model_C2ST.parameters()) + [w_C2ST] + [b_C2ST], lr=learning_rate_C2ST)\\r\\n criterion = torch.nn.CrossEntropyLoss()\\r\\n f = torch.nn.Softmax()\\r\\n ind = np.random.choice(N, N, replace=False)\\r\\n tr_ind = ind[:np.int(np.ceil(N * 1))]\\r\\n te_ind = tr_ind\\r\\n dataset = torch.utils.data.TensorDataset(S[tr_ind, :], y[tr_ind])\\r\\n dataloader_C2ST = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)\\r\\n len_dataloader = len(dataloader_C2ST)\\r\\n for epoch in range(N_epoch):\\r\\n data_iter = iter(dataloader_C2ST)\\r\\n tt = 0\\r\\n while tt < len_dataloader:\\r\\n # training model using source data\\r\\n data_source = data_iter.next()\\r\\n S_b, y_b = data_source\\r\\n output_b = model_C2ST(S_b).mm(w_C2ST) + b_C2ST\\r\\n loss_C2ST = criterion(output_b, y_b)\\r\\n optimizer_C2ST.zero_grad()\\r\\n loss_C2ST.backward(retain_graph=True)\\r\\n # Update sigma0 using gradient descent\\r\\n optimizer_C2ST.step()\\r\\n tt = tt + 1\\r\\n if epoch % 100 == 0:\\r\\n print(criterion(model_C2ST(S).mm(w_C2ST) + b_C2ST, y).item())\\r\\n\\r\\n output = f(model_C2ST(S[te_ind, :]).mm(w_C2ST) + b_C2ST)\\r\\n pred = output.max(1, keepdim=True)[1]\\r\\n STAT_C2ST = abs(pred[:N1].type(torch.FloatTensor).mean() - pred[N1:].type(torch.FloatTensor).mean())\\r\\n return pred, STAT_C2ST, model_C2ST, w_C2ST, b_C2ST\",\n \"def DynamicsCo(x, t, T0, alpha, cost_co, cost_ch, K_co, K_ch, n, r):\\n y=np.zeros([np.size(x)])\\n D=np.zeros([2]) \\n #define fitnss\\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \\n #degradation\\n deg=fmax*x[1]/(x[1]+Kd) \\n #ODE of eco-evo dynamics\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r*(1-cost_co)*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\\n y[2]=x[2]*(r*(1-cost_ch)*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\\n \\n return y\",\n \"def get_cost_updates(self,learning_rate, beta=0.9):\\n max_x = T.max(self.x)\\n min_x = T.min(self.x)\\n self.x = (self.x - min_x) / (max_x - min_x)\\n y = self.get_hidden_values(self.x)\\n z = self.get_reconstructed_input(y)\\n # note : we sum over the size of a datapoint; if we are using\\n # minibatches, L will be a vector, with one entry per\\n # example in minibatch\\n # L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)\\n L_prime = T.sum(T.square(z - self.x), axis=1)\\n # note : L is now a vector, where each element is the\\n # cross-entropy cost of the reconstruction of the\\n # corresponding example of the minibatch. We need to\\n # compute the average of all these to get the cost of\\n # the minibatch\\n cost = T.mean(L_prime)\\n\\n # compute the gradients of the cost of the `dA` with respect\\n # to its parameters\\n gparams = T.grad(cost, self.params)\\n # generate the list of updates\\n updates = []\\n for momen, gparm1 in zip(self.mom, gparams):\\n updates.append((momen, momen * beta + (1 - beta) * gparm1))\\n for param, momen in zip(self.params, self.mom):\\n updates.append((param, param - learning_rate * momen))\\n\\n return (cost, updates)\",\n \"def run_sgd(self, inputs, step_size=0.01, momentum=0.9, num_epoch=200,\\r\\n minibatch_size=100, l2_coef=1e-5, test_inputs=None,\\r\\n display=False):\\r\\n train_loss = []\\r\\n train_grad = []\\r\\n test_loss = []\\r\\n test_grad = []\\r\\n max_inputs = np.max(inputs) + 1.0\\r\\n max_test_inputs = np.max(test_inputs) + 1.0\\r\\n inputs = inputs / max_inputs\\r\\n test_inputs = test_inputs / max_test_inputs\\r\\n w = np.random.normal(loc=0.0, scale=0.2, size=self.net.params_number)\\r\\n self.net.set_weights(w)\\r\\n for i in range(num_epoch):\\r\\n first = 0\\r\\n dw = 0\\r\\n while first < inputs.shape[1]:\\r\\n step_input = inputs[:, first: first + minibatch_size]\\r\\n first += minibatch_size\\r\\n step_output = self.net.compute_outputs(step_input)\\r\\n loss = np.sum(np.abs(step_output - step_input), axis=0).mean()\\r\\n dz = np.sign(step_output - step_input)\\r\\n loss_grad = self.net.compute_loss_grad(dz)\\r\\n w = self.net.get_weights()\\r\\n l2_loss_grad = loss_grad + 2.0 * l2_coef * w\\r\\n learning_rate = step_size / (i + 1) ** 0.25\\r\\n dw = momentum * dw - learning_rate * l2_loss_grad\\r\\n w = w + dw\\r\\n self.net.set_weights(w)\\r\\n if first >= inputs.shape[1]:\\r\\n loss_grad_norm = math.sqrt(np.sum(l2_loss_grad ** 2))\\r\\n train_loss.append(loss)\\r\\n train_grad.append(loss_grad_norm)\\r\\n\\r\\n test_outputs = self.net.compute_outputs(test_inputs)\\r\\n loss2 = np.sum(np.abs(test_outputs - test_inputs),\\r\\n axis=0).mean()\\r\\n dz = np.sign(test_outputs - test_inputs)\\r\\n test_loss_grad = self.net.compute_loss_grad(dz)\\r\\n test_loss_grad_norm = math.sqrt(np.sum(test_loss_grad ** 2))\\r\\n test_loss.append(loss2)\\r\\n test_grad.append(test_loss_grad_norm)\\r\\n\\r\\n if display is True:\\r\\n print(loss)\\r\\n\\r\\n return {'train_loss': train_loss, 'train_grad': train_grad,\\r\\n 'test_loss': test_loss, 'test_grad': test_grad}\",\n \"def update(self, dLds, alpha, beta):\\n T = len(self.x)\\n self.nodes.reset_error()\\n self.igate.reset_error()\\n self.fgate.reset_error()\\n self.ogate.reset_error()\\n dLdx = np.zeros((T, self.input_size))\\n dLdc = np.zeros(self.hidden_size)\\n for t in xrange(T-1, -1, -1):\\n dLdpo = dLds[t] * self.h[t] * self.gatefun.derivate(self.o[t])\\n # parameters for output gate\\n self.ogate.dLdu += np.outer(dLdpo, self.x[t])\\n self.ogate.dLdw += np.outer(dLdpo, self.s[t-1])\\n self.ogate.dLdv += np.outer(dLdpo, self.c[t-1])\\n dLds[t-1] += np.dot(self.ogate.w.T, dLdpo)\\n dLdx[t] += np.dot(self.ogate.u.T, dLdpo)\\n dLdc += np.dot(self.ogate.v.T, dLdpo)\\n\\n dLdc += dLds[t] * self.o[t] * self.acfun.derivate(self.h[t])\\n dLdpi = dLdc * self.g[t] * self.gatefun.derivate(self.i[t])\\n dLdpf = dLdc * self.c[t-1] * self.gatefun.derivate(self.f[t])\\n dLdpg = dLdc * self.i[t] * self.acfun.derivate(self.g[t])\\n dLdc = dLdc * self.f[t]\\n # parameters for nodes in hidden layer\\n self.nodes.dLdu += np.outer(dLdpg, self.x[t])\\n self.nodes.dLdw += np.outer(dLdpg, self.s[t-1])\\n dLds[t-1] += np.dot(self.nodes.w.T, dLdpg)\\n dLdx[t] += np.dot(self.nodes.u.T, dLdpg)\\n # parameters for input gate\\n self.igate.dLdu += np.outer(dLdpi, self.x[t])\\n self.igate.dLdw += np.outer(dLdpi, self.s[t-1])\\n self.igate.dLdv += np.outer(dLdpi, self.c[t-1])\\n dLds[t-1] += np.dot(self.igate.w.T, dLdpi)\\n dLdx[t] += np.dot(self.igate.u.T, dLdpi)\\n dLdc += np.dot(self.igate.v.T, dLdpi)\\n # parameters for forget gate\\n self.fgate.dLdu += np.outer(dLdpf, self.x[t])\\n self.fgate.dLdw += np.outer(dLdpf, self.s[t-1])\\n self.fgate.dLdv += np.outer(dLdpf, self.c[t-1])\\n dLds[t-1] += np.dot(self.fgate.w.T, dLdpf)\\n dLdx[t] += np.dot(self.fgate.u.T, dLdpf)\\n dLdc += np.dot(self.fgate.v.T, dLdpf)\\n if self.en_bias:\\n self.nodes.dLdb += dLdpg\\n self.igate.dLdb += dLdpi\\n self.fgate.dLdb += dLdpf\\n self.ogate.dLdb += dLdpo\\n # update weight matrix of current hidden node\\n self.nodes.update(alpha, beta)\\n self.igate.update(alpha, beta)\\n self.fgate.update(alpha, beta)\\n self.ogate.update(alpha, beta)\\n return dLdx\",\n \"def CA_Algorithm(self, states, actions, rewards, next_states, terminals):\\n states = states.reshape(-1, self.input_width)\\n next_states = next_states.reshape(-1, self.input_width)\\n update_rule = self.update_rule\\n terminals = terminals.astype(np.float32)\\n if (self.freeze_interval > 0 and\\n self.update_counter % self.freeze_interval == 0):\\n self.reset_q_hat()\\n p_vals, next_p_vals = self.sess.run([self.p_vals, self.next_p_vals],{self.S: states, self.A: actions, self.R: rewards, self.S_: next_states, self.T: terminals})\\n\\n p_target = p_vals.copy()\\n BestAct = np.argmax(np.sum(np.multiply(self.Z, next_p_vals),axis =2), axis = 1)\\n terminals_false = np.ones_like(terminals)-terminals\\n\\n for batchIndex, r in enumerate(rewards):\\n m = np.zeros(self.atoms)\\n for j in range(self.atoms):\\n Tau_z_j = np.clip(r + terminals_false[batchIndex][0]*self.discount * self.Z[j], self.Vmin, self.Vmax)\\n b_j = float(Tau_z_j-self.Vmin)/self.delta_z\\n l = math.floor(b_j)\\n u = math.ceil(b_j)\\n l_int = int(l)\\n u_int = int(u)\\n m[l_int] = m[l_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(u - b_j)\\n m[u_int] = m[u_int] + next_p_vals[batchIndex][BestAct[batchIndex]][j]*(b_j - l)\\n p_target[batchIndex,BestAct[batchIndex],:] = m\\n\\n _,loss = self.sess.run([self._train,self.loss], feed_dict={self.S: states, self.p_target: p_target})\\n self.update_counter += 1\\n return loss\",\n \"def learn(self, lr_a, lr_l, lr_lag, lr_c, batch):\\n\\n # Adjust optimizer learning rates (decay)\\n self._set_learning_rates(\\n lr_a=lr_a, lr_alpha=lr_a, lr_l=lr_l, lr_labda=lr_lag, lr_c=lr_c\\n )\\n\\n ################################################\\n # Optimize (Lyapunov/Q) critic #################\\n ################################################\\n if self.use_lyapunov:\\n # Get target Lyapunov value (Bellman-backup)\\n a2_, _ = self.ga_(\\n batch[\\\"s_\\\"]\\n ) # NOTE (rickstaa): Target actions come from *current* *target* policy\\n l_pi_targ = self.lc_(batch[\\\"s_\\\"], a2_)\\n l_backup = (\\n batch[\\\"r\\\"] + self._gamma * (1 - batch[\\\"terminal\\\"]) * l_pi_targ\\n ) # The Lyapunov candidate\\n\\n # Compute Lyapunov Critic error gradients\\n with tf.GradientTape() as l_tape:\\n\\n # Get current Lyapunov value\\n l1 = self.lc(batch[\\\"s\\\"], batch[\\\"a\\\"])\\n\\n # Calculate Lyapunov *CRITIC* error\\n # NOTE (rickstaa): The 0.5 multiplication factor was added to make the\\n # derivation cleaner and can be safely removed without influencing the\\n # minimization. We kept it here for consistency.\\n l_error = 0.5 * tf.reduce_mean((l1 - l_backup) ** 2) # See eq. 7\\n\\n # Perform one gradient descent step for the Lyapunov critic\\n l_grads = l_tape.gradient(l_error, self.lc.trainable_variables)\\n self._l_train.apply_gradients(zip(l_grads, self.lc.trainable_variables))\\n else:\\n\\n # Get target Q values (Bellman-backup)\\n # NOTE (rickstaa): Here we use max-clipping instead of min-clipping used\\n # in the SAC algorithm since we want to minimize the return.\\n a2, logp_a2 = self.ga(\\n batch[\\\"s_\\\"]\\n ) # NOTE (rickstaa): Target actions come from *current* policy\\n q1_pi_targ = self.q_1_(batch[\\\"s_\\\"], a2)\\n q2_pi_targ = self.q_2_(batch[\\\"s_\\\"], a2)\\n q_pi_targ = tf.maximum(\\n q1_pi_targ, q2_pi_targ\\n ) # Use max clipping to prevent overestimation bias.\\n q_backup = batch[\\\"r\\\"] + self._gamma * (1 - batch[\\\"terminal\\\"]) * (\\n q_pi_targ - self.alpha * logp_a2\\n )\\n\\n # Compute the Q-Critic loss gradients\\n with tf.GradientTape() as q_tape:\\n # Get the current Q values\\n q1 = self.q_1(batch[\\\"s\\\"], batch[\\\"a\\\"])\\n q2 = self.q_2(batch[\\\"s\\\"], batch[\\\"a\\\"])\\n\\n # Calculate Q-critic loss\\n loss_q1 = 0.5 * tf.reduce_mean(\\n (q1 - q_backup) ** 2\\n ) # See Haarnoja eq. 5\\n loss_q2 = 0.5 * tf.reduce_mean((q2 - q_backup) ** 2)\\n loss_q = loss_q1 + loss_q2\\n\\n # Perform one gradient descent step for the Q-critic\\n q_grads = q_tape.gradient(loss_q, self._main_q_vars)\\n self._q_train.apply_gradients(zip(q_grads, self._main_q_vars))\\n\\n ################################################\\n # Optimize Gaussian actor ######################\\n ################################################\\n\\n # Compute actor loss gradients\\n with tf.GradientTape() as a_tape:\\n\\n # Retrieve log probabilities of batch observations based on *current*\\n # policy\\n pi, log_pis = self.ga(batch[\\\"s\\\"])\\n\\n # Compute actor loss\\n if self.use_lyapunov:\\n # Calculate the target Lyapunov value\\n a2, _ = self.ga(\\n batch[\\\"s_\\\"]\\n ) # NOTE (rickstaa): Target actions come from *current* policy\\n lya_l_ = self.lc(batch[\\\"s_\\\"], a2)\\n\\n # Compute Lyapunov Actor error\\n self.l_delta = tf.reduce_mean(\\n lya_l_ - tf.stop_gradient(l1) + self._alpha_3 * batch[\\\"r\\\"]\\n ) # See eq. 11\\n\\n # Calculate actor loss\\n a_loss = tf.stop_gradient(self.labda) * self.l_delta + tf.stop_gradient(\\n self.alpha\\n ) * tf.reduce_mean(\\n log_pis\\n ) # See eq. 12\\n else:\\n\\n # Retrieve the current Q values\\n q1_pi = self.q_1(\\n batch[\\\"s\\\"], pi\\n ) # NOTE (rickstaa): Actions come from *current* policy\\n q2_pi = self.q_2(\\n batch[\\\"s\\\"], pi\\n ) # NOTE (rickstaa): Actions come from *current* policy\\n q_pi = tf.maximum(q1_pi, q2_pi)\\n\\n # Calculate actor loss\\n a_loss = tf.reduce_mean(\\n tf.stop_gradient(self.alpha) * log_pis - q_pi\\n ) # See Haarnoja eq. 7\\n\\n # Perform one gradient descent step for the Gaussian Actor\\n a_grads = a_tape.gradient(a_loss, self.ga.trainable_variables)\\n self._a_train.apply_gradients(zip(a_grads, self.ga.trainable_variables))\\n\\n ################################################\\n # Optimize alpha (Entropy temperature) #########\\n ################################################\\n\\n # Compute alpha loss gradients\\n with tf.GradientTape() as alpha_tape:\\n\\n # Calculate alpha loss\\n alpha_loss = -tf.reduce_mean(\\n self.alpha * tf.stop_gradient(log_pis + self.target_entropy)\\n ) # See Haarnoja eq. 17\\n\\n # Perform one gradient descent step for alpha\\n alpha_grads = alpha_tape.gradient(alpha_loss, [self.log_alpha])\\n self._alpha_train.apply_gradients(zip(alpha_grads, [self.log_alpha]))\\n\\n ################################################\\n # Optimize labda (Lyapunov temperature) ########\\n ################################################\\n if self.use_lyapunov:\\n\\n # Compute labda loss gradients\\n with tf.GradientTape() as lambda_tape:\\n\\n # Calculate labda loss\\n # NOTE (rickstaa): Log_labda was used in the lambda_loss function\\n # because using lambda caused the gradients to vanish. This is caused\\n # since we restrict lambda within a 0-1.0 range using the clamp function\\n # (see #38). Using log_lambda also is more numerically stable.\\n labda_loss = -tf.reduce_mean(\\n self.log_labda * tf.stop_gradient(self.l_delta)\\n ) # See formulas under eq. 14\\n\\n # Perform one gradient descent step for labda\\n lambda_grads = lambda_tape.gradient(labda_loss, [self.log_labda])\\n self._lambda_train.apply_gradients(zip(lambda_grads, [self.log_labda]))\\n\\n ################################################\\n # Update target networks and return ############\\n # diagnostics. #################################\\n ################################################\\n\\n # Update target networks\\n self._update_targets()\\n\\n # Return diagnostics\\n if self.use_lyapunov:\\n return (\\n self.labda,\\n self.alpha,\\n l_error,\\n tf.reduce_mean(tf.stop_gradient(-log_pis)),\\n a_loss,\\n alpha_loss,\\n labda_loss,\\n )\\n else:\\n return (\\n self.alpha,\\n loss_q,\\n tf.reduce_mean(tf.stop_gradient(-log_pis)),\\n a_loss,\\n alpha_loss,\\n )\",\n \"def sgd(self, data, iterations, learning_rate, initial_momentum, final_momentum, minibatch=10, \\\\\\n\\t\\tannealing=None, max_epoch_without_improvement=30, early_stop=True, corruption=None):\\n\\t\\t\\n\\t\\tm = data.shape[1]\\n\\t\\tdata = data.T\\n\\t\\t\\n\\t\\t###########################################################################################\\n\\t\\t# Initialisation of the weights and bias\\n\\t\\t\\n\\t\\t# Copy the weights and biases into a state vector theta\\n\\t\\tweights = []\\n\\t\\tbiases = []\\n\\t\\tfor jj in range(self.mid * 2):\\n\\t\\t\\tweights.append(copy.copy(self.layers[jj].weights))\\n\\t\\t\\tbiases.append(self.layers[jj].hidden_biases) \\n\\t\\t\\t\\n\\t\\ttheta, indices, weights_shape, biases_shape = self._roll(weights, biases)\\n\\t\\tdel weights, biases\\n\\t\\t\\n\\t\\t###########################################################################################\\n\\t\\tv_mom = 0\\n\\t\\tbest_cost = 1e8\\n\\t\\t\\n\\t\\tbatch_indices = np.arange(m)\\n\\t\\tn_minibatches = np.int(np.ceil(m/minibatch))\\n\\t\\t\\n\\t\\tgamma = initial_momentum\\n\\t\\t\\n\\t\\tfor epoch in range(iterations):\\n\\t\\t\\tnp.random.shuffle(batch_indices)\\t\\t\\t\\n\\t\\t\\tfor ibatch in range(n_minibatches+1):\\n\\t\\t\\t\\tids = batch_indices[ibatch*minibatch:(ibatch+1)*minibatch]\\n\\t\\t\\t\\tbatch = data[:,ids]\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t_, thetan = self.cost(theta, indices, weights_shape, biases_shape,\\n\\t\\t\\t\\t0, 0, 0, batch, corruption=corruption, cost_fct='cross-entropy', log_cost=False)\\n\\t\\t\\t\\tv_mom = gamma * v_mom + learning_rate * thetan\\n\\t\\t\\t\\ttheta -= v_mom\\n\\t\\t\\t\\n\\t\\t\\tactual = self.feedforward(data.T)\\n\\t\\t\\tcost = utils.cross_entropy(data.T, actual)\\n\\t\\t\\tprint 'Epoch %4d/%4d:\\\\t%e' % (epoch+1, iterations, cost)\\n\\n\\t\\t\\tself.train_history.append(cost)\\n\\t\\t\\t\\n\\t\\t\\tif cost <= best_cost :\\n\\t\\t\\t\\tbest_cost = cost\\n\\t\\t\\t\\titer_best = epoch\\n\\t\\t\\t\\t\\n\\t\\t\\tif epoch - iter_best > max_epoch_without_improvement :\\n\\t\\t\\t\\tprint 'STOP: %d epoches without improvment' % max_epoch_without_improvement\\n\\t\\t\\t\\tbreak\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tif annealing is not None:\\n\\t\\t\\t\\tlearning_rate /= (1. + float(epoch) / annealing)\\n\\t\\t\\t\\t\\n\\t\\t\\tif epoch > 100:\\n\\t\\t\\t\\tgamma = final_momentum\\n\\t\\t\\telse:\\n\\t\\t\\t\\tgamma = initial_momentum + (final_momentum - initial_momentum) * utils.sigmoid(epoch - 50)\\n\\t\\t\\tprint learning_rate, gamma\\n\\t\\t\\t\\n\\t\\t###########################################################################################\\n\\t\\t# Unroll the state vector and saves it to self.\\t\\n\\t\\tfor jj in range(self.mid * 2):\\n\\t\\t\\tw, b = self._unroll(theta, jj, indices, weights_shape, biases_shape)\\n\\t\\t\\t\\n\\t\\t\\tself.layers[jj].weights = w\\n\\t\\t\\tself.layers[jj].hidden_biases = b\\n\\t\\t\\t\\n\\t\\t# We're done !\\n\\t\\tself.is_trained = True\",\n \"def update_critics(self, s, a, r, t, s_):\\n q1_loss, q2_loss = self.cal_critic_loss(s, a, r, t, s_)\\n\\n self.critic1_optimiser.zero_grad()\\n q1_loss.backward()\\n self.critic1_optimiser.step()\\n\\n self.critic2_optimiser.zero_grad()\\n q2_loss.backward()\\n self.critic2_optimiser.step()\",\n \"def _stochastic_gradient_descent(self, X, y, lr, epochs, sample_rate):\\n\\n # Initialize the bias and weights.\\n m, n = X.shape\\n self.bias = 0\\n self.weights = np.random.normal(size=n)\\n\\n n_sample = int(m * sample_rate)\\n for i in range(epochs):\\n for idx in choice(range(m), n_sample, replace=False):\\n # Calculate the gradient delta of each sample\\n grad_bias, grad_weights = self._get_gradient(X[idx], y[idx])\\n\\n # Update the bias and weight by gradient of current sample\\n self.bias += lr * grad_bias\\n self.weights += lr * grad_weights\\n\\n # Show the gradient of each epoch.\\n grad_bias, grad_weights = self._get_gradient(X, y)\\n grad = (grad_bias + grad_weights.mean()) / 2\\n print(\\\"Epochs %d gradient %.3f\\\" % (i + 1, grad), flush=True)\",\n \"def sorm(func, dist_list, init_search_point, alg): \\n def SLSQP(func, dist_list, init_search_point):\\n \\n dim = len(dist_list)\\n current_beta = 0\\n new_beta = 1\\n sig = np.empty((1, dim))\\n mu = np.empty((1, dim))\\n new_search_point = np.array(init_search_point).reshape((1, dim))\\n \\n def f_l(x_l):\\n return(func([x_l[i,:]*sig[0,i] + mu[0,i] for i in range(0, dim)]))\\n \\n while abs(current_beta-new_beta) > 0.001:\\n current_search_point = new_search_point\\n current_beta = new_beta\\n for i in range(0, dim):\\n if dist_list[i][1] != 'norm':\\n mu[0,i], sig[0, i] = Rosenblatt_Transform(dist_list[i][0], current_search_point[0,i])\\n else:\\n mu[0,i], sig[0, i] = dist_list[i][0].mean(), dist_list[i][0].std()\\n \\n dist_fun = lambda u: np.linalg.norm(u) \\n \\n alg = 'SLSQP'\\n \\n H = lambda u: f_l(u)\\n cons = ({'type': 'eq', 'fun': lambda u: -(H(u.reshape(-1,1)))})\\n \\n result = scipy.optimize.minimize(dist_fun, x0 = current_search_point, constraints = cons, method=alg)\\n \\n new_beta = result.fun\\n u = np.array(result.x).reshape((1,dim))\\n \\n new_search_point = np.empty((1, dim))\\n for i in range(0, dim):\\n new_search_point[0,i] = mu[0,i] + u[0,i]*sig[0,i]\\n \\n beta_value = new_beta \\n p_f = sst.norm.cdf(-beta_value)\\n iterations = result.nit\\n u = result.x\\n x = u[:]*sig[0,:] + mu[0,:]\\n grad_val = scipy.optimize.approx_fprime(x, func, 0.00000001)\\n grad_val = grad_val.reshape((1, dim))\\n \\n sum1 = np.sum((grad_val[0,:]**2)*(sig[0,:]**2))\\n cosines = np.empty((1, dim))\\n \\n for i in range(0, dim):\\n cosines[0,i] = grad_val[0,i]*sig[0,i]/np.sqrt(sum1) \\n \\n return(beta_value, p_f, x, u, mu, sig, cosines, iterations) \\n \\n def HL_R(func, dist_list, init_search_point):\\n \\n iterations = 0\\n cur_beta = 3\\n new_beta = 0\\n dim = len(dist_list)\\n global_mean_arr = np.empty((1, dim))\\n global_std_arr = np.empty((1, dim))\\n new_search_point = np.array(init_search_point).reshape((1, dim))\\n \\n while abs(cur_beta - new_beta) > 0.001:\\n cur_beta = new_beta\\n cur_cosines = np.zeros((1, dim))\\n new_cosines = np.ones((1, dim))\\n \\n while max((abs(cur_cosines - new_cosines))[0]) > 0.005:\\n \\n cur_cosines = new_cosines\\n \\n cur_search_point = new_search_point\\n \\n for i in range(0, dim):\\n if dist_list[i][1] != 'norm':\\n global_mean_arr[0, i], global_std_arr[0, i] = Rosenblatt_Transform(dist_list[i][0], cur_search_point[0,i])\\n else:\\n global_mean_arr[0, i], global_std_arr[0, i] = dist_list[i][0].mean(), dist_list[i][0].std()\\n \\n \\n grad_val = scipy.optimize.approx_fprime(cur_search_point[0], func, 0.00000001)\\n grad_val = grad_val.reshape((1, dim))\\n \\n sum1 = np.sum((grad_val[0,:]**2)*(global_std_arr[0,:]**2))\\n cosines = np.empty((1, dim))\\n \\n for i in range(0, dim):\\n cosines[0,i] = grad_val[0,i]*global_std_arr[0,i]/np.sqrt(sum1)\\n \\n new_cosines = cosines\\n new_search_point = np.empty((1, dim))\\n for i in range(0, dim):\\n new_search_point[0,i] = global_mean_arr[0,i] - new_cosines[0,i]*global_std_arr[0,i]*cur_beta\\n \\n iterations = iterations + 1\\n \\n \\n B = Symbol('B')\\n coordinates = []\\n for i in range(0, dim):\\n coordinates.append(global_mean_arr[0, i] - new_cosines[0,i]*global_std_arr[0, i]*B)\\n new_beta = float(solve(func(coordinates), B)[0])\\n \\n cosines = new_cosines \\n beta_value = new_beta\\n p_f = sst.norm.cdf(-new_beta)\\n x = new_search_point\\n u = (x[0,:] - global_mean_arr[0,:])/global_std_arr\\n \\n return(beta_value, p_f, x, u, global_mean_arr, global_std_arr, cosines, iterations)\\n \\n def HL_RF(func, dist_list, init_search_point):\\n\\n cur_beta = 3\\n new_beta = 0\\n dim = len(dist_list)\\n\\n new_search_point = np.array(init_search_point).reshape((1, dim))\\n iterations = 0\\n while abs(cur_beta - new_beta) > 0.001 and abs(func(new_search_point[0])) > 0.001:\\n global_mean_arr = np.empty((1, dim))\\n global_std_arr = np.empty((1, dim))\\n cur_beta = new_beta\\n cur_search_point = new_search_point\\n \\n for i in range(0, dim):\\n if dist_list[i][1] != 'norm':\\n global_mean_arr[0,i], global_std_arr[0, i] = Rosenblatt_Transform(dist_list[i][0], cur_search_point[0,i])\\n else:\\n global_mean_arr[0,i], global_std_arr[0, i] = dist_list[i][0].mean(), dist_list[i][0].std()\\n \\n f_val = func(cur_search_point[0])\\n \\n x_ast = np.empty((1, dim))\\n for i in range(0, dim):\\n x_ast[0,i] =(cur_search_point[0,i] - global_mean_arr[0,i])/global_std_arr[0,i]\\n\\n grad_val = scipy.optimize.approx_fprime(cur_search_point[0], func, 0.000001)\\n grad_val = grad_val.reshape((1, dim)) \\n \\n grad_val_ast = np.empty(grad_val.shape)\\n for i in range(0, dim):\\n grad_val_ast[0,i] = grad_val[0,i]*global_std_arr[0,i]\\n \\n t1 = 1/np.sum(grad_val_ast[0,:]**2)\\n\\n t2 = sum(grad_val_ast[0,:]*x_ast[0,:]) - f_val\\n \\n t3 = t1*t2\\n \\n new_x_ast = np.empty(x_ast.shape)\\n for i in range(0, dim):\\n new_x_ast[0,i] = t3*grad_val_ast[0,i]\\n u = new_x_ast\\n new_beta = np.linalg.norm(new_x_ast)\\n \\n new_search_point = np.empty((1, dim))\\n for i in range(0, dim):\\n new_search_point[0,i] = new_x_ast[0,i]*global_std_arr[0,i] + global_mean_arr[0,i]\\n iterations = iterations + 1\\n \\n grad_val_ast_sum = sum(grad_val_ast[0,:]**2)\\n cosines = grad_val_ast/(grad_val_ast_sum**0.5)\\n beta_value = new_beta\\n x = new_search_point\\n p_f = sst.norm.cdf(-beta_value)\\n \\n return(beta_value, p_f, x, u, global_mean_arr, global_std_arr, cosines, iterations)\\n \\n if alg == 'slsqp':\\n beta_value, p_f, x, u, mu, sig, cosines, iterations = SLSQP(func, dist_list, init_search_point)\\n elif alg == 'HL-R':\\n beta_value, p_f, x, u, mu, sig, cosines, iterations = HL_R(func, dist_list, init_search_point)\\n elif alg == 'HL-RF':\\n beta_value, p_f, x, u, mu, sig, cosines, iterations = HL_RF(func, dist_list, init_search_point)\\n \\n d = len(dist_list)\\n\\n R0 = np.eye(d)\\n \\n for i in range(0, d):\\n R0[-1,i] = cosines[0,i]\\n \\n Q, R = scipy.linalg.rq(R0)\\n \\n def f_l(x_l):\\n return(func([x_l[i]*sig[0,i] + mu[0,i] for i in range(0, d)]))\\n \\n x = np.array(x).reshape((1, -1))\\n u = x[0,:]*sig[0,:] + mu[0,:]\\n \\n H = nd.Hessian(f_l)(u)\\n \\n grad_val_standard = (scipy.optimize.approx_fprime(x[0], func, 0.00000001)[:])*(sig[0,:])\\n \\n dist_standard = np.linalg.norm(grad_val_standard)\\n \\n A_1 = 1/dist_standard\\n R_transp = np.transpose(R)\\n A_2 = R.dot(H)\\n A_3 = A_2.dot(R_transp)\\n \\n A = A_3.dot(A_1)\\n \\n A = A[0:-1, 0:-1]\\n \\n k = np.linalg.eig(A)[0]\\n \\n prod_arr = np.empty((1, len(k)))\\n for i in range(0, len(k)):\\n prod_arr[0,i] = (1 + beta_value*k[i])**-0.5\\n \\n p_f_sorm = p_f*np.prod(prod_arr)\\n beta_sorm = -1*scipy.stats.norm.ppf(p_f_sorm)\\n \\n print('-------------------------')\\n print('Second-Order Reliability Analysis')\\n print('Algorithm:',alg,'solver')\\n print('Iterations: {}\\\\nReliability index = {}\\\\nProbability of failure = {}'.format(iterations, beta_sorm, p_f_sorm))\\n print('-------------------------')\\n \\n return(beta_sorm, p_f_sorm)\",\n \"def _resource_apply_dense(self, grad, var):\\n\\n assignments = []\\n\\n param_name = self._get_variable_name(var.name)\\n\\n m = self.get_slot(var, \\\"m\\\")\\n v = self.get_slot(var, \\\"v\\\")\\n\\n # Standard Adam update.\\n next_m = (\\n tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))\\n next_v = (\\n tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,\\n tf.square(grad)))\\n\\n update = next_m / (tf.sqrt(next_v) + self.epsilon)\\n\\n # Just adding the square of the weights to the loss function is *not*\\n # the correct way of using L2 regularization/weight decay with Adam,\\n # since that will interact with the m and v parameters in strange ways.\\n #\\n # Instead we want ot decay the weights in a manner that doesn't interact\\n # with the m/v parameters. This is equivalent to adding the square\\n # of the weights to the loss with plain (non-momentum) SGD.\\n if self._do_use_weight_decay(param_name):\\n update += self.weight_decay_rate * var\\n\\n update_with_lr = self.learning_rate * update\\n\\n next_param = var - update_with_lr\\n\\n assignments.extend([var.assign(next_param, use_locking=self._use_locking),\\n m.assign(next_m),\\n v.assign(next_v)])\\n return tf.group(*assignments)\",\n \"def least_squares_SGD(y, tx, initial_w, max_iters, gamma, batch_size=10, verbose=False):\\n return stochastic_gradient_descent(y, tx, initial_w, max_iters, gamma, compute_mse, \\n compute_mse_gradient, batch_size=batch_size, verbose=verbose)\",\n \"def SSC_test():\\n \\n # generating data\\n\\n D = 40 # Dimension of ambient space\\n k = 4 # Number of subspaces\\n d = 1\\n N = 90 # Number of points in subspaces\\n # Generating N points in d dim. subspaces\\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\\n for _ in range(k)]\\n X = np.concatenate(Xi, axis=1)\\n\\n # Generating the ground-truth for evaluating clustering results\\n lbls = [i * np.ones([1, N]) for i in range(k)]\\n s = np.concatenate(lbls, axis=1)\\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\\n K = 0 #max(d1, d2)\\n if Cst == 1:\\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\\n\\n Xp = DataProjection(X, r, 'NormalProj')\\n \\n # testing clustering\\n \\n '''\\n # using wrapper function\\n Grps, sc = sparseSubspaceClustering(\\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n '''\\n \\n '''\\n # calling internal tools\\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\\n # Make small values 0\\n eps = np.finfo(float).eps\\n CMat[np.abs(CMat) < eps] = 0\\n\\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\\n\\n if Fail == False:\\n CKSym = BuildAdjacency(CMatC, K)\\n Grps = SpectralClustering(CKSym, n)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n else:\\n print(\\\"Something failed\\\")\\n '''\\n \\n labels, _, __ = KSubspaces(Xp.T, k, d)\\n labels = BestMap(s, labels)\\n Missrate = float(np.sum(s != labels)) / s.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\",\n \"def SynchronousSGDOptimizer(optimizer,\\n nccl=False,\\n nccl_fusion=False,\\n hierarchical_nccl=False,\\n monitor=False,\\n name=None,\\n use_locking=False,\\n with_keras=False):\\n sync_sgd_algo = _SynchronousSGD(nccl=nccl,\\n nccl_fusion=nccl_fusion,\\n hierarchical_nccl=hierarchical_nccl,\\n monitor=monitor)\\n if with_keras:\\n return _create_kungfu_keras_optimizer(optimizer, sync_sgd_algo)\\n else:\\n return _create_kungfu_optimizer(optimizer, sync_sgd_algo, name,\\n use_locking)\",\n \"def test_ccsd_doubles(parthole_drudge):\\n\\n dr = parthole_drudge\\n p = dr.names\\n\\n a, b, c, d = p.V_dumms[:4]\\n i, j = p.O_dumms[:2]\\n u = dr.two_body\\n t = IndexedBase('t')\\n dr.set_dbbar_base(t, 2)\\n\\n tensor = dr.define_einst(\\n IndexedBase('r')[a, b, i, j],\\n t[c, d, i, j] * u[a, b, c, d] + u[a, b, c, d] * t[c, i] * t[d, j]\\n )\\n targets = [tensor]\\n\\n all_eval_seq = optimize(\\n targets, substs={p.nv: p.no * 10},\\n strategy=Strategy.ALL | Strategy.SUM | Strategy.COMMON\\n )\\n\\n assert verify_eval_seq(all_eval_seq, targets)\\n assert len(all_eval_seq) == 2\\n all_cost = get_flop_cost(all_eval_seq)\\n\\n best_eval_seq = optimize(\\n targets, substs={p.nv: p.no * 10},\\n strategy=Strategy.BEST | Strategy.SUM | Strategy.COMMON\\n )\\n assert verify_eval_seq(best_eval_seq, targets)\\n assert len(best_eval_seq) == 2\\n best_cost = get_flop_cost(best_eval_seq)\\n\\n assert (best_cost - all_cost).xreplace({p.no: 1, p.nv: 10}) > 0\",\n \"def adam_optimizer() -> mt.HyperparameterConfig:\\n # Create a dict of hyperparameters and their feasible ranges\\n hyperparam_dict = {\\n # ADAM optimization hyperparameters\\n # Ref: Kingma, Diederik P., and Jimmy Ba.\\n # \\\"Adam: A method for stochastic optimization.\\\" (2014).\\n # log10 of alpha1 := 1 - beta1\\n 'log_alpha1': -1.5,\\n # log10 of alpha2 := 1 - beta2\\n 'log_alpha2': -2.1,\\n # log10 of epsilon\\n 'log_epsilon': -7.,\\n # Other hyperparameters\\n # Minimum value for the voxel weights in the summed xentropy op\\n 'weight_floor': 0.01,\\n\\n # Exponential learning rate decay hyperparams\\n # log10 of the learning rate\\n 'log_learning_rate': -3.,\\n # log10 of the number of Decay steps\\n 'log_decay_steps': 3.4,\\n # Exponential decay rate\\n 'exponential_decay_rate': 0.75\\n }\\n\\n return mt.HyperparameterConfig(hyperparam_dict)\",\n \"def run_sda(datasets=None, batch_size=100,\\n window_size=7, n_principle=4,\\n pretraining_epochs=2000, pretrain_lr=0.02,\\n training_epochs=10000, finetune_lr=0.008, \\n hidden_layers_sizes=[310, 100], corruption_levels = [0., 0.]):\\n \\n print 'finetuning learning rate=', finetune_lr\\n print 'pretraining learning rate=', pretrain_lr\\n print 'pretraining epoches=', pretraining_epochs\\n print 'fine tuning epoches=', training_epochs\\n print 'batch size=', batch_size\\n print 'hidden layers sizes=', hidden_layers_sizes\\n print 'corruption levels=', corruption_levels\\n\\n # compute number of minibatches for training, validation and testing\\n n_train_batches = datasets[0][0].get_value(borrow=True).shape[0]\\n n_train_batches /= batch_size\\n\\n # numpy random generator\\n numpy_rng = numpy.random.RandomState(89677)\\n print '... building the model'\\n # construct the stacked denoising autoencoder class\\n sda = SdA(numpy_rng=numpy_rng, n_ins=datasets[0][0].get_value(borrow=True).shape[1],\\n hidden_layers_sizes=hidden_layers_sizes,\\n n_outs=gnd_img.max())\\n\\n ################################################################################\\n # PRETRAINING THE MODEL #\\n #########################\\n\\n print '... getting the pretraining functions'\\n pretraining_fns = sda.pretraining_functions(train_set_x=datasets[0][0],\\n batch_size=batch_size)\\n\\n print '... pre-training the model'\\n start_time = time.clock()\\n ## Pre-train layer-wise\\n for i in xrange(sda.n_layers):\\n # go through pretraining epochs\\n for epoch in xrange(pretraining_epochs):\\n # go through the training set\\n c = []\\n for batch_index in xrange(n_train_batches):\\n c.append(pretraining_fns[i](index=batch_index,\\n corruption=corruption_levels[i],\\n lr=pretrain_lr))\\n \\n if epoch % 100 == 0:\\n print 'Pre-training layer %i, epoch %d, cost ' % (i, epoch),\\n print numpy.mean(c)\\n\\n end_time = time.clock()\\n\\n print >> sys.stderr, ('The pretraining code for file ' +\\n os.path.split(__file__)[1] +\\n ' ran for %.2fm' % ((end_time - start_time) / 60.))\\n\\n ################################################################################\\n # FINETUNING THE MODEL #\\n ########################\\n\\n # get the training, validation and testing function for the model\\n print '... getting the finetuning functions'\\n train_fn, validate_model, test_model = sda.build_finetune_functions(\\n datasets=datasets, batch_size=batch_size,\\n learning_rate=finetune_lr)\\n\\n print '... finetunning the model'\\n # early-stopping parameters\\n patience = 100 * n_train_batches # look as this many examples regardless\\n patience_increase = 2. # wait this much longer when a new best is\\n # found\\n improvement_threshold = 0.995 # a relative improvement of this much is\\n # considered significant\\n validation_frequency = min(10 * n_train_batches, patience / 2)\\n # go through this many\\n # minibatche before checking the network\\n # on the validation set; in this case we\\n # check every epoch\\n\\n best_params = None\\n best_validation_loss = numpy.inf\\n test_score = 0.\\n start_time = time.clock()\\n\\n done_looping = False\\n epoch = 0\\n\\n while (epoch < training_epochs) and (not done_looping):\\n epoch = epoch + 1\\n for minibatch_index in xrange(n_train_batches):\\n minibatch_avg_cost = train_fn(minibatch_index)\\n iter = (epoch - 1) * n_train_batches + minibatch_index\\n\\n if (iter + 1) % validation_frequency == 0:\\n validation_losses = validate_model()\\n this_validation_loss = numpy.mean(validation_losses)\\n print('epoch %i, minibatch %i/%i, validation error %f %%' %\\n (epoch, minibatch_index + 1, n_train_batches,\\n this_validation_loss * 100.))\\n\\n # if we got the best validation score until now\\n if this_validation_loss < best_validation_loss:\\n # improve patience if loss improvement is good enough\\n if (this_validation_loss < best_validation_loss *\\n improvement_threshold):\\n patience = max(patience, iter * patience_increase)\\n\\n # save best validation score and iteration number\\n best_validation_loss = this_validation_loss\\n best_iter = iter\\n\\n # test it on the test set\\n test_losses = test_model()\\n test_score = numpy.mean(test_losses)\\n print((' epoch %i, minibatch %i/%i, test error of '\\n 'best model %f %%') %\\n (epoch, minibatch_index + 1, n_train_batches,\\n test_score * 100.))\\n\\n end_time = time.clock()\\n print(('Optimization complete with best validation score of %f %%,'\\n 'with test performance %f %%') %\\n (best_validation_loss * 100., test_score * 100.))\\n print >> sys.stdout, ('The training code for file ' +\\n os.path.split(__file__)[1] +\\n ' ran for %.2fm' % ((end_time - start_time) / 60.))\\n\\n # keep the following line consistent with line 227, function \\\"prepare_data\\\"\\n filename = 'ksc_l1sda_pt%d_ft%d_lrp%.4f_f%.4f_bs%d_pca%d_ws%d' % \\\\\\n (pretraining_epochs, training_epochs, pretrain_lr, finetune_lr, \\n batch_size, n_principle, window_size) \\n\\n print '... classifying test set with learnt model:'\\n pred_func = theano.function(inputs=[sda.x], outputs=sda.logLayer.y_pred)\\n pred_test = pred_func(datasets[2][0].get_value(borrow=True))\\n true_test = datasets[2][1].get_value(borrow=True)\\n true_valid = datasets[1][1].get_value(borrow=True)\\n true_train = datasets[0][1].get_value(borrow=True)\\n result_analysis(pred_test, true_train, true_valid, true_test)\\n\\n print '... classifying the whole image with learnt model:'\\n print '...... extracting data'\\n data_spectral, data_spatial, _, _ = \\\\\\n T_pca_constructor(hsi_img=img, gnd_img=gnd_img, n_principle=n_principle, \\n window_size=window_size, flag='unsupervised', \\n merge=True)\\n \\n start_time = time.clock()\\n print '...... begin '\\n y = pred_func(data_spectral) + 1\\n print '...... done '\\n end_time = time.clock()\\n print 'finished, running time:%fs' % (end_time - start_time)\\n\\n y_rgb = cmap[y, :]\\n margin = (window_size / 2) * 2 # floor it to a multiple of 2\\n y_image = y_rgb.reshape(width - margin, height - margin, 3)\\n scipy.misc.imsave(filename + 'wholeimg.png' , y_image)\\n print 'Saving classification results'\\n sio.savemat(filename + 'wholeimg.mat', \\n {'y': y.reshape(width - margin, height - margin)})\\n\\n ############################################################################\\n print '... performing Student\\\\'s t-test'\\n best_c = 10000.\\n best_g = 10.\\n svm_classifier = svm.SVC(C=best_c, gamma=best_g, kernel='rbf')\\n svm_classifier.fit(datasets[0][0].get_value(), datasets[0][1].get_value())\\n\\n data = [numpy.vstack((datasets[1][0].get_value(),\\n datasets[2][0].get_value())),\\n numpy.hstack((datasets[1][1].get_value(),\\n datasets[2][1].get_value()))]\\n numpy_rng = numpy.random.RandomState(89677)\\n num_test = 100\\n print 'Total number of tests: %d' % num_test\\n k_sae = []\\n k_svm = []\\n for i in xrange(num_test):\\n [_, _], [_, _], [test_x, test_y], _ = \\\\\\n train_valid_test(data, ratio=[0, 1, 1], batch_size=1, \\n random_state=numpy_rng.random_integers(1e10))\\n test_y = test_y + 1 # fix the label scale problem\\n pred_y = pred_func(test_x)\\n cm = confusion_matrix(test_y, pred_y)\\n pr_a = cm.trace()*1.0 / test_y.size\\n pr_e = ((cm.sum(axis=0)*1.0/test_y.size) * \\\\\\n (cm.sum(axis=1)*1.0/test_y.size)).sum()\\n k_sae.append( (pr_a - pr_e) / (1 - pr_e) )\\n\\n pred_y = svm_classifier.predict(test_x)\\n cm = confusion_matrix(test_y, pred_y)\\n pr_a = cm.trace()*1.0 / test_y.size\\n pr_e = ((cm.sum(axis=0)*1.0/test_y.size) * \\\\\\n (cm.sum(axis=1)*1.0/test_y.size)).sum()\\n k_svm.append( (pr_a - pr_e) / (1 - pr_e) )\\n\\n std_k_sae = numpy.std(k_sae)\\n std_k_svm = numpy.std(k_svm)\\n mean_k_sae = numpy.mean(k_sae)\\n mean_k_svm = numpy.mean(k_svm)\\n left = ( (mean_k_sae - mean_k_svm) * numpy.sqrt(num_test*2-2)) \\\\\\n / ( numpy.sqrt(2./num_test) * num_test * (std_k_sae**2 + std_k_svm**2) )\\n\\n rv = t(num_test*2.0 - 2)\\n right = rv.ppf(0.95)\\n\\n print '\\\\tstd\\\\t\\\\tmean'\\n print 'k_sae\\\\t%f\\\\t%f' % (std_k_sae, mean_k_sae)\\n print 'k_svm\\\\t%f\\\\t%f' % (std_k_svm, mean_k_svm)\\n if left > right:\\n print 'left = %f, right = %f, test PASSED.' % (left, right)\\n else:\\n print 'left = %f, right = %f, test FAILED.' % (left, right)\\n\\n return test_score\",\n \"def mt10_sac(ctxt=None, seed=1):\\n runner = LocalRunner(ctxt)\\n MT10_envs_by_id = {}\\n MT10_envs_test = {}\\n for (task, env) in EASY_MODE_CLS_DICT.items():\\n MT10_envs_by_id[task] = MetaRLEnv(env(*EASY_MODE_ARGS_KWARGS[task]['args'],\\n **EASY_MODE_ARGS_KWARGS[task]['kwargs']))\\n # python 3.6 dicts are ordered\\n MT10_envs_test[task] = MetaRLEnv(env(*EASY_MODE_ARGS_KWARGS[task]['args'],\\n **EASY_MODE_ARGS_KWARGS[task]['kwargs']))\\n\\n env = IgnoreDoneWrapper(MTMetaWorldWrapper(MT10_envs_by_id))\\n\\n policy = TanhGaussianMLPPolicy2(env_spec=env.spec,\\n hidden_sizes=[400, 400, 400],\\n hidden_nonlinearity=nn.ReLU,\\n output_nonlinearity=None,\\n min_std=np.exp(-20.),\\n max_std=np.exp(2.),)\\n\\n qf1 = ContinuousMLPQFunction(env_spec=env.spec,\\n hidden_sizes=[400, 400, 400],\\n hidden_nonlinearity=F.relu)\\n\\n qf2 = ContinuousMLPQFunction(env_spec=env.spec,\\n hidden_sizes=[400, 400, 400],\\n hidden_nonlinearity=F.relu)\\n\\n replay_buffer = SACReplayBuffer(env_spec=env.spec,\\n max_size=int(1e6))\\n sampler_args = {'agent': policy, 'max_path_length': 150}\\n\\n timesteps = 20000000\\n batch_size = int(150 * env.num_tasks)\\n num_evaluation_points = 500\\n epochs = timesteps // batch_size\\n epoch_cycles = epochs // num_evaluation_points\\n epochs = epochs // epoch_cycles\\n sac = MTSAC(env=env,\\n eval_env_dict=MT10_envs_test,\\n env_spec=env.spec,\\n policy=policy,\\n qf1=qf1,\\n qf2=qf2,\\n gradient_steps_per_itr=150,\\n epoch_cycles=epoch_cycles,\\n use_automatic_entropy_tuning=True,\\n replay_buffer=replay_buffer,\\n min_buffer_size=1500,\\n target_update_tau=5e-3,\\n discount=0.99,\\n buffer_batch_size=1280)\\n tu.set_gpu_mode(True)\\n sac.to('cuda:0')\\n\\n runner.setup(algo=sac, env=env, sampler_cls=SimpleSampler, sampler_args=sampler_args)\\n\\n runner.train(n_epochs=epochs, batch_size=batch_size)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58430123","0.57700384","0.559415","0.55526096","0.5507653","0.5500585","0.54425055","0.5425867","0.5423508","0.5412528","0.54118615","0.5398304","0.53416395","0.534044","0.53132707","0.52848023","0.5283411","0.5282129","0.5275689","0.5273703","0.52306956","0.5222955","0.51928484","0.5191712","0.5181114","0.51801795","0.5152932","0.5151803","0.5147249","0.51404446","0.5136876","0.51245207","0.51072496","0.5103796","0.5091973","0.50823504","0.5059717","0.5059717","0.505696","0.5056436","0.5052911","0.5051895","0.5043496","0.50404","0.50383353","0.5033773","0.5031675","0.5030174","0.50249785","0.50217634","0.5019696","0.50180393","0.500803","0.5004289","0.5002422","0.49822137","0.49816927","0.49813834","0.49769732","0.49714747","0.4969872","0.49675348","0.49636707","0.49512458","0.49422505","0.49239618","0.49114758","0.49109903","0.4910465","0.49069476","0.49035412","0.49032265","0.49003178","0.48968947","0.48968926","0.4894126","0.48831582","0.48821902","0.4880842","0.48736843","0.48676103","0.48641774","0.48635605","0.48614416","0.48593357","0.48568216","0.48469347","0.48455834","0.48442975","0.48434186","0.48376855","0.48099503","0.4806933","0.48041233","0.4801194","0.47994608","0.47910646","0.4782747","0.4782583","0.47749877"],"string":"[\n \"0.58430123\",\n \"0.57700384\",\n \"0.559415\",\n \"0.55526096\",\n \"0.5507653\",\n \"0.5500585\",\n \"0.54425055\",\n \"0.5425867\",\n \"0.5423508\",\n \"0.5412528\",\n \"0.54118615\",\n \"0.5398304\",\n \"0.53416395\",\n \"0.534044\",\n \"0.53132707\",\n \"0.52848023\",\n \"0.5283411\",\n \"0.5282129\",\n \"0.5275689\",\n \"0.5273703\",\n \"0.52306956\",\n \"0.5222955\",\n \"0.51928484\",\n \"0.5191712\",\n \"0.5181114\",\n \"0.51801795\",\n \"0.5152932\",\n \"0.5151803\",\n \"0.5147249\",\n \"0.51404446\",\n \"0.5136876\",\n \"0.51245207\",\n \"0.51072496\",\n \"0.5103796\",\n \"0.5091973\",\n \"0.50823504\",\n \"0.5059717\",\n \"0.5059717\",\n \"0.505696\",\n \"0.5056436\",\n \"0.5052911\",\n \"0.5051895\",\n \"0.5043496\",\n \"0.50404\",\n \"0.50383353\",\n \"0.5033773\",\n \"0.5031675\",\n \"0.5030174\",\n \"0.50249785\",\n \"0.50217634\",\n \"0.5019696\",\n \"0.50180393\",\n \"0.500803\",\n \"0.5004289\",\n \"0.5002422\",\n \"0.49822137\",\n \"0.49816927\",\n \"0.49813834\",\n \"0.49769732\",\n \"0.49714747\",\n \"0.4969872\",\n \"0.49675348\",\n \"0.49636707\",\n \"0.49512458\",\n \"0.49422505\",\n \"0.49239618\",\n \"0.49114758\",\n \"0.49109903\",\n \"0.4910465\",\n \"0.49069476\",\n \"0.49035412\",\n \"0.49032265\",\n \"0.49003178\",\n \"0.48968947\",\n \"0.48968926\",\n \"0.4894126\",\n \"0.48831582\",\n \"0.48821902\",\n \"0.4880842\",\n \"0.48736843\",\n \"0.48676103\",\n \"0.48641774\",\n \"0.48635605\",\n \"0.48614416\",\n \"0.48593357\",\n \"0.48568216\",\n \"0.48469347\",\n \"0.48455834\",\n \"0.48442975\",\n \"0.48434186\",\n \"0.48376855\",\n \"0.48099503\",\n \"0.4806933\",\n \"0.48041233\",\n \"0.4801194\",\n \"0.47994608\",\n \"0.47910646\",\n \"0.4782747\",\n \"0.4782583\",\n \"0.47749877\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68696374"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":13285,"cells":{"query":{"kind":"string","value":"r\"\"\"Applies L1 regularization shrink step on the parameters."},"document":{"kind":"string","value":"def _sdca_shrink_l1(weights, l1, l2, name=None):\n result = _op_def_lib.apply_op(\"SdcaShrinkL1\", weights=weights, l1=l1, l2=l2,\n name=name)\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def l1_regularizer(scale):\n if isinstance(scale, numbers.Integral):\n raise ValueError('scale cannot be an integer: %s' % scale)\n if isinstance(scale, numbers.Real):\n if scale < 0.:\n raise ValueError('Setting a scale less than 0 on a regularizer: %g' %\n scale)\n if scale >= 1.:\n raise ValueError('Setting a scale greater than 1 on a regularizer: %g' %\n scale)\n if scale == 0.:\n logging.info('Scale of 0 disables regularizer.')\n return lambda _, name=None: None\n\n def l1(weights, name=None):\n \"\"\"Applies L1 regularization to weights.\"\"\"\n with ops.op_scope([weights], name, 'l1_regularizer') as scope:\n my_scale = ops.convert_to_tensor(scale,\n dtype=weights.dtype.base_dtype,\n name='scale')\n return standard_ops.mul(\n my_scale,\n standard_ops.reduce_sum(standard_ops.abs(weights)),\n name=scope)\n\n return l1","def _update_parameters(self, delta):\n if delta is not None:\n self.SGD.update_with_L1_regularization(self.variables, delta, self.L1)","def l1_regularization(variables, factor=1e-4, name='l1_regularization', collections=['regularization']):\n l1 = tf.add_n([tf.reduce_sum(tf.abs(var)) for var in variables], name=name) if variables else tf.constant(0.)\n loss = factor * l1\n scalar_summary(loss, name, collections)\n return loss","def _step1_optimization_closure(self, iteration, step):\n if iteration == self.num_iter_first_step - 1:\n reg_noise_std = 0\n else:\n reg_noise_std = (1 / 1000.) * (iteration // 300) # TODO: make it dependant in the max number of iterations\n aug = self._get_augmentation(iteration)\n if iteration == self.num_iter_first_step - 1:\n aug = 0\n # creates left_net_inputs and right_net_inputs by adding small noise\n clean_net_input = self.clean_net_inputs[aug] + (self.clean_net_inputs[aug].clone().normal_() * reg_noise_std)\n # watermark_net_input = self.watermark_net_inputs[aug] # + (self.watermark_net_input.clone().normal_())\n # mask_net_input = self.mask_net_inputs[aug]\n # applies the nets\n self.clean_net_output = self.clean_net(clean_net_input)\n self.total_loss = 0\n self.blur = 0\n self.total_loss += self.extended_l1_loss(self.clean_net_output,\n self.image_torchs[aug],\n (1 - self.watermark_hint_torchs[aug]))\n self.total_loss.backward(retain_graph=True)","def update_regularizer(self, regularizer = regularizers.l1(0.1)):\n # for layer in self.layers:\n # layer.kernel_regularizer = regularizer\n self.list_cnn[-1].kernel_regularizer = regularizer","def l1(weights, name=None):\n with ops.op_scope([weights], name, 'l1_regularizer') as scope:\n my_scale = ops.convert_to_tensor(scale,\n dtype=weights.dtype.base_dtype,\n name='scale')\n return standard_ops.mul(\n my_scale,\n standard_ops.reduce_sum(standard_ops.abs(weights)),\n name=scope)","def regularizer(self):\n \n # L2 regularization for the fully connected parameters.\n regularizers = (tf.nn.l2_loss(self.weights.wd1) + tf.nn.l2_loss(self.weights.bd1) + \n tf.nn.l2_loss(self.weights.wout) + tf.nn.l2_loss(self.weights.bout))\n return regularizers","def l1(parameter, bias=None, reg=0.01, lr=0.1):\n Norm = reg*lr\n\n # Update W\n if parameter.is_cuda:\n Norms_w = Norm*torch.ones(parameter.size(), device=torch.device(\"cuda\"))\n else:\n Norms_w = Norm*torch.ones(parameter.size(), device=torch.device(\"cpu\"))\n pos = torch.min(Norms_w, Norm*torch.clamp(parameter, min=0)) # get all positive values\n neg = torch.min(Norms_w, -1.0*Norm*torch.clamp(parameter, max=0)) # get all negative values\n update_w = parameter - pos + neg # l1 step is the magnitude of all positive and all negative\n parameter.data = update_w\n\n if bias is not None:\n if bias.is_cuda:\n Norms_b = Norm*torch.ones(bias.size(), device=torch.device(\"cuda\"))\n else:\n Norms_b = Norm*torch.ones(bias.size(), device=torch.device(\"cpu\"))\n pos = torch.min(Norms_b, Norm*torch.clamp(bias, min=0))\n neg = torch.min(Norms_b, -1.0*Norm*torch.clamp(bias, max=0))\n update_b = bias - pos + neg\n bias.data = update_b","def apply_regularization(self, w, loss, gradient, regularization, lambda_, m):\n if regularization == 'l2':\n loss += lambda_ / (2 * m) * np.squeeze(w.T.dot(w))\n gradient += lambda_ / m * w\n elif regularization == 'l1':\n loss += lambda_ / (2 * m) * np.sum(np.abs(w))\n gradient += lambda_ / m * np.sum((w >= 0) * 1 + (w < 0) * -1)\n return loss, gradient","def EmbeddingL1RegularizationUpdate(embedding_variable, net_input, learn_rate, l1_reg_val):\n # TODO(student): Change this to something useful. Currently, this is a no-op.\n net_input = tf.nn.l2_normalize(net_input, axis=0)\n sign_inside = tf.sign(tf.matmul(net_input, embedding_variable))\n where = tf.equal(sign_inside, 0)\n # should replace 0's with random in [-1, 1] for an better (not necessarily acute)implementation\n grad = l1_reg_val * tf.matmul(tf.transpose(net_input), sign_inside)\n embedding_variable_ = embedding_variable - learn_rate * grad\n\n ## local test #better to disable when learning\n batch_size, number_of_vocabulary_tokens = net_input.shape\n net_example = numpy.random.binomial(1, .1, (3, number_of_vocabulary_tokens))\n sigma_fnc = l1_reg_val * tf.norm(tf.matmul(net_input, embedding_variable), ord=1)\n # assert tf.gradients(sigma_fnc, embedding_variable) == grad, \"wrong grad in L2\"\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n tf_grad = sess.run(tf.gradients(sigma_fnc, embedding_variable)[0], feed_dict={net_input: net_example})\n my_grad = sess.run(grad, feed_dict={net_input: net_example})\n differ = numpy.linalg.norm(tf_grad - my_grad)\n differ = differ / numpy.linalg.norm(tf_grad)\n print('l1 grad differentage {}'.format(differ))\n print('l2 grad max difference {}'.format(numpy.max(tf_grad - my_grad)))\n\n return embedding_variable.assign(embedding_variable_)","def reg_loss(model: nn.Module, regularizer: str, l1: float=0.01, l2: float=0.01):\n if regularizer == 'l1':\n l1_reg = l1 * sum(torch.abs(p).sum() for p in model.parameters())\n return l1_reg\n if regularizer == 'l2':\n l2_reg = l2 * sum(torch.square(p).sum() for p in model.parameters())\n return l2_reg\n if regularizer == 'l1_l2':\n l1_reg = l1 * sum(torch.abs(p).sum() for p in model.parameters())\n l2_reg = l2 * sum(torch.square(p).sum() for p in model.parameters())\n return l1_reg + l2_reg","def l2_regularization_penalty(self):\n return self.l2 * (np.linalg.norm(self.weights)**2)","def l1(name, weights):\n\n with tf.name_scope(name):\n regularizer = np.float32(0.0)\n for weight in weights:\n tf.add(regularizer, tf.nn.l1_loss(weight))\n\n return regularizer","def __init__(self, l1_regularization=0.):\n self.l1_regularization = l1_regularization\n self.nspec = None\n self.npixels = None\n self.nlabels = None\n self.ncoeffs = None\n\n self.coeffs = None\n self.scatter = None\n\n # normalization factor\n self.labels_median = 0.\n self.labels_std = 1.\n\n # labels names\n self.label_names = ['Teff', 'Logg', 'M_H', 'Alpha_M']\n\n self.trained_flag = False\n self.force_cpu = False\n self.log_device_placement = False","def set_kernel_reg(model, lambdal1 = 0, lambdal2 = 0):\r\n\r\n\r\n\tfor layer in model.layers:\r\n\t\tif hasattr(layer, 'kernel_regularizer'):\r\n\t\t\tlayer.kernel_regularizer = l1_l2(l1 = lambdal1, l2 = lambdal2)\r\n\r\n\treturn model","def l2_regularizer(scale):\n if isinstance(scale, numbers.Integral):\n raise ValueError('scale cannot be an integer: %s' % (scale,))\n if isinstance(scale, numbers.Real):\n if scale < 0.:\n raise ValueError('Setting a scale less than 0 on a regularizer: %g.' %\n scale)\n if scale >= 1.:\n raise ValueError('Setting a scale greater than 1 on a regularizer: %g.' %\n scale)\n if scale == 0.:\n logging.info('Scale of 0 disables regularizer.')\n return lambda _, name=None: None\n\n def l2(weights, name=None):\n \"\"\"Applies l2 regularization to weights.\"\"\"\n with ops.op_scope([weights], name, 'l2_regularizer') as scope:\n my_scale = ops.convert_to_tensor(scale,\n dtype=weights.dtype.base_dtype,\n name='scale')\n return standard_ops.mul(my_scale, nn.l2_loss(weights), name=scope)\n\n return l2","def mp_regular_linreg(X, y, beta_0, alpha, L1_ratio, max_iter=50, tol=0.0001, *args, **kwargs):\n\n N, p = X.shape\n beta = beta_0.copy()\n b_new = np.zeros(p)\n\n for itr in range(max_iter):\n with ProcessPoolExecutor(max_workers=8) as pool:\n b_new = np.array(list(pool.map(deco, [j for j in range(p)], repeat(X), repeat(y), repeat(N),\n repeat(p), repeat(beta), repeat(alpha), repeat(L1_ratio))))\n beta = b_new\n return beta","def regularization_loss(params: hk.Params) -> jnp.ndarray:\r\n\r\n # L1 Loss\r\n sum_in_layer = lambda p: jnp.sum(jnp.abs(p))\r\n sum_p_layers = [sum_in_layer(p) for p in jax.tree_leaves(params)]\r\n l1_loss = sum(sum_p_layers)\r\n\r\n # L2 Loss\r\n l2_loss = 0.5 * sum(jnp.sum(jnp.square(p)) for p in jax.tree_leaves(params))\r\n\r\n return l2_coef * l2_loss + l1_coef * l1_loss","def rescale_all(self):\n for param_code in self.parameters.keys():\n self.rescale_parameter(param_code)","def l2_regularization(cg, rate=0.01):\n W = VariableFilter(roles=[WEIGHT])(cg.variables)\n L2_cost = rate * l2_norm(W)\n\n return L2_cost","def _reset_parameters(self):\r\n\t\tfor p in self.parameters():\r\n\t\t\tif p.dim() > 1:\r\n\t\t\t\txavier_uniform_(p)","def adjust_learning_rate(optimizer, shrink_factor):\n\n print(\"\\nDECAYING learning rate.\")\n for param_group in optimizer.param_groups:\n param_group['lr'] = param_group['lr'] * shrink_factor\n print(\"The new learning rate is %f\\n\" % (optimizer.param_groups[0]['lr'],))","def adjust_learning_rate(optimizer, shrink_factor):\n\n print(\"\\nDECAYING learning rate.\")\n for param_group in optimizer.param_groups:\n param_group['lr'] = param_group['lr'] * shrink_factor\n print(\"The new learning rate is %f\\n\" % (optimizer.param_groups[0]['lr'],))","def prox_l1_norm(w, lamb):\n\treturn np.sign(w) * np.maximum( np.abs(w) - lamb, 0)","def test_l1norm () :\n n = 10\n rfs = RewardFnSpace(list(range(n)))\n for i in range(10): \n b = rfs.bs[i]\n rfs.lp += b == 0\n rfs.lp.solve()\n rfs._setCoeffs()\n coeffs = np.array(rfs.coeffs)\n assert(np.linalg.norm(coeffs - np.ones(n)) < 1e-4)","def l2(parameter, bias=None, reg=0.01, lr=0.1):\n \n if bias is not None:\n w_and_b = torch.cat((parameter, bias.unfold(0,1,1)),1)\n else:\n w_and_b = parameter\n L2 = reg # lambda: regularization strength\n Norm = (lr*L2/w_and_b.norm(2))\n if Norm.is_cuda:\n ones_w = torch.ones(parameter.size(), device=torch.device(\"cuda\"))\n else:\n ones_w = torch.ones(parameter.size(), device=torch.device(\"cpu\"))\n l2T = 1.0 - torch.min(ones_w, Norm)\n update = (parameter*l2T) \n parameter.data = update\n # Update bias\n if bias is not None:\n if Norm.is_cuda:\n ones_b = torch.ones(bias.size(), device=torch.device(\"cuda\"))\n else:\n ones_b = torch.ones(bias.size(), device=torch.device(\"cpu\"))\n l2T = 1.0 - torch.min(ones_b, bias)\n update_b = (bias*l2T)\n bias.data = update_b","def l2_regularization(W, reg_strength):\n # TODO: Copy from the previous assignment\n loss = reg_strength*np.sum(W*W)\n grad = 2*reg_strength*W\n return loss, grad","def l2_regularization(variables, factor=1e-4, name='l2_regularization', collections=['regularization']):\n l2 = tf.add_n([tf.sqrt(2.*tf.nn.l2_loss(var)) for var in variables], name=name) if variables else tf.constant(0.)\n loss = factor * l2\n scalar_summary(loss, name, collections)\n return loss","def forward(self, parameters: List[Tuple[str, nn.Parameter]]) -> torch.Tensor:\n # calculate regularized loss \n reg_loss = regularize(parameters, self.weight_decay, self.norm)\n\n return reg_loss","def fit_regularized(self, start_params=None, method='l1', alpha=0,\n ceps=1e-4, ptol=1e-6, maxit=200, **fit_kwargs):\n\n if type(method) == str and (method.lower() != 'l1'):\n raise ValueError(\"Invalid regularization method\")\n\n # If method is a smooth penalty just optimize directly.\n if isinstance(method, Penalty):\n # Scale the penalty weights by alpha\n method.alpha = alpha\n fit_kwargs.update({\"fe_pen\": method})\n return self.fit(**fit_kwargs)\n\n if np.isscalar(alpha):\n alpha = alpha * np.ones(self.k_fe, dtype=np.float64)\n\n # Fit the unpenalized model to get the dependence structure.\n mdf = self.fit(**fit_kwargs)\n fe_params = mdf.fe_params\n cov_re = mdf.cov_re\n scale = mdf.scale\n try:\n cov_re_inv = np.linalg.inv(cov_re)\n except np.linalg.LinAlgError:\n cov_re_inv = None\n\n for itr in range(maxit):\n\n fe_params_s = fe_params.copy()\n for j in range(self.k_fe):\n\n if abs(fe_params[j]) < ceps:\n continue\n\n # The residuals\n fe_params[j] = 0.\n expval = np.dot(self.exog, fe_params)\n resid_all = self.endog - expval\n\n # The loss function has the form\n # a*x^2 + b*x + pwt*|x|\n a, b = 0., 0.\n for k, lab in enumerate(self.group_labels):\n\n exog = self.exog_li[k]\n ex_r = self.exog_re_li[k]\n ex2_r = self.exog_re2_li[k]\n resid = resid_all[self.row_indices[lab]]\n\n x = exog[:,j]\n u = _smw_solve(scale, ex_r, ex2_r, cov_re,\n cov_re_inv, x)\n a += np.dot(u, x)\n b -= 2 * np.dot(u, resid)\n\n pwt1 = alpha[j]\n if b > pwt1:\n fe_params[j] = -(b - pwt1) / (2 * a)\n elif b < -pwt1:\n fe_params[j] = -(b + pwt1) / (2 * a)\n\n if np.abs(fe_params_s - fe_params).max() < ptol:\n break\n\n # Replace the fixed effects estimates with their penalized\n # values, leave the dependence parameters in their unpenalized\n # state.\n params_prof = mdf.params.copy()\n params_prof[0:self.k_fe] = fe_params\n\n scale = self.get_scale(fe_params, mdf.cov_re_unscaled)\n\n # Get the Hessian including only the nonzero fixed effects,\n # then blow back up to the full size after inverting.\n hess = self.hessian_full(params_prof)\n pcov = np.nan * np.ones_like(hess)\n ii = np.abs(params_prof) > ceps\n ii[self.k_fe:] = True\n ii = np.flatnonzero(ii)\n hess1 = hess[ii, :][:, ii]\n pcov[np.ix_(ii,ii)] = np.linalg.inv(-hess1)\n\n results = MixedLMResults(self, params_prof, pcov / scale)\n results.fe_params = fe_params\n results.cov_re = cov_re\n results.scale = scale\n results.cov_re_unscaled = mdf.cov_re_unscaled\n results.method = mdf.method\n results.converged = True\n results.cov_pen = self.cov_pen\n results.k_fe = self.k_fe\n results.k_re = self.k_re\n results.k_re2 = self.k_re2\n\n return MixedLMResultsWrapper(results)","def test_regularization_0size_interval(self):\n reg = modelgen.get_regularization(2, 2)\n assert reg == 0.01","def l2_reg_cost(cost, lambtha, weights, L, m):\n f = 0\n while (L):\n index = \"W{}\".format(L)\n weight = weights[index]\n f += np.linalg.norm(weight)\n L -= 1\n return cost + lambtha / (2 * m) * f","def _l1(self, y, x, y_minus_g, w_0):\n # Initialize weight vector to return\n w_1 = np.zeros(len(w_0))\n \n for j in range(len(x)):\n reg = float(self._sign(w_0[j])) / (self._lambda*self._num_training)\n w_1[j] = w_0[j] + self._epsilon*(x[j]*y_minus_g - reg)\n \n return w_1","def _reset_parameters(self):\n\n for p in self.parameters():\n if p.dim() > 1:\n xavier_uniform_(p)","def regularizer(self) -> Callable[[jnp.ndarray, jnp.ndarray], float]:\n if self._regularizer is not None:\n return self._regularizer\n return lambda *args, **kwargs: 0.","def reBuild(self): # redefine the rebuild method for loss function (polymorphism)\n self.updateRange()\n self.buildLine()\n self.normalize() # normalize loss function to have total area of 1 ","def l2_reg_cost(cost, lambtha, weights, L, m):\n w_norm = 0\n for i in range(1, L + 1):\n w_norm += np.linalg.norm(weights['W' + str(i)])\n L2 = cost + (lambtha / (2 * m) * w_norm)\n return L2","def apply_1d_regularizer(list_data, sijmat):\n ncol = len(list_data)\n list_grad = np.zeros(ncol, dtype=np.float32)\n list_grad[1:-1] = (-1) * np.diff(list_data, 2)\n list_grad[0] = list_data[0] - list_data[1]\n list_grad[-1] = list_data[-1] - list_data[-2]\n list_coe = np.sum(np.tile(list_grad, (ncol, 1)) * sijmat, axis=1)\n return list_data + list_coe","def l2_reg_cost(cost, lambtha, weights, L, m):\n sumWeights = 0\n for i in range(1, L + 1):\n sumWeights += np.linalg.norm(weights['W' + str(i)])\n return cost + sumWeights * lambtha / (2 * m)","def _optimization_closure(self, iteration, step):\n aug = self._get_augmentation(iteration)\n if iteration == self.num_iter_per_step - 1:\n reg_noise_std = 0\n aug = 0\n else:\n reg_noise_std = (1 / 1000.) * (iteration // 400)\n # creates left_net_inputs and right_net_inputs by adding small noise\n clean_nets_inputs = [clean_net_input[aug] + (clean_net_input[aug].clone().normal_() * reg_noise_std)\n for clean_net_input in self.clean_nets_inputs]\n watermark_net_input = self.watermark_net_input[aug] # + (self.watermark_net_input[aug].clone().normal_() * reg_noise_std)\n mask_net_input = self.mask_net_input[aug]\n # applies the nets\n self.clean_nets_outputs = [clean_net(clean_net_input) for clean_net, clean_net_input\n in zip(self.clean_nets, clean_nets_inputs)]\n self.watermark_net_output = self.watermark_net(watermark_net_input)\n self.mask_net_output = self.mask_net(mask_net_input)\n self.total_loss = 0\n self.blur = 0\n\n self.total_loss += sum(self.l1_loss(self.watermark_net_output * self.mask_net_output +\n clean_net_output * (1 - self.mask_net_output), image_torch[aug])\n for clean_net_output, image_torch in zip(self.clean_nets_outputs, self.images_torch))\n self.total_loss.backward(retain_graph=True)","def l2_reg_cost(cost, lambtha, weights, L, m):\n enorm = 0\n for i in range(1, L + 1):\n layer = 'W{}'.format(i)\n enorm += np.linalg.norm(weights[layer])\n return cost + (lambtha / (2 * m)) * enorm","def mpt11_w18_2_lr(optimizer, args, **kwargs):\n\n def _lr_adjuster(epoch, iteration):\n if epoch >= 46:\n lr = args.lr * 0.1\n\n if epoch >= 65:\n lr = lr * 0.1\n\n if epoch >= 80:\n lr = lr * 0.01\n else:\n lr = args.lr\n\n assign_learning_rate(optimizer, lr)\n\n return lr\n\n return _lr_adjuster","def adapt_length_scale(self):\n Ne = max(1,self.Ne)\n Nc = max(1,self.Nc)\n ratio = Ne/(Ne+Nc)\n self.mu *= 2*ratio","def compute_cost_with_regularization(A3, Y, parameters, lambd):\n\n m = Y.shape[1]\n W1 = parameters[\"W1\"]\n W2 = parameters[\"W2\"]\n W3 = parameters[\"W3\"]\n\n cross_entropy_cost = compute_cost(A3, Y)\n L2_regularization_cost = (np.sum(np.square(W1)) + np.sum(np.square(W2)) + np.sum(np.square(W3))) * lambd / (2 * m)\n\n cost = cross_entropy_cost + L2_regularization_cost\n\n return cost","def linf1(parameter, bias=None, reg=0.01, lr=0.1):\n\n Norm = reg*lr\n if bias is not None:\n w_and_b = torch.cat((parameter, bias.unfold(0,1,1)),1)\n else:\n w_and_b = parameter\n sorted_w_and_b, indices = torch.sort(torch.abs(w_and_b), descending=True)\n\n # CUDA or CPU\n devicetype=\"cuda\"\n if w_and_b.is_cuda:\n devicetype=\"cuda\"\n else:\n devicetype=\"cpu\"\n\n\n #SLOW\n rows, cols = sorted_w_and_b.size()\n\n sorted_z = torch.cat((sorted_w_and_b, torch.zeros(rows,1, device=torch.device(devicetype))),1)\n subtracted = torch.clamp(sorted_w_and_b - sorted_z[:,1:],max=Norm) #Max=Norm important\n\n scale_indices = torch.cumsum(torch.ones(rows,cols, device=torch.device(devicetype)),1)\n scaled_subtracted = subtracted * scale_indices\n max_mass = torch.cumsum(scaled_subtracted,1)\n nonzero = torch.clamp(-1*(max_mass - Norm),0)\n\n oneN = 1.0/scale_indices\n\n # Algorithm described in paper, but these are all efficient GPU operation steps)\n # First we subtract every value from the cell next to it\n nonzero_ones = torch.clamp(nonzero * 1000000, max=1) #Hacky, but efficient\n shifted_ones = torch.cat((torch.ones(rows,1, device=torch.device(devicetype)),nonzero_ones[:,:(cols-1)]),1)\n over_one = -1*(nonzero_ones - shifted_ones)\n last_one = torch.cat((over_one,torch.zeros(rows,1, device=torch.device(devicetype))),1)[:,1:]\n max_remain = last_one * nonzero\n shift_max = torch.cat((torch.zeros(rows,1, device=torch.device(devicetype)),max_remain[:,:(cols-1)]),1)\n first_col_nonzero_ones = torch.cat((torch.ones(rows,1, device=torch.device(devicetype)),nonzero_ones[:,1:]),1) #Edge case for only first column\n tosub = first_col_nonzero_ones * subtracted + shift_max * oneN\n\n # We flip the tensor so that we can get a cumulative sum for the value to subtract, then flip back\n nastyflipS = torch.flip(torch.flip(tosub,[0,1]),[0])\n aggsubS = torch.cumsum(nastyflipS,1)\n nastyflipagainS = torch.flip(torch.flip(aggsubS,[0,1]),[0])\n\n # The proximal gradient step is equal to subtracting the sorted cumulative sum\n updated_weights = sorted_w_and_b - nastyflipagainS\n unsorted = torch.zeros(rows,cols, device=torch.device(devicetype)).scatter_(1,indices,updated_weights)\n final_w_and_b = torch.sign(w_and_b) * unsorted\n\n # Actually update parameters and bias\n if bias is not None:\n update = final_w_and_b[:,:cols-1]\n parameter.data = update\n update_b = final_w_and_b[:,-1]\n bias.data = update_b\n else:\n parameter.data = final_w_and_b","def reduce(self, threshold):\n def percentage_change(old, new):\n return (old - new) / old\n real_reduction_iterations = 0\n padic_reduction_iterations = 0\n cont_reduction_iterations = 0\n factor = len(self.constants.primes) + 1\n \n print('initial bound',max(self.coefficients['n1_bound'],max(self.coefficients['Z_bounds'])))\n\n # First, go through the real reduction loop.\n current_n1_bound = self.coefficients['n1_bound']\n current_diff_bound = None\n while True:\n real_reduction_iterations += 1\n logging.info(\"Real Reduction - Iteration %d\" % real_reduction_iterations)\n\n large_constant = self.calculate_large_constant(current_n1_bound, factor)\n logging.info(\"Large constant contains %d digits \" % large_constant.ndigits())\n\n # Find a new bound on n_1 - n_k\n new_diff_bound = self.real_reduce(current_n1_bound, large_constant)\n logging.info(\"Current bound on n1: \" + str(current_n1_bound))\n self.update_real_constants(new_diff_bound)\n logging.info(\"new diff bound: \" + str(new_diff_bound))\n logging.info(\"New bound on n1: \" + str(self.coefficients[\"n1_bound\"]))\n logging.info(\"New bound on zi: \" + str(self.coefficients['Z_bounds']))\n \n if percentage_change(current_n1_bound, self.coefficients[\"n1_bound\"]) < self.threshold:\n logging.info(\"New bound did not improve in the real step; real reduction process is done.\")\n factor = factor + 5\n break\n\n current_n1_bound = self.coefficients['n1_bound']\n current_diff_bound = new_diff_bound\n\n # Second, go through the p-adic reduction loop.\n current_Z_bounds = self.coefficients['Z_bounds']\n while True:\n padic_reduction_iterations += 1\n logging.info(\"p-adic Reduction - Iteration %d\" % padic_reduction_iterations)\n\n new_Z_bounds = self.padic_reduce(math.ceil(current_diff_bound))\n logging.info(\"New bound on zi: \" + str(new_Z_bounds))\n logging.info(\"Current bound on n1: \" + str(current_n1_bound))\n new_n1_bound = self.update_padic_constants(new_Z_bounds)\n logging.info(\"New bound on n1: \" + str(new_n1_bound))\n if percentage_change(current_n1_bound, new_n1_bound) < self.threshold:\n logging.info(\"New bound did not improve in the p-adic step; p-adic reduction process is done.\")\n break\n\n current_n1_bound = new_n1_bound\n\n print(current_n1_bound)\n\n return self.constants","def l2_reg_cost(cost, lambtha, weights, L, m):\n Frobenius = 0\n for k, v in weights.items():\n if k[0] == \"W\":\n Frobenius += np.linalg.norm(v)\n return cost + (lambtha/(2*m)) * Frobenius","def l21_slow(parameter, reg=0.01, lr=0.1):\n \n w_and_b = parameter\n l21s = []\n for row in w_and_b:\n L21 = reg\n l21 = lr * L21/row.norm(2) \n l21 = 1.0 - min(1.0, l21) \n l21s.append(l21)\n counter = 0\n for row in parameter:\n updated = row * l21s[counter]\n parameter.data[counter] = updated\n counter = counter + 1\n counter = 0","def rl_modelrl_l1_short():\n hparams = rl_modelrl_short()\n hparams.generative_model_params = \"basic_conv_l1\"\n return hparams","def adjust_LR(optimizer, params, iternum):\n if params.distributed and iternum<5000:\n lr = params.ngpu*params.lr*(iternum/5000.) #warmup for distributed training\n elif iternum<40000:\n lr = params.ngpu*params.lr\n elif iternum>80000:\n lr = params.ngpu*params.lr/4.\n else:\n lr = params.ngpu*params.lr/2.\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr","def regularize_bwd(X, y, mu0, mu1, v1, nz, K, verbose=False):\n \n if verbose: sss=0#print '\\ncompute bath between mu=%.4f and mu=%.4f'%(mu0, mu1)\n \n n, m = X.shape\n X_nz = np.atleast_2d(X[:, nz])\n b = np.dot(X.T, y)\n G = np.dot(X.T, X)\n \n nbr = 0\n mu = mu0\n trans_type = -1\n trans_sign = 0\n trans_ind = -1\n if verbose: nbr=0#print 'initial active features =', nz\n \n while mu > mu1:\n \n # find the breakpoints where coefficients become zero\n b_nz = b[nz]\n Kv1 = np.dot(K, v1)\n Kb_nz = np.dot(K, b_nz)\n mu_0 = Kb_nz / Kv1\n \n # find the breakpoints where new coefficients become active\n z = np.setdiff1d(np.arange(m), nz)\n X_z = np.atleast_2d(X[:, z])\n b_z = b[z]\n M = G[np.ix_(z, nz)]\n MKb_nz = np.dot(M, Kb_nz)\n MKv1 = np.dot(M, Kv1)\n mu_1 = (b_z - MKb_nz) / (1 - MKv1)\n mu_m1 = (b_z - MKb_nz) / (-1 - MKv1)\n \n if trans_type > 0: mu_0[-1] = mu1\n mu_0[mu_0 >= mu] = mu1\n if len(mu_0) > 0: \n mu_0_argmax = mu_0.argmax()\n mu_0_max = mu_0[mu_0_argmax][0]\n else:\n mu_0_max = mu1\n if trans_type == 0:\n if trans_sign == 1: mu_1[np.where(z == trans_ind)[0]] = mu1 - 1\n else: mu_m1[np.where(z == trans_ind)[0]] = mu1 - 1\n mu_1[mu_1 >= mu] = mu1\n if len(mu_1) > 0: \n mu_1_argmax = mu_1.argmax()\n mu_1_max = mu_1[mu_1_argmax][0]\n else:\n mu_1_max = mu1\n mu_m1[mu_m1 >= mu] = mu1\n if len(mu_m1) > 0: \n mu_m1_argmax = mu_m1.argmax()\n mu_m1_max = mu_m1[mu_m1_argmax][0]\n else:\n mu_m1_max = mu1\n \n # compute the breakpoint\n mu_br_all = np.array([mu_0_max, mu_1_max, mu_m1_max])\n trans_type = mu_br_all.argmax()\n mu_br = mu_br_all[trans_type]\n \n if mu_br > mu1:\n \n nbr += 1\n mu = mu_br\n \n if trans_type == 0: # an element of theta(t) goes to zero\n trans_ind = nz[mu_0_argmax]\n trans_sign = v1[mu_0_argmax]\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is inactive'%(mu, trans_ind)\n nzind = range(len(nz))\n rr=np.where(nz==trans_ind)[0][0]\n #print 'longa:',len(nz),len(nzind),len(v1)\n #print 'c:',nz.index(trans_ind)\n nzind=np.delete(nzind,rr)#nzind=np.delete(nzind,np.where(nzind==nz.index(trans_ind)))#nzind.remove(nz.index(trans_ind))\n v1 = v1[nzind]\n nz=np.delete(nz,rr)#nz=np.delete(nz,np.where(nz==trans_ind))#nz.remove(trans_ind)\n #print 'longa2:',len(nz),len(nzind),len(v1)\n X_nz = X[:, nz]\n K = invupdatered(K, mu_0_argmax)\n else: # new active element\n if trans_type == 1: # it is positive\n trans_ind = z[mu_1_argmax]\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is positive'%(mu, trans_ind)\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\n v1 = np.vstack([v1, 1])\n else: # it is negative\n trans_ind = z[mu_m1_argmax]\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is negative'%(mu, trans_ind)\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\n v1 = np.vstack([v1, -1])\n X_new = np.atleast_2d(X[:, trans_ind]).T\n K = invupdateapp(K, np.dot(X_nz.T, X_new), np.dot(X_new.T, X_nz), \n np.dot(X_new.T, X_new))\n X_nz = X[:, nz]\n \n else: # compute solution at mu1\n \n if verbose: sss=0#print 'compute solution at mu =', mu1\n theta_nz = Kb_nz - mu1*Kv1\n mu = mu1\n \n return theta_nz, nz, K, nbr","def regularize_if_necessary(self) -> None:\n # As described in [wang2014], all entities and relations are used to compute the regularization term\n # which enforces the defined soft constraints.\n super().regularize_if_necessary(\n self.entity_embeddings.weight,\n self.normal_vector_embeddings.weight,\n self.relation_embeddings.weight,\n )","def test_scale_features_L1_norm(self):\n # Get some data\n data = array([[0.564, 20.661], [-18.512, 41.168], [-0.009, 20.440]])\n cdata = CData(data)\n\n # Correct answer computed in Mathematica\n # TODO: can we compute the right answer in Python?\n answer = array([[0.029552, 0.25114], [-0.969976, 0.500407], [-0.000471575, 0.248453]])\n\n # Perform L1 normalization and check answer\n cdata.scale_features('L1 norm')\n self.assertTrue(allclose(cdata.data, answer))","def update_param(self, lr):\n\n\n self.W=self.W-lr*self.W_grad\n self.b = self.b - lr*self.b_grad","def rl_modelrl_l1_medium():\n hparams = rl_modelrl_medium()\n hparams.generative_model_params = \"basic_conv_l1\"\n return hparams","def shrink(self):\n x = np.nan_to_num(self.X.values)\n\n # de-mean returns\n t, n = np.shape(x)\n meanx = x.mean(axis=0)\n x = x - np.tile(meanx, (t, 1))\n xmkt = x.mean(axis=1).reshape(t, 1)\n\n # compute sample covariance matrix\n sample = np.cov(np.append(x, xmkt, axis=1), rowvar=False) * (t - 1) / t\n covmkt = sample[0:n, n].reshape(n, 1)\n varmkt = sample[n, n]\n sample = sample[:n, :n]\n prior = np.dot(covmkt, covmkt.T) / varmkt\n prior[np.eye(n) == 1] = np.diag(sample)\n\n # compute shrinkage parameters\n if self.delta is None:\n c = np.linalg.norm(sample - prior, \"fro\") ** 2\n y = x ** 2\n p = 1 / t * np.sum(np.dot(y.T, y)) - np.sum(sample ** 2)\n # r is divided into diagonal\n # and off-diagonal terms, and the off-diagonal term\n # is itself divided into smaller terms\n rdiag = 1 / t * np.sum(y ** 2) - sum(np.diag(sample) ** 2)\n z = x * np.tile(xmkt, (n,))\n v1 = 1 / t * np.dot(y.T, z) - np.tile(covmkt, (n,)) * sample\n roff1 = (\n np.sum(v1 * np.tile(covmkt, (n,)).T) / varmkt\n - np.sum(np.diag(v1) * covmkt.T) / varmkt\n )\n v3 = 1 / t * np.dot(z.T, z) - varmkt * sample\n roff3 = (\n np.sum(v3 * np.dot(covmkt, covmkt.T)) / varmkt ** 2\n - np.sum(np.diag(v3).reshape(-1, 1) * covmkt ** 2) / varmkt ** 2\n )\n roff = 2 * roff1 - roff3\n r = rdiag + roff\n\n # compute shrinkage constant\n k = (p - r) / c\n shrinkage = max(0, min(1, k / t))\n self.delta = shrinkage\n else:\n # use specified constant\n shrinkage = self.delta\n\n # compute the estimator\n sigma = shrinkage * prior + (1 - shrinkage) * sample\n return self.format_and_annualise(sigma)","def step(self):\n\n self.compute_lr()\n\n self.optimizer.param_groups[self.param_group]['lr'] = self.lr\n self.optimizer.param_groups[self.param_group]['momentum'] = self.momentum","def poly_adjust_learning_rate(optimizer, lr0, step, n_step):\n lr = lr0 * (1.0 - step*1.0/n_step)\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr\n return lr","def __call__(self, parameters):\n\n chosen_rom = self._rng.choice(self.roms)\n self._ale_handler.set_parameters(rom=chosen_rom,\n seed=self._rng.randint(1, 2000000))\n # Update handles\n self._agent_handler.ale = self._ale_handler.handle\n self._objective_handler.agent = self._agent_handler.handle\n self._objective_handler.ale = self._ale_handler.handle\n\n return self.cost_normalizer(self._objective_handler.handle(parameters),\n chosen_rom)","def force_rescale(self,rescaleFactor):\n if not self.built:\n raise Exception(\"model should be built before calling this function\")\n for l in self.layerList:\n l.rescale(rescaleFactor)\n self.rescaleFactor.assign(rescaleFactor)","def mpt11_w18_2_v2_lr(optimizer, args, **kwargs):\n\n def _lr_adjuster(epoch, iteration):\n if epoch >= 35:\n lr = args.lr * 0.1\n\n if epoch >= 50:\n lr = lr * 0.1\n\n if epoch >= 60:\n lr = lr * 0.01\n else:\n lr = args.lr\n\n assign_learning_rate(optimizer, lr)\n\n return lr\n\n return _lr_adjuster","def scale_lambda(self, lmbd, nr_iterations, lmbd_schedule = 500000):\n self.scaled_lambda = lmbd * float(min(lmbd_schedule,nr_iterations)) / lmbd_schedule","def mpt11_w34_2_v2_lr(optimizer, args, **kwargs):\n\n def _lr_adjuster(epoch, iteration):\n if epoch >= 50:\n lr = args.lr * 0.1\n\n if epoch >= 62:\n lr = lr * 0.1\n\n if epoch >= 70:\n lr = lr * 0.01\n else:\n lr = args.lr\n\n assign_learning_rate(optimizer, lr)\n\n return lr\n\n return _lr_adjuster","def b1relu( regularizers, x):\n N, M, F = x.get_shape()\n b = _bias_variable(regularizers,[1, 1, int(F)], regularization=True)\n return tf.nn.relu(x + b)","def l21_reg(data):\n m = data.size()[0] # number of data points\n n = data.size()[1] # number of dimensions on the data points\n # find L2,1 regularization term\n outer_sum = 0\n for i in range(m):\n inner_sum = 0\n for j in range(n):\n inner_sum += data[i][j] ** 2\n outer_sum += inner_sum ** 0.5\n return outer_sum","def fill(self, recoValue, l1Value, weight=1.):\n self._total.fill(recoValue, weight)\n self._dist.fill(l1Value, weight)\n if l1Value > self._threshold:\n self._pass.fill(recoValue, weight)","def adjust_learning_rate(self, optimizer, batch, learning_rate, steps, scales, batch_size):\n lr = learning_rate\n for i in range(len(steps)):\n scale = scales[i] if i < len(scales) else 1\n if batch >= steps[i]:\n lr = lr * scale\n if batch == steps[i]:\n break\n else:\n break\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr/batch_size\n return lr","def adagrad_l1_update(loss, w, l1, learning_rate=1.0):\n g = theano.grad(loss, w) # (tef_n, )\n updates = OrderedDict()\n\n # for each gradient-weights vector pair compile the following\n\n # empty initializations, later of size (tef_n, )\n # maximum penalty accumulator\n u = theano.shared(np.zeros(1, dtype=theano.config.floatX), broadcastable=w.broadcastable)\n\n # actual accumulated penalties\n q = theano.shared(np.zeros(1, dtype=theano.config.floatX), broadcastable=w.broadcastable)\n\n # squared gradients accumulator\n gg = theano.shared(np.zeros(1, dtype=theano.config.floatX), broadcastable=w.broadcastable)\n\n # adagrad learning rate upgrade\n gradient_squared_accu_new = gg + g ** 2 # (tef_n, )\n adagrad_learning_rate = learning_rate / T.sqrt(gradient_squared_accu_new)\n\n # total possible accumulated l1 penalty\n u_new = u + l1 * adagrad_learning_rate\n\n # update rule: w_k+1/2,i = w_k,i - adagrad_lr_k * g_i\n w_tmp = w - adagrad_learning_rate * g\n\n # apply penalties\n if T.gt(l1, 0):\n # if w_k+1/2,i > 0: w_k+1,i = max(0, w_k+1/2,i - (u_k,i + q_k-1,i)) else if: ...\n w_update = T.switch(T.gt(w_tmp, 0.),\n T.maximum(w_tmp - (u_new + q), 0.), # w_tmp > 0\n T.switch(T.lt(w_tmp, 0.0),\n T.minimum(w_tmp + (u_new - q), 0.), # w_tmp < 0\n 0.) # w_tmp == 0\n )\n else:\n w_update = w_tmp\n\n # return updates (key: shared variable, value: symbolic variable)\n updates[w] = w_update\n updates[gg] = gradient_squared_accu_new\n updates[u] = u_new\n # actually accumulated penalty\n updates[q] = q + w_update - w_tmp\n\n return updates, u, q, gg","def _finalize_leaf(self, node):\n node.value = -self.shrinkage * node.sum_gradients / (\n node.sum_hessians + self.splitter.l2_regularization)\n self.finalized_leaves.append(node)","def shrink(self):\n x = np.nan_to_num(self.X.values)\n\n # de-mean returns\n t, n = np.shape(x)\n meanx = x.mean(axis=0)\n x = x - np.tile(meanx, (t, 1))\n\n # compute sample covariance matrix\n sample = (1.0 / t) * np.dot(x.T, x)\n\n # compute prior\n var = np.diag(sample).reshape(-1, 1)\n sqrtvar = np.sqrt(var)\n _var = np.tile(var, (n,))\n _sqrtvar = np.tile(sqrtvar, (n,))\n r_bar = (np.sum(sample / (_sqrtvar * _sqrtvar.T)) - n) / (n * (n - 1))\n prior = r_bar * (_sqrtvar * _sqrtvar.T)\n prior[np.eye(n) == 1] = var.reshape(-1)\n\n # compute shrinkage parameters and constant\n if self.delta is None:\n\n # what we call pi-hat\n y = x ** 2.0\n phi_mat = np.dot(y.T, y) / t - 2 * np.dot(x.T, x) * sample / t + sample ** 2\n phi = np.sum(phi_mat)\n\n # what we call rho-hat\n term1 = np.dot((x ** 3).T, x) / t\n help_ = np.dot(x.T, x) / t\n help_diag = np.diag(help_)\n term2 = np.tile(help_diag, (n, 1)).T * sample\n term3 = help_ * _var\n term4 = _var * sample\n theta_mat = term1 - term2 - term3 + term4\n theta_mat[np.eye(n) == 1] = np.zeros(n)\n rho = sum(np.diag(phi_mat)) + r_bar * np.sum(\n np.dot((1.0 / sqrtvar), sqrtvar.T) * theta_mat\n )\n\n # what we call gamma-hat\n gamma = np.linalg.norm(sample - prior, \"fro\") ** 2\n\n # compute shrinkage constant\n kappa = (phi - rho) / gamma\n shrinkage = max(0.0, min(1.0, kappa / t))\n self.delta = shrinkage\n else:\n # use specified constant\n shrinkage = self.delta\n\n # compute the estimator\n sigma = shrinkage * prior + (1 - shrinkage) * sample\n return self.format_and_annualise(sigma)","def rl_modelrl_l1_base():\n hparams = rl_modelrl_base()\n hparams.generative_model_params = \"basic_conv_l1\"\n return hparams","def _step(self, w1, y1,y1_short):\n\n #reajust the return y1 using the sign of w1\n #if is negative means we shorted so the return is the inverse\n\n y1_aux=y1.copy()\n for i in range(len(w1)):\n if(w1[i]<0):\n y1_aux[i]=y1_short[i]\n y1=y1_aux.copy()\n\n\n\n\n #print (\"enter step\")\n assert w1.shape == y1.shape, 'w1 and y1 must have the same shape'\n assert y1[0] == 1.0, 'y1[0] must be 1'\n\n p0 = self.p0\n\n dw1 = (y1 * w1) / (np.dot(y1, w1) + eps) # (eq7) weights evolve into\n\n mu1 = self.cost * (np.abs(dw1 - w1)).sum() # (eq16) cost to change portfolio\n\n assert mu1 < 1.0, 'Cost is larger than current holding'\n\n p1 = p0 * (1 - mu1) * np.dot(y1, w1) # (eq11) final portfolio value\n\n p1 = p1 * (1 - self.time_cost) # we can add a cost to holding\n\n rho1 = p1 / p0 - 1 # rate of returns\n r1 = np.log((p1 + eps) / (p0 + eps)) # log rate of return\n reward = r1 / self.steps * 1000. # (22) average logarithmic accumulated return\n # remember for next step\n self.p0 = p1\n\n # if we run out of money, we're done (losing all the money)\n done = p1 == 0\n\n\n info = {\n \"reward\": reward,\n \"log_return\": r1,\n \"portfolio_value\": p1,\n \"return\": y1.mean(),\n \"rate_of_return\": rho1,\n \"weights_mean\": w1.mean(),\n \"weights_std\": w1.std(),\n \"cost\": mu1,\n }\n\n #print (info)\n\n self.infos.append(info)\n return reward, info, done","def adjust_learning_rate(optimizer, gamma, step):\n global lr\n lr = lr * (gamma ** (step))\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr","def _cook_optimizer(self, \n lr = 0.01, \n optimizer = 'sgd',\n l1_coeff = 0.00001,\n l2_coeff = 0.00001):\n with tf.variable_scope (self.name + '_train') as scope:\n apply_regularizer (name = self.name, var_list = tf.get_collection(\n self.name + '_regularizer_worthy_params'), \n l1_coeff = l1_coeff,\n l2_coeff = l2_coeff )\n self.obj = tf.add_n(tf.get_collection( self.name + '_objectives'), name='objective')\n tf.summary.scalar('total_objective', self.obj)\n\n # Change (supply as arguments) parameters here directly in the code.\n if optimizer == 'sgd': \n self.back_prop = apply_gradient_descent(var_list = tf.get_collection(\n self.name + '_trainable_params'),\n obj = self.obj, learning_rate = lr )\n elif optimizer == 'adagrad': \n self.back_prop = apply_adagrad(var_list = tf.get_collection(\n self.name + '_trainable_params'),\n obj = self.obj, learning_rate = lr ) \n elif optimizer == 'rmsprop':\n self.back_prop = apply_rmsprop(var_list = tf.get_collection(\n self.name + '_trainable_params') ,\n obj = self.obj, learning_rate = lr)\n elif optimizer == 'adam':\n self.back_prop = apply_adam (var_list = tf.get_collection(\n self.name + '_trainable_params') ,\n obj = self.obj, learning_rate = lr )\n else:\n raise Error('Invalid entry to optimizer')","def mpt132_w34_2_lr(optimizer, args, **kwargs):\n\n def _lr_adjuster(epoch, iteration):\n if epoch >= 27:\n lr = args.lr * 0.1\n\n if epoch >= 44:\n lr = lr * 0.1\n\n if epoch >= 54:\n lr = lr * 0.01\n else:\n lr = args.lr\n\n assign_learning_rate(optimizer, lr)\n\n return lr\n\n return _lr_adjuster","def greedy_shrink(self):\n while self.single_greedy_shrink_iteration():\n self.run_shrink_pass(\"lower_common_block_offset\")","def g1(self, nx, ny, x_des):\n\n # :evaluating unscaled constraints at the initial point\n g_1_0 = self.g1_unscaled(nx, ny, .5 * np.ones(4 * nx + 5 * ny))\n\n # :evaluating unscaled constraints:\n g_1 = self.g1_unscaled(nx, ny, x_des)\n\n # :define the threshold \"tow\" to translate the scaled constraint\n # :alpha determines to what extent the inactive constraints are satisfied\n tow, alpha = [], self.alpha_g1\n [tow.append(i) if self.mu_g1[list(g_1_0).index(i)] < self.p else tow.append(alpha + (1 - alpha) * i) for i in g_1_0]\n\n # define the translated constraint\n g_1_translated = []\n [g_1_translated.append(g_1[i] - tow[i]) for i in range(nx)]\n return g_1_translated","def pre_phasing_r1(self, pre_phasing_r1):\n\n self._pre_phasing_r1 = pre_phasing_r1","def step_adjust_learning_rate(optimizer, lr0, step, step_size, gamma):\n\n if len(step_size) == 0:\n lr = lr0 * (gamma ** (step // step_size))\n else:\n lr = lr0 * gamma ** (sum([step > i for i in step_size]))\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr\n return lr","def _adjust_learning_rate(self, optimizer, lr):\n\n if len(optimizer.param_groups) == 1:\n optimizer.param_groups[0]['lr'] = lr\n else:\n # enlarge the lr at the head\n optimizer.param_groups[0]['lr'] = lr\n for i in range(1, len(optimizer.param_groups)):\n optimizer.param_groups[i]['lr'] = lr * 10","def shrink(self):\n self.mass *= 0.8","def _step2_optimization_closure(self, iteration, step):\n if iteration == self.num_iter_second_step - 1:\n reg_noise_std = 0\n else:\n reg_noise_std = (1 / 1000.) * (iteration // 700)\n\n aug = self._get_augmentation(iteration)\n if iteration == self.num_iter_second_step - 1:\n aug = 0\n # creates left_net_inputs and right_net_inputs by adding small noise\n clean_net_input = self.clean_net_inputs[aug] + (self.clean_net_inputs[aug].clone().normal_() * reg_noise_std)\n watermark_net_input = self.watermark_net_inputs[aug] + (self.watermark_net_inputs[aug].clone().normal_() * reg_noise_std)\n mask_net_input = self.mask_net_inputs[aug] # + (self.mask_net_input.clone().normal_() * reg_noise_std)\n # applies the nets\n self.clean_net_output = self.clean_net(clean_net_input)\n self.watermark_net_output = self.watermark_net(watermark_net_input)\n self.mask_net_output = self.mask_net(mask_net_input)\n self.total_loss = 0\n # loss on clean region\n self.total_loss += self.extended_l1_loss(self.clean_net_output,\n self.image_torchs[aug],\n (1 - self.watermark_hint_torchs[aug]))\n # loss in second region\n self.total_loss += 0.5 * self.l1_loss(self.watermark_hint_torchs[aug] *\n self.mask_net_output * self.watermark_net_output\n +\n (1 - self.mask_net_output) * self.clean_net_output,\n self.image_torchs[aug]) # this part learns the watermark\n self.total_loss.backward(retain_graph=True)","def learn(self, Xtrain, ytrain):\n pass\n self.weights = np.zeros(Xtrain.shape[1],)\n\n ### YOUR CODE HERE\n \n lmbd = self.params['lamb']\n \n numsamples = Xtrain.shape[0]\n # Xless = Xtrain[:,self.params['features']]\n Xless = Xtrain\n self.weights = np.random.rand(Xless.shape[1])\n err = 10000;\n #cw =0;\n tolerance = 10*np.exp(-4)\n i=0;\n \n \n w1 = self.weights\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, self.weights.T)\n cw = self.logit_cost(cw_v, Xless, ytrain) + lmbd * self.regularizer[0](self.weights)\n # print(cw)\n errors = []\n runtm = []\n epch = []\n \n err = 1\n iteration= 1000\n #tm= time.time()\n while (abs(cw-err)>tolerance) and (i <iteration):\n err = cw\n g = self.logit_cost_grad(cw_v, Xless, ytrain)\n obj = cw\n j=0\n ita = -1* self.params['stepsize']\n w = self.weights\n # w1 = np.add(w,np.dot(ita,g))\n while(j<iteration):\n w1 = np.add(w,np.dot(ita,g))\n # cw_v =(np.dot(Xless, w1)-ytrain)\n # cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, w1.T)\n cw = self.logit_cost(cw_v, Xless, ytrain)+lmbd * self.regularizer[0](w1)\n ## print (cw)\n \n if(cw<np.absolute(obj-tolerance)): ############################################\n break\n ita = 0.7*ita\n j=j+1\n \n if(j==iteration):\n self.weights=w\n ita =0\n else:\n self.weights = w1\n \n # cw_v =(np.dot(Xless, self.weights)-ytrain)\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, self.weights.T)\n cw = self.logit_cost(cw_v, Xless, ytrain)\n #tm1 = time.time()-tm\n #runtm.append(tm1)\n #err = cw\n errors.append(err)\n i=i+1\n epch.append(i)","def optimize_parameters(self):\n pass","def optimize_parameters(self):\n pass","def optimize_parameters(self):\n pass","def LinReg_fit(X, y, X_test=None, y_test=None, lr=1e-7, batch=1, lamb=0,\n epoch=10000, print_every=100, lamb1=0, momentum=0):\n # initialize\n W = np.random.randn(X.shape[1]) / X.shape[1] / X.shape[0]\n\n train_loss = []\n train_RMSE = []\n test_loss = []\n test_RMSE = []\n\n # batch size indicator\n b = 0\n # cache for adagrad\n G = np.zeros(W.shape)\n\n for i in range(epoch):\n inds = []\n last_step = 0\n\n for j in np.random.permutation(X.shape[0]):\n inds.append(j)\n b += 1\n\n # do the adagrad to update the parameter\n if b >= batch:\n diff = X[inds].dot(W) - y[inds]\n\n # calculate gradients\n w = np.array(W)\n w[w > 0] = 1\n w[w < 0] = -1\n grad_X = X[inds].T.dot(diff)\n grad_regulariz = lamb * W * batch / X.shape[0]\n grad_first_order_reg = lamb1 * w * batch / X.shape[0]\n grad = grad_X + grad_regulariz + grad_first_order_reg\n\n # calculate update step\n G += grad**2\n delta_W = (grad + momentum * last_step) / np.sqrt(G)\n W -= lr * delta_W\n\n # reset variables\n last_step = delta_W\n b = 0\n inds = []\n\n objective = (((X.dot(W) - y)**2).sum() + lamb * (W**2).sum()) / 2.0\n RMSE = cal_RMSE(X, W, y)\n\n if X_test is not None and y_test is not None:\n # losses\n loss_X = ((X_test.dot(W) - y_test)**2).sum() / 2.0\n loss_reg = lamb * (W**2).sum() / 2.0\n loss_first_reg = lamb1 * (abs(W).sum())\n\n obj_t = loss_X + loss_reg + loss_first_reg\n RMSE_t = cal_RMSE(X_test, W, y_test)\n\n test_loss.append(obj_t)\n test_RMSE.append(RMSE_t)\n\n # print out the progress\n if i % print_every == 0:\n if X_test is not None and y_test is not None:\n print('\\tepoch: %d; obj: %.4f; RMSE: %.4f; RMSE_test: %.4f' %\n (i, objective, RMSE, RMSE_t))\n else:\n print('\\tepoch: %d; obj: %.4f; RMSE: %.4f' %\n (i, objective, RMSE))\n\n train_loss.append(objective)\n train_RMSE.append(RMSE)\n\n print('final obj: %.4f' % train_loss[-1])\n\n return W, train_loss, train_RMSE, test_loss, test_RMSE","def adjust_learning_rate(optimizer, gamma, step):\r\n lr = args.lr * (gamma ** (step))\r\n for param_group in optimizer.param_groups:\r\n param_group['lr'] = lr","def _calc_smooth_loss(self, loss, len_examples, regularizer_type=None):\n if regularizer_type == 'L2':\n # Add regulatization term to loss\n\n return 1./len_examples * loss\n else:\n return 1./len_examples * loss","def adjust_learning_rate(optimizer, gamma, step):\n lr = args.lr * (0.8 ** step)\n print(lr)\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr","def __call__(self, step):\n\n # decrease linearly\n steprate = math_ops.abs(math_ops.divide(\n math_ops.subtract(self.finallr, self.initlr), self.nsteps))\n\n lr = math_ops.subtract(self.initlr, math_ops.multiply(\n steprate, math_ops.subtract(step, self.shiftstep)))\n\n pred = math_ops.greater(step, self.shiftstep)\n lr = control_flow_ops.cond(pred, lambda: lr, lambda: self.initlr)\n\n return lr","def compute_gradient_and_loss1(W, X, y, reg, reg_type, opt):\n if opt == 0: # compute gradient only if opt == 0\n dW = np.zeros(W.shape) # initialize the gradient as zero\n \n # compute the loss and the gradient\n num_classes = W.shape[1]\n num_train = X.shape[0]\n loss = 0.0\n #############################################################################\n # TODO: #\n # Implement the routine to compute the loss, storing the result in loss #\n ############################################################################# \n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\n s = X[i].dot(W) # compute s (scores)\n s_y = s[y[i]] # keep the correct ground truth class score\n for j in xrange(num_classes): # for every class\n if j != y[i]: # don't take the correct ground truth index\n term = s[j] - s_y + 1 # max term with Delta = 1, according to Hinge loss formula\n if term > 0: # trick: take only the term > 0, equal to max(0,...) formula\n loss += term # add the possitive term \n if opt == 0: # compute gradient only if opt == 0\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\n dW[:, y[i]] -= X[i] # case j==y[i]\n\n# loss /= num_train # num_train = M, according to given formula \n\n if reg_type == 1: # loss + regularization , l2 or l1\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\n else:\n loss += reg * np.sum(W * W) # l2\n \n if opt == 0: # compute gradient only if opt == 0\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\n if reg_type == 1: # we use deriv_abs function for l1 derivative\n dW += reg * deriv_abs(W)\n else:\n dW += 2 * reg * W # l2 derivative formula\n \n return loss, dW\n else:\n return loss, None\n \n print 'CSFAK INSIDE compute_gradient_and_loss'\n #############################################################################\n # TODO: #\n # Implement the gradient for the required loss, storing the result in dW.\t #\n # #\n # Hint: Instead of computing the gradient from scratch, it may be easier #\n # to reuse some of the intermediate values that you used to compute the #\n # loss. #\n #############################################################################\n \n #pass\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################","def adjust_learning_rate(optimizer, epoch, args, step):\n lr = args.lr * (0.1 ** (epoch // step))\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr","def get_regularizer(type, l1, l2):\n if type == 'l1':\n reg = keras.regularizers.l1(l1)\n elif type == 'l2':\n reg = keras.regularizers.l2(l2)\n elif type == 'l1_l2':\n reg = keras.regularizers.l1_l2(l1, l2)\n else:\n reg = None\n return reg","def step_and_update_lr(self):\r\n self._update_learning_rate()\r\n self._optimizer.step()","def step_update(self, num_updates):\n cycle = math.floor(num_updates / (2 * self.stepsize))\n\n lr_shrink = self.lr_shrink ** cycle\n max_lr = self.max_lr * lr_shrink\n if self.shrink_min:\n min_lr = self.min_lr * lr_shrink\n else:\n min_lr = self.min_lr\n\n x = abs(num_updates / self.stepsize - 2 * (cycle + 1) + 1)\n self.lr = min_lr + (max_lr - min_lr) * max(0, (1 - x))\n\n self.optimizer.set_lr(self.lr)\n return self.lr","def update_lr(epoch, optimizer, args):\n gamma = 0\n for step in args.step:\n if epoch + 1.0 > int(step):\n gamma += 1\n lr = args.lr * math.pow(0.1, gamma)\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr","def set_lam_kld_l1l2(self, lam_kld_l1l2=1.0):\n zero_ary = np.zeros((1,))\n new_val = zero_ary + lam_kld_l1l2\n self.lam_kld_l1l2.set_value(to_fX(new_val))\n return","def adjust_learning_rate_step(optimizer, epoch, steps, gamma=0.1):\n if epoch in steps:\n for param_group in optimizer.param_groups:\n lr = param_group['lr']*gamma\n param_group['lr'] = lr","def _sa1():\n The.optimize.early=4\n sa(ZDT1)"],"string":"[\n \"def l1_regularizer(scale):\\n if isinstance(scale, numbers.Integral):\\n raise ValueError('scale cannot be an integer: %s' % scale)\\n if isinstance(scale, numbers.Real):\\n if scale < 0.:\\n raise ValueError('Setting a scale less than 0 on a regularizer: %g' %\\n scale)\\n if scale >= 1.:\\n raise ValueError('Setting a scale greater than 1 on a regularizer: %g' %\\n scale)\\n if scale == 0.:\\n logging.info('Scale of 0 disables regularizer.')\\n return lambda _, name=None: None\\n\\n def l1(weights, name=None):\\n \\\"\\\"\\\"Applies L1 regularization to weights.\\\"\\\"\\\"\\n with ops.op_scope([weights], name, 'l1_regularizer') as scope:\\n my_scale = ops.convert_to_tensor(scale,\\n dtype=weights.dtype.base_dtype,\\n name='scale')\\n return standard_ops.mul(\\n my_scale,\\n standard_ops.reduce_sum(standard_ops.abs(weights)),\\n name=scope)\\n\\n return l1\",\n \"def _update_parameters(self, delta):\\n if delta is not None:\\n self.SGD.update_with_L1_regularization(self.variables, delta, self.L1)\",\n \"def l1_regularization(variables, factor=1e-4, name='l1_regularization', collections=['regularization']):\\n l1 = tf.add_n([tf.reduce_sum(tf.abs(var)) for var in variables], name=name) if variables else tf.constant(0.)\\n loss = factor * l1\\n scalar_summary(loss, name, collections)\\n return loss\",\n \"def _step1_optimization_closure(self, iteration, step):\\n if iteration == self.num_iter_first_step - 1:\\n reg_noise_std = 0\\n else:\\n reg_noise_std = (1 / 1000.) * (iteration // 300) # TODO: make it dependant in the max number of iterations\\n aug = self._get_augmentation(iteration)\\n if iteration == self.num_iter_first_step - 1:\\n aug = 0\\n # creates left_net_inputs and right_net_inputs by adding small noise\\n clean_net_input = self.clean_net_inputs[aug] + (self.clean_net_inputs[aug].clone().normal_() * reg_noise_std)\\n # watermark_net_input = self.watermark_net_inputs[aug] # + (self.watermark_net_input.clone().normal_())\\n # mask_net_input = self.mask_net_inputs[aug]\\n # applies the nets\\n self.clean_net_output = self.clean_net(clean_net_input)\\n self.total_loss = 0\\n self.blur = 0\\n self.total_loss += self.extended_l1_loss(self.clean_net_output,\\n self.image_torchs[aug],\\n (1 - self.watermark_hint_torchs[aug]))\\n self.total_loss.backward(retain_graph=True)\",\n \"def update_regularizer(self, regularizer = regularizers.l1(0.1)):\\n # for layer in self.layers:\\n # layer.kernel_regularizer = regularizer\\n self.list_cnn[-1].kernel_regularizer = regularizer\",\n \"def l1(weights, name=None):\\n with ops.op_scope([weights], name, 'l1_regularizer') as scope:\\n my_scale = ops.convert_to_tensor(scale,\\n dtype=weights.dtype.base_dtype,\\n name='scale')\\n return standard_ops.mul(\\n my_scale,\\n standard_ops.reduce_sum(standard_ops.abs(weights)),\\n name=scope)\",\n \"def regularizer(self):\\n \\n # L2 regularization for the fully connected parameters.\\n regularizers = (tf.nn.l2_loss(self.weights.wd1) + tf.nn.l2_loss(self.weights.bd1) + \\n tf.nn.l2_loss(self.weights.wout) + tf.nn.l2_loss(self.weights.bout))\\n return regularizers\",\n \"def l1(parameter, bias=None, reg=0.01, lr=0.1):\\n Norm = reg*lr\\n\\n # Update W\\n if parameter.is_cuda:\\n Norms_w = Norm*torch.ones(parameter.size(), device=torch.device(\\\"cuda\\\"))\\n else:\\n Norms_w = Norm*torch.ones(parameter.size(), device=torch.device(\\\"cpu\\\"))\\n pos = torch.min(Norms_w, Norm*torch.clamp(parameter, min=0)) # get all positive values\\n neg = torch.min(Norms_w, -1.0*Norm*torch.clamp(parameter, max=0)) # get all negative values\\n update_w = parameter - pos + neg # l1 step is the magnitude of all positive and all negative\\n parameter.data = update_w\\n\\n if bias is not None:\\n if bias.is_cuda:\\n Norms_b = Norm*torch.ones(bias.size(), device=torch.device(\\\"cuda\\\"))\\n else:\\n Norms_b = Norm*torch.ones(bias.size(), device=torch.device(\\\"cpu\\\"))\\n pos = torch.min(Norms_b, Norm*torch.clamp(bias, min=0))\\n neg = torch.min(Norms_b, -1.0*Norm*torch.clamp(bias, max=0))\\n update_b = bias - pos + neg\\n bias.data = update_b\",\n \"def apply_regularization(self, w, loss, gradient, regularization, lambda_, m):\\n if regularization == 'l2':\\n loss += lambda_ / (2 * m) * np.squeeze(w.T.dot(w))\\n gradient += lambda_ / m * w\\n elif regularization == 'l1':\\n loss += lambda_ / (2 * m) * np.sum(np.abs(w))\\n gradient += lambda_ / m * np.sum((w >= 0) * 1 + (w < 0) * -1)\\n return loss, gradient\",\n \"def EmbeddingL1RegularizationUpdate(embedding_variable, net_input, learn_rate, l1_reg_val):\\n # TODO(student): Change this to something useful. Currently, this is a no-op.\\n net_input = tf.nn.l2_normalize(net_input, axis=0)\\n sign_inside = tf.sign(tf.matmul(net_input, embedding_variable))\\n where = tf.equal(sign_inside, 0)\\n # should replace 0's with random in [-1, 1] for an better (not necessarily acute)implementation\\n grad = l1_reg_val * tf.matmul(tf.transpose(net_input), sign_inside)\\n embedding_variable_ = embedding_variable - learn_rate * grad\\n\\n ## local test #better to disable when learning\\n batch_size, number_of_vocabulary_tokens = net_input.shape\\n net_example = numpy.random.binomial(1, .1, (3, number_of_vocabulary_tokens))\\n sigma_fnc = l1_reg_val * tf.norm(tf.matmul(net_input, embedding_variable), ord=1)\\n # assert tf.gradients(sigma_fnc, embedding_variable) == grad, \\\"wrong grad in L2\\\"\\n sess = tf.Session()\\n sess.run(tf.global_variables_initializer())\\n tf_grad = sess.run(tf.gradients(sigma_fnc, embedding_variable)[0], feed_dict={net_input: net_example})\\n my_grad = sess.run(grad, feed_dict={net_input: net_example})\\n differ = numpy.linalg.norm(tf_grad - my_grad)\\n differ = differ / numpy.linalg.norm(tf_grad)\\n print('l1 grad differentage {}'.format(differ))\\n print('l2 grad max difference {}'.format(numpy.max(tf_grad - my_grad)))\\n\\n return embedding_variable.assign(embedding_variable_)\",\n \"def reg_loss(model: nn.Module, regularizer: str, l1: float=0.01, l2: float=0.01):\\n if regularizer == 'l1':\\n l1_reg = l1 * sum(torch.abs(p).sum() for p in model.parameters())\\n return l1_reg\\n if regularizer == 'l2':\\n l2_reg = l2 * sum(torch.square(p).sum() for p in model.parameters())\\n return l2_reg\\n if regularizer == 'l1_l2':\\n l1_reg = l1 * sum(torch.abs(p).sum() for p in model.parameters())\\n l2_reg = l2 * sum(torch.square(p).sum() for p in model.parameters())\\n return l1_reg + l2_reg\",\n \"def l2_regularization_penalty(self):\\n return self.l2 * (np.linalg.norm(self.weights)**2)\",\n \"def l1(name, weights):\\n\\n with tf.name_scope(name):\\n regularizer = np.float32(0.0)\\n for weight in weights:\\n tf.add(regularizer, tf.nn.l1_loss(weight))\\n\\n return regularizer\",\n \"def __init__(self, l1_regularization=0.):\\n self.l1_regularization = l1_regularization\\n self.nspec = None\\n self.npixels = None\\n self.nlabels = None\\n self.ncoeffs = None\\n\\n self.coeffs = None\\n self.scatter = None\\n\\n # normalization factor\\n self.labels_median = 0.\\n self.labels_std = 1.\\n\\n # labels names\\n self.label_names = ['Teff', 'Logg', 'M_H', 'Alpha_M']\\n\\n self.trained_flag = False\\n self.force_cpu = False\\n self.log_device_placement = False\",\n \"def set_kernel_reg(model, lambdal1 = 0, lambdal2 = 0):\\r\\n\\r\\n\\r\\n\\tfor layer in model.layers:\\r\\n\\t\\tif hasattr(layer, 'kernel_regularizer'):\\r\\n\\t\\t\\tlayer.kernel_regularizer = l1_l2(l1 = lambdal1, l2 = lambdal2)\\r\\n\\r\\n\\treturn model\",\n \"def l2_regularizer(scale):\\n if isinstance(scale, numbers.Integral):\\n raise ValueError('scale cannot be an integer: %s' % (scale,))\\n if isinstance(scale, numbers.Real):\\n if scale < 0.:\\n raise ValueError('Setting a scale less than 0 on a regularizer: %g.' %\\n scale)\\n if scale >= 1.:\\n raise ValueError('Setting a scale greater than 1 on a regularizer: %g.' %\\n scale)\\n if scale == 0.:\\n logging.info('Scale of 0 disables regularizer.')\\n return lambda _, name=None: None\\n\\n def l2(weights, name=None):\\n \\\"\\\"\\\"Applies l2 regularization to weights.\\\"\\\"\\\"\\n with ops.op_scope([weights], name, 'l2_regularizer') as scope:\\n my_scale = ops.convert_to_tensor(scale,\\n dtype=weights.dtype.base_dtype,\\n name='scale')\\n return standard_ops.mul(my_scale, nn.l2_loss(weights), name=scope)\\n\\n return l2\",\n \"def mp_regular_linreg(X, y, beta_0, alpha, L1_ratio, max_iter=50, tol=0.0001, *args, **kwargs):\\n\\n N, p = X.shape\\n beta = beta_0.copy()\\n b_new = np.zeros(p)\\n\\n for itr in range(max_iter):\\n with ProcessPoolExecutor(max_workers=8) as pool:\\n b_new = np.array(list(pool.map(deco, [j for j in range(p)], repeat(X), repeat(y), repeat(N),\\n repeat(p), repeat(beta), repeat(alpha), repeat(L1_ratio))))\\n beta = b_new\\n return beta\",\n \"def regularization_loss(params: hk.Params) -> jnp.ndarray:\\r\\n\\r\\n # L1 Loss\\r\\n sum_in_layer = lambda p: jnp.sum(jnp.abs(p))\\r\\n sum_p_layers = [sum_in_layer(p) for p in jax.tree_leaves(params)]\\r\\n l1_loss = sum(sum_p_layers)\\r\\n\\r\\n # L2 Loss\\r\\n l2_loss = 0.5 * sum(jnp.sum(jnp.square(p)) for p in jax.tree_leaves(params))\\r\\n\\r\\n return l2_coef * l2_loss + l1_coef * l1_loss\",\n \"def rescale_all(self):\\n for param_code in self.parameters.keys():\\n self.rescale_parameter(param_code)\",\n \"def l2_regularization(cg, rate=0.01):\\n W = VariableFilter(roles=[WEIGHT])(cg.variables)\\n L2_cost = rate * l2_norm(W)\\n\\n return L2_cost\",\n \"def _reset_parameters(self):\\r\\n\\t\\tfor p in self.parameters():\\r\\n\\t\\t\\tif p.dim() > 1:\\r\\n\\t\\t\\t\\txavier_uniform_(p)\",\n \"def adjust_learning_rate(optimizer, shrink_factor):\\n\\n print(\\\"\\\\nDECAYING learning rate.\\\")\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = param_group['lr'] * shrink_factor\\n print(\\\"The new learning rate is %f\\\\n\\\" % (optimizer.param_groups[0]['lr'],))\",\n \"def adjust_learning_rate(optimizer, shrink_factor):\\n\\n print(\\\"\\\\nDECAYING learning rate.\\\")\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = param_group['lr'] * shrink_factor\\n print(\\\"The new learning rate is %f\\\\n\\\" % (optimizer.param_groups[0]['lr'],))\",\n \"def prox_l1_norm(w, lamb):\\n\\treturn np.sign(w) * np.maximum( np.abs(w) - lamb, 0)\",\n \"def test_l1norm () :\\n n = 10\\n rfs = RewardFnSpace(list(range(n)))\\n for i in range(10): \\n b = rfs.bs[i]\\n rfs.lp += b == 0\\n rfs.lp.solve()\\n rfs._setCoeffs()\\n coeffs = np.array(rfs.coeffs)\\n assert(np.linalg.norm(coeffs - np.ones(n)) < 1e-4)\",\n \"def l2(parameter, bias=None, reg=0.01, lr=0.1):\\n \\n if bias is not None:\\n w_and_b = torch.cat((parameter, bias.unfold(0,1,1)),1)\\n else:\\n w_and_b = parameter\\n L2 = reg # lambda: regularization strength\\n Norm = (lr*L2/w_and_b.norm(2))\\n if Norm.is_cuda:\\n ones_w = torch.ones(parameter.size(), device=torch.device(\\\"cuda\\\"))\\n else:\\n ones_w = torch.ones(parameter.size(), device=torch.device(\\\"cpu\\\"))\\n l2T = 1.0 - torch.min(ones_w, Norm)\\n update = (parameter*l2T) \\n parameter.data = update\\n # Update bias\\n if bias is not None:\\n if Norm.is_cuda:\\n ones_b = torch.ones(bias.size(), device=torch.device(\\\"cuda\\\"))\\n else:\\n ones_b = torch.ones(bias.size(), device=torch.device(\\\"cpu\\\"))\\n l2T = 1.0 - torch.min(ones_b, bias)\\n update_b = (bias*l2T)\\n bias.data = update_b\",\n \"def l2_regularization(W, reg_strength):\\n # TODO: Copy from the previous assignment\\n loss = reg_strength*np.sum(W*W)\\n grad = 2*reg_strength*W\\n return loss, grad\",\n \"def l2_regularization(variables, factor=1e-4, name='l2_regularization', collections=['regularization']):\\n l2 = tf.add_n([tf.sqrt(2.*tf.nn.l2_loss(var)) for var in variables], name=name) if variables else tf.constant(0.)\\n loss = factor * l2\\n scalar_summary(loss, name, collections)\\n return loss\",\n \"def forward(self, parameters: List[Tuple[str, nn.Parameter]]) -> torch.Tensor:\\n # calculate regularized loss \\n reg_loss = regularize(parameters, self.weight_decay, self.norm)\\n\\n return reg_loss\",\n \"def fit_regularized(self, start_params=None, method='l1', alpha=0,\\n ceps=1e-4, ptol=1e-6, maxit=200, **fit_kwargs):\\n\\n if type(method) == str and (method.lower() != 'l1'):\\n raise ValueError(\\\"Invalid regularization method\\\")\\n\\n # If method is a smooth penalty just optimize directly.\\n if isinstance(method, Penalty):\\n # Scale the penalty weights by alpha\\n method.alpha = alpha\\n fit_kwargs.update({\\\"fe_pen\\\": method})\\n return self.fit(**fit_kwargs)\\n\\n if np.isscalar(alpha):\\n alpha = alpha * np.ones(self.k_fe, dtype=np.float64)\\n\\n # Fit the unpenalized model to get the dependence structure.\\n mdf = self.fit(**fit_kwargs)\\n fe_params = mdf.fe_params\\n cov_re = mdf.cov_re\\n scale = mdf.scale\\n try:\\n cov_re_inv = np.linalg.inv(cov_re)\\n except np.linalg.LinAlgError:\\n cov_re_inv = None\\n\\n for itr in range(maxit):\\n\\n fe_params_s = fe_params.copy()\\n for j in range(self.k_fe):\\n\\n if abs(fe_params[j]) < ceps:\\n continue\\n\\n # The residuals\\n fe_params[j] = 0.\\n expval = np.dot(self.exog, fe_params)\\n resid_all = self.endog - expval\\n\\n # The loss function has the form\\n # a*x^2 + b*x + pwt*|x|\\n a, b = 0., 0.\\n for k, lab in enumerate(self.group_labels):\\n\\n exog = self.exog_li[k]\\n ex_r = self.exog_re_li[k]\\n ex2_r = self.exog_re2_li[k]\\n resid = resid_all[self.row_indices[lab]]\\n\\n x = exog[:,j]\\n u = _smw_solve(scale, ex_r, ex2_r, cov_re,\\n cov_re_inv, x)\\n a += np.dot(u, x)\\n b -= 2 * np.dot(u, resid)\\n\\n pwt1 = alpha[j]\\n if b > pwt1:\\n fe_params[j] = -(b - pwt1) / (2 * a)\\n elif b < -pwt1:\\n fe_params[j] = -(b + pwt1) / (2 * a)\\n\\n if np.abs(fe_params_s - fe_params).max() < ptol:\\n break\\n\\n # Replace the fixed effects estimates with their penalized\\n # values, leave the dependence parameters in their unpenalized\\n # state.\\n params_prof = mdf.params.copy()\\n params_prof[0:self.k_fe] = fe_params\\n\\n scale = self.get_scale(fe_params, mdf.cov_re_unscaled)\\n\\n # Get the Hessian including only the nonzero fixed effects,\\n # then blow back up to the full size after inverting.\\n hess = self.hessian_full(params_prof)\\n pcov = np.nan * np.ones_like(hess)\\n ii = np.abs(params_prof) > ceps\\n ii[self.k_fe:] = True\\n ii = np.flatnonzero(ii)\\n hess1 = hess[ii, :][:, ii]\\n pcov[np.ix_(ii,ii)] = np.linalg.inv(-hess1)\\n\\n results = MixedLMResults(self, params_prof, pcov / scale)\\n results.fe_params = fe_params\\n results.cov_re = cov_re\\n results.scale = scale\\n results.cov_re_unscaled = mdf.cov_re_unscaled\\n results.method = mdf.method\\n results.converged = True\\n results.cov_pen = self.cov_pen\\n results.k_fe = self.k_fe\\n results.k_re = self.k_re\\n results.k_re2 = self.k_re2\\n\\n return MixedLMResultsWrapper(results)\",\n \"def test_regularization_0size_interval(self):\\n reg = modelgen.get_regularization(2, 2)\\n assert reg == 0.01\",\n \"def l2_reg_cost(cost, lambtha, weights, L, m):\\n f = 0\\n while (L):\\n index = \\\"W{}\\\".format(L)\\n weight = weights[index]\\n f += np.linalg.norm(weight)\\n L -= 1\\n return cost + lambtha / (2 * m) * f\",\n \"def _l1(self, y, x, y_minus_g, w_0):\\n # Initialize weight vector to return\\n w_1 = np.zeros(len(w_0))\\n \\n for j in range(len(x)):\\n reg = float(self._sign(w_0[j])) / (self._lambda*self._num_training)\\n w_1[j] = w_0[j] + self._epsilon*(x[j]*y_minus_g - reg)\\n \\n return w_1\",\n \"def _reset_parameters(self):\\n\\n for p in self.parameters():\\n if p.dim() > 1:\\n xavier_uniform_(p)\",\n \"def regularizer(self) -> Callable[[jnp.ndarray, jnp.ndarray], float]:\\n if self._regularizer is not None:\\n return self._regularizer\\n return lambda *args, **kwargs: 0.\",\n \"def reBuild(self): # redefine the rebuild method for loss function (polymorphism)\\n self.updateRange()\\n self.buildLine()\\n self.normalize() # normalize loss function to have total area of 1 \",\n \"def l2_reg_cost(cost, lambtha, weights, L, m):\\n w_norm = 0\\n for i in range(1, L + 1):\\n w_norm += np.linalg.norm(weights['W' + str(i)])\\n L2 = cost + (lambtha / (2 * m) * w_norm)\\n return L2\",\n \"def apply_1d_regularizer(list_data, sijmat):\\n ncol = len(list_data)\\n list_grad = np.zeros(ncol, dtype=np.float32)\\n list_grad[1:-1] = (-1) * np.diff(list_data, 2)\\n list_grad[0] = list_data[0] - list_data[1]\\n list_grad[-1] = list_data[-1] - list_data[-2]\\n list_coe = np.sum(np.tile(list_grad, (ncol, 1)) * sijmat, axis=1)\\n return list_data + list_coe\",\n \"def l2_reg_cost(cost, lambtha, weights, L, m):\\n sumWeights = 0\\n for i in range(1, L + 1):\\n sumWeights += np.linalg.norm(weights['W' + str(i)])\\n return cost + sumWeights * lambtha / (2 * m)\",\n \"def _optimization_closure(self, iteration, step):\\n aug = self._get_augmentation(iteration)\\n if iteration == self.num_iter_per_step - 1:\\n reg_noise_std = 0\\n aug = 0\\n else:\\n reg_noise_std = (1 / 1000.) * (iteration // 400)\\n # creates left_net_inputs and right_net_inputs by adding small noise\\n clean_nets_inputs = [clean_net_input[aug] + (clean_net_input[aug].clone().normal_() * reg_noise_std)\\n for clean_net_input in self.clean_nets_inputs]\\n watermark_net_input = self.watermark_net_input[aug] # + (self.watermark_net_input[aug].clone().normal_() * reg_noise_std)\\n mask_net_input = self.mask_net_input[aug]\\n # applies the nets\\n self.clean_nets_outputs = [clean_net(clean_net_input) for clean_net, clean_net_input\\n in zip(self.clean_nets, clean_nets_inputs)]\\n self.watermark_net_output = self.watermark_net(watermark_net_input)\\n self.mask_net_output = self.mask_net(mask_net_input)\\n self.total_loss = 0\\n self.blur = 0\\n\\n self.total_loss += sum(self.l1_loss(self.watermark_net_output * self.mask_net_output +\\n clean_net_output * (1 - self.mask_net_output), image_torch[aug])\\n for clean_net_output, image_torch in zip(self.clean_nets_outputs, self.images_torch))\\n self.total_loss.backward(retain_graph=True)\",\n \"def l2_reg_cost(cost, lambtha, weights, L, m):\\n enorm = 0\\n for i in range(1, L + 1):\\n layer = 'W{}'.format(i)\\n enorm += np.linalg.norm(weights[layer])\\n return cost + (lambtha / (2 * m)) * enorm\",\n \"def mpt11_w18_2_lr(optimizer, args, **kwargs):\\n\\n def _lr_adjuster(epoch, iteration):\\n if epoch >= 46:\\n lr = args.lr * 0.1\\n\\n if epoch >= 65:\\n lr = lr * 0.1\\n\\n if epoch >= 80:\\n lr = lr * 0.01\\n else:\\n lr = args.lr\\n\\n assign_learning_rate(optimizer, lr)\\n\\n return lr\\n\\n return _lr_adjuster\",\n \"def adapt_length_scale(self):\\n Ne = max(1,self.Ne)\\n Nc = max(1,self.Nc)\\n ratio = Ne/(Ne+Nc)\\n self.mu *= 2*ratio\",\n \"def compute_cost_with_regularization(A3, Y, parameters, lambd):\\n\\n m = Y.shape[1]\\n W1 = parameters[\\\"W1\\\"]\\n W2 = parameters[\\\"W2\\\"]\\n W3 = parameters[\\\"W3\\\"]\\n\\n cross_entropy_cost = compute_cost(A3, Y)\\n L2_regularization_cost = (np.sum(np.square(W1)) + np.sum(np.square(W2)) + np.sum(np.square(W3))) * lambd / (2 * m)\\n\\n cost = cross_entropy_cost + L2_regularization_cost\\n\\n return cost\",\n \"def linf1(parameter, bias=None, reg=0.01, lr=0.1):\\n\\n Norm = reg*lr\\n if bias is not None:\\n w_and_b = torch.cat((parameter, bias.unfold(0,1,1)),1)\\n else:\\n w_and_b = parameter\\n sorted_w_and_b, indices = torch.sort(torch.abs(w_and_b), descending=True)\\n\\n # CUDA or CPU\\n devicetype=\\\"cuda\\\"\\n if w_and_b.is_cuda:\\n devicetype=\\\"cuda\\\"\\n else:\\n devicetype=\\\"cpu\\\"\\n\\n\\n #SLOW\\n rows, cols = sorted_w_and_b.size()\\n\\n sorted_z = torch.cat((sorted_w_and_b, torch.zeros(rows,1, device=torch.device(devicetype))),1)\\n subtracted = torch.clamp(sorted_w_and_b - sorted_z[:,1:],max=Norm) #Max=Norm important\\n\\n scale_indices = torch.cumsum(torch.ones(rows,cols, device=torch.device(devicetype)),1)\\n scaled_subtracted = subtracted * scale_indices\\n max_mass = torch.cumsum(scaled_subtracted,1)\\n nonzero = torch.clamp(-1*(max_mass - Norm),0)\\n\\n oneN = 1.0/scale_indices\\n\\n # Algorithm described in paper, but these are all efficient GPU operation steps)\\n # First we subtract every value from the cell next to it\\n nonzero_ones = torch.clamp(nonzero * 1000000, max=1) #Hacky, but efficient\\n shifted_ones = torch.cat((torch.ones(rows,1, device=torch.device(devicetype)),nonzero_ones[:,:(cols-1)]),1)\\n over_one = -1*(nonzero_ones - shifted_ones)\\n last_one = torch.cat((over_one,torch.zeros(rows,1, device=torch.device(devicetype))),1)[:,1:]\\n max_remain = last_one * nonzero\\n shift_max = torch.cat((torch.zeros(rows,1, device=torch.device(devicetype)),max_remain[:,:(cols-1)]),1)\\n first_col_nonzero_ones = torch.cat((torch.ones(rows,1, device=torch.device(devicetype)),nonzero_ones[:,1:]),1) #Edge case for only first column\\n tosub = first_col_nonzero_ones * subtracted + shift_max * oneN\\n\\n # We flip the tensor so that we can get a cumulative sum for the value to subtract, then flip back\\n nastyflipS = torch.flip(torch.flip(tosub,[0,1]),[0])\\n aggsubS = torch.cumsum(nastyflipS,1)\\n nastyflipagainS = torch.flip(torch.flip(aggsubS,[0,1]),[0])\\n\\n # The proximal gradient step is equal to subtracting the sorted cumulative sum\\n updated_weights = sorted_w_and_b - nastyflipagainS\\n unsorted = torch.zeros(rows,cols, device=torch.device(devicetype)).scatter_(1,indices,updated_weights)\\n final_w_and_b = torch.sign(w_and_b) * unsorted\\n\\n # Actually update parameters and bias\\n if bias is not None:\\n update = final_w_and_b[:,:cols-1]\\n parameter.data = update\\n update_b = final_w_and_b[:,-1]\\n bias.data = update_b\\n else:\\n parameter.data = final_w_and_b\",\n \"def reduce(self, threshold):\\n def percentage_change(old, new):\\n return (old - new) / old\\n real_reduction_iterations = 0\\n padic_reduction_iterations = 0\\n cont_reduction_iterations = 0\\n factor = len(self.constants.primes) + 1\\n \\n print('initial bound',max(self.coefficients['n1_bound'],max(self.coefficients['Z_bounds'])))\\n\\n # First, go through the real reduction loop.\\n current_n1_bound = self.coefficients['n1_bound']\\n current_diff_bound = None\\n while True:\\n real_reduction_iterations += 1\\n logging.info(\\\"Real Reduction - Iteration %d\\\" % real_reduction_iterations)\\n\\n large_constant = self.calculate_large_constant(current_n1_bound, factor)\\n logging.info(\\\"Large constant contains %d digits \\\" % large_constant.ndigits())\\n\\n # Find a new bound on n_1 - n_k\\n new_diff_bound = self.real_reduce(current_n1_bound, large_constant)\\n logging.info(\\\"Current bound on n1: \\\" + str(current_n1_bound))\\n self.update_real_constants(new_diff_bound)\\n logging.info(\\\"new diff bound: \\\" + str(new_diff_bound))\\n logging.info(\\\"New bound on n1: \\\" + str(self.coefficients[\\\"n1_bound\\\"]))\\n logging.info(\\\"New bound on zi: \\\" + str(self.coefficients['Z_bounds']))\\n \\n if percentage_change(current_n1_bound, self.coefficients[\\\"n1_bound\\\"]) < self.threshold:\\n logging.info(\\\"New bound did not improve in the real step; real reduction process is done.\\\")\\n factor = factor + 5\\n break\\n\\n current_n1_bound = self.coefficients['n1_bound']\\n current_diff_bound = new_diff_bound\\n\\n # Second, go through the p-adic reduction loop.\\n current_Z_bounds = self.coefficients['Z_bounds']\\n while True:\\n padic_reduction_iterations += 1\\n logging.info(\\\"p-adic Reduction - Iteration %d\\\" % padic_reduction_iterations)\\n\\n new_Z_bounds = self.padic_reduce(math.ceil(current_diff_bound))\\n logging.info(\\\"New bound on zi: \\\" + str(new_Z_bounds))\\n logging.info(\\\"Current bound on n1: \\\" + str(current_n1_bound))\\n new_n1_bound = self.update_padic_constants(new_Z_bounds)\\n logging.info(\\\"New bound on n1: \\\" + str(new_n1_bound))\\n if percentage_change(current_n1_bound, new_n1_bound) < self.threshold:\\n logging.info(\\\"New bound did not improve in the p-adic step; p-adic reduction process is done.\\\")\\n break\\n\\n current_n1_bound = new_n1_bound\\n\\n print(current_n1_bound)\\n\\n return self.constants\",\n \"def l2_reg_cost(cost, lambtha, weights, L, m):\\n Frobenius = 0\\n for k, v in weights.items():\\n if k[0] == \\\"W\\\":\\n Frobenius += np.linalg.norm(v)\\n return cost + (lambtha/(2*m)) * Frobenius\",\n \"def l21_slow(parameter, reg=0.01, lr=0.1):\\n \\n w_and_b = parameter\\n l21s = []\\n for row in w_and_b:\\n L21 = reg\\n l21 = lr * L21/row.norm(2) \\n l21 = 1.0 - min(1.0, l21) \\n l21s.append(l21)\\n counter = 0\\n for row in parameter:\\n updated = row * l21s[counter]\\n parameter.data[counter] = updated\\n counter = counter + 1\\n counter = 0\",\n \"def rl_modelrl_l1_short():\\n hparams = rl_modelrl_short()\\n hparams.generative_model_params = \\\"basic_conv_l1\\\"\\n return hparams\",\n \"def adjust_LR(optimizer, params, iternum):\\n if params.distributed and iternum<5000:\\n lr = params.ngpu*params.lr*(iternum/5000.) #warmup for distributed training\\n elif iternum<40000:\\n lr = params.ngpu*params.lr\\n elif iternum>80000:\\n lr = params.ngpu*params.lr/4.\\n else:\\n lr = params.ngpu*params.lr/2.\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\",\n \"def regularize_bwd(X, y, mu0, mu1, v1, nz, K, verbose=False):\\n \\n if verbose: sss=0#print '\\\\ncompute bath between mu=%.4f and mu=%.4f'%(mu0, mu1)\\n \\n n, m = X.shape\\n X_nz = np.atleast_2d(X[:, nz])\\n b = np.dot(X.T, y)\\n G = np.dot(X.T, X)\\n \\n nbr = 0\\n mu = mu0\\n trans_type = -1\\n trans_sign = 0\\n trans_ind = -1\\n if verbose: nbr=0#print 'initial active features =', nz\\n \\n while mu > mu1:\\n \\n # find the breakpoints where coefficients become zero\\n b_nz = b[nz]\\n Kv1 = np.dot(K, v1)\\n Kb_nz = np.dot(K, b_nz)\\n mu_0 = Kb_nz / Kv1\\n \\n # find the breakpoints where new coefficients become active\\n z = np.setdiff1d(np.arange(m), nz)\\n X_z = np.atleast_2d(X[:, z])\\n b_z = b[z]\\n M = G[np.ix_(z, nz)]\\n MKb_nz = np.dot(M, Kb_nz)\\n MKv1 = np.dot(M, Kv1)\\n mu_1 = (b_z - MKb_nz) / (1 - MKv1)\\n mu_m1 = (b_z - MKb_nz) / (-1 - MKv1)\\n \\n if trans_type > 0: mu_0[-1] = mu1\\n mu_0[mu_0 >= mu] = mu1\\n if len(mu_0) > 0: \\n mu_0_argmax = mu_0.argmax()\\n mu_0_max = mu_0[mu_0_argmax][0]\\n else:\\n mu_0_max = mu1\\n if trans_type == 0:\\n if trans_sign == 1: mu_1[np.where(z == trans_ind)[0]] = mu1 - 1\\n else: mu_m1[np.where(z == trans_ind)[0]] = mu1 - 1\\n mu_1[mu_1 >= mu] = mu1\\n if len(mu_1) > 0: \\n mu_1_argmax = mu_1.argmax()\\n mu_1_max = mu_1[mu_1_argmax][0]\\n else:\\n mu_1_max = mu1\\n mu_m1[mu_m1 >= mu] = mu1\\n if len(mu_m1) > 0: \\n mu_m1_argmax = mu_m1.argmax()\\n mu_m1_max = mu_m1[mu_m1_argmax][0]\\n else:\\n mu_m1_max = mu1\\n \\n # compute the breakpoint\\n mu_br_all = np.array([mu_0_max, mu_1_max, mu_m1_max])\\n trans_type = mu_br_all.argmax()\\n mu_br = mu_br_all[trans_type]\\n \\n if mu_br > mu1:\\n \\n nbr += 1\\n mu = mu_br\\n \\n if trans_type == 0: # an element of theta(t) goes to zero\\n trans_ind = nz[mu_0_argmax]\\n trans_sign = v1[mu_0_argmax]\\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is inactive'%(mu, trans_ind)\\n nzind = range(len(nz))\\n rr=np.where(nz==trans_ind)[0][0]\\n #print 'longa:',len(nz),len(nzind),len(v1)\\n #print 'c:',nz.index(trans_ind)\\n nzind=np.delete(nzind,rr)#nzind=np.delete(nzind,np.where(nzind==nz.index(trans_ind)))#nzind.remove(nz.index(trans_ind))\\n v1 = v1[nzind]\\n nz=np.delete(nz,rr)#nz=np.delete(nz,np.where(nz==trans_ind))#nz.remove(trans_ind)\\n #print 'longa2:',len(nz),len(nzind),len(v1)\\n X_nz = X[:, nz]\\n K = invupdatered(K, mu_0_argmax)\\n else: # new active element\\n if trans_type == 1: # it is positive\\n trans_ind = z[mu_1_argmax]\\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is positive'%(mu, trans_ind)\\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\\n v1 = np.vstack([v1, 1])\\n else: # it is negative\\n trans_ind = z[mu_m1_argmax]\\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is negative'%(mu, trans_ind)\\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\\n v1 = np.vstack([v1, -1])\\n X_new = np.atleast_2d(X[:, trans_ind]).T\\n K = invupdateapp(K, np.dot(X_nz.T, X_new), np.dot(X_new.T, X_nz), \\n np.dot(X_new.T, X_new))\\n X_nz = X[:, nz]\\n \\n else: # compute solution at mu1\\n \\n if verbose: sss=0#print 'compute solution at mu =', mu1\\n theta_nz = Kb_nz - mu1*Kv1\\n mu = mu1\\n \\n return theta_nz, nz, K, nbr\",\n \"def regularize_if_necessary(self) -> None:\\n # As described in [wang2014], all entities and relations are used to compute the regularization term\\n # which enforces the defined soft constraints.\\n super().regularize_if_necessary(\\n self.entity_embeddings.weight,\\n self.normal_vector_embeddings.weight,\\n self.relation_embeddings.weight,\\n )\",\n \"def test_scale_features_L1_norm(self):\\n # Get some data\\n data = array([[0.564, 20.661], [-18.512, 41.168], [-0.009, 20.440]])\\n cdata = CData(data)\\n\\n # Correct answer computed in Mathematica\\n # TODO: can we compute the right answer in Python?\\n answer = array([[0.029552, 0.25114], [-0.969976, 0.500407], [-0.000471575, 0.248453]])\\n\\n # Perform L1 normalization and check answer\\n cdata.scale_features('L1 norm')\\n self.assertTrue(allclose(cdata.data, answer))\",\n \"def update_param(self, lr):\\n\\n\\n self.W=self.W-lr*self.W_grad\\n self.b = self.b - lr*self.b_grad\",\n \"def rl_modelrl_l1_medium():\\n hparams = rl_modelrl_medium()\\n hparams.generative_model_params = \\\"basic_conv_l1\\\"\\n return hparams\",\n \"def shrink(self):\\n x = np.nan_to_num(self.X.values)\\n\\n # de-mean returns\\n t, n = np.shape(x)\\n meanx = x.mean(axis=0)\\n x = x - np.tile(meanx, (t, 1))\\n xmkt = x.mean(axis=1).reshape(t, 1)\\n\\n # compute sample covariance matrix\\n sample = np.cov(np.append(x, xmkt, axis=1), rowvar=False) * (t - 1) / t\\n covmkt = sample[0:n, n].reshape(n, 1)\\n varmkt = sample[n, n]\\n sample = sample[:n, :n]\\n prior = np.dot(covmkt, covmkt.T) / varmkt\\n prior[np.eye(n) == 1] = np.diag(sample)\\n\\n # compute shrinkage parameters\\n if self.delta is None:\\n c = np.linalg.norm(sample - prior, \\\"fro\\\") ** 2\\n y = x ** 2\\n p = 1 / t * np.sum(np.dot(y.T, y)) - np.sum(sample ** 2)\\n # r is divided into diagonal\\n # and off-diagonal terms, and the off-diagonal term\\n # is itself divided into smaller terms\\n rdiag = 1 / t * np.sum(y ** 2) - sum(np.diag(sample) ** 2)\\n z = x * np.tile(xmkt, (n,))\\n v1 = 1 / t * np.dot(y.T, z) - np.tile(covmkt, (n,)) * sample\\n roff1 = (\\n np.sum(v1 * np.tile(covmkt, (n,)).T) / varmkt\\n - np.sum(np.diag(v1) * covmkt.T) / varmkt\\n )\\n v3 = 1 / t * np.dot(z.T, z) - varmkt * sample\\n roff3 = (\\n np.sum(v3 * np.dot(covmkt, covmkt.T)) / varmkt ** 2\\n - np.sum(np.diag(v3).reshape(-1, 1) * covmkt ** 2) / varmkt ** 2\\n )\\n roff = 2 * roff1 - roff3\\n r = rdiag + roff\\n\\n # compute shrinkage constant\\n k = (p - r) / c\\n shrinkage = max(0, min(1, k / t))\\n self.delta = shrinkage\\n else:\\n # use specified constant\\n shrinkage = self.delta\\n\\n # compute the estimator\\n sigma = shrinkage * prior + (1 - shrinkage) * sample\\n return self.format_and_annualise(sigma)\",\n \"def step(self):\\n\\n self.compute_lr()\\n\\n self.optimizer.param_groups[self.param_group]['lr'] = self.lr\\n self.optimizer.param_groups[self.param_group]['momentum'] = self.momentum\",\n \"def poly_adjust_learning_rate(optimizer, lr0, step, n_step):\\n lr = lr0 * (1.0 - step*1.0/n_step)\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\\n return lr\",\n \"def __call__(self, parameters):\\n\\n chosen_rom = self._rng.choice(self.roms)\\n self._ale_handler.set_parameters(rom=chosen_rom,\\n seed=self._rng.randint(1, 2000000))\\n # Update handles\\n self._agent_handler.ale = self._ale_handler.handle\\n self._objective_handler.agent = self._agent_handler.handle\\n self._objective_handler.ale = self._ale_handler.handle\\n\\n return self.cost_normalizer(self._objective_handler.handle(parameters),\\n chosen_rom)\",\n \"def force_rescale(self,rescaleFactor):\\n if not self.built:\\n raise Exception(\\\"model should be built before calling this function\\\")\\n for l in self.layerList:\\n l.rescale(rescaleFactor)\\n self.rescaleFactor.assign(rescaleFactor)\",\n \"def mpt11_w18_2_v2_lr(optimizer, args, **kwargs):\\n\\n def _lr_adjuster(epoch, iteration):\\n if epoch >= 35:\\n lr = args.lr * 0.1\\n\\n if epoch >= 50:\\n lr = lr * 0.1\\n\\n if epoch >= 60:\\n lr = lr * 0.01\\n else:\\n lr = args.lr\\n\\n assign_learning_rate(optimizer, lr)\\n\\n return lr\\n\\n return _lr_adjuster\",\n \"def scale_lambda(self, lmbd, nr_iterations, lmbd_schedule = 500000):\\n self.scaled_lambda = lmbd * float(min(lmbd_schedule,nr_iterations)) / lmbd_schedule\",\n \"def mpt11_w34_2_v2_lr(optimizer, args, **kwargs):\\n\\n def _lr_adjuster(epoch, iteration):\\n if epoch >= 50:\\n lr = args.lr * 0.1\\n\\n if epoch >= 62:\\n lr = lr * 0.1\\n\\n if epoch >= 70:\\n lr = lr * 0.01\\n else:\\n lr = args.lr\\n\\n assign_learning_rate(optimizer, lr)\\n\\n return lr\\n\\n return _lr_adjuster\",\n \"def b1relu( regularizers, x):\\n N, M, F = x.get_shape()\\n b = _bias_variable(regularizers,[1, 1, int(F)], regularization=True)\\n return tf.nn.relu(x + b)\",\n \"def l21_reg(data):\\n m = data.size()[0] # number of data points\\n n = data.size()[1] # number of dimensions on the data points\\n # find L2,1 regularization term\\n outer_sum = 0\\n for i in range(m):\\n inner_sum = 0\\n for j in range(n):\\n inner_sum += data[i][j] ** 2\\n outer_sum += inner_sum ** 0.5\\n return outer_sum\",\n \"def fill(self, recoValue, l1Value, weight=1.):\\n self._total.fill(recoValue, weight)\\n self._dist.fill(l1Value, weight)\\n if l1Value > self._threshold:\\n self._pass.fill(recoValue, weight)\",\n \"def adjust_learning_rate(self, optimizer, batch, learning_rate, steps, scales, batch_size):\\n lr = learning_rate\\n for i in range(len(steps)):\\n scale = scales[i] if i < len(scales) else 1\\n if batch >= steps[i]:\\n lr = lr * scale\\n if batch == steps[i]:\\n break\\n else:\\n break\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr/batch_size\\n return lr\",\n \"def adagrad_l1_update(loss, w, l1, learning_rate=1.0):\\n g = theano.grad(loss, w) # (tef_n, )\\n updates = OrderedDict()\\n\\n # for each gradient-weights vector pair compile the following\\n\\n # empty initializations, later of size (tef_n, )\\n # maximum penalty accumulator\\n u = theano.shared(np.zeros(1, dtype=theano.config.floatX), broadcastable=w.broadcastable)\\n\\n # actual accumulated penalties\\n q = theano.shared(np.zeros(1, dtype=theano.config.floatX), broadcastable=w.broadcastable)\\n\\n # squared gradients accumulator\\n gg = theano.shared(np.zeros(1, dtype=theano.config.floatX), broadcastable=w.broadcastable)\\n\\n # adagrad learning rate upgrade\\n gradient_squared_accu_new = gg + g ** 2 # (tef_n, )\\n adagrad_learning_rate = learning_rate / T.sqrt(gradient_squared_accu_new)\\n\\n # total possible accumulated l1 penalty\\n u_new = u + l1 * adagrad_learning_rate\\n\\n # update rule: w_k+1/2,i = w_k,i - adagrad_lr_k * g_i\\n w_tmp = w - adagrad_learning_rate * g\\n\\n # apply penalties\\n if T.gt(l1, 0):\\n # if w_k+1/2,i > 0: w_k+1,i = max(0, w_k+1/2,i - (u_k,i + q_k-1,i)) else if: ...\\n w_update = T.switch(T.gt(w_tmp, 0.),\\n T.maximum(w_tmp - (u_new + q), 0.), # w_tmp > 0\\n T.switch(T.lt(w_tmp, 0.0),\\n T.minimum(w_tmp + (u_new - q), 0.), # w_tmp < 0\\n 0.) # w_tmp == 0\\n )\\n else:\\n w_update = w_tmp\\n\\n # return updates (key: shared variable, value: symbolic variable)\\n updates[w] = w_update\\n updates[gg] = gradient_squared_accu_new\\n updates[u] = u_new\\n # actually accumulated penalty\\n updates[q] = q + w_update - w_tmp\\n\\n return updates, u, q, gg\",\n \"def _finalize_leaf(self, node):\\n node.value = -self.shrinkage * node.sum_gradients / (\\n node.sum_hessians + self.splitter.l2_regularization)\\n self.finalized_leaves.append(node)\",\n \"def shrink(self):\\n x = np.nan_to_num(self.X.values)\\n\\n # de-mean returns\\n t, n = np.shape(x)\\n meanx = x.mean(axis=0)\\n x = x - np.tile(meanx, (t, 1))\\n\\n # compute sample covariance matrix\\n sample = (1.0 / t) * np.dot(x.T, x)\\n\\n # compute prior\\n var = np.diag(sample).reshape(-1, 1)\\n sqrtvar = np.sqrt(var)\\n _var = np.tile(var, (n,))\\n _sqrtvar = np.tile(sqrtvar, (n,))\\n r_bar = (np.sum(sample / (_sqrtvar * _sqrtvar.T)) - n) / (n * (n - 1))\\n prior = r_bar * (_sqrtvar * _sqrtvar.T)\\n prior[np.eye(n) == 1] = var.reshape(-1)\\n\\n # compute shrinkage parameters and constant\\n if self.delta is None:\\n\\n # what we call pi-hat\\n y = x ** 2.0\\n phi_mat = np.dot(y.T, y) / t - 2 * np.dot(x.T, x) * sample / t + sample ** 2\\n phi = np.sum(phi_mat)\\n\\n # what we call rho-hat\\n term1 = np.dot((x ** 3).T, x) / t\\n help_ = np.dot(x.T, x) / t\\n help_diag = np.diag(help_)\\n term2 = np.tile(help_diag, (n, 1)).T * sample\\n term3 = help_ * _var\\n term4 = _var * sample\\n theta_mat = term1 - term2 - term3 + term4\\n theta_mat[np.eye(n) == 1] = np.zeros(n)\\n rho = sum(np.diag(phi_mat)) + r_bar * np.sum(\\n np.dot((1.0 / sqrtvar), sqrtvar.T) * theta_mat\\n )\\n\\n # what we call gamma-hat\\n gamma = np.linalg.norm(sample - prior, \\\"fro\\\") ** 2\\n\\n # compute shrinkage constant\\n kappa = (phi - rho) / gamma\\n shrinkage = max(0.0, min(1.0, kappa / t))\\n self.delta = shrinkage\\n else:\\n # use specified constant\\n shrinkage = self.delta\\n\\n # compute the estimator\\n sigma = shrinkage * prior + (1 - shrinkage) * sample\\n return self.format_and_annualise(sigma)\",\n \"def rl_modelrl_l1_base():\\n hparams = rl_modelrl_base()\\n hparams.generative_model_params = \\\"basic_conv_l1\\\"\\n return hparams\",\n \"def _step(self, w1, y1,y1_short):\\n\\n #reajust the return y1 using the sign of w1\\n #if is negative means we shorted so the return is the inverse\\n\\n y1_aux=y1.copy()\\n for i in range(len(w1)):\\n if(w1[i]<0):\\n y1_aux[i]=y1_short[i]\\n y1=y1_aux.copy()\\n\\n\\n\\n\\n #print (\\\"enter step\\\")\\n assert w1.shape == y1.shape, 'w1 and y1 must have the same shape'\\n assert y1[0] == 1.0, 'y1[0] must be 1'\\n\\n p0 = self.p0\\n\\n dw1 = (y1 * w1) / (np.dot(y1, w1) + eps) # (eq7) weights evolve into\\n\\n mu1 = self.cost * (np.abs(dw1 - w1)).sum() # (eq16) cost to change portfolio\\n\\n assert mu1 < 1.0, 'Cost is larger than current holding'\\n\\n p1 = p0 * (1 - mu1) * np.dot(y1, w1) # (eq11) final portfolio value\\n\\n p1 = p1 * (1 - self.time_cost) # we can add a cost to holding\\n\\n rho1 = p1 / p0 - 1 # rate of returns\\n r1 = np.log((p1 + eps) / (p0 + eps)) # log rate of return\\n reward = r1 / self.steps * 1000. # (22) average logarithmic accumulated return\\n # remember for next step\\n self.p0 = p1\\n\\n # if we run out of money, we're done (losing all the money)\\n done = p1 == 0\\n\\n\\n info = {\\n \\\"reward\\\": reward,\\n \\\"log_return\\\": r1,\\n \\\"portfolio_value\\\": p1,\\n \\\"return\\\": y1.mean(),\\n \\\"rate_of_return\\\": rho1,\\n \\\"weights_mean\\\": w1.mean(),\\n \\\"weights_std\\\": w1.std(),\\n \\\"cost\\\": mu1,\\n }\\n\\n #print (info)\\n\\n self.infos.append(info)\\n return reward, info, done\",\n \"def adjust_learning_rate(optimizer, gamma, step):\\n global lr\\n lr = lr * (gamma ** (step))\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\",\n \"def _cook_optimizer(self, \\n lr = 0.01, \\n optimizer = 'sgd',\\n l1_coeff = 0.00001,\\n l2_coeff = 0.00001):\\n with tf.variable_scope (self.name + '_train') as scope:\\n apply_regularizer (name = self.name, var_list = tf.get_collection(\\n self.name + '_regularizer_worthy_params'), \\n l1_coeff = l1_coeff,\\n l2_coeff = l2_coeff )\\n self.obj = tf.add_n(tf.get_collection( self.name + '_objectives'), name='objective')\\n tf.summary.scalar('total_objective', self.obj)\\n\\n # Change (supply as arguments) parameters here directly in the code.\\n if optimizer == 'sgd': \\n self.back_prop = apply_gradient_descent(var_list = tf.get_collection(\\n self.name + '_trainable_params'),\\n obj = self.obj, learning_rate = lr )\\n elif optimizer == 'adagrad': \\n self.back_prop = apply_adagrad(var_list = tf.get_collection(\\n self.name + '_trainable_params'),\\n obj = self.obj, learning_rate = lr ) \\n elif optimizer == 'rmsprop':\\n self.back_prop = apply_rmsprop(var_list = tf.get_collection(\\n self.name + '_trainable_params') ,\\n obj = self.obj, learning_rate = lr)\\n elif optimizer == 'adam':\\n self.back_prop = apply_adam (var_list = tf.get_collection(\\n self.name + '_trainable_params') ,\\n obj = self.obj, learning_rate = lr )\\n else:\\n raise Error('Invalid entry to optimizer')\",\n \"def mpt132_w34_2_lr(optimizer, args, **kwargs):\\n\\n def _lr_adjuster(epoch, iteration):\\n if epoch >= 27:\\n lr = args.lr * 0.1\\n\\n if epoch >= 44:\\n lr = lr * 0.1\\n\\n if epoch >= 54:\\n lr = lr * 0.01\\n else:\\n lr = args.lr\\n\\n assign_learning_rate(optimizer, lr)\\n\\n return lr\\n\\n return _lr_adjuster\",\n \"def greedy_shrink(self):\\n while self.single_greedy_shrink_iteration():\\n self.run_shrink_pass(\\\"lower_common_block_offset\\\")\",\n \"def g1(self, nx, ny, x_des):\\n\\n # :evaluating unscaled constraints at the initial point\\n g_1_0 = self.g1_unscaled(nx, ny, .5 * np.ones(4 * nx + 5 * ny))\\n\\n # :evaluating unscaled constraints:\\n g_1 = self.g1_unscaled(nx, ny, x_des)\\n\\n # :define the threshold \\\"tow\\\" to translate the scaled constraint\\n # :alpha determines to what extent the inactive constraints are satisfied\\n tow, alpha = [], self.alpha_g1\\n [tow.append(i) if self.mu_g1[list(g_1_0).index(i)] < self.p else tow.append(alpha + (1 - alpha) * i) for i in g_1_0]\\n\\n # define the translated constraint\\n g_1_translated = []\\n [g_1_translated.append(g_1[i] - tow[i]) for i in range(nx)]\\n return g_1_translated\",\n \"def pre_phasing_r1(self, pre_phasing_r1):\\n\\n self._pre_phasing_r1 = pre_phasing_r1\",\n \"def step_adjust_learning_rate(optimizer, lr0, step, step_size, gamma):\\n\\n if len(step_size) == 0:\\n lr = lr0 * (gamma ** (step // step_size))\\n else:\\n lr = lr0 * gamma ** (sum([step > i for i in step_size]))\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\\n return lr\",\n \"def _adjust_learning_rate(self, optimizer, lr):\\n\\n if len(optimizer.param_groups) == 1:\\n optimizer.param_groups[0]['lr'] = lr\\n else:\\n # enlarge the lr at the head\\n optimizer.param_groups[0]['lr'] = lr\\n for i in range(1, len(optimizer.param_groups)):\\n optimizer.param_groups[i]['lr'] = lr * 10\",\n \"def shrink(self):\\n self.mass *= 0.8\",\n \"def _step2_optimization_closure(self, iteration, step):\\n if iteration == self.num_iter_second_step - 1:\\n reg_noise_std = 0\\n else:\\n reg_noise_std = (1 / 1000.) * (iteration // 700)\\n\\n aug = self._get_augmentation(iteration)\\n if iteration == self.num_iter_second_step - 1:\\n aug = 0\\n # creates left_net_inputs and right_net_inputs by adding small noise\\n clean_net_input = self.clean_net_inputs[aug] + (self.clean_net_inputs[aug].clone().normal_() * reg_noise_std)\\n watermark_net_input = self.watermark_net_inputs[aug] + (self.watermark_net_inputs[aug].clone().normal_() * reg_noise_std)\\n mask_net_input = self.mask_net_inputs[aug] # + (self.mask_net_input.clone().normal_() * reg_noise_std)\\n # applies the nets\\n self.clean_net_output = self.clean_net(clean_net_input)\\n self.watermark_net_output = self.watermark_net(watermark_net_input)\\n self.mask_net_output = self.mask_net(mask_net_input)\\n self.total_loss = 0\\n # loss on clean region\\n self.total_loss += self.extended_l1_loss(self.clean_net_output,\\n self.image_torchs[aug],\\n (1 - self.watermark_hint_torchs[aug]))\\n # loss in second region\\n self.total_loss += 0.5 * self.l1_loss(self.watermark_hint_torchs[aug] *\\n self.mask_net_output * self.watermark_net_output\\n +\\n (1 - self.mask_net_output) * self.clean_net_output,\\n self.image_torchs[aug]) # this part learns the watermark\\n self.total_loss.backward(retain_graph=True)\",\n \"def learn(self, Xtrain, ytrain):\\n pass\\n self.weights = np.zeros(Xtrain.shape[1],)\\n\\n ### YOUR CODE HERE\\n \\n lmbd = self.params['lamb']\\n \\n numsamples = Xtrain.shape[0]\\n # Xless = Xtrain[:,self.params['features']]\\n Xless = Xtrain\\n self.weights = np.random.rand(Xless.shape[1])\\n err = 10000;\\n #cw =0;\\n tolerance = 10*np.exp(-4)\\n i=0;\\n \\n \\n w1 = self.weights\\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, self.weights.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain) + lmbd * self.regularizer[0](self.weights)\\n # print(cw)\\n errors = []\\n runtm = []\\n epch = []\\n \\n err = 1\\n iteration= 1000\\n #tm= time.time()\\n while (abs(cw-err)>tolerance) and (i <iteration):\\n err = cw\\n g = self.logit_cost_grad(cw_v, Xless, ytrain)\\n obj = cw\\n j=0\\n ita = -1* self.params['stepsize']\\n w = self.weights\\n # w1 = np.add(w,np.dot(ita,g))\\n while(j<iteration):\\n w1 = np.add(w,np.dot(ita,g))\\n # cw_v =(np.dot(Xless, w1)-ytrain)\\n # cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, w1.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain)+lmbd * self.regularizer[0](w1)\\n ## print (cw)\\n \\n if(cw<np.absolute(obj-tolerance)): ############################################\\n break\\n ita = 0.7*ita\\n j=j+1\\n \\n if(j==iteration):\\n self.weights=w\\n ita =0\\n else:\\n self.weights = w1\\n \\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, self.weights.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain)\\n #tm1 = time.time()-tm\\n #runtm.append(tm1)\\n #err = cw\\n errors.append(err)\\n i=i+1\\n epch.append(i)\",\n \"def optimize_parameters(self):\\n pass\",\n \"def optimize_parameters(self):\\n pass\",\n \"def optimize_parameters(self):\\n pass\",\n \"def LinReg_fit(X, y, X_test=None, y_test=None, lr=1e-7, batch=1, lamb=0,\\n epoch=10000, print_every=100, lamb1=0, momentum=0):\\n # initialize\\n W = np.random.randn(X.shape[1]) / X.shape[1] / X.shape[0]\\n\\n train_loss = []\\n train_RMSE = []\\n test_loss = []\\n test_RMSE = []\\n\\n # batch size indicator\\n b = 0\\n # cache for adagrad\\n G = np.zeros(W.shape)\\n\\n for i in range(epoch):\\n inds = []\\n last_step = 0\\n\\n for j in np.random.permutation(X.shape[0]):\\n inds.append(j)\\n b += 1\\n\\n # do the adagrad to update the parameter\\n if b >= batch:\\n diff = X[inds].dot(W) - y[inds]\\n\\n # calculate gradients\\n w = np.array(W)\\n w[w > 0] = 1\\n w[w < 0] = -1\\n grad_X = X[inds].T.dot(diff)\\n grad_regulariz = lamb * W * batch / X.shape[0]\\n grad_first_order_reg = lamb1 * w * batch / X.shape[0]\\n grad = grad_X + grad_regulariz + grad_first_order_reg\\n\\n # calculate update step\\n G += grad**2\\n delta_W = (grad + momentum * last_step) / np.sqrt(G)\\n W -= lr * delta_W\\n\\n # reset variables\\n last_step = delta_W\\n b = 0\\n inds = []\\n\\n objective = (((X.dot(W) - y)**2).sum() + lamb * (W**2).sum()) / 2.0\\n RMSE = cal_RMSE(X, W, y)\\n\\n if X_test is not None and y_test is not None:\\n # losses\\n loss_X = ((X_test.dot(W) - y_test)**2).sum() / 2.0\\n loss_reg = lamb * (W**2).sum() / 2.0\\n loss_first_reg = lamb1 * (abs(W).sum())\\n\\n obj_t = loss_X + loss_reg + loss_first_reg\\n RMSE_t = cal_RMSE(X_test, W, y_test)\\n\\n test_loss.append(obj_t)\\n test_RMSE.append(RMSE_t)\\n\\n # print out the progress\\n if i % print_every == 0:\\n if X_test is not None and y_test is not None:\\n print('\\\\tepoch: %d; obj: %.4f; RMSE: %.4f; RMSE_test: %.4f' %\\n (i, objective, RMSE, RMSE_t))\\n else:\\n print('\\\\tepoch: %d; obj: %.4f; RMSE: %.4f' %\\n (i, objective, RMSE))\\n\\n train_loss.append(objective)\\n train_RMSE.append(RMSE)\\n\\n print('final obj: %.4f' % train_loss[-1])\\n\\n return W, train_loss, train_RMSE, test_loss, test_RMSE\",\n \"def adjust_learning_rate(optimizer, gamma, step):\\r\\n lr = args.lr * (gamma ** (step))\\r\\n for param_group in optimizer.param_groups:\\r\\n param_group['lr'] = lr\",\n \"def _calc_smooth_loss(self, loss, len_examples, regularizer_type=None):\\n if regularizer_type == 'L2':\\n # Add regulatization term to loss\\n\\n return 1./len_examples * loss\\n else:\\n return 1./len_examples * loss\",\n \"def adjust_learning_rate(optimizer, gamma, step):\\n lr = args.lr * (0.8 ** step)\\n print(lr)\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\",\n \"def __call__(self, step):\\n\\n # decrease linearly\\n steprate = math_ops.abs(math_ops.divide(\\n math_ops.subtract(self.finallr, self.initlr), self.nsteps))\\n\\n lr = math_ops.subtract(self.initlr, math_ops.multiply(\\n steprate, math_ops.subtract(step, self.shiftstep)))\\n\\n pred = math_ops.greater(step, self.shiftstep)\\n lr = control_flow_ops.cond(pred, lambda: lr, lambda: self.initlr)\\n\\n return lr\",\n \"def compute_gradient_and_loss1(W, X, y, reg, reg_type, opt):\\n if opt == 0: # compute gradient only if opt == 0\\n dW = np.zeros(W.shape) # initialize the gradient as zero\\n \\n # compute the loss and the gradient\\n num_classes = W.shape[1]\\n num_train = X.shape[0]\\n loss = 0.0\\n #############################################################################\\n # TODO: #\\n # Implement the routine to compute the loss, storing the result in loss #\\n ############################################################################# \\n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\\n s = X[i].dot(W) # compute s (scores)\\n s_y = s[y[i]] # keep the correct ground truth class score\\n for j in xrange(num_classes): # for every class\\n if j != y[i]: # don't take the correct ground truth index\\n term = s[j] - s_y + 1 # max term with Delta = 1, according to Hinge loss formula\\n if term > 0: # trick: take only the term > 0, equal to max(0,...) formula\\n loss += term # add the possitive term \\n if opt == 0: # compute gradient only if opt == 0\\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\\n dW[:, y[i]] -= X[i] # case j==y[i]\\n\\n# loss /= num_train # num_train = M, according to given formula \\n\\n if reg_type == 1: # loss + regularization , l2 or l1\\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\\n else:\\n loss += reg * np.sum(W * W) # l2\\n \\n if opt == 0: # compute gradient only if opt == 0\\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\\n if reg_type == 1: # we use deriv_abs function for l1 derivative\\n dW += reg * deriv_abs(W)\\n else:\\n dW += 2 * reg * W # l2 derivative formula\\n \\n return loss, dW\\n else:\\n return loss, None\\n \\n print 'CSFAK INSIDE compute_gradient_and_loss'\\n #############################################################################\\n # TODO: #\\n # Implement the gradient for the required loss, storing the result in dW.\\t #\\n # #\\n # Hint: Instead of computing the gradient from scratch, it may be easier #\\n # to reuse some of the intermediate values that you used to compute the #\\n # loss. #\\n #############################################################################\\n \\n #pass\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\",\n \"def adjust_learning_rate(optimizer, epoch, args, step):\\n lr = args.lr * (0.1 ** (epoch // step))\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\",\n \"def get_regularizer(type, l1, l2):\\n if type == 'l1':\\n reg = keras.regularizers.l1(l1)\\n elif type == 'l2':\\n reg = keras.regularizers.l2(l2)\\n elif type == 'l1_l2':\\n reg = keras.regularizers.l1_l2(l1, l2)\\n else:\\n reg = None\\n return reg\",\n \"def step_and_update_lr(self):\\r\\n self._update_learning_rate()\\r\\n self._optimizer.step()\",\n \"def step_update(self, num_updates):\\n cycle = math.floor(num_updates / (2 * self.stepsize))\\n\\n lr_shrink = self.lr_shrink ** cycle\\n max_lr = self.max_lr * lr_shrink\\n if self.shrink_min:\\n min_lr = self.min_lr * lr_shrink\\n else:\\n min_lr = self.min_lr\\n\\n x = abs(num_updates / self.stepsize - 2 * (cycle + 1) + 1)\\n self.lr = min_lr + (max_lr - min_lr) * max(0, (1 - x))\\n\\n self.optimizer.set_lr(self.lr)\\n return self.lr\",\n \"def update_lr(epoch, optimizer, args):\\n gamma = 0\\n for step in args.step:\\n if epoch + 1.0 > int(step):\\n gamma += 1\\n lr = args.lr * math.pow(0.1, gamma)\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\",\n \"def set_lam_kld_l1l2(self, lam_kld_l1l2=1.0):\\n zero_ary = np.zeros((1,))\\n new_val = zero_ary + lam_kld_l1l2\\n self.lam_kld_l1l2.set_value(to_fX(new_val))\\n return\",\n \"def adjust_learning_rate_step(optimizer, epoch, steps, gamma=0.1):\\n if epoch in steps:\\n for param_group in optimizer.param_groups:\\n lr = param_group['lr']*gamma\\n param_group['lr'] = lr\",\n \"def _sa1():\\n The.optimize.early=4\\n sa(ZDT1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6826777","0.61285764","0.6045434","0.59946656","0.59823173","0.5980362","0.59782636","0.5918527","0.58867913","0.57994086","0.57767415","0.57330287","0.57198095","0.56476456","0.55648047","0.5526961","0.5520416","0.5410303","0.5392533","0.5335324","0.5330576","0.53217465","0.53217465","0.5307455","0.53030574","0.529683","0.5290117","0.5284549","0.52834356","0.5252479","0.5198402","0.517758","0.5174212","0.5172272","0.51533705","0.5149048","0.51370454","0.5133902","0.5125352","0.5116431","0.5116041","0.511203","0.50996584","0.5094563","0.50939375","0.5087832","0.5078715","0.5063783","0.50594515","0.5051762","0.5041421","0.5026431","0.5014764","0.5014555","0.50038415","0.5000279","0.4998101","0.49880525","0.4979811","0.4974887","0.49647364","0.4961942","0.49562496","0.49471116","0.49342456","0.49304304","0.49260917","0.49219373","0.49174172","0.4913719","0.49046057","0.4902749","0.48977107","0.48960564","0.48922652","0.4888854","0.4888388","0.4887651","0.4887014","0.48867163","0.48858342","0.48845255","0.48808917","0.48788226","0.48788226","0.48788226","0.48775983","0.4875057","0.4870537","0.48698896","0.48681214","0.48650077","0.48586217","0.4856559","0.4849653","0.4847591","0.4846284","0.48316345","0.48301786","0.48283955"],"string":"[\n \"0.6826777\",\n \"0.61285764\",\n \"0.6045434\",\n \"0.59946656\",\n \"0.59823173\",\n \"0.5980362\",\n \"0.59782636\",\n \"0.5918527\",\n \"0.58867913\",\n \"0.57994086\",\n \"0.57767415\",\n \"0.57330287\",\n \"0.57198095\",\n \"0.56476456\",\n \"0.55648047\",\n \"0.5526961\",\n \"0.5520416\",\n \"0.5410303\",\n \"0.5392533\",\n \"0.5335324\",\n \"0.5330576\",\n \"0.53217465\",\n \"0.53217465\",\n \"0.5307455\",\n \"0.53030574\",\n \"0.529683\",\n \"0.5290117\",\n \"0.5284549\",\n \"0.52834356\",\n \"0.5252479\",\n \"0.5198402\",\n \"0.517758\",\n \"0.5174212\",\n \"0.5172272\",\n \"0.51533705\",\n \"0.5149048\",\n \"0.51370454\",\n \"0.5133902\",\n \"0.5125352\",\n \"0.5116431\",\n \"0.5116041\",\n \"0.511203\",\n \"0.50996584\",\n \"0.5094563\",\n \"0.50939375\",\n \"0.5087832\",\n \"0.5078715\",\n \"0.5063783\",\n \"0.50594515\",\n \"0.5051762\",\n \"0.5041421\",\n \"0.5026431\",\n \"0.5014764\",\n \"0.5014555\",\n \"0.50038415\",\n \"0.5000279\",\n \"0.4998101\",\n \"0.49880525\",\n \"0.4979811\",\n \"0.4974887\",\n \"0.49647364\",\n \"0.4961942\",\n \"0.49562496\",\n \"0.49471116\",\n \"0.49342456\",\n \"0.49304304\",\n \"0.49260917\",\n \"0.49219373\",\n \"0.49174172\",\n \"0.4913719\",\n \"0.49046057\",\n \"0.4902749\",\n \"0.48977107\",\n \"0.48960564\",\n \"0.48922652\",\n \"0.4888854\",\n \"0.4888388\",\n \"0.4887651\",\n \"0.4887014\",\n \"0.48867163\",\n \"0.48858342\",\n \"0.48845255\",\n \"0.48808917\",\n \"0.48788226\",\n \"0.48788226\",\n \"0.48788226\",\n \"0.48775983\",\n \"0.4875057\",\n \"0.4870537\",\n \"0.48698896\",\n \"0.48681214\",\n \"0.48650077\",\n \"0.48586217\",\n \"0.4856559\",\n \"0.4849653\",\n \"0.4847591\",\n \"0.4846284\",\n \"0.48316345\",\n \"0.48301786\",\n \"0.48283955\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61554843"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":13286,"cells":{"query":{"kind":"string","value":"Creates a new column called \"state_name\" which has the corresponding state name."},"document":{"kind":"string","value":"def convert_names(self):\n names_map = {\n \"AL\": \"Alabama\",\n \"CT\": \"Conn\",\n \"CA\": \"Cali\",\n \"CO\": \"Colo\",\n \"DC\": \"District of Columbia\"\n }\n self[\"state_name\"] = self[\"abbrev\"].map(names_map)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def state_name(self):\n return self.state.name if self.state else None","def _state_name(self):\n return '{}_{}'.format(self.function_name, self.STATE_CONFIG_SUFFIX)","def state_name(self):\n return task_states.to_str(self.state)","def test_state_name(self):\n state = State('test-state')\n self.assertEqual(state.name, 'test-state')","def createStateTable(self):\r\n tableName = self._names['state']\r\n con = None\r\n try:\r\n con = sql.connect(self._filename, timeout=10, \r\n isolation_level=\"IMMEDIATE\")\r\n with con:\r\n c = con.cursor()\r\n c.execute(\"CREATE TABLE IF NOT EXISTS \"\r\n \"{}(id INTEGER PRIMARY KEY, manager TEXT, \"\r\n \"module TEXT, state TEXT)\".format(tableName))\r\n finally:\r\n _closeConnection(con)\r\n return tableName","def state_to_abbreviation(state: str, df: pd.DataFrame) -> str:\n\n return df.loc[df['State Name'] == state.title(), 'State Abbreviation'].iloc[0]","def create_user_state_table():\n connection = connection_to_db()\n cursor = connection.cursor()\n\n cursor.execute(\n \"CREATE TABLE IF NOT EXISTS user_state \"\n \"(id serial PRIMARY KEY, \"\n \"user_id INTEGER NOT NULL, \"\n \"state INTEGER DEFAULT 0);\"\n )\n\n connection.commit()","def sample_name_colname(self):\n return SAMPLE_NAME_ATTR \\\n if SAMPLE_NAME_ATTR == self.st_index else self.st_index","def state(self, state: \"str\"):\n if isinstance(state, Enum):\n self._attrs[\"state\"] = state.value\n else:\n self._attrs[\"state\"] = state # If you supply a string, we presume you know the service will take it.","def test_query_new_column(self):\n session = self.prepare(user_table=True)\n\n session.execute((\"CREATE MATERIALIZED VIEW users_by_state2 AS SELECT state, username FROM users \"\n \"WHERE STATE IS NOT NULL AND USERNAME IS NOT NULL PRIMARY KEY (state, username)\"))\n\n self._insert_data(session)\n\n assert_one(\n session,\n \"SELECT * FROM users_by_state2 WHERE state = 'TX' AND username = 'user1'\",\n ['TX', 'user1']\n )\n\n session.execute(\"ALTER TABLE users ADD first_name varchar;\")\n\n results = list(session.execute(\"SELECT * FROM users_by_state2 WHERE state = 'TX' AND username = 'user1'\"))\n assert len(results) == 1\n assert not hasattr(results[0], 'first_name'), 'Column \"first_name\" found in view'\n assert_one(\n session,\n \"SELECT * FROM users_by_state2 WHERE state = 'TX' AND username = 'user1'\",\n ['TX', 'user1']\n )","def test_rename_column(self):\n session = self.prepare(user_table=True)\n\n self._insert_data(session)\n\n assert_one(\n session,\n \"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\",\n ['TX', 'user1', 1968, 'f', 'ch@ngem3a', None]\n )\n\n session.execute(\"ALTER TABLE users RENAME username TO user\")\n\n results = list(session.execute(\"SELECT * FROM users_by_state WHERE state = 'TX' AND user = 'user1'\"))\n assert len(results) == 1\n assert hasattr(results[0], 'user'), 'Column \"user\" not found'\n assert_one(\n session,\n \"SELECT state, user, birth_year, gender FROM users_by_state WHERE state = 'TX' AND user = 'user1'\",\n ['TX', 'user1', 1968, 'f']\n )","def format_state(data):\n if us.states.lookup(data) is None:\n return None\n else:\n return us.states.lookup(data).name","def state_abbreviated():\r\n\r\n cursor.execute('SELECT * FROM american_cities_with_states \\\r\n order by RANDOM() limit 1;')\r\n return (cursor.fetchone()[0])[-2:]","def get_lookup_state(self, state):\n return \"\".join(map(str, state))","def state(self, state: str) -> None:","def set_column_name(self, name):\r\n self.column_name = name","def set_column_name(self, name):\r\n self.column_name = name","def create_state():\n if not request.json:\n abort(400, \"Not a JSON\")\n if 'name' not in request.json:\n abort(400, \"Missing name\")\n state = models.state.State(name=request.json['name'])\n state.save()\n return jsonify(state.to_dict()), 201","def native_value(self) -> str:\n if isinstance(self._state, Enum):\n return self._state.name.lower()\n return self._state.lower()","def rename(self, newname):\n # set the new column name\n self.colname = newname","def _create_new_state(\n self,\n new_state: str,\n prev_state: CircuitBreakerState | None = None,\n notify: bool = False,\n ) -> CBStateType:\n state_map: dict[str, Type[CBStateType]] = {\n STATE_CLOSED: CircuitClosedState,\n STATE_OPEN: CircuitOpenState,\n STATE_HALF_OPEN: CircuitHalfOpenState,\n }\n try:\n cls = state_map[new_state]\n return cls(self, prev_state=prev_state, notify=notify)\n except KeyError:\n msg = \"Unknown state {!r}, valid states: {}\"\n raise ValueError(msg.format(new_state, \", \".join(state_map)))","def append_state_label(symbol):\n\t\tif symbol == \"c\":\n\t\t\tself.state_label = self.state_label.replace(\"o\", \"\")\n\t\tif symbol == \"d\":\n\t\t\tself.state_label = self.state_label.replace(\"k\", \"\")\n\t\telse:\n\t\t\tself.state_label += symbol","def add_state(self, name, on_enter=None, on_exit=None):\n args = locals()\n del args['self']\n self.states.append(State(**args))","def add_state(self, name, on_enter=None, on_exit=None):\n args = locals()\n del args['self']\n self.states.append(State(**args))","def upgrade_state_dict_named(self, state_dict, name):\n return state_dict","def _update_column_name(self, column, idx, old_name, name):\n dtype = self.dtype\n # Updating the names on the dtype should suffice\n dtype.names = dtype.names[:idx] + (name,) + dtype.names[idx + 1 :]","def create_state():\n state_json = request.get_json(silent=True)\n if not state_json:\n return jsonify({'error': 'Not a JSON'}), 400\n if 'name' not in state_json:\n return jsonify({'error': 'Missing name'}), 400\n state = State(**state_json)\n state.save()\n return jsonify(state.to_dict()), 201","def addState(self, s=[]):\n k = State(len(self.states))\n if s != []:\n for x in s:\n k.addRow(x[0], x[1][0], x[1][1], x[1][2])\n self.states.append(k)","def state_name(self):\n return TASK_STATE.get(self.state, 'UNKNOWN')","def get_state(self, state_description, dt, class_=State):\n dt = pd.Timestamp(dt)\n names = state_description.keys()\n name_value_mapping = {name: self.get(name, dt) for name in names}\n return state_description.to_state(class_, **name_value_mapping)","def test_create_state(self):\n state_2 = State('name=\"California\"')\n self.assertEqual(state_2.name, 'California')","def rename_column(self, table_name, old, new):\r\n self._remake_table(table_name, renames={old: new})","def create_state():\n state_json = request.get_json()\n if state_json is None:\n abort(400, 'Not a JSON')\n if state_json.get('name') is None:\n abort(400, \"Missing name\")\n state = State(**state_json)\n storage.new(state)\n storage.save()\n return jsonify(state.to_dict()), 201","def add_fsm_state_names():\n from migen.fhdl.visit import NodeTransformer\n from migen.genlib.fsm import NextState, NextValue, _target_eq\n from migen.fhdl.bitcontainer import value_bits_sign\n\n class My_LowerNext(NodeTransformer):\n def __init__(self, next_state_signal, next_state_name_signal, encoding,\n aliases):\n self.next_state_signal = next_state_signal\n self.next_state_name_signal = next_state_name_signal\n self.encoding = encoding\n self.aliases = aliases\n # (target, next_value_ce, next_value)\n self.registers = []\n\n def _get_register_control(self, target):\n for x in self.registers:\n if _target_eq(target, x[0]):\n return x[1], x[2]\n raise KeyError\n\n def visit_unknown(self, node):\n if isinstance(node, NextState):\n try:\n actual_state = self.aliases[node.state]\n except KeyError:\n actual_state = node.state\n return [\n self.next_state_signal.eq(self.encoding[actual_state]),\n self.next_state_name_signal.eq(\n int.from_bytes(actual_state.encode(), byteorder=\"big\"))\n ]\n elif isinstance(node, NextValue):\n try:\n next_value_ce, next_value = self._get_register_control(\n node.target)\n except KeyError:\n related = node.target if isinstance(node.target,\n Signal) else None\n next_value = Signal(bits_sign=value_bits_sign(node.target),\n related=related)\n next_value_ce = Signal(related=related)\n self.registers.append(\n (node.target, next_value_ce, next_value))\n return next_value.eq(node.value), next_value_ce.eq(1)\n else:\n return node\n\n import migen.genlib.fsm as fsm\n\n def my_lower_controls(self):\n self.state_name = Signal(len(max(self.encoding, key=len)) * 8,\n reset=int.from_bytes(\n self.reset_state.encode(),\n byteorder=\"big\"))\n self.next_state_name = Signal(len(max(self.encoding, key=len)) * 8,\n reset=int.from_bytes(\n self.reset_state.encode(),\n byteorder=\"big\"))\n self.comb += self.next_state_name.eq(self.state_name)\n self.sync += self.state_name.eq(self.next_state_name)\n return My_LowerNext(self.next_state, self.next_state_name,\n self.encoding, self.state_aliases)\n\n fsm.FSM._lower_controls = my_lower_controls","def _change_state(self, state):\r\n self.table_entry.state = state\r\n self.creator_admin.save_model(self.request, self.table_entry, None, True)","def get_file_state_name(self, fstateid):\n cond = SQLBinaryExpr(COL_NAME_FILESTATES_FILESTATEID, OP_EQ, SQLLiteral(fstateid))\n entries = self.select_generic_data(select_list=[COL_NAME_FILESTATES_NAME],\n table_list=[TABLE_NAME_FILESTATES],\n where=cond)\n if len(entries) == 1:\n return entries[0][COL_NAME_FILESTATES_NAME]\n elif len(entries) > 1:\n raise AdasDBError(\"File state '%s' cannot be resolved because it is ambiguous. (%s)\" % (fstateid, entries))\n\n raise AdasDBError(\"No resolution of '%s'. (%s)\" % (fstateid, entries))","def getnodestatename(self, node_p, state=0):\n node_p = self.getnodenamed(node_p) # Verify pointer.\n\n # GetNodeStateName_bn (\tconst node_bn* node, state_bn state )\n cnetica.GetNodeStateName_bn.argtypes = [c_void_p, c_int]\n cnetica.GetNodeStateName_bn.restype = c_char_p\n return cnetica.GetNodeStateName_bn(node_p, state) # node_levels","def get_vehicle_cfg_state_name(self, vehcfgstateid):\n vehcfgid_cond = SQLBinaryExpr(COL_NAME_VEHICLECFGSTATES_VEHICLECFGSTATEID, OP_EQ, SQLLiteral(vehcfgstateid))\n entries = self.select_generic_data(select_list=[COL_NAME_VEHICLECFGSTATES_NAME],\n table_list=[TABLE_NAME_VEHICLECFGSTATES],\n where=vehcfgid_cond)\n if len(entries) == 1:\n return entries[0][COL_NAME_VEHICLECFGSTATES_NAME]\n elif len(entries) > 1:\n tmp = \"Vehicle configuration state ID '%s' \" % vehcfgstateid\n tmp += \"cannot be resolved because it is ambiguous. (%s)\" % entries\n raise AdasDBError(tmp)\n\n raise AdasDBError(\"No resolution of '%s'. (%s)\" % (vehcfgstateid, entries))","def state_change(current_cell):\n state = \"\"\n if current_cell == \"Purchase Orders\":\n state = \"PURCHASE_ORDERS\"\n elif current_cell == \"Warehouse Orders\":\n state = \"WAREHOUSE_ORDERS\"\n elif current_cell == \"DESIGN ID\":\n state = \"PROPOSED_ORDERS\"\n return state","def create_event(self, last_state, state, clean_server_name, replset_name, agentConfig):\n\n status = self.get_state_description(state)\n short_status = self.get_state_name(state)\n last_short_status = self.get_state_name(last_state)\n hostname = self.hostname_for_event(clean_server_name, agentConfig)\n msg_title = \"%s is %s for %s\" % (hostname, short_status, replset_name)\n msg = \"MongoDB %s (%s) just reported as %s (%s) for %s; it was %s before.\" % (hostname, clean_server_name, status, short_status, replset_name, last_short_status)\n\n self.event({\n 'timestamp': int(time.time()),\n 'source_type_name': self.SOURCE_TYPE_NAME,\n 'msg_title': msg_title,\n 'msg_text': msg,\n 'host': hostname,\n 'tags': [\n 'action:mongo_replset_member_status_change',\n 'member_status:' + short_status,\n 'previous_member_status:' + last_short_status,\n 'replset:' + replset_name,\n ]\n })","def pretty_state(state, was_changed):\n pstate = state + \" \"\n if was_changed:\n pstate = state + \"*\"\n if not uses_rich:\n return pstate\n\n scols = {\n # forks\n 'wg' : 'gray',\n 'wu' : 'yellow',\n 'wd' : 'blue',\n\n # philosophers\n 'sl' : 'green',\n 'wt' : 'yellow',\n 'gl' : 'cyan',\n 'gr' : 'bright_cyan',\n 'es' : 'purple',\n 'dl' : 'yellow',\n 'dr' : 'bright_yellow',\n 'xx' : 'white', # done\n }\n if was_changed:\n return f\"[red][bold]{pstate}[/bold][/red]\"\n col = scols.get(state, 'white')\n return f\"[{col}]{pstate}[/{col}]\"","def name(self) -> Text:\n\n return \"5knn_state\"","def name(self):\n return self.NAMES[self._mystate]","def add_state( self , name , handler , end_state = False ):\n name = name.upper()\n self.handlers[ name ] = handler\n # If the user has designated this as an end state, then add to end states\n if end_state:\n self.endStates.append( name )","def add_state(committer_id, exploration_id, state_name, state_id=None):\n exploration = get_exploration_by_id(exploration_id)\n if exploration.has_state_named(state_name):\n raise ValueError('Duplicate state name %s' % state_name)\n\n state_id = state_id or exp_models.StateModel.get_new_id(state_name)\n new_state = exp_domain.State(state_id, state_name, [], [], None)\n\n def _add_state_transaction(committer_id, exploration_id, new_state):\n exploration_memcache_key = _get_exploration_memcache_key(\n exploration_id)\n memcache_services.delete(exploration_memcache_key)\n\n save_state(committer_id, exploration_id, new_state)\n exploration = get_exploration_by_id(exploration_id)\n exploration.state_ids.append(state_id)\n save_exploration(committer_id, exploration)\n\n transaction_services.run_in_transaction(\n _add_state_transaction, committer_id, exploration_id, new_state)","def construct_state(state_info_col):\n\n state_info_col_properties = state_info_col[\"properties\"]\n state_info_col_key_row = state_info_col[\"keyRowAsUnsafe\"]\n state_info_col_object = state_info_col[\"object\"]\n\n state_properties = json.loads(state_info_col_properties)\n if state_info_col_object:\n state_object = self.pickleSer.loads(state_info_col_object)\n else:\n state_object = None\n state_properties[\"optionalValue\"] = state_object\n\n return GroupState(\n keyAsUnsafe=state_info_col_key_row,\n valueSchema=self.state_object_schema,\n **state_properties,\n )","def state_string(self):\n return AddressStates._to_string(self.state)","def get_name(self):\n return self.col_name","def _initial_state_scope(self, name):\n return name if name else \"%s_initial_state\" % self.scope_name","def post_state():\n new_state = request.get_json()\n if new_state is None:\n abort(400, 'Not a JSON')\n if 'name' not in new_state:\n abort(400, 'Missing name')\n new_state = State(name=request.json['name'])\n storage.new(new_state)\n storage.save()\n return jsonify(new_state.to_dict()), 201","def _get_design_name(self, state: Dict[str, Any]) -> str:\n fname = self.base_design_name\n for value in state.values():\n fname += \"_\" + str(value)\n return fname","def get_city_state(self):\n\n city = self.city\n return f'{city.name}, {city.state}'","def add_state(self, name, handler, end_state=0):\n name = name.upper()\n self.handlers[name] = handler\n if end_state:\n self.end_states.append(name)","def get_state_function(faker):\n\n if has_function(faker, 'state'):\n return faker.format('state')\n if has_function(faker, 'province'):\n return faker.province()\n if has_function(faker, 'county'):\n return faker.county()\n if has_function(faker, 'prefecture'):\n return faker.prefecture()\n if has_function(faker, 'region'):\n return faker.region()\n\n return \"\"","def state_transl(state):\n nonlocal state_cnt\n nonlocal state_transl_dict\n\n if state not in state_transl_dict.keys():\n state_transl_dict[state] = state_cnt\n state_cnt += 1\n\n return str(state_transl_dict[state])","def state_transl(state):\n nonlocal state_cnt\n nonlocal state_transl_dict\n\n if state not in state_transl_dict.keys():\n state_transl_dict[state] = state_cnt\n state_cnt += 1\n\n return str(state_transl_dict[state])","def column_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"column_name\")","def column_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"column_name\")","def add_state(self, state):\n self.states.add(state)","def column_name(name):\n # Only needs exceptions to standard token cleanup\n column_map = {\n \"line#\" : \"ignore\",\n \"date\" : \"timestamp\",\n \"rh\" : \"humidity\",\n \"par\" : \"par_ue\"\n }\n\n if name in column_map:\n return column_map[name]\n \n return name","def ad_rep_city_state(obj):\n return '%s, %s' % (obj.ad_rep.geolocation_object.us_city.name,\n obj.ad_rep.geolocation_object.us_state.abbreviation)","def make_column(options, name, column):\n # (ElasticsearchFDWOptions, str, multicorn.ColumnDefinition) -> Column\n assert name not in {\n options.rowid_column,\n options.score_column,\n options.query_column,\n }, \"Programmer error: bad name passed to make_column {name}\".format(name=name)\n\n if column.base_type_name.upper() in {\"JSON\", \"JSONB\"}:\n return JsonColumn(name=name)\n return BasicColumn(name=name)","def extra_state_attributes(self):\n return {STATE_ATTRIBUTE_ROOM_NAME: self._room_name}","def state(self, state: str):\n\n self._state = state","def update_column_title(col):\n col_type = self.features_bucket_mapping_.get(col).type\n return [f\"Feature '{col}'\"], [col_type]","def create_column(self, new_column, dtype):\n self.logger.debug(\"[%u] Ready to add column %s\" %\n (os.getpid(), new_column))\n ddl = \"\"\"\n ALTER TABLE {schema}.{table}\n ADD COLUMN IF NOT EXISTS {col} {type}\n \"\"\"\n # TODO Replace by execute_ddl func and test it\n with get_sink_connection_string(self) as conn:\n with conn.cursor() as cursor:\n cursor.execute(ddl.format(schema=self.config['schema'],\n table=self.config['table'],\n col=new_column,\n type=dtype))\n self.logger.debug(\"[%u] Column %s has been added\" %\n (os.getpid(), new_column))","def state(self) -> str:","def volunteer_statename(self):\n return ABBR_TO_STATE.get(self.volunteerhomestate,\n self.volunteerhomestate)","def create_state():\n state = request.get_json()\n if type(state) is not dict:\n abort(400, {'Not a JSON'})\n elif 'name' not in state:\n abort(400, {'Missing name'})\n else:\n new_state = State(**state)\n storage.new(new_state)\n storage.save()\n return make_response(jsonify(new_state.to_dict()), 201)","def state(self, state_str: str) -> None:\n with self._lock:\n self._state = self._create_new_state(\n state_str, prev_state=self._state, notify=True\n )","def States_func():\n engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(\n sys.argv[1], sys.argv[2], sys.argv[3]), pool_pre_ping=True)\n Base.metadata.create_all(engine)\n\n Session = sessionmaker(bind=engine)\n session = Session()\n x = session.query(State).get(2)\n x.name = 'New Mexico'\n session.commit()\n session.close()","def add_city_state_to_dataframe(dataframe):\n dataframe[['city', 'state']] = dataframe.apply(parse_city_state_from_row,\n axis=1)\n dataframe = dataframe[dataframe.state != \"NULL\"]\n return dataframe","def setnodestatenames(self, node_p=None, state_names=None):\n node_p = self.getnodenamed(node_p) # Verify pointer.\n if not isinstance(state_names, types.StringType):\n # Construct single string from list/tuple.\n newstr = [st + ', ' for st in state_names]\n state_names = ''.join(newstr)\n\n # (node_bn* node, const char* state_names)\n cnetica.SetNodeStateNames_bn.argtypes = [c_void_p, c_char_p]\n cnetica.SetNodeStateNames_bn.restype = None\n cnetica.SetNodeStateNames_bn(node_p, ccharp(state_names))","def createState(self):\n return ''.join(random.choice(string.ascii_letters + string.digits) for x in range(30))","def postStates():\n thing = request.get_json(silent=True)\n if thing is None or not request.json:\n return (jsonify({\"error\": \"Not a JSON\"}), 400)\n state = thing.get(\"name\")\n if state is None or len(thing) == 0:\n return (jsonify({\"error\": \"Missing name\"}), 400)\n s = State()\n s.name = state\n s.save()\n return (jsonify(s.to_dict()), 201)","def create_state():\n data = {}\n for key in request.form.keys():\n \tfor value in request.form.getlist(key):\n \t\tdata[key] = value\n try:\n ''' Check that name key is in data '''\n if not 'name' in data:\n raise KeyError('name')\n\n ''' Check that name key is not null '''\n if not data['name']:\n raise TypeError(\"'name' cannot be NULL\")\n\n ''' Check that name key value is a string '''\n if not type_test(data['name'], 'string'):\n raise TypeError(\"'name' must be a string\")\n\n ''' Check if state already exists '''\n query = State.select().where(State.name == data['name'])\n if query.exists():\n raise ValueError('State already exists')\n\n new = State.create(\n name = data['name']\n )\n res = {}\n res['code'] = 201\n res['id'] = new.id\n res['msg'] = \"State was created successfully\"\n return res, 201\n except TypeError as e:\n response = {}\n response['code'] = 400\n response['msg'] = e.message\n return response, 400\n except ValueError as e:\n response = {}\n response['code'] = 10001\n response['msg'] = e.message\n return response, 409\n except KeyError as e:\n response = {}\n response['code'] = 40000\n response['msg'] = 'Missing parameters'\n return response, 400\n except Exception as e:\n print e.message\n abort(500)","def state(self, state: \"StatusState\"):\n if state is None:\n raise ValueError(\"Invalid value for `state`, must not be `None`\")\n if isinstance(state, Enum):\n self._attrs[\"state\"] = state.value\n else:\n self._attrs[\"state\"] = state # If you supply a string, we presume you know the service will take it.","def new_state():\n return ''.join(random.choice(string.ascii_uppercase + string.digits)\n for x in range(32))","def setstate(self,name,state):\n if (name not in KFNode.names):\n print ' state name ',name,' not in KNode!'\n self.states[name]=state.copy()\n self.status = name\n return","def state(self, state: str) -> None:\n self._state = state","def from_esi_name(cls, esi_state_name: str) -> \"Structure.State\":\n STATES_ESI_MAP = {\n \"anchor_vulnerable\": cls.ANCHOR_VULNERABLE,\n \"anchoring\": cls.ANCHORING,\n \"armor_reinforce\": cls.ARMOR_REINFORCE,\n \"armor_vulnerable\": cls.ARMOR_VULNERABLE,\n \"deploy_vulnerable\": cls.DEPLOY_VULNERABLE,\n \"fitting_invulnerable\": cls.FITTING_INVULNERABLE,\n \"hull_reinforce\": cls.HULL_REINFORCE,\n \"hull_vulnerable\": cls.HULL_VULNERABLE,\n \"online_deprecated\": cls.ONLINE_DEPRECATED,\n \"onlining_vulnerable\": cls.ONLINING_VULNERABLE,\n \"shield_vulnerable\": cls.SHIELD_VULNERABLE,\n \"unanchored\": cls.UNANCHORED,\n \"offline\": cls.POS_OFFLINE,\n \"online\": cls.POS_ONLINE,\n \"onlining\": cls.POS_ONLINING,\n \"reinforced\": cls.POS_REINFORCED,\n \"unanchoring \": cls.POS_UNANCHORING,\n }\n return (\n STATES_ESI_MAP[esi_state_name]\n if esi_state_name in STATES_ESI_MAP\n else cls.UNKNOWN\n )","def get_new_state():\n state = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in xrange(32))\n return state","def make_costate_names(states):\n\n return [sympify('lam'+str(s.name).upper()) for s in states]","def col_strings(self):\n return [self.name, self.room, \n \":\".join(['%02X' % x for x in self.address]), self.state_str()]","def add_state(self, state):\n self._validate_state(state)\n self._state.add(state)","def create_diseasestate_column(num_ppl, seed=1):\n # initialize all 0s array\n initial_diseasestate = np.zeros(num_ppl)\n # infect exactly `seed` number of elements\n initial_diseasestate[np.random.choice(num_ppl, seed)] = 1\n # return infection state\n return initial_diseasestate","def abbr_2_st(state_series, abbr_2_st=True):\n us_state_abbrev = {\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 if abbr_2_st == True:\n inv_map = {v: k for k, v in us_state_abbrev.items()}\n full_names = []\n for abbv in state_series:\n full_names.append(inv_map[abbv])\n return full_names\n else:\n # Return Abbreviation\n abbvs = []\n for full_name in state_series:\n abbvs.append(us_state_abbrev[full_name])\n return abbvs","def upgrade_state_dict_named(self, state_dict, name):\n layer_norm_map = {\"0\": \"self_attn_layer_norm\", \"1\": \"final_layer_norm\"}\n for old, new in layer_norm_map.items():\n for m in (\"weight\", \"bias\"):\n k = \"{}.layer_norms.{}.{}\".format(name, old, m)\n if k in state_dict:\n state_dict[\"{}.{}.{}\".format(name, new, m)] = state_dict[k]\n del state_dict[k]","def new_index_name(self, column, unique=False):\n table_name = self.name.lstrip('migrate_')\n column = column.replace(', ', '')\n return '{}_{}_{}{}'.format(table_name, column, self._random_string(6), '_unique' if unique else '')","def state(self, statename, value=None):\n if statename in self.v:\n raise ValueError, \"state already exists\"\n self.rv[statename]=len(self.v)\n self.v[statename]=value","def _state_container_prefix(self):\n return self._name_camel_plural","def column_name(self) -> Optional[str]:\n return pulumi.get(self, \"column_name\")","def convert_state_name_to_id(exploration_id, state_name):\n if state_name == feconf.END_DEST:\n return feconf.END_DEST\n return get_state_by_name(exploration_id, state_name).id","def clean_state(self):\n return self.cleaned_data['state'].upper()","def genStatesCode(self):\n for s, d in self.info['machine'].items():\n transition_code_arr = []\n for t in self.info['transitionnames']:\n tcode = self.tmpl['transition_none'].render(transition=t)\n if t in d['transitions'].keys():\n tcode = self.tmpl['transition_ok'].render(transition=t, post=d['transitions'][t])\n transition_code_arr.append(tcode)\n transition_code = '\\n'.join(transition_code_arr) + '\\n'\n state_code = self.tmpl['concreatestate'].render(state=s.title(), description=d['description'])\n self.codeinfo[s.lower()+\".py\"] = '\\n'.join([state_code, transition_code]) + '\\n'","def wrap_columns_name(self, format_string):\n self._data_frame = self._data_frame.rename(\n columns=lambda column: format_string.format(column)\n )","def put(cls, new_state: TState) -> \"State[Tuple, TState]\":\n return State(lambda state: (Unit, new_state))","def changeState(self, node, name, state):","def __str__(self):\n return \"\".join(list(map(lambda row: ''.join(row), self.state)))","def rename_column_values_for_comparison(df, sourcename):\n\n # at the national level, only have information for 'FlowName' = 'total'\n # and 'Compartment' = 'total'. At state/county level, have information\n # for fresh/saline and ground/surface water. Therefore, to compare\n # subset data to national level, rename to match national values.\n if sourcename == 'USGS_NWIS_WU':\n df['FlowName'] = np.where(\n df['ActivityConsumedBy'] != 'Livestock', 'total', df['FlowName'])\n df['Compartment'] = df['Compartment'].str.replace(\n 'ground', 'total', regex=True)\n df['Compartment'] = df['Compartment'].str.replace(\n 'surface', 'total', regex=True)\n\n return df"],"string":"[\n \"def state_name(self):\\n return self.state.name if self.state else None\",\n \"def _state_name(self):\\n return '{}_{}'.format(self.function_name, self.STATE_CONFIG_SUFFIX)\",\n \"def state_name(self):\\n return task_states.to_str(self.state)\",\n \"def test_state_name(self):\\n state = State('test-state')\\n self.assertEqual(state.name, 'test-state')\",\n \"def createStateTable(self):\\r\\n tableName = self._names['state']\\r\\n con = None\\r\\n try:\\r\\n con = sql.connect(self._filename, timeout=10, \\r\\n isolation_level=\\\"IMMEDIATE\\\")\\r\\n with con:\\r\\n c = con.cursor()\\r\\n c.execute(\\\"CREATE TABLE IF NOT EXISTS \\\"\\r\\n \\\"{}(id INTEGER PRIMARY KEY, manager TEXT, \\\"\\r\\n \\\"module TEXT, state TEXT)\\\".format(tableName))\\r\\n finally:\\r\\n _closeConnection(con)\\r\\n return tableName\",\n \"def state_to_abbreviation(state: str, df: pd.DataFrame) -> str:\\n\\n return df.loc[df['State Name'] == state.title(), 'State Abbreviation'].iloc[0]\",\n \"def create_user_state_table():\\n connection = connection_to_db()\\n cursor = connection.cursor()\\n\\n cursor.execute(\\n \\\"CREATE TABLE IF NOT EXISTS user_state \\\"\\n \\\"(id serial PRIMARY KEY, \\\"\\n \\\"user_id INTEGER NOT NULL, \\\"\\n \\\"state INTEGER DEFAULT 0);\\\"\\n )\\n\\n connection.commit()\",\n \"def sample_name_colname(self):\\n return SAMPLE_NAME_ATTR \\\\\\n if SAMPLE_NAME_ATTR == self.st_index else self.st_index\",\n \"def state(self, state: \\\"str\\\"):\\n if isinstance(state, Enum):\\n self._attrs[\\\"state\\\"] = state.value\\n else:\\n self._attrs[\\\"state\\\"] = state # If you supply a string, we presume you know the service will take it.\",\n \"def test_query_new_column(self):\\n session = self.prepare(user_table=True)\\n\\n session.execute((\\\"CREATE MATERIALIZED VIEW users_by_state2 AS SELECT state, username FROM users \\\"\\n \\\"WHERE STATE IS NOT NULL AND USERNAME IS NOT NULL PRIMARY KEY (state, username)\\\"))\\n\\n self._insert_data(session)\\n\\n assert_one(\\n session,\\n \\\"SELECT * FROM users_by_state2 WHERE state = 'TX' AND username = 'user1'\\\",\\n ['TX', 'user1']\\n )\\n\\n session.execute(\\\"ALTER TABLE users ADD first_name varchar;\\\")\\n\\n results = list(session.execute(\\\"SELECT * FROM users_by_state2 WHERE state = 'TX' AND username = 'user1'\\\"))\\n assert len(results) == 1\\n assert not hasattr(results[0], 'first_name'), 'Column \\\"first_name\\\" found in view'\\n assert_one(\\n session,\\n \\\"SELECT * FROM users_by_state2 WHERE state = 'TX' AND username = 'user1'\\\",\\n ['TX', 'user1']\\n )\",\n \"def test_rename_column(self):\\n session = self.prepare(user_table=True)\\n\\n self._insert_data(session)\\n\\n assert_one(\\n session,\\n \\\"SELECT * FROM users_by_state WHERE state = 'TX' AND username = 'user1'\\\",\\n ['TX', 'user1', 1968, 'f', 'ch@ngem3a', None]\\n )\\n\\n session.execute(\\\"ALTER TABLE users RENAME username TO user\\\")\\n\\n results = list(session.execute(\\\"SELECT * FROM users_by_state WHERE state = 'TX' AND user = 'user1'\\\"))\\n assert len(results) == 1\\n assert hasattr(results[0], 'user'), 'Column \\\"user\\\" not found'\\n assert_one(\\n session,\\n \\\"SELECT state, user, birth_year, gender FROM users_by_state WHERE state = 'TX' AND user = 'user1'\\\",\\n ['TX', 'user1', 1968, 'f']\\n )\",\n \"def format_state(data):\\n if us.states.lookup(data) is None:\\n return None\\n else:\\n return us.states.lookup(data).name\",\n \"def state_abbreviated():\\r\\n\\r\\n cursor.execute('SELECT * FROM american_cities_with_states \\\\\\r\\n order by RANDOM() limit 1;')\\r\\n return (cursor.fetchone()[0])[-2:]\",\n \"def get_lookup_state(self, state):\\n return \\\"\\\".join(map(str, state))\",\n \"def state(self, state: str) -> None:\",\n \"def set_column_name(self, name):\\r\\n self.column_name = name\",\n \"def set_column_name(self, name):\\r\\n self.column_name = name\",\n \"def create_state():\\n if not request.json:\\n abort(400, \\\"Not a JSON\\\")\\n if 'name' not in request.json:\\n abort(400, \\\"Missing name\\\")\\n state = models.state.State(name=request.json['name'])\\n state.save()\\n return jsonify(state.to_dict()), 201\",\n \"def native_value(self) -> str:\\n if isinstance(self._state, Enum):\\n return self._state.name.lower()\\n return self._state.lower()\",\n \"def rename(self, newname):\\n # set the new column name\\n self.colname = newname\",\n \"def _create_new_state(\\n self,\\n new_state: str,\\n prev_state: CircuitBreakerState | None = None,\\n notify: bool = False,\\n ) -> CBStateType:\\n state_map: dict[str, Type[CBStateType]] = {\\n STATE_CLOSED: CircuitClosedState,\\n STATE_OPEN: CircuitOpenState,\\n STATE_HALF_OPEN: CircuitHalfOpenState,\\n }\\n try:\\n cls = state_map[new_state]\\n return cls(self, prev_state=prev_state, notify=notify)\\n except KeyError:\\n msg = \\\"Unknown state {!r}, valid states: {}\\\"\\n raise ValueError(msg.format(new_state, \\\", \\\".join(state_map)))\",\n \"def append_state_label(symbol):\\n\\t\\tif symbol == \\\"c\\\":\\n\\t\\t\\tself.state_label = self.state_label.replace(\\\"o\\\", \\\"\\\")\\n\\t\\tif symbol == \\\"d\\\":\\n\\t\\t\\tself.state_label = self.state_label.replace(\\\"k\\\", \\\"\\\")\\n\\t\\telse:\\n\\t\\t\\tself.state_label += symbol\",\n \"def add_state(self, name, on_enter=None, on_exit=None):\\n args = locals()\\n del args['self']\\n self.states.append(State(**args))\",\n \"def add_state(self, name, on_enter=None, on_exit=None):\\n args = locals()\\n del args['self']\\n self.states.append(State(**args))\",\n \"def upgrade_state_dict_named(self, state_dict, name):\\n return state_dict\",\n \"def _update_column_name(self, column, idx, old_name, name):\\n dtype = self.dtype\\n # Updating the names on the dtype should suffice\\n dtype.names = dtype.names[:idx] + (name,) + dtype.names[idx + 1 :]\",\n \"def create_state():\\n state_json = request.get_json(silent=True)\\n if not state_json:\\n return jsonify({'error': 'Not a JSON'}), 400\\n if 'name' not in state_json:\\n return jsonify({'error': 'Missing name'}), 400\\n state = State(**state_json)\\n state.save()\\n return jsonify(state.to_dict()), 201\",\n \"def addState(self, s=[]):\\n k = State(len(self.states))\\n if s != []:\\n for x in s:\\n k.addRow(x[0], x[1][0], x[1][1], x[1][2])\\n self.states.append(k)\",\n \"def state_name(self):\\n return TASK_STATE.get(self.state, 'UNKNOWN')\",\n \"def get_state(self, state_description, dt, class_=State):\\n dt = pd.Timestamp(dt)\\n names = state_description.keys()\\n name_value_mapping = {name: self.get(name, dt) for name in names}\\n return state_description.to_state(class_, **name_value_mapping)\",\n \"def test_create_state(self):\\n state_2 = State('name=\\\"California\\\"')\\n self.assertEqual(state_2.name, 'California')\",\n \"def rename_column(self, table_name, old, new):\\r\\n self._remake_table(table_name, renames={old: new})\",\n \"def create_state():\\n state_json = request.get_json()\\n if state_json is None:\\n abort(400, 'Not a JSON')\\n if state_json.get('name') is None:\\n abort(400, \\\"Missing name\\\")\\n state = State(**state_json)\\n storage.new(state)\\n storage.save()\\n return jsonify(state.to_dict()), 201\",\n \"def add_fsm_state_names():\\n from migen.fhdl.visit import NodeTransformer\\n from migen.genlib.fsm import NextState, NextValue, _target_eq\\n from migen.fhdl.bitcontainer import value_bits_sign\\n\\n class My_LowerNext(NodeTransformer):\\n def __init__(self, next_state_signal, next_state_name_signal, encoding,\\n aliases):\\n self.next_state_signal = next_state_signal\\n self.next_state_name_signal = next_state_name_signal\\n self.encoding = encoding\\n self.aliases = aliases\\n # (target, next_value_ce, next_value)\\n self.registers = []\\n\\n def _get_register_control(self, target):\\n for x in self.registers:\\n if _target_eq(target, x[0]):\\n return x[1], x[2]\\n raise KeyError\\n\\n def visit_unknown(self, node):\\n if isinstance(node, NextState):\\n try:\\n actual_state = self.aliases[node.state]\\n except KeyError:\\n actual_state = node.state\\n return [\\n self.next_state_signal.eq(self.encoding[actual_state]),\\n self.next_state_name_signal.eq(\\n int.from_bytes(actual_state.encode(), byteorder=\\\"big\\\"))\\n ]\\n elif isinstance(node, NextValue):\\n try:\\n next_value_ce, next_value = self._get_register_control(\\n node.target)\\n except KeyError:\\n related = node.target if isinstance(node.target,\\n Signal) else None\\n next_value = Signal(bits_sign=value_bits_sign(node.target),\\n related=related)\\n next_value_ce = Signal(related=related)\\n self.registers.append(\\n (node.target, next_value_ce, next_value))\\n return next_value.eq(node.value), next_value_ce.eq(1)\\n else:\\n return node\\n\\n import migen.genlib.fsm as fsm\\n\\n def my_lower_controls(self):\\n self.state_name = Signal(len(max(self.encoding, key=len)) * 8,\\n reset=int.from_bytes(\\n self.reset_state.encode(),\\n byteorder=\\\"big\\\"))\\n self.next_state_name = Signal(len(max(self.encoding, key=len)) * 8,\\n reset=int.from_bytes(\\n self.reset_state.encode(),\\n byteorder=\\\"big\\\"))\\n self.comb += self.next_state_name.eq(self.state_name)\\n self.sync += self.state_name.eq(self.next_state_name)\\n return My_LowerNext(self.next_state, self.next_state_name,\\n self.encoding, self.state_aliases)\\n\\n fsm.FSM._lower_controls = my_lower_controls\",\n \"def _change_state(self, state):\\r\\n self.table_entry.state = state\\r\\n self.creator_admin.save_model(self.request, self.table_entry, None, True)\",\n \"def get_file_state_name(self, fstateid):\\n cond = SQLBinaryExpr(COL_NAME_FILESTATES_FILESTATEID, OP_EQ, SQLLiteral(fstateid))\\n entries = self.select_generic_data(select_list=[COL_NAME_FILESTATES_NAME],\\n table_list=[TABLE_NAME_FILESTATES],\\n where=cond)\\n if len(entries) == 1:\\n return entries[0][COL_NAME_FILESTATES_NAME]\\n elif len(entries) > 1:\\n raise AdasDBError(\\\"File state '%s' cannot be resolved because it is ambiguous. (%s)\\\" % (fstateid, entries))\\n\\n raise AdasDBError(\\\"No resolution of '%s'. (%s)\\\" % (fstateid, entries))\",\n \"def getnodestatename(self, node_p, state=0):\\n node_p = self.getnodenamed(node_p) # Verify pointer.\\n\\n # GetNodeStateName_bn (\\tconst node_bn* node, state_bn state )\\n cnetica.GetNodeStateName_bn.argtypes = [c_void_p, c_int]\\n cnetica.GetNodeStateName_bn.restype = c_char_p\\n return cnetica.GetNodeStateName_bn(node_p, state) # node_levels\",\n \"def get_vehicle_cfg_state_name(self, vehcfgstateid):\\n vehcfgid_cond = SQLBinaryExpr(COL_NAME_VEHICLECFGSTATES_VEHICLECFGSTATEID, OP_EQ, SQLLiteral(vehcfgstateid))\\n entries = self.select_generic_data(select_list=[COL_NAME_VEHICLECFGSTATES_NAME],\\n table_list=[TABLE_NAME_VEHICLECFGSTATES],\\n where=vehcfgid_cond)\\n if len(entries) == 1:\\n return entries[0][COL_NAME_VEHICLECFGSTATES_NAME]\\n elif len(entries) > 1:\\n tmp = \\\"Vehicle configuration state ID '%s' \\\" % vehcfgstateid\\n tmp += \\\"cannot be resolved because it is ambiguous. (%s)\\\" % entries\\n raise AdasDBError(tmp)\\n\\n raise AdasDBError(\\\"No resolution of '%s'. (%s)\\\" % (vehcfgstateid, entries))\",\n \"def state_change(current_cell):\\n state = \\\"\\\"\\n if current_cell == \\\"Purchase Orders\\\":\\n state = \\\"PURCHASE_ORDERS\\\"\\n elif current_cell == \\\"Warehouse Orders\\\":\\n state = \\\"WAREHOUSE_ORDERS\\\"\\n elif current_cell == \\\"DESIGN ID\\\":\\n state = \\\"PROPOSED_ORDERS\\\"\\n return state\",\n \"def create_event(self, last_state, state, clean_server_name, replset_name, agentConfig):\\n\\n status = self.get_state_description(state)\\n short_status = self.get_state_name(state)\\n last_short_status = self.get_state_name(last_state)\\n hostname = self.hostname_for_event(clean_server_name, agentConfig)\\n msg_title = \\\"%s is %s for %s\\\" % (hostname, short_status, replset_name)\\n msg = \\\"MongoDB %s (%s) just reported as %s (%s) for %s; it was %s before.\\\" % (hostname, clean_server_name, status, short_status, replset_name, last_short_status)\\n\\n self.event({\\n 'timestamp': int(time.time()),\\n 'source_type_name': self.SOURCE_TYPE_NAME,\\n 'msg_title': msg_title,\\n 'msg_text': msg,\\n 'host': hostname,\\n 'tags': [\\n 'action:mongo_replset_member_status_change',\\n 'member_status:' + short_status,\\n 'previous_member_status:' + last_short_status,\\n 'replset:' + replset_name,\\n ]\\n })\",\n \"def pretty_state(state, was_changed):\\n pstate = state + \\\" \\\"\\n if was_changed:\\n pstate = state + \\\"*\\\"\\n if not uses_rich:\\n return pstate\\n\\n scols = {\\n # forks\\n 'wg' : 'gray',\\n 'wu' : 'yellow',\\n 'wd' : 'blue',\\n\\n # philosophers\\n 'sl' : 'green',\\n 'wt' : 'yellow',\\n 'gl' : 'cyan',\\n 'gr' : 'bright_cyan',\\n 'es' : 'purple',\\n 'dl' : 'yellow',\\n 'dr' : 'bright_yellow',\\n 'xx' : 'white', # done\\n }\\n if was_changed:\\n return f\\\"[red][bold]{pstate}[/bold][/red]\\\"\\n col = scols.get(state, 'white')\\n return f\\\"[{col}]{pstate}[/{col}]\\\"\",\n \"def name(self) -> Text:\\n\\n return \\\"5knn_state\\\"\",\n \"def name(self):\\n return self.NAMES[self._mystate]\",\n \"def add_state( self , name , handler , end_state = False ):\\n name = name.upper()\\n self.handlers[ name ] = handler\\n # If the user has designated this as an end state, then add to end states\\n if end_state:\\n self.endStates.append( name )\",\n \"def add_state(committer_id, exploration_id, state_name, state_id=None):\\n exploration = get_exploration_by_id(exploration_id)\\n if exploration.has_state_named(state_name):\\n raise ValueError('Duplicate state name %s' % state_name)\\n\\n state_id = state_id or exp_models.StateModel.get_new_id(state_name)\\n new_state = exp_domain.State(state_id, state_name, [], [], None)\\n\\n def _add_state_transaction(committer_id, exploration_id, new_state):\\n exploration_memcache_key = _get_exploration_memcache_key(\\n exploration_id)\\n memcache_services.delete(exploration_memcache_key)\\n\\n save_state(committer_id, exploration_id, new_state)\\n exploration = get_exploration_by_id(exploration_id)\\n exploration.state_ids.append(state_id)\\n save_exploration(committer_id, exploration)\\n\\n transaction_services.run_in_transaction(\\n _add_state_transaction, committer_id, exploration_id, new_state)\",\n \"def construct_state(state_info_col):\\n\\n state_info_col_properties = state_info_col[\\\"properties\\\"]\\n state_info_col_key_row = state_info_col[\\\"keyRowAsUnsafe\\\"]\\n state_info_col_object = state_info_col[\\\"object\\\"]\\n\\n state_properties = json.loads(state_info_col_properties)\\n if state_info_col_object:\\n state_object = self.pickleSer.loads(state_info_col_object)\\n else:\\n state_object = None\\n state_properties[\\\"optionalValue\\\"] = state_object\\n\\n return GroupState(\\n keyAsUnsafe=state_info_col_key_row,\\n valueSchema=self.state_object_schema,\\n **state_properties,\\n )\",\n \"def state_string(self):\\n return AddressStates._to_string(self.state)\",\n \"def get_name(self):\\n return self.col_name\",\n \"def _initial_state_scope(self, name):\\n return name if name else \\\"%s_initial_state\\\" % self.scope_name\",\n \"def post_state():\\n new_state = request.get_json()\\n if new_state is None:\\n abort(400, 'Not a JSON')\\n if 'name' not in new_state:\\n abort(400, 'Missing name')\\n new_state = State(name=request.json['name'])\\n storage.new(new_state)\\n storage.save()\\n return jsonify(new_state.to_dict()), 201\",\n \"def _get_design_name(self, state: Dict[str, Any]) -> str:\\n fname = self.base_design_name\\n for value in state.values():\\n fname += \\\"_\\\" + str(value)\\n return fname\",\n \"def get_city_state(self):\\n\\n city = self.city\\n return f'{city.name}, {city.state}'\",\n \"def add_state(self, name, handler, end_state=0):\\n name = name.upper()\\n self.handlers[name] = handler\\n if end_state:\\n self.end_states.append(name)\",\n \"def get_state_function(faker):\\n\\n if has_function(faker, 'state'):\\n return faker.format('state')\\n if has_function(faker, 'province'):\\n return faker.province()\\n if has_function(faker, 'county'):\\n return faker.county()\\n if has_function(faker, 'prefecture'):\\n return faker.prefecture()\\n if has_function(faker, 'region'):\\n return faker.region()\\n\\n return \\\"\\\"\",\n \"def state_transl(state):\\n nonlocal state_cnt\\n nonlocal state_transl_dict\\n\\n if state not in state_transl_dict.keys():\\n state_transl_dict[state] = state_cnt\\n state_cnt += 1\\n\\n return str(state_transl_dict[state])\",\n \"def state_transl(state):\\n nonlocal state_cnt\\n nonlocal state_transl_dict\\n\\n if state not in state_transl_dict.keys():\\n state_transl_dict[state] = state_cnt\\n state_cnt += 1\\n\\n return str(state_transl_dict[state])\",\n \"def column_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"column_name\\\")\",\n \"def column_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"column_name\\\")\",\n \"def add_state(self, state):\\n self.states.add(state)\",\n \"def column_name(name):\\n # Only needs exceptions to standard token cleanup\\n column_map = {\\n \\\"line#\\\" : \\\"ignore\\\",\\n \\\"date\\\" : \\\"timestamp\\\",\\n \\\"rh\\\" : \\\"humidity\\\",\\n \\\"par\\\" : \\\"par_ue\\\"\\n }\\n\\n if name in column_map:\\n return column_map[name]\\n \\n return name\",\n \"def ad_rep_city_state(obj):\\n return '%s, %s' % (obj.ad_rep.geolocation_object.us_city.name,\\n obj.ad_rep.geolocation_object.us_state.abbreviation)\",\n \"def make_column(options, name, column):\\n # (ElasticsearchFDWOptions, str, multicorn.ColumnDefinition) -> Column\\n assert name not in {\\n options.rowid_column,\\n options.score_column,\\n options.query_column,\\n }, \\\"Programmer error: bad name passed to make_column {name}\\\".format(name=name)\\n\\n if column.base_type_name.upper() in {\\\"JSON\\\", \\\"JSONB\\\"}:\\n return JsonColumn(name=name)\\n return BasicColumn(name=name)\",\n \"def extra_state_attributes(self):\\n return {STATE_ATTRIBUTE_ROOM_NAME: self._room_name}\",\n \"def state(self, state: str):\\n\\n self._state = state\",\n \"def update_column_title(col):\\n col_type = self.features_bucket_mapping_.get(col).type\\n return [f\\\"Feature '{col}'\\\"], [col_type]\",\n \"def create_column(self, new_column, dtype):\\n self.logger.debug(\\\"[%u] Ready to add column %s\\\" %\\n (os.getpid(), new_column))\\n ddl = \\\"\\\"\\\"\\n ALTER TABLE {schema}.{table}\\n ADD COLUMN IF NOT EXISTS {col} {type}\\n \\\"\\\"\\\"\\n # TODO Replace by execute_ddl func and test it\\n with get_sink_connection_string(self) as conn:\\n with conn.cursor() as cursor:\\n cursor.execute(ddl.format(schema=self.config['schema'],\\n table=self.config['table'],\\n col=new_column,\\n type=dtype))\\n self.logger.debug(\\\"[%u] Column %s has been added\\\" %\\n (os.getpid(), new_column))\",\n \"def state(self) -> str:\",\n \"def volunteer_statename(self):\\n return ABBR_TO_STATE.get(self.volunteerhomestate,\\n self.volunteerhomestate)\",\n \"def create_state():\\n state = request.get_json()\\n if type(state) is not dict:\\n abort(400, {'Not a JSON'})\\n elif 'name' not in state:\\n abort(400, {'Missing name'})\\n else:\\n new_state = State(**state)\\n storage.new(new_state)\\n storage.save()\\n return make_response(jsonify(new_state.to_dict()), 201)\",\n \"def state(self, state_str: str) -> None:\\n with self._lock:\\n self._state = self._create_new_state(\\n state_str, prev_state=self._state, notify=True\\n )\",\n \"def States_func():\\n engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(\\n sys.argv[1], sys.argv[2], sys.argv[3]), pool_pre_ping=True)\\n Base.metadata.create_all(engine)\\n\\n Session = sessionmaker(bind=engine)\\n session = Session()\\n x = session.query(State).get(2)\\n x.name = 'New Mexico'\\n session.commit()\\n session.close()\",\n \"def add_city_state_to_dataframe(dataframe):\\n dataframe[['city', 'state']] = dataframe.apply(parse_city_state_from_row,\\n axis=1)\\n dataframe = dataframe[dataframe.state != \\\"NULL\\\"]\\n return dataframe\",\n \"def setnodestatenames(self, node_p=None, state_names=None):\\n node_p = self.getnodenamed(node_p) # Verify pointer.\\n if not isinstance(state_names, types.StringType):\\n # Construct single string from list/tuple.\\n newstr = [st + ', ' for st in state_names]\\n state_names = ''.join(newstr)\\n\\n # (node_bn* node, const char* state_names)\\n cnetica.SetNodeStateNames_bn.argtypes = [c_void_p, c_char_p]\\n cnetica.SetNodeStateNames_bn.restype = None\\n cnetica.SetNodeStateNames_bn(node_p, ccharp(state_names))\",\n \"def createState(self):\\n return ''.join(random.choice(string.ascii_letters + string.digits) for x in range(30))\",\n \"def postStates():\\n thing = request.get_json(silent=True)\\n if thing is None or not request.json:\\n return (jsonify({\\\"error\\\": \\\"Not a JSON\\\"}), 400)\\n state = thing.get(\\\"name\\\")\\n if state is None or len(thing) == 0:\\n return (jsonify({\\\"error\\\": \\\"Missing name\\\"}), 400)\\n s = State()\\n s.name = state\\n s.save()\\n return (jsonify(s.to_dict()), 201)\",\n \"def create_state():\\n data = {}\\n for key in request.form.keys():\\n \\tfor value in request.form.getlist(key):\\n \\t\\tdata[key] = value\\n try:\\n ''' Check that name key is in data '''\\n if not 'name' in data:\\n raise KeyError('name')\\n\\n ''' Check that name key is not null '''\\n if not data['name']:\\n raise TypeError(\\\"'name' cannot be NULL\\\")\\n\\n ''' Check that name key value is a string '''\\n if not type_test(data['name'], 'string'):\\n raise TypeError(\\\"'name' must be a string\\\")\\n\\n ''' Check if state already exists '''\\n query = State.select().where(State.name == data['name'])\\n if query.exists():\\n raise ValueError('State already exists')\\n\\n new = State.create(\\n name = data['name']\\n )\\n res = {}\\n res['code'] = 201\\n res['id'] = new.id\\n res['msg'] = \\\"State was created successfully\\\"\\n return res, 201\\n except TypeError as e:\\n response = {}\\n response['code'] = 400\\n response['msg'] = e.message\\n return response, 400\\n except ValueError as e:\\n response = {}\\n response['code'] = 10001\\n response['msg'] = e.message\\n return response, 409\\n except KeyError as e:\\n response = {}\\n response['code'] = 40000\\n response['msg'] = 'Missing parameters'\\n return response, 400\\n except Exception as e:\\n print e.message\\n abort(500)\",\n \"def state(self, state: \\\"StatusState\\\"):\\n if state is None:\\n raise ValueError(\\\"Invalid value for `state`, must not be `None`\\\")\\n if isinstance(state, Enum):\\n self._attrs[\\\"state\\\"] = state.value\\n else:\\n self._attrs[\\\"state\\\"] = state # If you supply a string, we presume you know the service will take it.\",\n \"def new_state():\\n return ''.join(random.choice(string.ascii_uppercase + string.digits)\\n for x in range(32))\",\n \"def setstate(self,name,state):\\n if (name not in KFNode.names):\\n print ' state name ',name,' not in KNode!'\\n self.states[name]=state.copy()\\n self.status = name\\n return\",\n \"def state(self, state: str) -> None:\\n self._state = state\",\n \"def from_esi_name(cls, esi_state_name: str) -> \\\"Structure.State\\\":\\n STATES_ESI_MAP = {\\n \\\"anchor_vulnerable\\\": cls.ANCHOR_VULNERABLE,\\n \\\"anchoring\\\": cls.ANCHORING,\\n \\\"armor_reinforce\\\": cls.ARMOR_REINFORCE,\\n \\\"armor_vulnerable\\\": cls.ARMOR_VULNERABLE,\\n \\\"deploy_vulnerable\\\": cls.DEPLOY_VULNERABLE,\\n \\\"fitting_invulnerable\\\": cls.FITTING_INVULNERABLE,\\n \\\"hull_reinforce\\\": cls.HULL_REINFORCE,\\n \\\"hull_vulnerable\\\": cls.HULL_VULNERABLE,\\n \\\"online_deprecated\\\": cls.ONLINE_DEPRECATED,\\n \\\"onlining_vulnerable\\\": cls.ONLINING_VULNERABLE,\\n \\\"shield_vulnerable\\\": cls.SHIELD_VULNERABLE,\\n \\\"unanchored\\\": cls.UNANCHORED,\\n \\\"offline\\\": cls.POS_OFFLINE,\\n \\\"online\\\": cls.POS_ONLINE,\\n \\\"onlining\\\": cls.POS_ONLINING,\\n \\\"reinforced\\\": cls.POS_REINFORCED,\\n \\\"unanchoring \\\": cls.POS_UNANCHORING,\\n }\\n return (\\n STATES_ESI_MAP[esi_state_name]\\n if esi_state_name in STATES_ESI_MAP\\n else cls.UNKNOWN\\n )\",\n \"def get_new_state():\\n state = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in xrange(32))\\n return state\",\n \"def make_costate_names(states):\\n\\n return [sympify('lam'+str(s.name).upper()) for s in states]\",\n \"def col_strings(self):\\n return [self.name, self.room, \\n \\\":\\\".join(['%02X' % x for x in self.address]), self.state_str()]\",\n \"def add_state(self, state):\\n self._validate_state(state)\\n self._state.add(state)\",\n \"def create_diseasestate_column(num_ppl, seed=1):\\n # initialize all 0s array\\n initial_diseasestate = np.zeros(num_ppl)\\n # infect exactly `seed` number of elements\\n initial_diseasestate[np.random.choice(num_ppl, seed)] = 1\\n # return infection state\\n return initial_diseasestate\",\n \"def abbr_2_st(state_series, abbr_2_st=True):\\n us_state_abbrev = {\\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 if abbr_2_st == True:\\n inv_map = {v: k for k, v in us_state_abbrev.items()}\\n full_names = []\\n for abbv in state_series:\\n full_names.append(inv_map[abbv])\\n return full_names\\n else:\\n # Return Abbreviation\\n abbvs = []\\n for full_name in state_series:\\n abbvs.append(us_state_abbrev[full_name])\\n return abbvs\",\n \"def upgrade_state_dict_named(self, state_dict, name):\\n layer_norm_map = {\\\"0\\\": \\\"self_attn_layer_norm\\\", \\\"1\\\": \\\"final_layer_norm\\\"}\\n for old, new in layer_norm_map.items():\\n for m in (\\\"weight\\\", \\\"bias\\\"):\\n k = \\\"{}.layer_norms.{}.{}\\\".format(name, old, m)\\n if k in state_dict:\\n state_dict[\\\"{}.{}.{}\\\".format(name, new, m)] = state_dict[k]\\n del state_dict[k]\",\n \"def new_index_name(self, column, unique=False):\\n table_name = self.name.lstrip('migrate_')\\n column = column.replace(', ', '')\\n return '{}_{}_{}{}'.format(table_name, column, self._random_string(6), '_unique' if unique else '')\",\n \"def state(self, statename, value=None):\\n if statename in self.v:\\n raise ValueError, \\\"state already exists\\\"\\n self.rv[statename]=len(self.v)\\n self.v[statename]=value\",\n \"def _state_container_prefix(self):\\n return self._name_camel_plural\",\n \"def column_name(self) -> Optional[str]:\\n return pulumi.get(self, \\\"column_name\\\")\",\n \"def convert_state_name_to_id(exploration_id, state_name):\\n if state_name == feconf.END_DEST:\\n return feconf.END_DEST\\n return get_state_by_name(exploration_id, state_name).id\",\n \"def clean_state(self):\\n return self.cleaned_data['state'].upper()\",\n \"def genStatesCode(self):\\n for s, d in self.info['machine'].items():\\n transition_code_arr = []\\n for t in self.info['transitionnames']:\\n tcode = self.tmpl['transition_none'].render(transition=t)\\n if t in d['transitions'].keys():\\n tcode = self.tmpl['transition_ok'].render(transition=t, post=d['transitions'][t])\\n transition_code_arr.append(tcode)\\n transition_code = '\\\\n'.join(transition_code_arr) + '\\\\n'\\n state_code = self.tmpl['concreatestate'].render(state=s.title(), description=d['description'])\\n self.codeinfo[s.lower()+\\\".py\\\"] = '\\\\n'.join([state_code, transition_code]) + '\\\\n'\",\n \"def wrap_columns_name(self, format_string):\\n self._data_frame = self._data_frame.rename(\\n columns=lambda column: format_string.format(column)\\n )\",\n \"def put(cls, new_state: TState) -> \\\"State[Tuple, TState]\\\":\\n return State(lambda state: (Unit, new_state))\",\n \"def changeState(self, node, name, state):\",\n \"def __str__(self):\\n return \\\"\\\".join(list(map(lambda row: ''.join(row), self.state)))\",\n \"def rename_column_values_for_comparison(df, sourcename):\\n\\n # at the national level, only have information for 'FlowName' = 'total'\\n # and 'Compartment' = 'total'. At state/county level, have information\\n # for fresh/saline and ground/surface water. Therefore, to compare\\n # subset data to national level, rename to match national values.\\n if sourcename == 'USGS_NWIS_WU':\\n df['FlowName'] = np.where(\\n df['ActivityConsumedBy'] != 'Livestock', 'total', df['FlowName'])\\n df['Compartment'] = df['Compartment'].str.replace(\\n 'ground', 'total', regex=True)\\n df['Compartment'] = df['Compartment'].str.replace(\\n 'surface', 'total', regex=True)\\n\\n return df\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59332365","0.5794769","0.57316923","0.56383705","0.56352866","0.5583133","0.55823433","0.5517401","0.5467954","0.5395791","0.5355729","0.53275317","0.5282603","0.52656084","0.5245819","0.5232131","0.5232131","0.52084243","0.51937133","0.514762","0.51289505","0.51252705","0.5110786","0.5110786","0.5074194","0.50586474","0.50367874","0.5003475","0.49841824","0.49837464","0.49758875","0.4950071","0.49471828","0.4940832","0.4940448","0.49374822","0.49343312","0.49328962","0.49303487","0.49254853","0.49175844","0.4910829","0.4894083","0.48865873","0.48753214","0.48705012","0.4825211","0.48214263","0.48100886","0.48039433","0.4800711","0.47999987","0.47996306","0.4786036","0.47710487","0.47710487","0.47671086","0.47671086","0.47486627","0.47458178","0.4740989","0.47405234","0.47261548","0.47245994","0.47172546","0.47125658","0.47115028","0.4708438","0.46960527","0.46922272","0.46870667","0.4685083","0.46767542","0.46731478","0.4661704","0.46532544","0.46521345","0.46518108","0.4650722","0.46489194","0.4636655","0.46291816","0.46288106","0.46262822","0.46262103","0.4620822","0.46160585","0.46147913","0.46107915","0.46049738","0.46040928","0.4596684","0.45826736","0.45826256","0.45717525","0.45692673","0.45560956","0.45550188","0.45476082","0.45468557"],"string":"[\n \"0.59332365\",\n \"0.5794769\",\n \"0.57316923\",\n \"0.56383705\",\n \"0.56352866\",\n \"0.5583133\",\n \"0.55823433\",\n \"0.5517401\",\n \"0.5467954\",\n \"0.5395791\",\n \"0.5355729\",\n \"0.53275317\",\n \"0.5282603\",\n \"0.52656084\",\n \"0.5245819\",\n \"0.5232131\",\n \"0.5232131\",\n \"0.52084243\",\n \"0.51937133\",\n \"0.514762\",\n \"0.51289505\",\n \"0.51252705\",\n \"0.5110786\",\n \"0.5110786\",\n \"0.5074194\",\n \"0.50586474\",\n \"0.50367874\",\n \"0.5003475\",\n \"0.49841824\",\n \"0.49837464\",\n \"0.49758875\",\n \"0.4950071\",\n \"0.49471828\",\n \"0.4940832\",\n \"0.4940448\",\n \"0.49374822\",\n \"0.49343312\",\n \"0.49328962\",\n \"0.49303487\",\n \"0.49254853\",\n \"0.49175844\",\n \"0.4910829\",\n \"0.4894083\",\n \"0.48865873\",\n \"0.48753214\",\n \"0.48705012\",\n \"0.4825211\",\n \"0.48214263\",\n \"0.48100886\",\n \"0.48039433\",\n \"0.4800711\",\n \"0.47999987\",\n \"0.47996306\",\n \"0.4786036\",\n \"0.47710487\",\n \"0.47710487\",\n \"0.47671086\",\n \"0.47671086\",\n \"0.47486627\",\n \"0.47458178\",\n \"0.4740989\",\n \"0.47405234\",\n \"0.47261548\",\n \"0.47245994\",\n \"0.47172546\",\n \"0.47125658\",\n \"0.47115028\",\n \"0.4708438\",\n \"0.46960527\",\n \"0.46922272\",\n \"0.46870667\",\n \"0.4685083\",\n \"0.46767542\",\n \"0.46731478\",\n \"0.4661704\",\n \"0.46532544\",\n \"0.46521345\",\n \"0.46518108\",\n \"0.4650722\",\n \"0.46489194\",\n \"0.4636655\",\n \"0.46291816\",\n \"0.46288106\",\n \"0.46262822\",\n \"0.46262103\",\n \"0.4620822\",\n \"0.46160585\",\n \"0.46147913\",\n \"0.46107915\",\n \"0.46049738\",\n \"0.46040928\",\n \"0.4596684\",\n \"0.45826736\",\n \"0.45826256\",\n \"0.45717525\",\n \"0.45692673\",\n \"0.45560956\",\n \"0.45550188\",\n \"0.45476082\",\n \"0.45468557\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57571137"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":13287,"cells":{"query":{"kind":"string","value":"This class holds the windows which shows the create experiment widget."},"document":{"kind":"string","value":"def __init__(self,currentExperiment):\n super(AmoebaCreateExperimentWindow,self).__init__()\n\n self.currentExperiment = currentExperiment\n\n #Create the window\n self.subWindow = QMdiSubWindow()\n\n self.widget = AmoebaCreateExperiment(self.subWindow,self.currentExperiment)\n \n #Create the UI.\n self.setWindowTitle(\"Create a new experiment.\")\n\n self.scroll = QScrollArea()\n\n self.scroll.setMinimumWidth(270)\n self.scroll.setWidget(self.widget)\n self.scroll.setWidgetResizable(True)\n\n #Connect button to next function.\n self.subWindow.setWidget(self.scroll)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def createWidgets(self):\n raise NotImplementedError","def showUI(cls):\r\n win = cls()\r\n win.create()\r\n return win","def build_window(self):\n\n main_frame = tk.Frame(self.root)\n main_frame.pack(fill='both')\n\n self.open_machine_learner_window_button = tk.Button(main_frame, text=\"Open Machine Learner\")\n self.open_machine_learner_window_button.bind('<Button-1>', self.open_machine_learner_window)\n self.open_machine_learner_window_button.pack(side=\"left\")\n\n self.open_web_crawler_window_button = tk.Button(main_frame, text=\"Open Web Crawler\")\n self.open_web_crawler_window_button.bind('<Button-1>', self.open_web_crawler_window)\n self.open_web_crawler_window_button.pack(side=\"left\")\n\n self.open_webpage_classifier_window_button = tk.Button(main_frame, text=\"Open WebPage Classifier\")\n self.open_webpage_classifier_window_button.bind('<Button-1>', self.open_webpage_classifier_window)\n self.open_webpage_classifier_window_button.pack(side=\"left\")\n\n self.run_steady_state_genetic_button = tk.Button(main_frame, text=\"Run Steady State\")\n self.run_steady_state_genetic_button.bind('<Button-1>', self.run_steady_state)\n self.run_steady_state_genetic_button.pack(side=\"left\")\n\n # Protocol for closing window using 'x' button\n self.root.protocol(\"WM_DELETE_WINDOW\", self.on_closing_event)","def create(self):\n\n cv2.namedWindow(winname=self.title, flags=self.style)","def create_widgets( self ):","def create_widgets(self):","def createWidgets(self):\r\n top = self.winfo_toplevel()\r\n top.rowconfigure(0, weight=1)\r\n top.columnconfigure(0, weight=1)\r\n self.rowconfigure(0, weight=1)\r\n self.columnconfigure(0, weight=1) \r\n\r\n self.button_quit = tk.Button(self, text='Quit', command=self.quit)\r\n self.button_quit.grid(row=0, column=0, sticky=tk.N+tk.S+tk.E+tk.W)","def _create_example_window():\n return Window({\"warning\": False, \"state\": \"close\"})","def create_widgets(self):\n # self.var_spherical = IntVar()\n # self.var_3d = IntVar()\n # self.var_spatial_audio = IntVar()\n # self.button_open[\"command\"] = self.action_open\n # self.button_inject[\"command\"] = self.action_inject\n pass","def buildUI(self):\n\n if cmds.window(\"pyART_AddToCanvasWIN\", exists=True):\n cmds.deleteUI(\"pyART_AddToCanvasWIN\", wnd=True)\n\n # create the main window\n self.mainWin = QtWidgets.QMainWindow(self.pickerUI)\n\n # create the main widget\n self.mainWidget = QtWidgets.QWidget()\n self.mainWin.setCentralWidget(self.mainWidget)\n\n # create the mainLayout\n self.layout = QtWidgets.QVBoxLayout(self.mainWidget)\n\n # load stylesheet\n styleSheetFile = utils.returnNicePath(self.toolsPath, \"Core/Scripts/Interfaces/StyleSheets/animPicker.qss\")\n f = open(styleSheetFile, \"r\")\n self.style = f.read()\n f.close()\n\n self.mainWin.setStyleSheet(self.style)\n\n self.mainWin.setMinimumSize(QtCore.QSize(250, 400))\n self.mainWin.setMaximumSize(QtCore.QSize(250, 400))\n self.mainWin.resize(250, 400)\n\n # set qt object name\n self.mainWin.setObjectName(\"pyART_AddToCanvasWIN\")\n self.mainWin.setWindowTitle(\"Add Module To Canvas\")\n\n # label, listWidget, button\n label = QtWidgets.QLabel(\"Available Modules:\")\n label.setProperty(\"boldFont\", True)\n self.layout.addWidget(label)\n\n self.moduleList = QtWidgets.QListWidget()\n self.moduleList.setMaximumSize(230, 300)\n self.moduleList.setMinimumSize(230, 300)\n self.layout.addWidget(self.moduleList)\n\n # add modules to listWidget\n self.addModulesToList()\n\n # create add button\n button = QtWidgets.QPushButton(\"Add Selected To Canvas\")\n self.layout.addWidget(button)\n button.setObjectName(\"blueButton\")\n button.clicked.connect(self.addSelectedToCanvas)\n\n # show ui\n self.mainWin.show()","def createWidgets(self):\n layout = QHBoxLayout()\n \n self.logsItem = TestsView.TestsView(parent=self, local = self.local)\n \n self.resumeView = ResumeView.TextualView(parent=self)\n if QtHelper.str2bool( Settings.instance().readValue( key = 'TestRun/hide-resume-view' ) ):\n self.hideResumeView()\n\n self.graphView = GraphView.FlowChartView(parent=self)\n self.logsView = TextualView.TextualView2(parent=self)\n self.hexLogsView = DetailedView.DetailedView(parent=self)\n \n self.displayTab = QTabWidget()\n\n hSplitter = QSplitter(self)\n hSplitter.setOrientation(Qt.Vertical)\n\n hSplitter.addWidget( self.resumeView )\n hSplitter.addWidget( self.logsView )\n hSplitter.addWidget( self.hexLogsView )\n\n self.displayTab.addTab(hSplitter, self.tr('Events') )\n self.displayTab.addTab(self.graphView, self.tr('Diagram') )\n \n defaultTab = Settings.instance().readValue( key = 'TestRun/default-tab-run' )\n self.displayTab.setCurrentIndex(int(defaultTab)) \n \n self.currentEdit = QLineEdit()\n self.currentEdit.setReadOnly(True)\n self.currentEdit.setStyleSheet(\"QLineEdit { background-color : #F0F0F0; color: grey; }\")\n\n leftFrame = QFrame()\n leftLayout = QVBoxLayout()\n leftLayout.setContentsMargins(0, 0, 0, 0) \n leftFrame.setLayout(leftLayout)\n\n leftLayout.addWidget(self.currentEdit)\n leftLayout.addWidget(self.displayTab)\n\n v_splitter = QSplitter(self) \n v_splitter.addWidget( self.logsItem )\n v_splitter.addWidget( leftFrame )\n v_splitter.setStretchFactor(1, 1)\n\n layout.addWidget(v_splitter)\n \n self.setLayout(layout)","def widgets(self):\r\n self.setWindowTitle(\"PyCrypt\")\r\n self.setMinimumSize(QSize(500, 500))\r\n self.setMaximumSize(QSize(500, 500))\r\n# Adding the sub def for widgets etc\r\n self.add_menus_and_status()\r\n self.add_buttons()","def _create_window(self):\n self.window = Gtk.Window()\n self.window.set_title(\"Yapsy Example\")\n self.window.set_default_size(400, 400)\n self.window.connect(\"destroy\", lambda w: Gtk.main_quit())\n # PluginList() is a composite widget that shows all installed plugins\n # in a Gtk.TreeView. See widgets.py\n self._plugin_list = PluginList(self.window)\n box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)\n box.pack_start(self._plugin_list, True, True, 0)\n box.show_all()\n self.window.add(box)","def _init_widgets(self):\n # Container frame\n self.container = Frame(self)\n # Workspace block\n self.main_container = Frame(self.container)\n\n self.text = Label(self.main_container)\n self.text.config(text=\"PyEventLogViewer is a timeline-based tool used to simplify the way\\n\"\n \"a user can view and explore Windows EVTX files. To begin using this\\n\"\n \"software you must do the following:\\n\\n\"\n \"\\t1) File → New → 'Create a new project'\\n\"\n \"\\t2) Tools → Import Log File → 'Open a specified EVTX file'\\n\"\n \"\\t3) Explore the presented timeline.\\n\"\n \"\\t4) Double-click a specific record to view the XML data for that record.\\n\"\n \"\\t5) File → Export → 'Generate a CSV or HTML file for timeline presentation.'\\n\\n\"\n \"At this point, only System and Security EVTX files are parsable with this software.\")\n\n self.show_var = BooleanVar()\n self.show_check = Checkbutton(self.main_container, text=\"Don't Show on Startup\", variable=self.show_var)\n\n # Action block\n self.button_ok = Button(self.main_container, text='Ok', underline=0, command=self.callback_close)\n self.bind('<Return>', self.callback_close)\n self.bind('<Escape>', self.callback_close)\n\n # Focus on window - required for binds to work.\n self.focus_set()","def createWindow(self):\r\n\t\t# give the window a title\r\n\t\tself.parent.title( 'Acrobat Data Acquisition')\r\n\t\t# set the style\r\n\t\tself.style = ttk.Style()\r\n\t\tself.style.theme_use('default')\r\n\t\tself.pack(fill= tk.BOTH, expand=1)","def createUI(self):\n\n q.getQItem(windowID, QtWidgets.QWidget)\n cmds.setParent(q.fullPath)\n\n # ################################################\n # Active Render Layer\n\n # cmds.separator(height=12, style='none')\n addFrameLayout(\n '%s_frameLayoutLayers' % windowID,\n 'Visible Render Layer', collapsable=False,\n labelVisible=False,\n marginHeight=0\n )\n\n addRowLayout(\n '%s_rowLayoutActiveRenderLayer' % windowID,\n 4,\n columnAlign4=('left', 'left', 'right', 'right'),\n columnAttach4=('left', 'both', 'right', 'right'),\n columnWidth4=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\n )\n )\n\n\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\n image='RS_create_layer', size=(21, 21))\n addOptionMenu('%s_selectActiveLayer' % windowID,\n 'Active Layer ', (), rsSelectActiveLayer)\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\n rsOpenRenderSetupWindow, image='render_setup.png',\n size=(21, 21))\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\n size=(21, 21))\n\n # ################################################\n # Work Render Layers\n\n cmds.setParent(q.fullPath)\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\n 'Work Render Layer', collapsable=False,\n labelVisible=False, marginHeight=0)\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\n columnAlign3=('left', 'left', 'right'),\n columnAttach3=('left', 'both', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\n\n cmds.separator()\n addOptionMenu('%s_selectVisibleLayer' % windowID,\n 'Visible Layer ', (), rsSelectVisibleLayer)\n cmds.separator()\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=12, style='none')\n\n # ################################################\n # Collections\n\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\n labelVisible=False, marginHeight=0)\n\n addRowLayout(\n '%s_rowLayout02' % windowID,\n 6,\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\n columnWidth6=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n )\n )\n\n addButton('rsAddCollection', 'Add', rsAddCollection)\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\n image='selectObject.png', size=(21, 21))\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\n size=(21, 21), image='QR_rename.png')\n addButton('rsDuplicateShader', 'Duplicate Shader',\n duplicateShader, size=(21, 21), image='newPreset.png')\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\n image='QR_refresh.png')\n\n # ###########################\n # Filter List\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout03' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\n\n addTextField('%s_filterShaderList' % windowID, 'Search',\n rsFilterShaderList_off, rsFilterShaderList_off,\n window.updateUI)\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\n\n # ###########################\n # The shaders scroll list\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\n + 12)\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\n rsShaderScrollList_doubleClick,\n rsShaderScrollList_onSelect,\n rsShaderScrollList_deleteKey)\n\n # Add popup menu:\n\n cmds.popupMenu('rsShaderScrollListPopupMenu',\n parent='%s_ShaderScrollList' % windowID,\n allowOptionBoxes=False, markingMenu=True,\n postMenuCommand=postMenuCommand)\n cmds.menuItem('%s_popupMenuItem02' % windowID,\n label='Duplicate Shader', command=duplicateShader)\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem04' % windowID,\n label='Graph Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem03' % windowID,\n label='Select Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem05' % windowID,\n label='Select Assigned Shapes')\n cmds.menuItem('%s_popupMenuItem06' % windowID,\n label='Select Assigned Transforms')\n\n # ##################################################\n # Arnold Property Overrides\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout20' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n addRowLayout('%s_rowLayout05' % windowID, 2,\n columnAlign2=('left', 'both'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\n 'Apply Arnold Property Overrides', 'plainLabelFont')\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\n rsArnoldPropertyOverridesCheckBox,\n rsArnoldPropertyOverridesCheckBox)\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n # Column Layout to toggle\n\n cmds.setParent('%s_columnLayout20' % windowID)\n cmds.columnLayout(\n '%s_columnLayout02' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n addCheckboxes('%s_columnLayout02' % windowID)\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\n visible=False)\n\n # #################################################\n # Shader Override\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout21' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n addRowLayout('%s_rowLayout06' % windowID, 2,\n columnAlign2=('left', 'right'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\n 'plainLabelFont')\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n\n cmds.setParent('%s_columnLayout21' % windowID)\n cmds.columnLayout(\n '%s_columnLayout03' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('both', 4),\n adjustableColumn=True,\n rowSpacing=0,\n )\n cmds.setParent('%s_columnLayout03' % windowID)\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\n rsShaderOverridesMenu)\n\n global selectedShaderOverride\n\n # default selection\n\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\n visible=False)\n\n # #################################################\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=10, style='none')\n\n # #################################################\n # Extras\n\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\n collapsable=True, marginHeight=0,\n labelVisible=False)\n\n # #################################################\n # Add & Assign Shader Groups\n\n addFrameLayout(\n '%s_frameLayout05' % windowID,\n 'Add & Assign Shader Groups',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=False,\n labelVisible=True,\n )\n\n # Add the renamer window\n\n self.gwCustomRenamer = CustomRenamer()\n self.gwCustomRenamer.createUI()\n\n # #################################################\n # AutoConnect\n\n cmds.setParent('%s_frameLayout50' % windowID)\n\n addFrameLayout(\n '%s_frameLayout03' % windowID,\n 'Adobe Connector',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\n 'left'), columnAttach3=('both', 'both', 'both'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addButton('updateConnections', '> Update Connections <',\n updateConnections)\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\n addButton('editTexture', 'Edit Texture', editTexture)\n\n # After Effects\n\n cmds.setParent('%s_frameLayout03' % windowID)\n addRowLayout('%s_rowLayout11' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\n addText('%s_text90' % windowID, 'Send to After Effects:')\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\n\n # #################################################\n # Render Setup /\n # Output settings\n\n cmds.setParent('%s_frameLayout50' % windowID)\n addFrameLayout(\n '%s_frameLayout04' % windowID,\n 'Output Settings',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout08' % windowID, 1,\n columnAlign1='center', columnAttach1='both',\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\n addButton('%s_revealOutputDirectory' % windowID,\n 'Output path not set yet', rsRevealOutputDirectory)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout09' % windowID, 3,\n columnAlign3=('left', 'right', 'right'),\n columnAttach3=('left', 'right', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\n\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\n rsSelectOutputTemplate)\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\n rsSelectOutputVersion)\n cmds.menuItem(label='v001')\n\n cmds.setParent('%s_rowLayout09' % windowID)\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\n rsIncrementOutputVersion, size=(21, 21))\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout10' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\n rsOutputTemplatesMenu)\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\n rsSetFPSMenu)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout12' % windowID, 4,\n columnAlign4=('right', 'left', 'right', 'left'),\n columnAttach4=('both', 'both', 'both', 'both'),\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\n\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\n setInFrame, setInFrame)\n\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\n setOutFrame, setOutFrame)","def createWindow():\n\n windowName = \"ObjectSpawner\"\n\n if cmds.window(windowName, query=True, exists=True):\n cmds.deleteUI(windowName)\n\n cmds.window(windowName)\n\n populateUI()\n enableEditorDrop()\n\n cmds.showWindow(windowName)","def create_widgets(self):\r\n self.create_containers()\r\n self.setup_containers()\r\n self.create_panel_widgets()\r\n self.setup_scrollbar()","def __init__(self,subWindow,currentExperiment):\n super(AmoebaCreateExperiment,self).__init__()\n self.stage = 0\n self.currentExperiment = currentExperiment\n #self.XMLWriter = ExperimentXMLWriter()\n self.XMLWriter = Amoeba_experiment()\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Create new experiment.\"\n\n self.subWindow = subWindow\n\n #Create a scroll bar for the summary area\n self.layout = QVBoxLayout()\n\n #Create the widgets\n self.SetFundamentalParameters = AmoebaSetFundamentalParameters()\n self.ShowAllInstruments = AmoebaShowAllInstuments()\n self.LinkInstruments = LinkInstrumentsForm()\n\n self.next = QPushButton(\"Next\")\n self.next.clicked.connect(self.next_pressed)\n\n #Add to the scroll widget\n self.layout.addWidget(self.SetFundamentalParameters)\n self.layout.addWidget(self.ShowAllInstruments)\n self.layout.addWidget(self.LinkInstruments)\n self.layout.addWidget(self.next)\n\n #Add the Widgets to the Subwindow\n self.setLayout(self.layout)\n\n #Hide all the widgets that will later be revealed.\n self.SetFundamentalParameters.hide()\n self.LinkInstruments.hide()","def showUI(cls):\r\n win = cls(uiFile)\r\n win.create()\r\n return win","def show(self, window):\r\n\r\n return","def _setup_ui(self):\n\n self.window = ui.Widget()\n self.window.dimensions = ui.normalize_dimension((\n 0, 0,\n self.normalized_screen_resolution[0],\n self.normalized_screen_resolution[1]\n ))\n self.window.background_color = ImageColor.getcolor('#000000', 'RGB')\n\n interface_frame = ui.Widget(parent=self.window)\n interface_frame.dimensions = ui.normalize_dimension((\n self.preview_renderer.window[2],\n 0,\n self.normalized_screen_resolution[0] - self.preview_renderer.window[2],\n self.normalized_screen_resolution[1]\n ))\n interface_frame.background_color = ImageColor.getcolor('#ffffff', 'RGB')\n\n number = ui.LabelWidget(\"\",\n name=NAME_GET_STARTED,\n parent=interface_frame,\n align=\"center\",\n font_color=(0, 0, 0, 255))\n number.dimensions = (\n 5, 5,\n interface_frame.width - 10,\n interface_frame.height - 10\n )","def __init__(self):\n self.r = Tk()\n self.r.title(\"Website Library 123\")\n self.r.geometry(\"500x250\")\n self.r.configure(background=\"#ddaf7e\")\n\n '''Configuring So that the First Window holds buttons'''\n\n self.title = Label(self.r, text=\"Website Library\", bg=\"#ddaf7e\", font=\"Calibri 26\").pack()\n self.divider = Label(self.r, text=\" \"*100, bg=\"#ddaf7e\").pack()\n self.saved = Button(self.r, text=\"View Saved Websites\", font=\"Verdana 15\", command=lambda: self.newwind(1)).pack(pady=10)\n self.addnew = Button(self.r, text=\"Add New Websites\", font=\"Verdana 15\", command=lambda: self.newwind(2)).pack(pady=10)\n self.r.protocol(\"WM_DELETE_WINDOW\", self.on_closing)\n self.r.mainloop()","def create(self, parent):\n self.widget = _QMainWindow(parent)","def createWindow(self):\n\n # create window, set basic attributes\n w = gtk.Window(gtk.WINDOW_TOPLEVEL)\n w.set_size_request(*self.__def_win_size__)\n w.set_decorated(False)\n #w.fullscreen()\n #w.unfullscreen()\n w.set_title(self.__name__)\n w.connect(\"destroy\", gtk.main_quit)\n\n # declare buttons and their associated handlers\n controls = (\n (\"open_button\", gtk.ToolButton(gtk.STOCK_OPEN), self.onPlay),\n (\"play_button\", gtk.ToolButton(gtk.STOCK_MEDIA_PLAY), self.onPlay),\n (\"stop_button\", gtk.ToolButton(gtk.STOCK_MEDIA_STOP), self.onStop),\n (\"quit_button\", gtk.ToolButton(gtk.STOCK_QUIT), gtk.main_quit)\n )\n\n # as well as the container in which to put them\n box = gtk.HButtonBox()\n\n # for every widget, connect to its clicked signal and add it\n # to the enclosing box\n for name, widget, handler in controls:\n widget.connect(\"clicked\", handler)\n box.pack_start(widget, True)\n setattr(self, name, widget)\n\n viewer = gtk.DrawingArea()\n viewer.modify_bg(gtk.STATE_NORMAL, viewer.style.black)\n\n # we will need this later\n self.xid = None\n\n # now finally do the top-level layout for the window\n layout = gtk.VBox(False)\n layout.pack_start(viewer)\n\n # subclasses can override childWidgets() to supply\n # custom controls\n layout.pack_start(self.customWidgets(), False, False)\n layout.pack_end(box, False, False)\n w.add(layout)\n w.show_all()\n\n # we want to return only the portion of the window which will\n # be used to display the video, not the whole top-level\n # window. a DrawingArea widget is, in fact, an X11 window.\n return viewer","def createWindow(self, type):\n # this = Browser(self.url())\n # this.show()\n\n self.popup = SequanixQWebView(**self.kwargs)\n self.popup.setObjectName(\"web_content\")\n self.popup.setWindowTitle(\"Sequana browser\")\n self.popup.page().windowCloseRequested.connect(self.popup.close)\n self.popup.show()\n return self.popup","def openWindow(self):\n # self.showSessionAct.setEnabled(False)\n self.musketeers_widget = MusketeersWidget(parent=self)\n self.setCentralWidget(self.musketeers_widget)\n self.saveGroupMenu = QAction('Save Group', self.fileMenu)\n self.fileMenu.addAction(self.saveGroupMenu)\n self.saveGroupMenu.triggered.connect(self.musketeers_widget.session_widget.save_group)","def setupWindow(self):\n\n\t\tself.main_menu_window = MenuFrame.MainMenuFrame(self.uiCoordinator)\n\t\tself.menu_window = self.main_menu_window._mf\n\t\tself.score_window = self.main_menu_window._hf\n\t\tself.instructions_window = self.main_menu_window._if\n\t\tself.menu_window.playButton.focus_set()","def create_widget(self):\n pass","def create_window(self, img, roi, name):\n\n self.window = SpinBalanceDialog()\n\n # call the user-implemented functionality\n self.window.main(img, roi)\n # show the window\n self.window.show()\n\n return self.window","def open_main_window(self):\r\n track_terms_dic = ''\r\n sg.theme(self.look)\r\n\r\n layout = [[sg.Text('Welcome to tweeet monitor ')],\r\n [sg.Text('Please enter Details ')],\r\n [sg.Text('User Mail', size=(15, 1)), sg.InputText()],\r\n [sg.Text('Timout', size=(15, 1)), sg.InputText('', enable_events=True, key='-DIGITS-')],\r\n [sg.Text('')],\r\n [sg.Text('You can select an existing list or create a new one '),\r\n sg.Combo(self.files, default_value='Select Track Terms List ', key='-COMBO1-')],\r\n [sg.Text('')],\r\n [sg.Button('Select Exists List'), sg.Button('Create a New List')],\r\n [sg.Text('\\n')],\r\n [sg.Button('Start Monitor'), sg.Button('Exit')]\r\n ]\r\n\r\n window = sg.Window('Monitor tweeter', layout)\r\n # Event Loop\r\n while True:\r\n event, values = window.read()\r\n\r\n if event == sg.WIN_CLOSED:\r\n exit()\r\n elif event == 'Select Exists List' or event == 'Create a New List' or event == 'Start Monitor':\r\n user_mail = values[0]\r\n timeout = values['-DIGITS-']\r\n list_dic = values['-COMBO1-']\r\n\r\n if self.check(user_mail) == 'Invalid Email':\r\n self.info_popup_window('You Enter not valid mail ', 'Info', self.look)\r\n elif event == 'Select Exists List':\r\n if list_dic == 'Select Track Terms List ':\r\n self.info_popup_window('Track Terms List ', 'Info', self.look)\r\n else:\r\n file_name = self.path + self.bachslash + list_dic\r\n os.system(file_name)\r\n track_terms_dic = list_dic\r\n elif event == 'Create a New List':\r\n track_terms_dic = self.open_window()\r\n track_terms_dic = track_terms_dic + '.txt'\r\n elif event == 'Start Monitor':\r\n if track_terms_dic == '':\r\n self.info_popup_window('Please, Create new Dictionary or select one ', 'Info', self.look)\r\n elif track_terms_dic != '':\r\n file_name = self.path + self.bachslash + track_terms_dic\r\n my_file = open(file_name, \"r\")\r\n content = my_file.read()\r\n content = content.split(\"\\n\")\r\n content = self.cleanList(content)\r\n # print(content)\r\n my_file.close()\r\n now = datetime.now()\r\n date_time = now.strftime(\"%m/%d/%Y, %H:%M:%S\")\r\n dict_list = {'User': user_mail,\r\n 'Timeout': timeout,\r\n 'Dictionary': list_dic,\r\n 'Create Date': date_time,\r\n 'track_terms_list': content\r\n }\r\n header = ['user_mail', 'Timeout', 'Dictionary', 'Create Date', 'list words']\r\n if os.path.isfile(self.file_track_terms_audit) == False:\r\n # check if the file exsist = if not: create file and print header to the file\r\n with open(self.file_track_terms_audit, 'a', newline='\\n') as file:\r\n try:\r\n write = csv.writer(file)\r\n write.writerow(header)\r\n write.writerows(self.values_list)\r\n file.close()\r\n except:\r\n print(\"Something went wrong when writing to the file\")\r\n else:\r\n self.values_list = list(dict_list.values())\r\n # print ('self.values_list :****',self.values_list)\r\n with open(self.file_track_terms_audit, 'a', newline='\\n') as file:\r\n try:\r\n write = csv.writer(file)\r\n self.values_list = [self.values_list]\r\n write.writerows(self.values_list)\r\n file.close()\r\n except:\r\n print(\"Something went wrong when writing to the file\")\r\n print('self.values_list:', self.values_list)\r\n\r\n window.close()\r\n\r\n print('track_terms_dic: ', track_terms_dic)\r\n print('dict_list:', dict_list)\r\n return (dict_list)\r\n\r\n # always check for closed window\r\n if event in (sg.WIN_CLOSED, 'Exit'):\r\n break\r\n\r\n if event == '-LIST-' and len(values['-LIST-']):\r\n sg.popup('Selected ', values['-LIST-'])\r\n\r\n if len(values['-DIGITS-']) and values['-DIGITS-'][-1] not in ('0123456789'):\r\n # delete last char from input\r\n window['-DIGITS-'].update(values['-DIGITS-'][:-1])\r\n\r\n window.close()","def __create_ui(self):\n vbox = gtk.VBox()\n\n # Create the viewable area of the file browser\n self.__view_port = gtk.ScrolledWindow()\n self.__view_port.set_policy(gtk.POLICY_AUTOMATIC,\n gtk.POLICY_AUTOMATIC)\n # Create the tree view and add it to the viewable area\n self.__tree_view = ProjectTreeView()\n self.__project_explorer = ProjectExplorer(self.window, self.__tree_view)\n self.__tree_view.connect('button_press_event',\n self.__on_treeview_button_press_event)\n self.__project_explorer.set_repository()\n self.__view_port.add(self.__tree_view)\n # Create the toolbar\n hbox = gtk.HBox()\n toolbar = gtk.Toolbar()\n toolbar.set_style(gtk.TOOLBAR_ICONS)\n toolbar.set_icon_size(gtk.ICON_SIZE_MENU)\n back = gtk.ToolButton(gtk.STOCK_GO_UP)\n back.connect('clicked', self.__on_back_clicked)\n toolbar.insert(back, 0)\n toolbar.insert(gtk.SeparatorToolItem(), 1)\n refresh = gtk.ToolButton(gtk.STOCK_REFRESH)\n refresh.connect('clicked', self.__on_refresh_clicked)\n toolbar.insert(refresh, 2)\n hbox.pack_start(toolbar, True, True, 0)\n vbox.pack_start(hbox, False, False, 0)\n vbox.pack_start(self.__view_port, True, True, 0)\n\n # Setup the create the buttons for:\n # New File, New Folder\n # ----------------------------------------------------------------------\n hbox1 = gtk.VBox()\n toolbar_actions = gtk.Toolbar()\n toolbar_actions.set_style(gtk.TOOLBAR_ICONS)\n toolbar_actions.set_icon_size(gtk.ICON_SIZE_MENU)\n new_file = gtk.ToolButton(gtk.STOCK_NEW)\n new_file.connect('clicked', self.__on_new_file_clicked_cb)\n toolbar_actions.insert(new_file, 0)\n new_dir = gtk.ToolButton(gtk.STOCK_OPEN) # TODO: use a custom icon\n new_dir.connect('clicked', self.__on_new_dir_clicked_cb)\n toolbar_actions.insert(new_dir, 1)\n hbox1.pack_start(gtk.HSeparator(), True, True, 0)\n hbox1.pack_start(toolbar_actions, True, True, 0)\n vbox.pack_end(hbox1, False, False, 0)\n # ----------------------------------------------------------------------\n vbox.show_all()\n # Attach the project explorer to GMate's side panel\n self.__side_panel = self.window.get_side_panel()\n self.__side_panel.add_tab(vbox, msg0005, gtk.STOCK_HARDDISK)","def setup_gui(self):\n # if there are more than 1 visualizer we need to assure that there\n # will not be tag conflicts\n BaseRealTimeVisualizer.setup_gui_lock.acquire()\n # look for valid tag\n dpg.create_context()\n\n self.id = 0\n while dpg.does_item_exist(f'main_window_{self.id}'):\n self.id += 1\n\n with dpg.texture_registry(show=False):\n dpg.add_dynamic_texture(\n width=self.width,\n height=self.height,\n default_value=np.zeros((self.width, self.height, 3)),\n tag=f'input_image_texture_{self.id}',\n )\n\n with dpg.window(\n tag=f'main_window_{self.id}',\n no_title_bar=True,\n autosize=True\n ):\n dpg.add_image(\n texture_tag=f'input_image_texture_{self.id}',\n tag=f'image_render_{self.id}',\n pos=(_PADDING, _PADDING)\n )\n\n dpg.set_global_font_scale(_FONT_SCALE)\n\n if self.id == 0:\n dpg.set_primary_window(f'main_window_{self.id}', True)\n dpg.create_viewport(\n title=self.title,\n width=self.width + _PADDING*2,\n height=self.height + _PADDING*2,\n resizable=True\n )\n dpg.setup_dearpygui()\n dpg.show_viewport()\n elif self.id == 1:\n dpg.set_primary_window('main_window_0', False)\n\n BaseRealTimeVisualizer.setup_gui_lock.release()","def open_generatorWindow(self):\n self.window = generatorWindow(self)\n self.hide()","def createWidgets(self):\n self.tab = WorkspaceTab( self )\n self.tab.setMinimumWidth(500)\n self.tab.setDocumentMode( False )\n self.tab.setMovable( True )\n\n # self.dockToolbar = QToolBar(self)\n # self.dockToolbar.setOrientation(Qt.Vertical)\n\n self.findWidget = FindReplace(self)\n self.findWidget.setDisabled(True)\n self.findWidget.hide()\n\n layout = QVBoxLayout()\n layout.addWidget( self.tab )\n layout.setContentsMargins(0,0,0,0)\n\n \n self.setLayout(layout)","def create_gui(self):\n\n selectors_widgets = list()\n\n for n in range(4):\n\n selectors_widgets.append(wd.Dropdown(\n options={'': 0, 'Orange': 1, 'Red': 2, 'Blue': 3, 'Green': 4},\n value=0,\n disabled=False,\n layout={'width': '148px'}\n ))\n\n self.confirm_button.on_click(\n self.create_combination_and_rate_function())\n self.user_interact.children = [self.selectors, self.confirm_button]\n\n self.selectors.children = selectors_widgets","def inicialUI(self):\r\n\r\n self.setGeometry(500, 500, 500, 500)\r\n self.setWindownTitle(\"Pesquisa\")\r\n self.displayWidgets()\r\n\r\n self.show()","def build_frames(self):\n self.cntrl_frame = tk.PanedWindow(self.root)\n self.cntrl_frame.pack(side = tk.TOP, padx = 1, pady = 1, fill = tk.Y)\n self.info_frame_1 = tk.PanedWindow(self.root)\n self.info_frame_1.pack(side = tk.TOP, padx = 1, pady = 2, fill = tk.Y)","def create(self, window):\r\n\r\n # Set the size of the editor area.\r\n if self.editor_area_size != (-1, -1):\r\n window.editor_area_size = self.editor_area_size\r\n\r\n # If the perspective has specific contents then add just those.\r\n if len(self.contents) > 0:\r\n self._add_contents(window, self.contents)\r\n\r\n # Otherwise, add all of the views defined in the window at their\r\n # default positions realtive to the editor area.\r\n else:\r\n self._add_all(window)\r\n\r\n # Activate the first view in every region.\r\n window.reset_views()\r\n \r\n return","def _open_window(self):\r\n\t\t# Creating the window\r\n\t\tself._window = Window(self, Locations.RESTAL)","def create_new_window():\n logging.debug(\"Function create_new_window() called\")\n\n new_window = tk.Toplevel()\n new_window.title(\"Test functions\")\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_origins()\",\n command=lambda: dss.update_origins(\n origin_list_=origin_list,\n champions_list_=champions_list,\n origin_counters_=origin_counters,\n ),\n )\n ButtonCal.grid(row=1, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_classes()\",\n command=lambda: dss.update_classes(\n class_list_=class_list,\n champions_list_=champions_list,\n class_counters_=class_counters,\n ),\n )\n ButtonCal.grid(row=2, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_classes_and_origins()\",\n command=lambda: dss.update_classes_and_origins(\n origin_list_=origin_list,\n champions_list_=champions_list,\n origin_counters_=origin_counters,\n class_list_=class_list,\n class_counters_=class_counters,\n ),\n )\n ButtonCal.grid(row=3, column=0)\n\n # is_in_game = tk.IntVar()\n # dss.create_gui_counter_with_plus_minus(window_tk=new_window, origin_index=1, counter=is_in_game, shift_between_upside_downside=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_champions_to_buy_from_ocr_detection()\",\n command=lambda: dss.update_champions_to_buy_from_ocr_detection(\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr__=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n ),\n )\n ButtonCal.grid(row=4, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"show_nonzero_counters_from_ocr()\",\n command=lambda: dss.show_nonzero_counters_from_ocr(\n tk_window=MainWindow,\n origin_champs_counters_=origin_champs_counters,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n df_=df,\n index_list=dss.update_champions_to_buy_from_ocr_detection(\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr__=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n )[1],\n ),\n )\n ButtonCal.grid(row=5, column=0)\n\n Labeling = tk.Label(\n new_window, text=\"Care additional points in below\", font=BOLDED_FONT\n )\n Labeling.grid(row=6, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"show_points_for_nonzero_counters_from_ocr()\",\n command=lambda: dss.show_points_for_nonzero_counters_from_ocr(\n tk_window=MainWindow,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n df_=df,\n index_list=dss.update_champions_to_buy_from_ocr_detection(\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr__=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n )[1],\n ),\n )\n ButtonCal.grid(row=7, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"show_nonzero_counters_with_points_from_ocr() OCR button\",\n command=lambda: dss.show_nonzero_counters_with_points_from_ocr(\n tk_window=MainWindow,\n origin_champs_counters_=origin_champs_counters,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n df_=df,\n index_list=dss.update_champions_to_buy_from_ocr_detection(\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr__=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n )[1],\n origin_list_=origin_list,\n origin_counters_=origin_counters,\n class_list_=class_list,\n class_counters_=class_counters,\n ),\n )\n ButtonCal.grid(row=8, column=0)\n\n Labeling = tk.Label(new_window, text=\"with Game\", font=BOLDED_FONT)\n Labeling.grid(row=0, column=1)\n\n ButtonCal = tk.Button(\n new_window, text=\"update_curent_ss()\", command=lambda: dss.update_curent_ss()\n )\n ButtonCal.grid(row=1, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_curent_cropped_ss_with_champions()\",\n command=lambda: dss.update_curent_cropped_ss_with_champions(),\n )\n ButtonCal.grid(row=2, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_ocr_results_champions()\",\n command=lambda: dss.update_ocr_results_champions(\n cropped_ss_with_champion_card_names=dss.crop_img,\n reader_=reader,\n ),\n )\n ButtonCal.grid(row=3, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_sorted_champions_to_buy()\",\n command=lambda: dss.update_sorted_champions_to_buy(\n ocr_results_sorted=dss.ocr_results_champions,\n champions_list_for_ocr_=champions_list_for_ocr,\n ),\n )\n ButtonCal.grid(row=4, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_champions_to_buy_from_ocr_detection()\",\n command=lambda: dss.update_champions_to_buy_from_ocr_detection(\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr__=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n ),\n )\n ButtonCal.grid(row=5, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"draw_rectangles_show_points_show_buttons_reset_counters() scan&go\",\n command=lambda: dss.draw_rectangles_show_points_show_buttons_reset_counters(\n rgb_colours_list_=rgb_colours_list,\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr_=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n tk_window=MainWindow,\n origin_champs_counters_=origin_champs_counters,\n df_=df,\n origin_list_=origin_list,\n champions_list_=champions_list,\n origin_counters_=origin_counters,\n class_list_=class_list,\n class_counters_=class_counters,\n round_counter=CounterOcrResultsRound,\n gold_counter=CounterOcrResultsGold,\n ),\n )\n ButtonCal.grid(row=6, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"filling_list_with_counter_for_namedtuple(4)\",\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\n field_to_check=4,\n input_list=champion_info,\n origin_list_=origin_list,\n class_list_=class_list,\n origin_counters_=origin_counters,\n class_counters_=class_counters,\n df_=df,\n ),\n )\n ButtonCal.grid(row=0, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"filling_list_with_counter_for_namedtuple(5)\",\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\n field_to_check=5,\n input_list=champion_info,\n origin_list_=origin_list,\n class_list_=class_list,\n origin_counters_=origin_counters,\n class_counters_=class_counters,\n df_=df,\n ),\n )\n ButtonCal.grid(row=1, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"filling_list_with_counter_for_namedtuple(6)\",\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\n field_to_check=6,\n input_list=champion_info,\n origin_list_=origin_list,\n class_list_=class_list,\n origin_counters_=origin_counters,\n class_counters_=class_counters,\n df_=df,\n ),\n )\n ButtonCal.grid(row=2, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"filling_list_with_counter_for_namedtuple(7)\",\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\n field_to_check=7,\n input_list=champion_info,\n origin_list_=origin_list,\n class_list_=class_list,\n origin_counters_=origin_counters,\n class_counters_=class_counters,\n df_=df,\n ),\n )\n ButtonCal.grid(row=3, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"append_counters_to_input_list(champion_info)\",\n command=lambda: dss.append_counters_to_input_list(\n input_list=champion_info,\n origin_list_=origin_list,\n class_list_=class_list,\n origin_counters_=origin_counters,\n class_counters_=class_counters,\n df_=df,\n ),\n )\n ButtonCal.grid(row=4, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"append_counters_to_input_list(champion_to_buy_info)\",\n command=lambda: dss.append_counters_to_input_list(\n input_list=champion_to_buy_info,\n origin_list_=origin_list,\n class_list_=class_list,\n origin_counters_=origin_counters,\n class_counters_=class_counters,\n df_=df,\n ),\n )\n ButtonCal.grid(row=5, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"calculate_card_position_on_screen(2)\",\n command=lambda: dss.calculate_card_position_on_screen(\n card_index=2,\n X_FIRST_CHAMPION_CARD_=dss.X_FIRST_CHAMPION_CARD,\n PADDING_BETWEEN_CHAMPION_CARDS_=dss.PADDING_BETWEEN_CHAMPION_CARDS,\n W_CHAMPION_CARD_=dss.W_CHAMPION_CARD,\n ),\n )\n ButtonCal.grid(row=0, column=3)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"build_list_of_champion_cards_rectangles()\",\n command=lambda: dss.build_list_of_champion_cards_rectangles(\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\n Y_FIRST_CHAMPION_CARD_=dss.Y_FIRST_CHAMPION_CARD,\n W_CHAMPION_CARD_=dss.W_CHAMPION_CARD,\n H_CHAMPION_CARD_=dss.H_CHAMPION_CARD,\n ),\n )\n ButtonCal.grid(row=1, column=3)\n\n Labeling = tk.Label(\n new_window, text=\"Another cases below this row\", font=BOLDED_FONT\n )\n Labeling.grid(row=9, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"check_nonzero_counters()\",\n command=lambda: dss.check_nonzero_counters(\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n ),\n )\n ButtonCal.grid(row=10, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"show_nonzero_counters()\",\n command=lambda: dss.show_nonzero_counters(\n tk_window=MainWindow,\n origin_champs_counters_=origin_champs_counters,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n df_=df,\n row_offset=0,\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\n SHIFT_BETWEEN_ORIGINS_=dss.SHIFT_BETWEEN_ORIGINS,\n ),\n )\n ButtonCal.grid(row=11, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_classes_and_origins()\",\n command=lambda: dss.update_classes_and_origins(\n origin_list_=origin_list,\n champions_list_=champions_list,\n origin_counters_=origin_counters,\n class_list_=class_list,\n class_counters_=class_counters,\n ),\n )\n ButtonCal.grid(row=12, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"show_points_for_nonzero_counters()\",\n command=lambda: dss.show_points_for_nonzero_counters(\n tk_window=MainWindow,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n df_=df,\n row_offset=2,\n show_mode=1,\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\n SHIFT_BETWEEN_ORIGINS_=dss.SHIFT_BETWEEN_ORIGINS,\n ),\n )\n ButtonCal.grid(row=13, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"show_nonzero_counters_with_points()\",\n command=lambda: dss.show_nonzero_counters_with_points(\n tk_window=MainWindow,\n origin_champs_counters_=origin_champs_counters,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n df_=df,\n origin_list_=origin_list,\n origin_counters_=origin_counters,\n class_list_=class_list,\n class_counters_=class_counters,\n ),\n )\n ButtonCal.grid(row=14, column=0)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"reset_counters_in_list()\",\n command=lambda: dss.reset_counters_in_list(\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy\n ),\n )\n ButtonCal.grid(row=10, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_champions_to_buy_from_ocr_detection()\",\n command=lambda: dss.update_champions_to_buy_from_ocr_detection(\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr__=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n ),\n )\n ButtonCal.grid(row=11, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"show_nonzero_counters_with_points_from_ocr()\",\n command=lambda: dss.show_nonzero_counters_with_points_from_ocr(\n tk_window=MainWindow,\n origin_champs_counters_=origin_champs_counters,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n champions_list_=champions_list,\n df_=df,\n index_list=dss.update_champions_to_buy_from_ocr_detection(\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr__=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n )[1],\n origin_list_=origin_list,\n origin_counters_=origin_counters,\n class_list_=class_list,\n class_counters_=class_counters,\n ),\n )\n ButtonCal.grid(row=12, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"build_list_of_champion_cards_rectangles()\",\n command=lambda: dss.build_list_of_champion_cards_rectangles(\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\n Y_FIRST_CHAMPION_CARD_=dss.Y_FIRST_CHAMPION_CARD,\n W_CHAMPION_CARD_=dss.W_CHAMPION_CARD,\n H_CHAMPION_CARD_=dss.H_CHAMPION_CARD,\n ),\n )\n ButtonCal.grid(row=13, column=1)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"draw_rectangles_show_points_show_buttons_reset_counters() scan&go\",\n command=lambda: dss.draw_rectangles_show_points_show_buttons_reset_counters(\n rgb_colours_list_=rgb_colours_list,\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\n champions_list_for_ocr_=champions_list_for_ocr,\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\n reader_=reader,\n tk_window=MainWindow,\n origin_champs_counters_=origin_champs_counters,\n df_=df,\n origin_list_=origin_list,\n champions_list_=champions_list,\n origin_counters_=origin_counters,\n class_list_=class_list,\n class_counters_=class_counters,\n round_counter=CounterOcrResultsRound,\n gold_counter=CounterOcrResultsGold,\n ),\n )\n ButtonCal.grid(row=14, column=1)\n\n ButtonCal = tk.Button(\n new_window, text=\"update_curent_ss()\", command=lambda: dss.update_curent_ss()\n )\n ButtonCal.grid(row=10, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_curent_cropped_ss_with_rounds()\",\n command=lambda: dss.update_curent_cropped_ss_with_rounds(),\n )\n ButtonCal.grid(row=11, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_ocr_results_round()\",\n command=lambda: dss.update_ocr_results_round(\n reader_=reader, round_counter=CounterOcrResultsRound\n ),\n )\n ButtonCal.grid(row=12, column=2)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"full_state_update_champions_ocr()\",\n command=lambda: dss.full_state_update_rounds_ocr(\n reader_=reader, round_counter=CounterOcrResultsRound\n ),\n )\n ButtonCal.grid(row=13, column=2)\n\n ButtonCal = tk.Button(\n new_window, text=\"update_curent_ss()\", command=lambda: dss.update_curent_ss()\n )\n ButtonCal.grid(row=10, column=3)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_curent_cropped_ss_with_gold()\",\n command=lambda: dss.update_curent_cropped_ss_with_gold(),\n )\n ButtonCal.grid(row=11, column=3)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"update_ocr_results_gold()\",\n command=lambda: dss.update_ocr_results_gold(\n reader_=reader,\n gold_counter=CounterOcrResultsGold,\n ),\n )\n ButtonCal.grid(row=12, column=3)\n\n ButtonCal = tk.Button(\n new_window,\n text=\"full_state_update_gold_ocr()\",\n command=lambda: dss.full_state_update_gold_ocr(\n reader_=reader,\n gold_counter=CounterOcrResultsGold,\n ),\n )\n ButtonCal.grid(row=13, column=3)\n\n logging.debug(\"Function create_new_window() end\")","def click_add():\n # TODO: 1. In frontend_script.py, create function \"create_window()\" that takes a Toplevel() as a parameter.\n # TODO: 2. In this file, implement the code below\n # new_window = Toplevel(root)\n # frontend_script.create_window(new_window)","def details_window(self, instance: Union[Nobleman, Location]):\n window = tk.Toplevel()\n window.title(instance.name)\n window.protocol(\"WM_DELETE_WINDOW\",\n partial(self.close_details_window, instance))\n self.register_extra_window(instance, window)\n self.generate_window_content(instance, window)","def open_editor(self):\n #Create dialogue box to configure empty words earch:\n self.customiser = Toplevel(self.root)\n self.customiser.title(\"Word Search Configuration\")\n \n #Widgets of dialogue box\n self.controls = Frame(self.customiser)\n self.controls.pack()\n self.message = LabelFrame(self.customiser, text = \"Instructions:\")\n self.message.pack()\n self.words_frame = Frame(self.customiser)\n self.words_frame.pack()\n self.row_entry = Scale(self.controls, from_ = 2, to = 20, orient = HORIZONTAL)\n self.row_entry.grid(row = 1, column = 2)\n self.row_label = Label(self.controls, text = \"Rows:\", justify = RIGHT)\n self.row_label.grid(row = 1, column = 1)\n self.column_entry = Scale(self.controls, from_ = 2, to = 20, orient = HORIZONTAL)\n self.column_entry.grid(row = 1, column = 4)\n self.column_label = Label(self.controls, text = \"Columns:\", justify = RIGHT)\n self.column_label.grid(row = 1, column = 3)\n self.submit_specs = Button(self.customiser, text = \"Generate Grid\", command = (lambda: self.set_grid(int(self.row_entry.get()), int(self.column_entry.get()))))\n self.submit_specs.pack()\n self.instructions = Message(self.message, text = \"Use the sliders above to define the number of rows and columns for the empty word search. Enter the words to look for below.\", width = 350)\n self.instructions.pack()\n self.words_label = Label(self.words_frame, text = \"Words to find (separate with a space):\")\n self.words_label.grid(row = 1, column = 1)\n self.words_box = Entry(self.words_frame, width = 40)\n self.words_box.grid(row = 1, column = 2)\n \n #Disable action button to prevent multiple configuration windows:\n self.action_button.config(state = DISABLED)","def launch(self) -> None:\n # create the containers that contain the windows\n self.create_right_left_containers()\n # 1 - displays the left window\n self.left_window = LeftWindow(self.frame_left)\n # 2 - displays the menu bar\n self.menubar = tk.Menu(self)\n menus_to_display = Menu.setup_main_menus_architecture(self.list_instances_menus_tournament,\n self.list_instances_menus_reports)\n for elem in menus_to_display:\n menu = tk.Menu(self.menubar, tearoff=0)\n for el in elem['unfold']:\n menu.add_command(label=el['label'], state=el['state'],\n command=eval(el['function'], {'RightWindow': RightWindow, 'self': self, 'ct': ct,\n 'ChooseTournamentForReport':\n ChooseTournamentForReport}))\n self.menubar.add_cascade(label=elem['name'], menu=menu)\n self.config(menu=self.menubar)","def setup(self):\n self.ui.setup_window()","def create_widgets(self):\n #create first button\n self.button1 = Button(self, text = \"Start\")\n self.button1.bind\n self.button1.grid()","def create(self, verbose=False):\r\n # delete the window if its handle exists\r\n if cmds.window(self.window, exists=True):\r\n cmds.deleteUI(self.window)\r\n # initialize the window as a pane for docking\r\n self.window = cmds.loadUI(uiFile=self.uiFile, verbose=verbose)\r\n #layoutWin = cmds.paneLayout(configuration='single')\r\n # create a dockControl and parent the control to layoutWin\r\n cmds.dockControl(allowedArea='all', area='right', floating=False, \r\n height=cmds.window(self.window, query=True, height=True), \r\n content=self.window, label='Docked Cone Pointer Window')\r\n cmds.showWindow(self.window)","def create_panel(self):\n # Main Frame creation\n frame1 = Frame(self.window)\n frame1.pack(fill=\"both\")\n tablayout = Notebook(frame1)\n \n ##### TRACKER #####\n tab = Frame(tablayout) # creating 1st nested frame\n tab.pack(fill=\"both\")\n table = Frame(tab)\n table.pack(fill=\"both\")\n self.show_table(self.t.timeline[\"week\" + str(self.week)], table) # Grids the week with data\n self.add_buttons(tab, table)\n tablayout.add(tab, text=\"Current Week\") \n \n \n ##### STATS #####\n tab = Frame(tablayout) # creating 2nd nested frame\n tab.pack(fill=\"both\")\n self.stats.create_canvas(tab)\n\n\n # once its packed you can add it to the window object under a title\n tablayout.add(tab, text=\"Statistics\") \n tablayout.pack(fill=\"both\") # once everything is done now you pack the tablayout","def create_main_enviroment(self):\n # self.layout=QGridLayout()\n self.resize(900, 900)\n self.centralWidget = CentralWidget(self) # CentralWidget(self)\n self.setCentralWidget(self.centralWidget)\n\n # self.toolbar = QToolBar(self)\n # self.addToolBar(self.toolbar)\n\n # self.setLayout(self.layout)\n self.setWindowTitle(\"Fitting elastic constants\")","def main():\n\tif mc.window( 'spiderWebCreatorUi_WIN', q = 1, ex = 1 ):\n\t\tmc.deleteUI( 'spiderWebCreatorUi_WIN' )\n\tPyForm=spiderWebCreatorUi()\n\tPyForm.show()","def createFrame(self):\n \n tkinterListBoxDialog.createFrame(self)\n self.addFrameButtons()","def initUI(self):\n\n self.wid = RosGenWidget()\n self.setCentralWidget(self.wid)\n menubar = self.menuBar()\n fileMenu = menubar.addMenu('&Файл')\n editMenu = menubar.addMenu('&Редактирование')\n self.create_menu_par('Менеджер подписчиков и издателей', self.wid.show_manager, fileMenu, 'Ctrl+M')\n self.create_menu_par('Очистить', self.wid.clear_all_lines, editMenu, 'Ctrl+D')\n self.create_menu_par('Загрузить данные из...', self.wid.open_fileDialog, fileMenu, 'Ctrl+F')\n self.create_menu_par('Сохранить как...', self.wid.save_fileDialog, fileMenu, 'Ctrl+S')\n self.create_menu_par('Выход', self.exit_app, fileMenu, 'Esc')\n self.statusbar = self.statusBar()\n self.statusbar.showMessage('Ожидание данных')\n self.wid.msg2Statusbar[str].connect(self.statusbar.showMessage)\n self.setGeometry(600, 200, 700, 400)\n self.setWindowTitle('Генератор шаблонов ROS-приложения')\n self.show()","def visualise(self):\n self.w = VisualizeSetupBox(self.master, self._df)\n self.master.wait_window(self.w.top)","def window(*args, width: int = 200, height: int = 200, autosize: bool = False,\n no_resize: bool = False, no_title_bar: bool = False, no_move: bool = False, no_scrollbar: bool = False,\n no_collapse: bool = False, horizontal_scrollbar: bool = False, no_focus_on_appearing: bool = False,\n no_bring_to_front_on_focus: bool = False, menubar: bool = False, no_close: bool = False,\n no_background: bool = False, label: str = '', show: bool = True, collapsed: bool = False,\n modal: bool = False, popup: bool = False,\n on_close: Callable = None, min_size: List[int]=[32, 32], max_size: List[int] = [30000, 30000], id:str=''):\n try:\n\n widget = internal_dpg.add_window(*args, width=width, height=height, autosize=autosize,\n no_resize=no_resize, no_title_bar=no_title_bar, no_move=no_move,\n no_scrollbar=no_scrollbar, no_collapse=no_collapse,\n horizontal_scrollbar=horizontal_scrollbar,\n no_focus_on_appearing=no_focus_on_appearing,\n no_bring_to_front_on_focus=no_bring_to_front_on_focus,\n menubar=menubar, no_close=no_close,\n no_background=no_background, label=label, show=show, \n collapsed=collapsed, on_close=on_close,\n min_size=min_size, max_size=max_size, id=id, modal=modal,\n popup=popup)\n internal_dpg.push_container_stack(widget)\n yield widget\n\n finally:\n internal_dpg.pop_container_stack()","def create_panel_widgets(self):\r\n self.panel_widgets[\"create_order_button\"] = tk.Button(\r\n master=self.container_widgets[\"panel_frame\"],\r\n command=lambda: self.create_order(),\r\n text=const.RECORD_WIDGET_CONFIG_VALUES[\"CREATE_ORDER_BUTTON\"][\"text\"],\r\n width=const.RECORD_WIDGET_CONFIG_VALUES[\"CREATE_ORDER_BUTTON\"][\"width\"],\r\n height=const.RECORD_WIDGET_CONFIG_VALUES[\"CREATE_ORDER_BUTTON\"][\"height\"])\r\n self.panel_widgets[\"create_order_button\"].grid(\r\n row=const.RECORD_WIDGET_CONFIG_VALUES[\"CREATE_ORDER_BUTTON\"][\"row\"],\r\n column=const.RECORD_WIDGET_CONFIG_VALUES[\"CREATE_ORDER_BUTTON\"][\"column\"])\r\n\r\n self.panel_widgets[\"show_menu_button\"] = tk.Button(\r\n self.container_widgets[\"panel_frame\"],\r\n command=lambda: MenuWindow(self.databases.menu),\r\n text=const.RECORD_WIDGET_CONFIG_VALUES[\"SHOW_MENU_BUTTON\"][\"text\"],\r\n width=const.RECORD_WIDGET_CONFIG_VALUES[\"SHOW_MENU_BUTTON\"][\"width\"],\r\n height=const.RECORD_WIDGET_CONFIG_VALUES[\"SHOW_MENU_BUTTON\"][\"height\"])\r\n self.panel_widgets[\"show_menu_button\"].grid(\r\n row=const.RECORD_WIDGET_CONFIG_VALUES[\"SHOW_MENU_BUTTON\"][\"row\"],\r\n column=const.RECORD_WIDGET_CONFIG_VALUES[\"SHOW_MENU_BUTTON\"][\"column\"])\r\n\r\n self.panel_widgets[\"show_orders_button\"] = tk.Button(\r\n self.container_widgets[\"panel_frame\"],\r\n command=lambda: self.open_archive(),\r\n text=const.RECORD_WIDGET_CONFIG_VALUES[\"OPEN_ARCHIVE_BUTTON\"][\"text\"],\r\n width=const.RECORD_WIDGET_CONFIG_VALUES[\"OPEN_ARCHIVE_BUTTON\"][\"width\"],\r\n height=const.RECORD_WIDGET_CONFIG_VALUES[\"OPEN_ARCHIVE_BUTTON\"][\"height\"])\r\n\r\n self.panel_widgets[\"show_orders_button\"].grid(\r\n row=const.RECORD_WIDGET_CONFIG_VALUES[\"OPEN_ARCHIVE_BUTTON\"][\"row\"],\r\n column=const.RECORD_WIDGET_CONFIG_VALUES[\"OPEN_ARCHIVE_BUTTON\"][\"column\"])\r\n\r\n self.panel_widgets[\"restore_orders_button\"] = tk.Button(\r\n self.container_widgets[\"panel_frame\"],\r\n command=lambda: self.restore_open_orders(),\r\n text=const.RECORD_WIDGET_CONFIG_VALUES[\"RESTORE_ORDERS_BUTTON\"][\"text\"],\r\n width=const.RECORD_WIDGET_CONFIG_VALUES[\"RESTORE_ORDERS_BUTTON\"][\"width\"],\r\n height=const.RECORD_WIDGET_CONFIG_VALUES[\"RESTORE_ORDERS_BUTTON\"][\"height\"])\r\n\r\n self.panel_widgets[\"restore_orders_button\"].grid(\r\n row=const.RECORD_WIDGET_CONFIG_VALUES[\"RESTORE_ORDERS_BUTTON\"][\"row\"],\r\n column=const.RECORD_WIDGET_CONFIG_VALUES[\"RESTORE_ORDERS_BUTTON\"][\"column\"])","def __createWidgets(self):\n # Widget canvas, used to draw rubik's cube\n self.cv = Canvas(self.master)\n self.cv['bg'] = 'white' # Background color\n self.cv['height'] = '440' # Height of canvas\n self.cv['width'] = '560' # Width of canvas\n self.cv.place(x=0, y=0)\n self.__drawCube()","def show(self):\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Show Window.\"\n self.subWindow.show()","def init_ui(self):\n # Create GUI elements, set them in dict structure\n labelwidth = 150\n\n # Add parameter line edit for Factor Tm to Tp\n\n # Add line edit with browsebutton for swan result folder\n self.input_elements['hares folder'] = widgets.ExtendedLineEdit(\n label='HARES uitvoerbestanden folder:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_hares_folder)\n )\n\n\n self.setLayout(QtWidgets.QVBoxLayout())\n self.layout().setSpacing(10)\n\n for _, item in self.input_elements.items():\n self.layout().addWidget(item)\n\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n self.layout().addWidget(line)\n\n # OK and Cancel buttons\n self.generateButton = QtWidgets.QPushButton('Start lezen uitvoerbestanden')\n self.generateButton.setDefault(True)\n self.generateButton.clicked.connect(self.generate)\n\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\n self.cancelButton.setAutoDefault(False)\n self.cancelButton.clicked.connect(self.cancel)\n\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\n button_box.accepted.connect(QtWidgets.QDialog.accept)\n\n self.layout().addWidget(button_box)","def gui(self):\n return gui","def initUI(self):\n self.logger.debug('Setting up the Measurement GUI')\n self.setWindowTitle(self.title)\n\n self.show()\n\n self.make_combobox_scanner()\n self.make_combobox_movements()\n self.make_combobox_configurate()\n self.make_combobox_basic()","def create_main_window_with_browser():\n main_win = create_main_window()\n return main_win.add_browser_tab()","def make_widgets(self):\n self.mode_select = Selector(**MODE_SELECT_SETTINGS)\n self.bind_keys_to_modes()\n self.layer_select = Selector(**LAYER_SELECT_SETTINGS)\n self.check_boxes = CheckBoxArray(**CHECK_ARRAY_SETTINGS)\n self.check_boxes.bind_key(pg.K_v, self.toggle_layer_visibility)\n self.navs = [Button(**NAV_LEFT), Button(**NAV_RIGHT)]\n self.save_button = Button(**SAVE_BUTTON)\n self.load_button = Button(**LOAD_BUTTON)\n self.new_button = Button(**NEW_BUTTON)\n self.widgets = [self.mode_select, self.layer_select, self.check_boxes,\n self.navs[0], self.navs[1],\n self.save_button, self.load_button, self.new_button]","def createApp(self):\n app = self.app\n window = self.window\n window.show()\n app.exec()","def initUI(self) -> None:\n ratio = 70\n width_to_set = (ratio * self.get_current_window_info()[0]) / 100.0\n height_to_set = (ratio * self.get_current_window_info()[1]) / 100.0\n self.setGeometry(200, 100, width_to_set, height_to_set)\n self.createTable()\n # Add box layout, add table to box layout and add box layout to widget\n self.layout = QVBoxLayout()\n self.layout.addWidget(self.tableWidget)\n self.setLayout(self.layout)\n self.setWindowTitle('View files')\n self.show()","def widgets(self):\n raise NotImplementedError(\"This method is not ready to be used yet\")","def __init__(self):\n self.defaultTheme = \"DarkAmber\"\n self.version = 1.4\n self.versionName = \"class update\"\n self.title = \"Lms GUI default window\"\n self.layout = [[sg.Text(\"This is the base window class layout.\")]]\n self.elementJustification = 'c'\n self.location=(500, 300)\n self.running = True\n self.window = None\n self.event = \"\"\n self.values = []\n self.nextAction = None","def start_GUI(self):\n experiment_names = list(GUI.api.get_experiment_names())\n #selected_exp = None #value picked in the list\n\n branch_log_dict = GUI.api.get_branching_indep_to_dep()\n #Separate columns for a new trial and a new experiment\n\n col_new_trial = [[sg.Radio('New Trial', \"RADIO1\", default=True, enable_events = True, key=\"new_trial_radio\", metadata='not_disable')],\n [sg.Text(text = \"Please pick your experiment from the list below:\")], \n [sg.Listbox(values=experiment_names, size=(30, 6), key=\"list\", select_mode = sg.LISTBOX_SELECT_MODE_SINGLE, enable_events= True)]]\n \n\n #metadata ahs true if we need to input filed\n col_new_experiment = [[sg.Radio('New experiment', \"RADIO1\", enable_events=True, key=\"new_exp_radio\", metadata='not_disable')]]\n col_new_experiment.extend(self.make_fields())#add fields to the form\n layout = [[sg.Column(col_new_trial), sg.Column(col_new_experiment)], \n [sg.Button(button_text= \"OK\", enable_events= True, key =\"OK\")]]\n \n window = sg.Window('New Data', layout, keep_on_top=True)#Creation of the window\n while True:\n event, values = window.read()\n # End program if user closes window or\n # presses the OK button\n # you can use switch-case here instead of if statements\n if event == sg.WIN_CLOSED:\n #Indicate abort\n return None, None, None, None\n elif event == \"new_exp_radio\":#if new experiment is picked, then disable the elements for the new trial\n #for evey field on which branching logic depends on, disable everything not selected\n window['list'].update(disabled = True)\n for row in col_new_experiment:\n for elem in row:\n if(elem.metadata != 'not_disable' and not isinstance(elem, sg.Text)):#do not block the radio button):\n window[elem.Key].update(disabled = False)\n \n self.clear_disable_all(window, branch_log_dict, col_new_experiment)#we could just enable a few, instead\n elif event == \"new_trial_radio\":#if new trial is picked, disable the elements for the new experiment, enable for the new trua\n #disable everything in the form\n for row in col_new_experiment:\n for elem in row:\n if(elem.metadata != 'not_disable' and not isinstance(elem, sg.Text)):#do not block the radio button and do not update textboxes\n window[elem.Key].update(disabled = True)\n #enable the listbox\n \n window['list'].update(disabled = False)\n elif event == \"OK\":\n field_missing = False\n #Check if the listbox has a value or the form has a value\n if values['new_exp_radio']:#we are doing new expriment\n # printing_params = {\"paxton\":\"\"}\n printing_params = {}\n #Check the all the stuff in the form of the new experiment\n for row in col_new_experiment:\n if(field_missing):\n break#do not check anymore\n for elem in row:\n if(elem.metadata != 'not_disable' and not isinstance(elem, sg.Text)):#do not check labels and the radio button\n if (elem.metadata and values[elem.Key]== \"\"): #value ahs to be filled and not empty\n field_missing = True\n sg.popup_ok('Required fields are missing!')#if at least one field is empty, throw a popup and stop checking\n break # Shows OK button\n #if at least one field does not have a value, then we generate a popup\n elif(values[elem.Key] != \"\"):#add to the dictonary of params\n printing_params[elem.Key] = values[elem.Key]\n \n if not field_missing:\n #if everything is filled, then validate\n \n #if user closes the popup, then the print is considered bad by default\n is_valid, field_name = self.validate_fields(window, values)\n if(is_valid):\n print_result, folderPath = self.getPicturesPrintEval()\n window.close()\n #now, we also return print_result\n return \"add_record\", printing_params, print_result, folderPath\n else:\n sg.popup_ok(\"The field could not be validated: \" + field_name)\n \n elif values['new_trial_radio']:#could use else\n if values['list'] == []:\n sg.popup_ok('Required fields are missing!')\n continue#go to while loop\n #we got here, so we now know the record_id of the experiment we want to do the new trial for\n record_lst = GUI.api.get_elements(values['list'][0])\n #create a new window with print quality + pictures\n print_result, folderPath = self.getPicturesPrintEval()\n window.close()\n return \"add_trial\", record_lst, print_result, folderPath\n elif event in branch_log_dict:#if branching logic is dependent on this element\n #we could only enable/disable stuff affected by the element\n self.enable_selected(window, copy.deepcopy(values), branch_log_dict, event)\n self.disable_not_selected(window, copy.deepcopy(values), branch_log_dict, event)","def __init__(self, title, dimensions, num_windows, fg = (255, 255, 255), bg = (0, 0, 0)):\n self.fg = fg\n self.bg = bg\n self.offset = 0\n self.screens = []\n for i in range(num_windows):\n screen = Screen(title, i, dimensions)\n self.screens.append(screen)\n screen.window.show()","def createWidgets(self, dialogType):\n # Create labels to identify the image being considered\n self.magnitudeLabel = QtGui.QLabel('Gradient Magnitude')\n self.directionLabel = QtGui.QLabel('Gradient Direction')\n self.horizontalLabel = QtGui.QLabel('Horizontal Gradient')\n self.verticalLabel = QtGui.QLabel('Vertical Gradient')\n\n # Create the buttons to show or save each image\n self.magnitudeOption = QtGui.QPushButton(dialogType)\n self.directionOption = QtGui.QPushButton(dialogType)\n self.horizontalOption = QtGui.QPushButton(dialogType)\n self.verticalOption = QtGui.QPushButton(dialogType)\n\n # Create a close button\n self.closeButton = QtGui.QPushButton('Close')\n\n # Connect the closing button to the exit function\n self.closeButton.clicked.connect(self.exit)\n\n # Connect each image option to the necessary function based on the\n # dialog type\n if dialogType == 'Show':\n # Func is used to shorten and neaten the code\n func = self.parent().showFunc\n\n # Connect each image with it's colourmap\n self.magnitudeOption.clicked.connect(lambda: func(\\\n self.parent().I.smagnitude, 'gray'))\n self.directionOption.clicked.connect(lambda: func(\\\n self.parent().I.sdirection, 'gist_rainbow'))\n self.horizontalOption.clicked.connect(lambda: func(\\\n self.parent().I.shgradient, 'gray'))\n self.verticalOption.clicked.connect(lambda: func(\\\n self.parent().I.svgradient, 'gray'))\n else:\n func = self.parent().saveFunc\n\n self.magnitudeOption.clicked.connect(lambda: func(\\\n self.parent().I.smagnitude))\n self.directionOption.clicked.connect(lambda: func(\\\n self.parent().I.sdirection))\n self.horizontalOption.clicked.connect(lambda: func(\\\n self.parent().I.shgradient))\n self.verticalOption.clicked.connect(lambda: func(\\\n self.parent().I.svgradient))","def create_widgets(self):\n root.title(\"Universal Converter\")\n root.resizable(False, False)\n root.config(bg=\"white\")\n head_frame = Frame(root, bd=3, bg=\"Navy\", relief=GROOVE)\n Label(head_frame, text=\"UNIVERSAL CONVERTER\", font=(\"Trebuchet MS\", 24, \"bold\"), fg=\"White\", bg=\"Navy\").pack(pady=50)\n head_frame.grid(row=0, column=0, columnspan=4, ipadx=20, sticky=\"ew\")\n Label(root, text=\" Choose the Converter \", font=(\"Trebuchet MS\", 16, \"bold\"), fg=\"Navy\", bg=\"White\").grid(row=2, column=0, columnspan=4, ipadx=20, ipady=20)\n button_frame = Frame(root, bd=5, bg=\"Navy\", relief=FLAT)\n self.measurements_list = [\"Angle\", \"Area\", \"Bit Byte\", \"Density\", \"Electric Current\", \"Energy\", \"Force\", \"Fuel Consumption\", \"Length\", \"Mass\", \"Power\", \"Pressure\", \"Speed\", \"Temperature\", \"Time\", \"Volume\"]\n self.measurements_dict = {\"Angle\": self.angle, \"Area\": self.area, \"Bit Byte\": self.bitbyte, \"Density\": self.density, \"Electric Current\": self.electriccurrent, \"Energy\": self.energy, \"Force\": self.force, \"Fuel Consumption\": self.fuelconsumption, \"Length\": self.length, \"Mass\": self.mass, \"Power\": self.power, \"Pressure\": self.pressure, \"Speed\": self.speed, \"Temperature\": self.temperature, \"Time\": self.time, \"Volume\": self.volume}\n for i in range(16):\n self.button = Button(button_frame, text=self.measurements_list[i], font=(\"Trebuchet MS\", 12), width=13, fg=\"Navy\", bg=\"White\", relief=FLAT, overrelief=SOLID, bd=5, activebackground=\"Navy\", activeforeground=\"White\", command=self.measurements_dict[self.measurements_list[i]])\n self.button.grid(row=i/4+4, column=i%4, ipady=15, ipadx=15, padx=2, pady=2)\n button_frame.grid(row=3, column=0, columnspan=4, sticky=\"we\", padx=5, pady=5)\n root.protocol(\"WM_DELETE_WINDOW\", self.callback) #When user will quit, program will show you the messagebox","def __init__(self):\n # Root window\n self.root = tk.Tk()\n self.root.title(\"Crossword\")\n # Padding frame\n self.frame = tk.Frame(self.root)\n self.frame.pack(fill=\"both\", padx=PAD, pady=PAD)\n # Initialize widget groups\n self.header = HeaderView(self)\n self.puzzle = PuzzleView(self)\n self.clues = CluesView(self)\n # Show widgets\n self.header.show()\n self.puzzle.show()\n self.clues.show()","def iniciaUI(self):\n\n self.setGeometry(100,100, 300, 200)\n self.setWindowTitle(\"Formulario\")\n self.displayWidgets()\n\n self.show()","def init(self):\n sg.theme(gui.app_theme)\n self.window = sg.Window(\n gui.app_title,\n gui.create_layout(),\n **gui.window_config,\n )\n gui.after_window_init(self.window)","def display_window(self):\n frame = tk.Frame(master=self.param_window)\n frame.grid(padx=10, pady=20, columnspan=2)\n tk.Label(master=frame, text=\"Enter simulation parameters\").pack()\n\n self.status_text = tk.StringVar()\n self.status_text.set(\"Status message\")\n \n self.rows = 1\n for input_key in self.inputs.keys():\n input_dict = self.inputs[input_key]\n \n frame = tk.Frame(master=self.param_window)\n frame.grid(row=self.rows, column=0, padx=10, pady=1)\n input_dict['label'] = tk.Label(master=frame, text=input_dict['label'])\n input_dict['label'].pack()\n\n frame = tk.Frame(master=self.param_window)\n frame.grid(row=self.rows, column=1, padx=10, pady=1)\n input_dict['entry'] = tk.Entry(master=frame, width=10)\n input_dict['entry'].insert(0, input_dict['default'])\n input_dict['entry'].pack()\n \n self.rows += 1\n\n frame = tk.Frame(master=self.param_window)\n frame.grid(padx=10, pady=20, columnspan = 2)\n self.submit_btn = tk.Button(master=frame, text=\"Submit\", width=10)\n self.submit_btn.pack()\n self.submit_btn.bind(\"<Button-1>\", self.submit_values)\n\n self.param_window.mainloop()\n return self.parameters","def init_ui(self):\n self.master.title(\"Backbone\")\n self.master.geometry(\"300x150\")\n\n self.pack(fill=BOTH, expand=1)\n\n self.btn_upload_file = Button(self, text=\"Upload file\", command=self.upload_file)\n self.btn_upload_file.place(x=90, y=10)\n\n self.btn_create_training_file = Button(self, text=\"Create & upload training file\",\n command=self.create_training_file)\n self.btn_create_training_file.place(x=30, y=40)\n\n self.btn_run_algorithm = Button(self, text=\"Run algorithm\", command=self.run_algorithm)\n self.btn_run_algorithm.place(x=80, y=70)\n\n self.btn_view_results = Button(self, text=\"View Results\", command=self.view_results)\n self.btn_view_results.place(x=85, y=100)","def populateUI():\n \n # Main form layout\n form = cmds.formLayout()\n\n # Tab Layout\n tabs = cmds.tabLayout(innerMarginWidth=5, innerMarginHeight=5)\n # Form attachment config\n cmds.formLayout( form, edit=True, attachForm=((tabs, 'top', 0), (tabs, 'left', 0), (tabs, 'bottom', 0), (tabs, 'right', 0)) )\n\n # The different Tabs on the window\n spawnTab = SpawnObjectsTab()\n roadTab = RoadRiverTab()\n environmentTab = EnvironmentTab()\n\n # Tab creation\n cmds.tabLayout( tabs, edit=True, tabLabel=((spawnTab, 'Spawn Buildings'), (roadTab, 'Create Roads / Rivers'), (environmentTab, \"Create Environment\") ))","def build_window(self):\n\n form_frame = tk.Frame(self.window)\n form_frame.pack(fill='x')\n\n tk.Label(form_frame, text=\"Url\").grid(row=0, column=0, sticky='W')\n url = tk.StringVar()\n self.url_entry = tk.Entry(form_frame, textvariable=url)\n self.url_entry.grid(row=0, column=1, sticky='W')\n\n tk.Label(form_frame, text=\"Depth\").grid(row=1, column=0, sticky='W')\n depth = tk.IntVar()\n self.depth_entry = tk.Entry(form_frame, textvariable=depth)\n self.depth_entry.grid(row=1, column=1, sticky='W')\n\n self.submit_button = tk.Button(form_frame, text=\"Submit\")\n self.submit_button.bind('<Button-1>', self.send_entry_event)\n self.submit_button.grid(row=2, column=0, columnspan=1, sticky='W')\n\n url_list_frame = tk.Frame(self.window)\n url_list_frame.pack(fill='x')\n\n self.url_list = tk.Listbox(url_list_frame, selectmode=tk.SINGLE, font=self.font,\n exportselection=False)\n self.url_list.bind('<<ListboxSelect>>', self.selected_url_event)\n self.url_list.pack(fill=tk.BOTH, expand=tk.YES)","def layout(self):\n menu = self.menuBar()\n menu.setNativeMenuBar(False)\n\n file_menu = menu.addMenu(\"File\")\n fitting_commands = menu.addMenu(\"Fitting\")\n help_menu = menu.addMenu(\"Help\")\n\n prog_info = QAction(\"About\", self)\n prog_info.triggered.connect(self.version)\n help_menu.addAction(prog_info)\n\n doc_info = QAction(\"Documentation\", self)\n doc_info.triggered.connect(self.docs)\n help_menu.addAction(doc_info)\n\n fit_exp = QAction(\"Fit Experiments\", self)\n fit_exp.setShortcut(\"Ctrl+F\")\n fit_exp.triggered.connect(self.fit_exp)\n fitting_commands.addAction(fit_exp)\n\n add_exp = QAction(\"Add Experiment\", self)\n add_exp.setShortcut(\"Ctrl+Shift+N\")\n add_exp.triggered.connect(self.add_file)\n file_menu.addAction(add_exp)\n\n save_exp = QAction(\"Export Results\", self)\n save_exp.setShortcut(\"Ctrl+S\")\n save_exp.triggered.connect(self.save_file)\n file_menu.addAction(save_exp)\n\n file_menu.addSeparator()\n\n new_exp = QAction(\"New Session\", self)\n new_exp.setShortcut(\"Ctrl+N\")\n new_exp.triggered.connect(self.new_exp)\n file_menu.addAction(new_exp)\n\n close_window = QAction(\"Close Window\", self)\n close_window.setShortcut(\"Ctrl+W\")\n close_window.triggered.connect(self.close_program)\n file_menu.addAction(close_window)\n\n # add shortcut actions to main window, for qt5 bug\n self.addAction(add_exp)\n self.addAction(fit_exp)\n self.addAction(save_exp)\n self.addAction(new_exp)\n self.addAction(close_window)\n self.addAction(doc_info)\n self.addAction(prog_info)\n\n self._exp = Splitter(self)\n self.setCentralWidget(self._exp)\n\n self.resize(1000, 600)\n self.move(QApplication.desktop().screen().rect().center()-self.rect().center())\n self.setWindowTitle('pytc')\n self.show()","def adv_new_window(self):\n adv=workflow.advancedoptions_w.ADialog()\n adv.exec_()","def populateWindow(self):\n if self.widget.abstractDb == None:\n QtGui.QMessageBox.critical(self, self.tr('Error!'), self.tr('First select a database!'))\n return\n if isinstance(self.sender(), QPushButton):\n sender = self.sender().text()\n else:\n sender = ''\n dlg = FieldSetup(self.widget.abstractDb)\n if sender != self.tr('Setup'):\n dlg.loadReclassificationConf(self.reclassificationDict)\n if sender != '':\n result = dlg.exec_()\n else:\n result = 1\n \n if result == 1:\n self.createButtonsOnInterface(dlg)\n self.setEditButtonEnabled(True)","def create_view(self):\n title_label = Label(self, text='Upload, Preview, Describe and Visualize',\n fg='blue', font=('Arial', 16))\n title_label.pack(fill=BOTH, expand=True)\n select_file_button = Button(self, background='White', text='Select Data File [.csv, .xlsx, .xls, .json, .txt]',\n command=self.start_upload)\n select_file_button.pack(padx=5, pady=10)","def __init__(self):\n self.root = tk.Tk()\n self.root.minsize(width=150, height=150)\n self.root.maxsize(height=500)\n self.root.title(\"GUV analysis\")\n self.root.iconbitmap(os.path.join(os.path.dirname(__file__), \"icon.ico\"))\n self.window = tk.Frame(self.root)\n self.window.pack(side=\"top\", fill=\"both\", expand=True)\n\n self.widgets = {}\n self.images = {}\n\n self.widgets['lblTitle'] = tk.Label(self.window, text='GUV analysis tool', font=\"-weight bold -size 20\")\n self.widgets['lblTitle'].grid(column=0, row=0, columnspan=3)\n\n self.images['newImg'] = tk.PhotoImage(file=os.path.join(os.path.dirname(__file__),'icon-new.png')).subsample(2,2)\n self.widgets['btnNew'] = tk.Button(self.window, text='New analysis', image=self.images['newImg'], command=self.start_new_analysis, compound=tk.TOP, borderwidth=0)\n self.widgets['btnNew'].grid(column=0, row=1, padx=10)\n\n self.images['openImg'] = PhotoImage_cd('icon-open.png').subsample(2,2)\n self.widgets['btnOpen'] = tk.Button(self.window, text='Open existing analysis', command=self.reopen_existing_analysis, image=self.images['openImg'], compound=tk.TOP, borderwidth=0)\n self.widgets['btnOpen'].grid(column=1, row=1, padx=10)\n\n self.images['closeImg'] = PhotoImage_cd('icon-close.png').subsample(2,2)\n self.widgets['btnClose'] = tk.Button(self.window, text='Close program', command=self.root.quit, image=self.images['closeImg'], compound=tk.TOP, borderwidth=0)\n self.widgets['btnClose'].grid(column=2, row=1, padx=10)","def _init_ui(self):\n hlayout = QtWidgets.QHBoxLayout()\n\n hlayout.addWidget(QtWidgets.QLabel('Kies een normtraject:'))\n\n self.section_combobox = QtWidgets.QComboBox()\n self.section_combobox.setFixedWidth(60)\n self._update_combobox()\n\n hlayout.addWidget(self.section_combobox)\n\n self.remove_button = QtWidgets.QPushButton('Verwijderen', clicked=self._del_flooddefence)\n hlayout.addWidget(self.remove_button)\n\n vlayout = QtWidgets.QVBoxLayout()\n vlayout.addLayout(hlayout)\n\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n\n vlayout.addWidget(line)\n\n self.close_button = QtWidgets.QPushButton('Sluiten', clicked=self.close)\n vlayout.addWidget(self.close_button, 0, QtCore.Qt.AlignRight)\n\n self.setLayout(vlayout)\n\n self.setWindowTitle(\"HB Havens: normtrajecten\")\n self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)","def __init__(self, root):\r\n self.root = root\r\n self.root.geometry(\"400x300\")\r\n \r\n self.button_rename = tk.Button(self.root, text = \"New window\",\r\n command= self.new_winF).pack()","def build_second_window():\r\n\r\n new_window = tk.Tk()\r\n windows.append(new_window)\r\n new_window.protocol(\"WM_DELETE_WINDOW\", new_round(new_window))\r\n\r\n ask = tk.Label(new_window, text='Would You Like To Play Again?', bg='Cyan')\r\n ask.pack(fill=tk.X)\r\n\r\n frame = tk.Frame(new_window)\r\n frame.pack()\r\n\r\n yes_button = tk.Button(frame, text='Yes', bg='green',\r\n command=new_round(new_window))\r\n yes_button.pack(side=tk.LEFT)\r\n\r\n no_button = tk.Button(frame, text='No', bg='red',\r\n command=close)\r\n no_button.pack(side=tk.LEFT)","def add_widgets(self):\n tkinter.Label(self.top_frame, text=\"File Path:\").grid(row=1, column=0)\n self.data_path_entry = tkinter.Entry(self.top_frame)\n self.data_path_entry.grid(row=1, column=1)\n self.data_path_entry.insert(10, self.data_path)\n # Create the Browse button\n tkinter.Button(self.top_frame,\n text=\"Browse...\",\n command=self.get_file).grid(row=1, column=2)\n # Create the Ok button\n tkinter.Button(self.top_frame,\n text=\"OK\",\n command=self.save_configurations).grid(row=2, column=0, sticky=tkinter.W, pady=3)\n # Create the Cancel button\n tkinter.Button(self.top_frame,\n text=\"Cancel\",\n command=self.exit).grid(row=2, column=1, sticky=tkinter.E, pady=3)","def _create_window(self):\n wc = win32gui.WNDCLASS()\n wc.lpfnWndProc = self._on_message\n wc.lpszClassName = self.__class__.__name__\n wc.hInstance = win32api.GetModuleHandle(None)\n class_atom = win32gui.RegisterClass(wc)\n return win32gui.CreateWindow(class_atom, self.__class__.__name__, 0, 0, 0, 0, 0, 0, 0, wc.hInstance, None)","def __init__(self, parent=None):\n super(MainWindow, self).__init__(parent)\n self.setupUi(self)\n \n self.setWindowTitle(\"RPI HMI - pH Debug\") # Title creation","def widgetSetup(self):\n self.master.resizable(0, 0)\n self.master.iconbitmap('logo.ico')\n self.master.title(\"Ejercicio POO\")\n\n self.master.bind(\"<Return>\", lambda e: self.create())\n self.master.bind(\"<Delete>\", lambda e: self.delete())","def create_window(self):\n self.course_name_var = tk.StringVar(self)\n self.course_score_var = tk.StringVar(self)\n self.course_category_var = tk.StringVar(self)\n\n self.course_name_var.trace(\"w\", self.filled)\n self.course_score_var.trace(\"w\", self.filled)\n self.course_category_var.trace(\"w\", self.filled)\n\n self.course_name_label = tk.Label(self, text='Course Name').grid(row=0, column=0)\n self.course_name_entry = tk.Entry(self, textvariable=self.course_name_var).grid(row=0, column=1)\n self.course_score_label = tk.Label(self, text='Course Score').grid(row=1, column=0)\n self.course_score_entry = tk.Entry(self, textvariable=self.course_score_var).grid(row=1, column=1)\n self.course_category_label = tk.Label(self, text='Course Category').grid(row=2, column=0)\n self.course_category_option = tk.OptionMenu(self, self.course_category_var, *self.course_categories).grid(row=2, column=1)\n self.course_is_weighted = tk.IntVar()\n self.course_honors = tk.Checkbutton(self, text='Honors', onvalue= 1, variable=self.course_is_weighted).grid(row=3, column=0)\n self.course_ap = tk.Checkbutton(self, text='AP', onvalue=2, variable=self.course_is_weighted).grid(row=3, column=1)\n\n self.button = tk.Button(self, text='Add Grade', command=self.add_course)\n self.button.config(state='disabled')\n self.button.grid(row=4, column=1, sticky='nesw')","def _init_ui(self):\n\n hlayout = QtWidgets.QHBoxLayout()\n\n label = QtWidgets.QLabel('Kies een normtraject:')\n\n hlayout.addWidget(label)\n\n self.section_combobox = QtWidgets.QComboBox()\n self.section_combobox.setFixedWidth(60)\n self.section_ids = sorted([''] + io.geometry.import_section_ids(self.datadir))\n self.section_combobox.addItems(self.section_ids)\n\n hlayout.addWidget(self.section_combobox)\n\n self.add_button = QtWidgets.QPushButton('Toevoegen', clicked=self._add_flooddefence)\n\n hlayout.addWidget(self.add_button)\n\n vlayout = QtWidgets.QVBoxLayout()\n vlayout.addLayout(hlayout)\n\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n\n vlayout.addWidget(line)\n\n self.close_button = QtWidgets.QPushButton('Sluiten', clicked=self.close)\n vlayout.addWidget(self.close_button, 0, QtCore.Qt.AlignRight)\n\n self.setLayout(vlayout)\n\n self.setWindowTitle(\"HB Havens: normtrajecten\")\n self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)","def createWidgets(self):\n\n # Phrase Label\n self.phrase_lbl = ttk.Label(self, text=\"Phrase:\")\n self.phrase_lbl.grid(row=0, column=0)\n\n # Phrase Entry\n self.phrase_ent = ttk.Entry(self)\n self.phrase_ent.grid(row=0, column=1)\n\n # City Label\n self.city_lbl = ttk.Label(self, text=\"City:\")\n self.city_lbl.grid(row=0, column=2)\n\n # City Entry\n self.city_ent = ttk.Entry(self)\n self.city_ent.grid(row=0, column=3)\n\n # Keyword Label\n self.keyword_lbl = ttk.Label(self, text=\"Keyword:\")\n self.keyword_lbl.grid(row=1, column=0)\n\n # Keyword Entry\n self.keyword_ent = ttk.Entry(self)\n self.keyword_ent.grid(row=1, column=1)\n\n # Add Button\n self.add_btn = ttk.Button(self, text=\"Add\")\n self.add_btn.grid(row=1, column=2)\n self.add_btn[\"command\"] = lambda: self.addCity(self.city_ent.get())\n \n # Delete Button\n self.delete_btn = ttk.Button(self, text=\"Delete\")\n self.delete_btn.grid(row=1, column=3)\n self.delete_btn[\"command\"] = lambda: self.deleteCity() \n\n # Reset Button\n self.reset_btn = ttk.Button(self, text=\"Reset\")\n self.reset_btn.grid(row=2, column=0)\n self.reset_btn[\"command\"] = lambda: self.resetApp()\n\n # Create Button\n self.create_btn = ttk.Button(self, text=\"Create\")\n self.create_btn.grid(row=2, column=1)\n self.create_btn[\"command\"] = lambda: self.createTXT() \n\n # Listbox\n self.city_lbx = tk.Listbox(self)\n self.city_lbx.grid(row=2, column=2, columnspan=2)\n \n # Directory Button\n self.dir_btn = ttk.Button(self, text=\"Select Folder\")\n self.dir_btn.grid(row=3, column=0)\n self.dir_btn[\"command\"] = lambda: self.getDir()\n\n # Directory Label\n self.dir_lbl = ttk.Label(self, text=\"No Folder Selected\")\n self.dir_lbl.grid(row=3, column=1)\n\n # Status Label\n self.stat_lbl = ttk.Label(self, text=\"\")\n self.stat_lbl.grid(row=3, column=2) \n\n # Clear Button\n self.clear_btn = ttk.Button(self, text=\"Clear\")\n self.clear_btn.grid(row=3, column=3)\n self.clear_btn[\"command\"] = lambda: self.clearCities()","def _create_notebook(self):\r\n\r\n _notebook = gtk.Notebook()\r\n\r\n # Set the user's preferred gtk.Notebook tab position.\r\n if Configuration.TABPOS[2] == 'left':\r\n _notebook.set_tab_pos(gtk.POS_LEFT)\r\n elif Configuration.TABPOS[2] == 'right':\r\n _notebook.set_tab_pos(gtk.POS_RIGHT)\r\n elif Configuration.TABPOS[2] == 'top':\r\n _notebook.set_tab_pos(gtk.POS_TOP)\r\n else:\r\n _notebook.set_tab_pos(gtk.POS_BOTTOM)\r\n\r\n self._create_analyses_input_page(_notebook)\r\n\r\n for __, _dist in enumerate(self._lst_results):\r\n _dist.create_results_page()\r\n for __, _dist in enumerate(self._lst_plots):\r\n _dist.create_plot_page()\r\n\r\n return _notebook","def _configureWindow(self):\n if self._win_type == WindowType.IMMERSIVE:\n pg.setConfigOptions(\n foreground='d',\n background=(_DARK_COLOUR if self._dark else _LIGHT_COLOUR))\n self._win = pg.plot(title=\"Abstact Map Visualisation\")\n self._plt = self._win.plotItem\n self._plt.setAspectLocked(True, 1)\n self._plt.hideAxis('left')\n self._plt.hideAxis('bottom')\n else: # DEFAULT\n pg.setConfigOptions(foreground='k', background='w')\n self._win = pg.plot(title=\"Abstact Map Visualisation\")\n self._plt = self._win.plotItem\n\n # Set up the overlay objects as they are static\n self._overlay_items = [\n QtWidgets.QGraphicsRectItem(-_OVERLAY_WIDTH / 2,\n -_OVERLAY_HEIGHT / 2, _OVERLAY_WIDTH,\n _OVERLAY_HEIGHT)\n ]\n self._overlay_items[0].setBrush(pg.mkBrush(_OVERLAY_COLOUR))\n self._overlay_items[0].setZValue(1000)\n self._win.addItem(self._overlay_items[0])\n self.toggleOverlay(enable=False)\n\n # Do any last settings in the window\n # self._win.parentWidget().showMaximized()\n limit = 30\n self._win.setRange(xRange=[-limit, limit], yRange=[-limit, limit])","def run_window(self) -> None:\n\n self.root.title('Spotify Recommender')\n\n sp_logo = ImageTk.PhotoImage(self._image)\n label = tk.Label(self.root, image=sp_logo)\n\n # We need to save the reference to the image\n label.image = sp_logo\n label.grid()\n\n tk.Label(self.root, text='Enter the link of your Spotify playlist below : ',\n font=(\"Proxima nova\", \"9\", \"bold\")).grid()\n\n self._link_entry.grid(ipadx=30)\n\n tk.Label(self.root, text=\"How adventurous are you feeling today?\",\n font=(\"Proxima nova\", \"9\", \"bold\")).grid()\n\n self._slider.grid()\n\n tk.Label(self.root, text='What do you want to name your new playlist? ',\n font=(\"Proxima nova\", \"9\", \"bold\")).grid()\n\n self._new_playlist_name_entry.grid(ipadx=30)\n\n tk.Button(self.root, text='ENTER', command=self.get_user_input, padx=5,\n pady=5, bg='#1DB954').grid()\n\n tk.Label(self.root, text='VISUALIZATION \\n Please choose a visualization option.',\n font=(\"Proxima nova\", \"9\", \"bold\")).grid(pady=15)\n\n self._dimension_menu.grid()\n\n tk.Label(self.root, text='Please choose your first attribute',\n font=(\"Proxima nova\", \"9\", \"bold\")).grid()\n self._attribute1_menu.grid()\n\n tk.Label(self.root, text='Please choose your second different attribute',\n font=(\"Proxima nova\", \"9\", \"bold\")).grid()\n self._attribute2_menu.grid()\n\n tk.Label(self.root, text='Choose your third different attribute',\n font=(\"Proxima nova\", \"9\", \"bold\")).grid()\n self._attribute3_menu.grid()\n\n tk.Label(self.root, text='IF CHOSEN GRAPH: Enter an integer 1-100',\n font=(\"Proxima nova\", \"9\", \"bold\")).grid()\n self._graph_int_entry.grid()\n\n tk.Button(self.root, text='VISUALIZE', command=self.visualize, padx=5,\n pady=5, bg='#1DB954').grid(pady=15)","def _addWidgets(self):\n self.temperatureToConvertLabel = tkinter.Label(self,\n text='Temperature to Convert',\n height=4).grid(row=0, column=0,\n sticky=tkinter.W) # Add 'Temperature to Convert' Label\n self.temperatureBox = tkinter.Entry(self,\n textvariable=self.controller.temperatureToConvert,\n width=15).grid(row=0, column=1) # Add 'Temperature to Convert' Entry\n\n self.temperatureBoxLabel = tkinter.Label(self,\n textvariable=self.controller.temperatureBoxLabelVar).grid(row=0,\n column=2,\n sticky=tkinter.E) # Add 'Temperature to Convert' Units\n\n self.FtoCRadioButton = tkinter.Radiobutton(self,\n text=self.controller.FAHRENHEIT + ' to ' + self.controller.CELSIUS,\n variable=self.controller.conversionVar,\n command=self.controller.conversionDirectionChanged,\n value=self.controller.FtoC).grid(row=1, column=0,\n sticky=tkinter.W) # Add Fahrenheit to Celsius Conversion Radio Button\n\n self.CtoFRadioButton = tkinter.Radiobutton(self,\n text=self.controller.CELSIUS + ' to ' + self.controller.FAHRENHEIT,\n variable=self.controller.conversionVar,\n command=self.controller.conversionDirectionChanged,\n value=self.controller.CtoF).grid(row=2, column=0,\n sticky=tkinter.W) # Add Celsius to Fahrenheit Conversion Radio Button\n\n self.convertedTemperatureLabel = tkinter.Label(self,\n text='Converted Temperature',\n height=4).grid(row=3, column=0,\n sticky=tkinter.W) # Add 'Converted Temperature' Label\n self.convertedTemperatureBox = tkinter.Entry(self,\n textvariable=self.controller.convertedTemperature,\n width=15).grid(row=3,\n column=1) # Add 'Converted Temperature' Entry\n self.convertedTemperatureBoxLabel = tkinter.Label(self,\n textvariable=self.controller.convertedTemperatureBoxLabelVar).grid(\n row=3, column=2, sticky=tkinter.E) # Add 'Converted Temperature' Units\n\n self.convertButton = tkinter.Button(self,\n text='Convert',\n command=self.controller.convertPressed).grid(row=4, column=0,\n sticky=tkinter.E) # Add 'Convert'Button\n self.quitButton = tkinter.Button(self,\n text='Quit',\n command=self.controller.quit).grid(row=4, column=1,\n sticky=tkinter.E) # Add 'Quit'Button","def buildUI(self):\n outside = QtWidgets.QVBoxLayout(self)\n columns = QtWidgets.QHBoxLayout(self)\n layout = QtWidgets.QVBoxLayout(self)\n self.details_layout = QtWidgets.QVBoxLayout(self) #column with edit panel\n self.restriction = QtWidgets.QWidget() #restricts size of details_layout\n self.restriction.setLayout(self.details_layout)\n self.restriction.setFixedWidth(200)\n columns.addLayout(layout)\n columns.addWidget(self.restriction)\n outside.addLayout(columns)\n\n #tab widget\n self.tabwidget = tabsWindow(self) #QtWidgets.QTabWidget(tabsClosable = True, movable = True)\n layout.addWidget(self.tabwidget)\n #add base tab\n self.tabwidget.newTab(name =\"Untitled\", image = \"\")\n\n #add second column with details\n self.updateDetails(\"edit\")\n\n #edit button\n layout_btns = QtWidgets.QHBoxLayout()\n editBtn = QtWidgets.QPushButton(\"Stop Editing\")\n editBtn.clicked.connect(lambda: self.editChange(editBtn))\n layout_btns.addWidget(editBtn)\n\n #save button\n saveBtn = QtWidgets.QPushButton(\"Save\")\n saveBtn.clicked.connect(self.save)\n layout_btns.addWidget(saveBtn)\n\n #load button\n loadBtn = QtWidgets.QPushButton(\"Load\")\n loadBtn.clicked.connect(self.load)\n layout_btns.addWidget(loadBtn)\n\n #close button\n closeBtn = QtWidgets.QPushButton('Close')\n closeBtn.clicked.connect(self.closeEvent)\n layout_btns.addWidget(closeBtn)\n\n outside.addLayout(layout_btns) #add buttons to layout","def create_ui(self):\n main_sizer = wx.BoxSizer(wx.VERTICAL)\n\n self.text_ctrl = wx.TextCtrl(self, style=wx.TE_MULTILINE)\n self.text_ctrl.Bind(wx.EVT_TEXT, self.on_text)\n main_sizer.Add(self.text_ctrl, 1, wx.ALL | wx.EXPAND, 5)\n\n self.SetSizer(main_sizer)","def build_window(self):\n # Size config\n self.root.geometry('{}x{}'.format(800, 450))\n self.root.minsize(600, 400)\n\n # create all of the main containers\n self.left_frame = Frame(self.root, bg='red', width=150, height=450, pady=3)\n self.right_frame = Frame(self.root, bg='blue', width=650, height=450, pady=3)\n\n # layout all of the main containers\n self.root.grid_rowconfigure(0, weight=1)\n self.root.grid_columnconfigure(1, weight=1)\n\n self.left_frame.grid(row=0,column=0,sticky='ns')\n self.right_frame.grid(row=0,column=1,sticky='nswe')\n\n # create all of the left containers\n self.Username_Search_Frame = Frame(self.left_frame, bg='yellow', pady=3)\n self.Username_Search_Frame.grid_rowconfigure(0, weight=1)\n self.Username_Search_Frame.grid_columnconfigure(0, weight=1)\n self.Username_label = Label(self.Username_Search_Frame, text=self.client.username)\n self.Search_entry = Entry(self.Username_Search_Frame, text='Add people')\n self.Search_entry.bind('<Return>', self.add_event)\n self.Username_label.grid(row=0,column=0,sticky='nswe')\n self.Search_entry.grid(row=1,column=0,sticky='nswe')\n\n self.Show_Friend_request_Frame = Frame(self.left_frame, bg='red', pady=3)\n self.Show_button = Button(self.Show_Friend_request_Frame, text='Chats')\n self.Show_button.bind('<Button-1>', self.show_event)\n self.Show_button_label = Label(self.Show_Friend_request_Frame, text='Chats')\n\n self.Friend_request_button = Button(self.Show_Friend_request_Frame, text='Friend_request')\n self.Friend_request_button.bind('<Button-1>', self.Friend_request_event)\n self.Friend_request_button_label = Label(self.Show_Friend_request_Frame, text='Friend_request')\n\n self.Show_button_label.pack(side=LEFT, fill=BOTH, expand=YES)\n self.Friend_request_button.pack(side=LEFT, fill=BOTH, expand=YES)\n\n self.logins_list_Frame = Frame(self.left_frame, bg='green', pady=3)\n self.logins_list_Frame.grid_rowconfigure(0, weight=1)\n self.logins_list_Frame.grid_columnconfigure(0, weight=1)\n self.logins_list = Listbox(self.logins_list_Frame, selectmode=SINGLE, exportselection=False)\n self.logins_list.bind('<<ListboxSelect>>', self.selected_login_event)\n self.logins_list.pack(side=LEFT, fill=BOTH, expand=YES)\n\n self.friend_request_list = Listbox(self.logins_list_Frame, selectmode=SINGLE, exportselection=False)\n self.friend_request_list.bind('<<ListboxSelect>>', self.select_friend_request)\n #self.friend_request_list.pack(side=LEFT, fill=BOTH, expand=YES)\n\n self.Username_Search_Frame.grid(row=0,column=0,sticky='nswe')\n self.Show_Friend_request_Frame.grid(row=1,column=0,sticky='nswe')\n self.logins_list_Frame.grid(row=2,column=0,sticky='nswe')\n\n self.left_frame.grid_rowconfigure(2, weight=1)\n self.left_frame.grid_columnconfigure(0, weight=1)\n\n\n # create all of the right containers\n self.Target_name_frame = Frame(self.right_frame, bg='yellow', pady=3)\n self.Target_name_frame.grid_rowconfigure(0, weight=1)\n self.Target_name_frame.grid_columnconfigure(0, weight=1)\n self.Target = Label(self.Target_name_frame, text='Target_name')\n self.Target.grid(row=0,column=0,sticky='nswe')\n\n self.Message_box_frame = Frame(self.right_frame, bg='black', pady=3)\n self.message_list = Message_list(self.Message_box_frame)\n self.message_list.show()\n\n self.Entry_frame = Frame(self.right_frame, bg='grey', height=100, pady=3)\n self.Entry_frame.grid_rowconfigure(0, weight=1)\n self.Entry_frame.grid_columnconfigure(0, weight=1)\n self.Entry = Text(self.Entry_frame)\n self.Entry.bind('<Return>', self.send_entry_event)\n self.Entry.grid(row=0,column=0,sticky='nswe')\n\n self.Send_file_button = Button(self.right_frame, text='Send file')\n self.Send_file_button.bind('<Button-1>', self.send_file_event)\n self.Send_file_button.grid(row=3,column=0,sticky='nswe')\n\n self.Target_name_frame.grid(row=0,column=0,sticky='nswe')\n self.Message_box_frame.grid(row=1,column=0,sticky='nswe')\n self.Entry_frame.grid(row=2,column=0,sticky='nswe')\n \n\n self.right_frame.grid_rowconfigure(1, weight=1)\n self.right_frame.grid_columnconfigure(0, weight=1)\n self.right_frame.grid_rowconfigure(2, weight=4)\n self.right_frame.grid_columnconfigure(0, weight=1)\n\n self.root.protocol(\"WM_DELETE_WINDOW\", self.on_closing_event)"],"string":"[\n \"def createWidgets(self):\\n raise NotImplementedError\",\n \"def showUI(cls):\\r\\n win = cls()\\r\\n win.create()\\r\\n return win\",\n \"def build_window(self):\\n\\n main_frame = tk.Frame(self.root)\\n main_frame.pack(fill='both')\\n\\n self.open_machine_learner_window_button = tk.Button(main_frame, text=\\\"Open Machine Learner\\\")\\n self.open_machine_learner_window_button.bind('<Button-1>', self.open_machine_learner_window)\\n self.open_machine_learner_window_button.pack(side=\\\"left\\\")\\n\\n self.open_web_crawler_window_button = tk.Button(main_frame, text=\\\"Open Web Crawler\\\")\\n self.open_web_crawler_window_button.bind('<Button-1>', self.open_web_crawler_window)\\n self.open_web_crawler_window_button.pack(side=\\\"left\\\")\\n\\n self.open_webpage_classifier_window_button = tk.Button(main_frame, text=\\\"Open WebPage Classifier\\\")\\n self.open_webpage_classifier_window_button.bind('<Button-1>', self.open_webpage_classifier_window)\\n self.open_webpage_classifier_window_button.pack(side=\\\"left\\\")\\n\\n self.run_steady_state_genetic_button = tk.Button(main_frame, text=\\\"Run Steady State\\\")\\n self.run_steady_state_genetic_button.bind('<Button-1>', self.run_steady_state)\\n self.run_steady_state_genetic_button.pack(side=\\\"left\\\")\\n\\n # Protocol for closing window using 'x' button\\n self.root.protocol(\\\"WM_DELETE_WINDOW\\\", self.on_closing_event)\",\n \"def create(self):\\n\\n cv2.namedWindow(winname=self.title, flags=self.style)\",\n \"def create_widgets( self ):\",\n \"def create_widgets(self):\",\n \"def createWidgets(self):\\r\\n top = self.winfo_toplevel()\\r\\n top.rowconfigure(0, weight=1)\\r\\n top.columnconfigure(0, weight=1)\\r\\n self.rowconfigure(0, weight=1)\\r\\n self.columnconfigure(0, weight=1) \\r\\n\\r\\n self.button_quit = tk.Button(self, text='Quit', command=self.quit)\\r\\n self.button_quit.grid(row=0, column=0, sticky=tk.N+tk.S+tk.E+tk.W)\",\n \"def _create_example_window():\\n return Window({\\\"warning\\\": False, \\\"state\\\": \\\"close\\\"})\",\n \"def create_widgets(self):\\n # self.var_spherical = IntVar()\\n # self.var_3d = IntVar()\\n # self.var_spatial_audio = IntVar()\\n # self.button_open[\\\"command\\\"] = self.action_open\\n # self.button_inject[\\\"command\\\"] = self.action_inject\\n pass\",\n \"def buildUI(self):\\n\\n if cmds.window(\\\"pyART_AddToCanvasWIN\\\", exists=True):\\n cmds.deleteUI(\\\"pyART_AddToCanvasWIN\\\", wnd=True)\\n\\n # create the main window\\n self.mainWin = QtWidgets.QMainWindow(self.pickerUI)\\n\\n # create the main widget\\n self.mainWidget = QtWidgets.QWidget()\\n self.mainWin.setCentralWidget(self.mainWidget)\\n\\n # create the mainLayout\\n self.layout = QtWidgets.QVBoxLayout(self.mainWidget)\\n\\n # load stylesheet\\n styleSheetFile = utils.returnNicePath(self.toolsPath, \\\"Core/Scripts/Interfaces/StyleSheets/animPicker.qss\\\")\\n f = open(styleSheetFile, \\\"r\\\")\\n self.style = f.read()\\n f.close()\\n\\n self.mainWin.setStyleSheet(self.style)\\n\\n self.mainWin.setMinimumSize(QtCore.QSize(250, 400))\\n self.mainWin.setMaximumSize(QtCore.QSize(250, 400))\\n self.mainWin.resize(250, 400)\\n\\n # set qt object name\\n self.mainWin.setObjectName(\\\"pyART_AddToCanvasWIN\\\")\\n self.mainWin.setWindowTitle(\\\"Add Module To Canvas\\\")\\n\\n # label, listWidget, button\\n label = QtWidgets.QLabel(\\\"Available Modules:\\\")\\n label.setProperty(\\\"boldFont\\\", True)\\n self.layout.addWidget(label)\\n\\n self.moduleList = QtWidgets.QListWidget()\\n self.moduleList.setMaximumSize(230, 300)\\n self.moduleList.setMinimumSize(230, 300)\\n self.layout.addWidget(self.moduleList)\\n\\n # add modules to listWidget\\n self.addModulesToList()\\n\\n # create add button\\n button = QtWidgets.QPushButton(\\\"Add Selected To Canvas\\\")\\n self.layout.addWidget(button)\\n button.setObjectName(\\\"blueButton\\\")\\n button.clicked.connect(self.addSelectedToCanvas)\\n\\n # show ui\\n self.mainWin.show()\",\n \"def createWidgets(self):\\n layout = QHBoxLayout()\\n \\n self.logsItem = TestsView.TestsView(parent=self, local = self.local)\\n \\n self.resumeView = ResumeView.TextualView(parent=self)\\n if QtHelper.str2bool( Settings.instance().readValue( key = 'TestRun/hide-resume-view' ) ):\\n self.hideResumeView()\\n\\n self.graphView = GraphView.FlowChartView(parent=self)\\n self.logsView = TextualView.TextualView2(parent=self)\\n self.hexLogsView = DetailedView.DetailedView(parent=self)\\n \\n self.displayTab = QTabWidget()\\n\\n hSplitter = QSplitter(self)\\n hSplitter.setOrientation(Qt.Vertical)\\n\\n hSplitter.addWidget( self.resumeView )\\n hSplitter.addWidget( self.logsView )\\n hSplitter.addWidget( self.hexLogsView )\\n\\n self.displayTab.addTab(hSplitter, self.tr('Events') )\\n self.displayTab.addTab(self.graphView, self.tr('Diagram') )\\n \\n defaultTab = Settings.instance().readValue( key = 'TestRun/default-tab-run' )\\n self.displayTab.setCurrentIndex(int(defaultTab)) \\n \\n self.currentEdit = QLineEdit()\\n self.currentEdit.setReadOnly(True)\\n self.currentEdit.setStyleSheet(\\\"QLineEdit { background-color : #F0F0F0; color: grey; }\\\")\\n\\n leftFrame = QFrame()\\n leftLayout = QVBoxLayout()\\n leftLayout.setContentsMargins(0, 0, 0, 0) \\n leftFrame.setLayout(leftLayout)\\n\\n leftLayout.addWidget(self.currentEdit)\\n leftLayout.addWidget(self.displayTab)\\n\\n v_splitter = QSplitter(self) \\n v_splitter.addWidget( self.logsItem )\\n v_splitter.addWidget( leftFrame )\\n v_splitter.setStretchFactor(1, 1)\\n\\n layout.addWidget(v_splitter)\\n \\n self.setLayout(layout)\",\n \"def widgets(self):\\r\\n self.setWindowTitle(\\\"PyCrypt\\\")\\r\\n self.setMinimumSize(QSize(500, 500))\\r\\n self.setMaximumSize(QSize(500, 500))\\r\\n# Adding the sub def for widgets etc\\r\\n self.add_menus_and_status()\\r\\n self.add_buttons()\",\n \"def _create_window(self):\\n self.window = Gtk.Window()\\n self.window.set_title(\\\"Yapsy Example\\\")\\n self.window.set_default_size(400, 400)\\n self.window.connect(\\\"destroy\\\", lambda w: Gtk.main_quit())\\n # PluginList() is a composite widget that shows all installed plugins\\n # in a Gtk.TreeView. See widgets.py\\n self._plugin_list = PluginList(self.window)\\n box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)\\n box.pack_start(self._plugin_list, True, True, 0)\\n box.show_all()\\n self.window.add(box)\",\n \"def _init_widgets(self):\\n # Container frame\\n self.container = Frame(self)\\n # Workspace block\\n self.main_container = Frame(self.container)\\n\\n self.text = Label(self.main_container)\\n self.text.config(text=\\\"PyEventLogViewer is a timeline-based tool used to simplify the way\\\\n\\\"\\n \\\"a user can view and explore Windows EVTX files. To begin using this\\\\n\\\"\\n \\\"software you must do the following:\\\\n\\\\n\\\"\\n \\\"\\\\t1) File → New → 'Create a new project'\\\\n\\\"\\n \\\"\\\\t2) Tools → Import Log File → 'Open a specified EVTX file'\\\\n\\\"\\n \\\"\\\\t3) Explore the presented timeline.\\\\n\\\"\\n \\\"\\\\t4) Double-click a specific record to view the XML data for that record.\\\\n\\\"\\n \\\"\\\\t5) File → Export → 'Generate a CSV or HTML file for timeline presentation.'\\\\n\\\\n\\\"\\n \\\"At this point, only System and Security EVTX files are parsable with this software.\\\")\\n\\n self.show_var = BooleanVar()\\n self.show_check = Checkbutton(self.main_container, text=\\\"Don't Show on Startup\\\", variable=self.show_var)\\n\\n # Action block\\n self.button_ok = Button(self.main_container, text='Ok', underline=0, command=self.callback_close)\\n self.bind('<Return>', self.callback_close)\\n self.bind('<Escape>', self.callback_close)\\n\\n # Focus on window - required for binds to work.\\n self.focus_set()\",\n \"def createWindow(self):\\r\\n\\t\\t# give the window a title\\r\\n\\t\\tself.parent.title( 'Acrobat Data Acquisition')\\r\\n\\t\\t# set the style\\r\\n\\t\\tself.style = ttk.Style()\\r\\n\\t\\tself.style.theme_use('default')\\r\\n\\t\\tself.pack(fill= tk.BOTH, expand=1)\",\n \"def createUI(self):\\n\\n q.getQItem(windowID, QtWidgets.QWidget)\\n cmds.setParent(q.fullPath)\\n\\n # ################################################\\n # Active Render Layer\\n\\n # cmds.separator(height=12, style='none')\\n addFrameLayout(\\n '%s_frameLayoutLayers' % windowID,\\n 'Visible Render Layer', collapsable=False,\\n labelVisible=False,\\n marginHeight=0\\n )\\n\\n addRowLayout(\\n '%s_rowLayoutActiveRenderLayer' % windowID,\\n 4,\\n columnAlign4=('left', 'left', 'right', 'right'),\\n columnAttach4=('left', 'both', 'right', 'right'),\\n columnWidth4=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\\n )\\n )\\n\\n\\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\\n image='RS_create_layer', size=(21, 21))\\n addOptionMenu('%s_selectActiveLayer' % windowID,\\n 'Active Layer ', (), rsSelectActiveLayer)\\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\\n rsOpenRenderSetupWindow, image='render_setup.png',\\n size=(21, 21))\\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\\n size=(21, 21))\\n\\n # ################################################\\n # Work Render Layers\\n\\n cmds.setParent(q.fullPath)\\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\\n 'Work Render Layer', collapsable=False,\\n labelVisible=False, marginHeight=0)\\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\\n columnAlign3=('left', 'left', 'right'),\\n columnAttach3=('left', 'both', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\\n\\n cmds.separator()\\n addOptionMenu('%s_selectVisibleLayer' % windowID,\\n 'Visible Layer ', (), rsSelectVisibleLayer)\\n cmds.separator()\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=12, style='none')\\n\\n # ################################################\\n # Collections\\n\\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\\n labelVisible=False, marginHeight=0)\\n\\n addRowLayout(\\n '%s_rowLayout02' % windowID,\\n 6,\\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\\n columnWidth6=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n )\\n )\\n\\n addButton('rsAddCollection', 'Add', rsAddCollection)\\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\\n image='selectObject.png', size=(21, 21))\\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\\n size=(21, 21), image='QR_rename.png')\\n addButton('rsDuplicateShader', 'Duplicate Shader',\\n duplicateShader, size=(21, 21), image='newPreset.png')\\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\\n image='QR_refresh.png')\\n\\n # ###########################\\n # Filter List\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout03' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\\n\\n addTextField('%s_filterShaderList' % windowID, 'Search',\\n rsFilterShaderList_off, rsFilterShaderList_off,\\n window.updateUI)\\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\\n\\n # ###########################\\n # The shaders scroll list\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\\n + 12)\\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\\n rsShaderScrollList_doubleClick,\\n rsShaderScrollList_onSelect,\\n rsShaderScrollList_deleteKey)\\n\\n # Add popup menu:\\n\\n cmds.popupMenu('rsShaderScrollListPopupMenu',\\n parent='%s_ShaderScrollList' % windowID,\\n allowOptionBoxes=False, markingMenu=True,\\n postMenuCommand=postMenuCommand)\\n cmds.menuItem('%s_popupMenuItem02' % windowID,\\n label='Duplicate Shader', command=duplicateShader)\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem04' % windowID,\\n label='Graph Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem03' % windowID,\\n label='Select Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem05' % windowID,\\n label='Select Assigned Shapes')\\n cmds.menuItem('%s_popupMenuItem06' % windowID,\\n label='Select Assigned Transforms')\\n\\n # ##################################################\\n # Arnold Property Overrides\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout20' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n addRowLayout('%s_rowLayout05' % windowID, 2,\\n columnAlign2=('left', 'both'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\\n 'Apply Arnold Property Overrides', 'plainLabelFont')\\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\\n rsArnoldPropertyOverridesCheckBox,\\n rsArnoldPropertyOverridesCheckBox)\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n # Column Layout to toggle\\n\\n cmds.setParent('%s_columnLayout20' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout02' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n addCheckboxes('%s_columnLayout02' % windowID)\\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n # Shader Override\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout21' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n addRowLayout('%s_rowLayout06' % windowID, 2,\\n columnAlign2=('left', 'right'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\\n 'plainLabelFont')\\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n\\n cmds.setParent('%s_columnLayout21' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout03' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('both', 4),\\n adjustableColumn=True,\\n rowSpacing=0,\\n )\\n cmds.setParent('%s_columnLayout03' % windowID)\\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\\n rsShaderOverridesMenu)\\n\\n global selectedShaderOverride\\n\\n # default selection\\n\\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=10, style='none')\\n\\n # #################################################\\n # Extras\\n\\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\\n collapsable=True, marginHeight=0,\\n labelVisible=False)\\n\\n # #################################################\\n # Add & Assign Shader Groups\\n\\n addFrameLayout(\\n '%s_frameLayout05' % windowID,\\n 'Add & Assign Shader Groups',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=False,\\n labelVisible=True,\\n )\\n\\n # Add the renamer window\\n\\n self.gwCustomRenamer = CustomRenamer()\\n self.gwCustomRenamer.createUI()\\n\\n # #################################################\\n # AutoConnect\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n\\n addFrameLayout(\\n '%s_frameLayout03' % windowID,\\n 'Adobe Connector',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\\n 'left'), columnAttach3=('both', 'both', 'both'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addButton('updateConnections', '> Update Connections <',\\n updateConnections)\\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\\n addButton('editTexture', 'Edit Texture', editTexture)\\n\\n # After Effects\\n\\n cmds.setParent('%s_frameLayout03' % windowID)\\n addRowLayout('%s_rowLayout11' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\\n addText('%s_text90' % windowID, 'Send to After Effects:')\\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\\n\\n # #################################################\\n # Render Setup /\\n # Output settings\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n addFrameLayout(\\n '%s_frameLayout04' % windowID,\\n 'Output Settings',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout08' % windowID, 1,\\n columnAlign1='center', columnAttach1='both',\\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\\n addButton('%s_revealOutputDirectory' % windowID,\\n 'Output path not set yet', rsRevealOutputDirectory)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout09' % windowID, 3,\\n columnAlign3=('left', 'right', 'right'),\\n columnAttach3=('left', 'right', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\\n\\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\\n rsSelectOutputTemplate)\\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\\n rsSelectOutputVersion)\\n cmds.menuItem(label='v001')\\n\\n cmds.setParent('%s_rowLayout09' % windowID)\\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\\n rsIncrementOutputVersion, size=(21, 21))\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout10' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\\n rsOutputTemplatesMenu)\\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\\n rsSetFPSMenu)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout12' % windowID, 4,\\n columnAlign4=('right', 'left', 'right', 'left'),\\n columnAttach4=('both', 'both', 'both', 'both'),\\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\\n\\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\\n setInFrame, setInFrame)\\n\\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\\n setOutFrame, setOutFrame)\",\n \"def createWindow():\\n\\n windowName = \\\"ObjectSpawner\\\"\\n\\n if cmds.window(windowName, query=True, exists=True):\\n cmds.deleteUI(windowName)\\n\\n cmds.window(windowName)\\n\\n populateUI()\\n enableEditorDrop()\\n\\n cmds.showWindow(windowName)\",\n \"def create_widgets(self):\\r\\n self.create_containers()\\r\\n self.setup_containers()\\r\\n self.create_panel_widgets()\\r\\n self.setup_scrollbar()\",\n \"def __init__(self,subWindow,currentExperiment):\\n super(AmoebaCreateExperiment,self).__init__()\\n self.stage = 0\\n self.currentExperiment = currentExperiment\\n #self.XMLWriter = ExperimentXMLWriter()\\n self.XMLWriter = Amoeba_experiment()\\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\\n print \\\"Create new experiment.\\\"\\n\\n self.subWindow = subWindow\\n\\n #Create a scroll bar for the summary area\\n self.layout = QVBoxLayout()\\n\\n #Create the widgets\\n self.SetFundamentalParameters = AmoebaSetFundamentalParameters()\\n self.ShowAllInstruments = AmoebaShowAllInstuments()\\n self.LinkInstruments = LinkInstrumentsForm()\\n\\n self.next = QPushButton(\\\"Next\\\")\\n self.next.clicked.connect(self.next_pressed)\\n\\n #Add to the scroll widget\\n self.layout.addWidget(self.SetFundamentalParameters)\\n self.layout.addWidget(self.ShowAllInstruments)\\n self.layout.addWidget(self.LinkInstruments)\\n self.layout.addWidget(self.next)\\n\\n #Add the Widgets to the Subwindow\\n self.setLayout(self.layout)\\n\\n #Hide all the widgets that will later be revealed.\\n self.SetFundamentalParameters.hide()\\n self.LinkInstruments.hide()\",\n \"def showUI(cls):\\r\\n win = cls(uiFile)\\r\\n win.create()\\r\\n return win\",\n \"def show(self, window):\\r\\n\\r\\n return\",\n \"def _setup_ui(self):\\n\\n self.window = ui.Widget()\\n self.window.dimensions = ui.normalize_dimension((\\n 0, 0,\\n self.normalized_screen_resolution[0],\\n self.normalized_screen_resolution[1]\\n ))\\n self.window.background_color = ImageColor.getcolor('#000000', 'RGB')\\n\\n interface_frame = ui.Widget(parent=self.window)\\n interface_frame.dimensions = ui.normalize_dimension((\\n self.preview_renderer.window[2],\\n 0,\\n self.normalized_screen_resolution[0] - self.preview_renderer.window[2],\\n self.normalized_screen_resolution[1]\\n ))\\n interface_frame.background_color = ImageColor.getcolor('#ffffff', 'RGB')\\n\\n number = ui.LabelWidget(\\\"\\\",\\n name=NAME_GET_STARTED,\\n parent=interface_frame,\\n align=\\\"center\\\",\\n font_color=(0, 0, 0, 255))\\n number.dimensions = (\\n 5, 5,\\n interface_frame.width - 10,\\n interface_frame.height - 10\\n )\",\n \"def __init__(self):\\n self.r = Tk()\\n self.r.title(\\\"Website Library 123\\\")\\n self.r.geometry(\\\"500x250\\\")\\n self.r.configure(background=\\\"#ddaf7e\\\")\\n\\n '''Configuring So that the First Window holds buttons'''\\n\\n self.title = Label(self.r, text=\\\"Website Library\\\", bg=\\\"#ddaf7e\\\", font=\\\"Calibri 26\\\").pack()\\n self.divider = Label(self.r, text=\\\" \\\"*100, bg=\\\"#ddaf7e\\\").pack()\\n self.saved = Button(self.r, text=\\\"View Saved Websites\\\", font=\\\"Verdana 15\\\", command=lambda: self.newwind(1)).pack(pady=10)\\n self.addnew = Button(self.r, text=\\\"Add New Websites\\\", font=\\\"Verdana 15\\\", command=lambda: self.newwind(2)).pack(pady=10)\\n self.r.protocol(\\\"WM_DELETE_WINDOW\\\", self.on_closing)\\n self.r.mainloop()\",\n \"def create(self, parent):\\n self.widget = _QMainWindow(parent)\",\n \"def createWindow(self):\\n\\n # create window, set basic attributes\\n w = gtk.Window(gtk.WINDOW_TOPLEVEL)\\n w.set_size_request(*self.__def_win_size__)\\n w.set_decorated(False)\\n #w.fullscreen()\\n #w.unfullscreen()\\n w.set_title(self.__name__)\\n w.connect(\\\"destroy\\\", gtk.main_quit)\\n\\n # declare buttons and their associated handlers\\n controls = (\\n (\\\"open_button\\\", gtk.ToolButton(gtk.STOCK_OPEN), self.onPlay),\\n (\\\"play_button\\\", gtk.ToolButton(gtk.STOCK_MEDIA_PLAY), self.onPlay),\\n (\\\"stop_button\\\", gtk.ToolButton(gtk.STOCK_MEDIA_STOP), self.onStop),\\n (\\\"quit_button\\\", gtk.ToolButton(gtk.STOCK_QUIT), gtk.main_quit)\\n )\\n\\n # as well as the container in which to put them\\n box = gtk.HButtonBox()\\n\\n # for every widget, connect to its clicked signal and add it\\n # to the enclosing box\\n for name, widget, handler in controls:\\n widget.connect(\\\"clicked\\\", handler)\\n box.pack_start(widget, True)\\n setattr(self, name, widget)\\n\\n viewer = gtk.DrawingArea()\\n viewer.modify_bg(gtk.STATE_NORMAL, viewer.style.black)\\n\\n # we will need this later\\n self.xid = None\\n\\n # now finally do the top-level layout for the window\\n layout = gtk.VBox(False)\\n layout.pack_start(viewer)\\n\\n # subclasses can override childWidgets() to supply\\n # custom controls\\n layout.pack_start(self.customWidgets(), False, False)\\n layout.pack_end(box, False, False)\\n w.add(layout)\\n w.show_all()\\n\\n # we want to return only the portion of the window which will\\n # be used to display the video, not the whole top-level\\n # window. a DrawingArea widget is, in fact, an X11 window.\\n return viewer\",\n \"def createWindow(self, type):\\n # this = Browser(self.url())\\n # this.show()\\n\\n self.popup = SequanixQWebView(**self.kwargs)\\n self.popup.setObjectName(\\\"web_content\\\")\\n self.popup.setWindowTitle(\\\"Sequana browser\\\")\\n self.popup.page().windowCloseRequested.connect(self.popup.close)\\n self.popup.show()\\n return self.popup\",\n \"def openWindow(self):\\n # self.showSessionAct.setEnabled(False)\\n self.musketeers_widget = MusketeersWidget(parent=self)\\n self.setCentralWidget(self.musketeers_widget)\\n self.saveGroupMenu = QAction('Save Group', self.fileMenu)\\n self.fileMenu.addAction(self.saveGroupMenu)\\n self.saveGroupMenu.triggered.connect(self.musketeers_widget.session_widget.save_group)\",\n \"def setupWindow(self):\\n\\n\\t\\tself.main_menu_window = MenuFrame.MainMenuFrame(self.uiCoordinator)\\n\\t\\tself.menu_window = self.main_menu_window._mf\\n\\t\\tself.score_window = self.main_menu_window._hf\\n\\t\\tself.instructions_window = self.main_menu_window._if\\n\\t\\tself.menu_window.playButton.focus_set()\",\n \"def create_widget(self):\\n pass\",\n \"def create_window(self, img, roi, name):\\n\\n self.window = SpinBalanceDialog()\\n\\n # call the user-implemented functionality\\n self.window.main(img, roi)\\n # show the window\\n self.window.show()\\n\\n return self.window\",\n \"def open_main_window(self):\\r\\n track_terms_dic = ''\\r\\n sg.theme(self.look)\\r\\n\\r\\n layout = [[sg.Text('Welcome to tweeet monitor ')],\\r\\n [sg.Text('Please enter Details ')],\\r\\n [sg.Text('User Mail', size=(15, 1)), sg.InputText()],\\r\\n [sg.Text('Timout', size=(15, 1)), sg.InputText('', enable_events=True, key='-DIGITS-')],\\r\\n [sg.Text('')],\\r\\n [sg.Text('You can select an existing list or create a new one '),\\r\\n sg.Combo(self.files, default_value='Select Track Terms List ', key='-COMBO1-')],\\r\\n [sg.Text('')],\\r\\n [sg.Button('Select Exists List'), sg.Button('Create a New List')],\\r\\n [sg.Text('\\\\n')],\\r\\n [sg.Button('Start Monitor'), sg.Button('Exit')]\\r\\n ]\\r\\n\\r\\n window = sg.Window('Monitor tweeter', layout)\\r\\n # Event Loop\\r\\n while True:\\r\\n event, values = window.read()\\r\\n\\r\\n if event == sg.WIN_CLOSED:\\r\\n exit()\\r\\n elif event == 'Select Exists List' or event == 'Create a New List' or event == 'Start Monitor':\\r\\n user_mail = values[0]\\r\\n timeout = values['-DIGITS-']\\r\\n list_dic = values['-COMBO1-']\\r\\n\\r\\n if self.check(user_mail) == 'Invalid Email':\\r\\n self.info_popup_window('You Enter not valid mail ', 'Info', self.look)\\r\\n elif event == 'Select Exists List':\\r\\n if list_dic == 'Select Track Terms List ':\\r\\n self.info_popup_window('Track Terms List ', 'Info', self.look)\\r\\n else:\\r\\n file_name = self.path + self.bachslash + list_dic\\r\\n os.system(file_name)\\r\\n track_terms_dic = list_dic\\r\\n elif event == 'Create a New List':\\r\\n track_terms_dic = self.open_window()\\r\\n track_terms_dic = track_terms_dic + '.txt'\\r\\n elif event == 'Start Monitor':\\r\\n if track_terms_dic == '':\\r\\n self.info_popup_window('Please, Create new Dictionary or select one ', 'Info', self.look)\\r\\n elif track_terms_dic != '':\\r\\n file_name = self.path + self.bachslash + track_terms_dic\\r\\n my_file = open(file_name, \\\"r\\\")\\r\\n content = my_file.read()\\r\\n content = content.split(\\\"\\\\n\\\")\\r\\n content = self.cleanList(content)\\r\\n # print(content)\\r\\n my_file.close()\\r\\n now = datetime.now()\\r\\n date_time = now.strftime(\\\"%m/%d/%Y, %H:%M:%S\\\")\\r\\n dict_list = {'User': user_mail,\\r\\n 'Timeout': timeout,\\r\\n 'Dictionary': list_dic,\\r\\n 'Create Date': date_time,\\r\\n 'track_terms_list': content\\r\\n }\\r\\n header = ['user_mail', 'Timeout', 'Dictionary', 'Create Date', 'list words']\\r\\n if os.path.isfile(self.file_track_terms_audit) == False:\\r\\n # check if the file exsist = if not: create file and print header to the file\\r\\n with open(self.file_track_terms_audit, 'a', newline='\\\\n') as file:\\r\\n try:\\r\\n write = csv.writer(file)\\r\\n write.writerow(header)\\r\\n write.writerows(self.values_list)\\r\\n file.close()\\r\\n except:\\r\\n print(\\\"Something went wrong when writing to the file\\\")\\r\\n else:\\r\\n self.values_list = list(dict_list.values())\\r\\n # print ('self.values_list :****',self.values_list)\\r\\n with open(self.file_track_terms_audit, 'a', newline='\\\\n') as file:\\r\\n try:\\r\\n write = csv.writer(file)\\r\\n self.values_list = [self.values_list]\\r\\n write.writerows(self.values_list)\\r\\n file.close()\\r\\n except:\\r\\n print(\\\"Something went wrong when writing to the file\\\")\\r\\n print('self.values_list:', self.values_list)\\r\\n\\r\\n window.close()\\r\\n\\r\\n print('track_terms_dic: ', track_terms_dic)\\r\\n print('dict_list:', dict_list)\\r\\n return (dict_list)\\r\\n\\r\\n # always check for closed window\\r\\n if event in (sg.WIN_CLOSED, 'Exit'):\\r\\n break\\r\\n\\r\\n if event == '-LIST-' and len(values['-LIST-']):\\r\\n sg.popup('Selected ', values['-LIST-'])\\r\\n\\r\\n if len(values['-DIGITS-']) and values['-DIGITS-'][-1] not in ('0123456789'):\\r\\n # delete last char from input\\r\\n window['-DIGITS-'].update(values['-DIGITS-'][:-1])\\r\\n\\r\\n window.close()\",\n \"def __create_ui(self):\\n vbox = gtk.VBox()\\n\\n # Create the viewable area of the file browser\\n self.__view_port = gtk.ScrolledWindow()\\n self.__view_port.set_policy(gtk.POLICY_AUTOMATIC,\\n gtk.POLICY_AUTOMATIC)\\n # Create the tree view and add it to the viewable area\\n self.__tree_view = ProjectTreeView()\\n self.__project_explorer = ProjectExplorer(self.window, self.__tree_view)\\n self.__tree_view.connect('button_press_event',\\n self.__on_treeview_button_press_event)\\n self.__project_explorer.set_repository()\\n self.__view_port.add(self.__tree_view)\\n # Create the toolbar\\n hbox = gtk.HBox()\\n toolbar = gtk.Toolbar()\\n toolbar.set_style(gtk.TOOLBAR_ICONS)\\n toolbar.set_icon_size(gtk.ICON_SIZE_MENU)\\n back = gtk.ToolButton(gtk.STOCK_GO_UP)\\n back.connect('clicked', self.__on_back_clicked)\\n toolbar.insert(back, 0)\\n toolbar.insert(gtk.SeparatorToolItem(), 1)\\n refresh = gtk.ToolButton(gtk.STOCK_REFRESH)\\n refresh.connect('clicked', self.__on_refresh_clicked)\\n toolbar.insert(refresh, 2)\\n hbox.pack_start(toolbar, True, True, 0)\\n vbox.pack_start(hbox, False, False, 0)\\n vbox.pack_start(self.__view_port, True, True, 0)\\n\\n # Setup the create the buttons for:\\n # New File, New Folder\\n # ----------------------------------------------------------------------\\n hbox1 = gtk.VBox()\\n toolbar_actions = gtk.Toolbar()\\n toolbar_actions.set_style(gtk.TOOLBAR_ICONS)\\n toolbar_actions.set_icon_size(gtk.ICON_SIZE_MENU)\\n new_file = gtk.ToolButton(gtk.STOCK_NEW)\\n new_file.connect('clicked', self.__on_new_file_clicked_cb)\\n toolbar_actions.insert(new_file, 0)\\n new_dir = gtk.ToolButton(gtk.STOCK_OPEN) # TODO: use a custom icon\\n new_dir.connect('clicked', self.__on_new_dir_clicked_cb)\\n toolbar_actions.insert(new_dir, 1)\\n hbox1.pack_start(gtk.HSeparator(), True, True, 0)\\n hbox1.pack_start(toolbar_actions, True, True, 0)\\n vbox.pack_end(hbox1, False, False, 0)\\n # ----------------------------------------------------------------------\\n vbox.show_all()\\n # Attach the project explorer to GMate's side panel\\n self.__side_panel = self.window.get_side_panel()\\n self.__side_panel.add_tab(vbox, msg0005, gtk.STOCK_HARDDISK)\",\n \"def setup_gui(self):\\n # if there are more than 1 visualizer we need to assure that there\\n # will not be tag conflicts\\n BaseRealTimeVisualizer.setup_gui_lock.acquire()\\n # look for valid tag\\n dpg.create_context()\\n\\n self.id = 0\\n while dpg.does_item_exist(f'main_window_{self.id}'):\\n self.id += 1\\n\\n with dpg.texture_registry(show=False):\\n dpg.add_dynamic_texture(\\n width=self.width,\\n height=self.height,\\n default_value=np.zeros((self.width, self.height, 3)),\\n tag=f'input_image_texture_{self.id}',\\n )\\n\\n with dpg.window(\\n tag=f'main_window_{self.id}',\\n no_title_bar=True,\\n autosize=True\\n ):\\n dpg.add_image(\\n texture_tag=f'input_image_texture_{self.id}',\\n tag=f'image_render_{self.id}',\\n pos=(_PADDING, _PADDING)\\n )\\n\\n dpg.set_global_font_scale(_FONT_SCALE)\\n\\n if self.id == 0:\\n dpg.set_primary_window(f'main_window_{self.id}', True)\\n dpg.create_viewport(\\n title=self.title,\\n width=self.width + _PADDING*2,\\n height=self.height + _PADDING*2,\\n resizable=True\\n )\\n dpg.setup_dearpygui()\\n dpg.show_viewport()\\n elif self.id == 1:\\n dpg.set_primary_window('main_window_0', False)\\n\\n BaseRealTimeVisualizer.setup_gui_lock.release()\",\n \"def open_generatorWindow(self):\\n self.window = generatorWindow(self)\\n self.hide()\",\n \"def createWidgets(self):\\n self.tab = WorkspaceTab( self )\\n self.tab.setMinimumWidth(500)\\n self.tab.setDocumentMode( False )\\n self.tab.setMovable( True )\\n\\n # self.dockToolbar = QToolBar(self)\\n # self.dockToolbar.setOrientation(Qt.Vertical)\\n\\n self.findWidget = FindReplace(self)\\n self.findWidget.setDisabled(True)\\n self.findWidget.hide()\\n\\n layout = QVBoxLayout()\\n layout.addWidget( self.tab )\\n layout.setContentsMargins(0,0,0,0)\\n\\n \\n self.setLayout(layout)\",\n \"def create_gui(self):\\n\\n selectors_widgets = list()\\n\\n for n in range(4):\\n\\n selectors_widgets.append(wd.Dropdown(\\n options={'': 0, 'Orange': 1, 'Red': 2, 'Blue': 3, 'Green': 4},\\n value=0,\\n disabled=False,\\n layout={'width': '148px'}\\n ))\\n\\n self.confirm_button.on_click(\\n self.create_combination_and_rate_function())\\n self.user_interact.children = [self.selectors, self.confirm_button]\\n\\n self.selectors.children = selectors_widgets\",\n \"def inicialUI(self):\\r\\n\\r\\n self.setGeometry(500, 500, 500, 500)\\r\\n self.setWindownTitle(\\\"Pesquisa\\\")\\r\\n self.displayWidgets()\\r\\n\\r\\n self.show()\",\n \"def build_frames(self):\\n self.cntrl_frame = tk.PanedWindow(self.root)\\n self.cntrl_frame.pack(side = tk.TOP, padx = 1, pady = 1, fill = tk.Y)\\n self.info_frame_1 = tk.PanedWindow(self.root)\\n self.info_frame_1.pack(side = tk.TOP, padx = 1, pady = 2, fill = tk.Y)\",\n \"def create(self, window):\\r\\n\\r\\n # Set the size of the editor area.\\r\\n if self.editor_area_size != (-1, -1):\\r\\n window.editor_area_size = self.editor_area_size\\r\\n\\r\\n # If the perspective has specific contents then add just those.\\r\\n if len(self.contents) > 0:\\r\\n self._add_contents(window, self.contents)\\r\\n\\r\\n # Otherwise, add all of the views defined in the window at their\\r\\n # default positions realtive to the editor area.\\r\\n else:\\r\\n self._add_all(window)\\r\\n\\r\\n # Activate the first view in every region.\\r\\n window.reset_views()\\r\\n \\r\\n return\",\n \"def _open_window(self):\\r\\n\\t\\t# Creating the window\\r\\n\\t\\tself._window = Window(self, Locations.RESTAL)\",\n \"def create_new_window():\\n logging.debug(\\\"Function create_new_window() called\\\")\\n\\n new_window = tk.Toplevel()\\n new_window.title(\\\"Test functions\\\")\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_origins()\\\",\\n command=lambda: dss.update_origins(\\n origin_list_=origin_list,\\n champions_list_=champions_list,\\n origin_counters_=origin_counters,\\n ),\\n )\\n ButtonCal.grid(row=1, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_classes()\\\",\\n command=lambda: dss.update_classes(\\n class_list_=class_list,\\n champions_list_=champions_list,\\n class_counters_=class_counters,\\n ),\\n )\\n ButtonCal.grid(row=2, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_classes_and_origins()\\\",\\n command=lambda: dss.update_classes_and_origins(\\n origin_list_=origin_list,\\n champions_list_=champions_list,\\n origin_counters_=origin_counters,\\n class_list_=class_list,\\n class_counters_=class_counters,\\n ),\\n )\\n ButtonCal.grid(row=3, column=0)\\n\\n # is_in_game = tk.IntVar()\\n # dss.create_gui_counter_with_plus_minus(window_tk=new_window, origin_index=1, counter=is_in_game, shift_between_upside_downside=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_champions_to_buy_from_ocr_detection()\\\",\\n command=lambda: dss.update_champions_to_buy_from_ocr_detection(\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr__=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n ),\\n )\\n ButtonCal.grid(row=4, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"show_nonzero_counters_from_ocr()\\\",\\n command=lambda: dss.show_nonzero_counters_from_ocr(\\n tk_window=MainWindow,\\n origin_champs_counters_=origin_champs_counters,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n df_=df,\\n index_list=dss.update_champions_to_buy_from_ocr_detection(\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr__=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n )[1],\\n ),\\n )\\n ButtonCal.grid(row=5, column=0)\\n\\n Labeling = tk.Label(\\n new_window, text=\\\"Care additional points in below\\\", font=BOLDED_FONT\\n )\\n Labeling.grid(row=6, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"show_points_for_nonzero_counters_from_ocr()\\\",\\n command=lambda: dss.show_points_for_nonzero_counters_from_ocr(\\n tk_window=MainWindow,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n df_=df,\\n index_list=dss.update_champions_to_buy_from_ocr_detection(\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr__=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n )[1],\\n ),\\n )\\n ButtonCal.grid(row=7, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"show_nonzero_counters_with_points_from_ocr() OCR button\\\",\\n command=lambda: dss.show_nonzero_counters_with_points_from_ocr(\\n tk_window=MainWindow,\\n origin_champs_counters_=origin_champs_counters,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n df_=df,\\n index_list=dss.update_champions_to_buy_from_ocr_detection(\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr__=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n )[1],\\n origin_list_=origin_list,\\n origin_counters_=origin_counters,\\n class_list_=class_list,\\n class_counters_=class_counters,\\n ),\\n )\\n ButtonCal.grid(row=8, column=0)\\n\\n Labeling = tk.Label(new_window, text=\\\"with Game\\\", font=BOLDED_FONT)\\n Labeling.grid(row=0, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window, text=\\\"update_curent_ss()\\\", command=lambda: dss.update_curent_ss()\\n )\\n ButtonCal.grid(row=1, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_curent_cropped_ss_with_champions()\\\",\\n command=lambda: dss.update_curent_cropped_ss_with_champions(),\\n )\\n ButtonCal.grid(row=2, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_ocr_results_champions()\\\",\\n command=lambda: dss.update_ocr_results_champions(\\n cropped_ss_with_champion_card_names=dss.crop_img,\\n reader_=reader,\\n ),\\n )\\n ButtonCal.grid(row=3, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_sorted_champions_to_buy()\\\",\\n command=lambda: dss.update_sorted_champions_to_buy(\\n ocr_results_sorted=dss.ocr_results_champions,\\n champions_list_for_ocr_=champions_list_for_ocr,\\n ),\\n )\\n ButtonCal.grid(row=4, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_champions_to_buy_from_ocr_detection()\\\",\\n command=lambda: dss.update_champions_to_buy_from_ocr_detection(\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr__=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n ),\\n )\\n ButtonCal.grid(row=5, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"draw_rectangles_show_points_show_buttons_reset_counters() scan&go\\\",\\n command=lambda: dss.draw_rectangles_show_points_show_buttons_reset_counters(\\n rgb_colours_list_=rgb_colours_list,\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr_=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n tk_window=MainWindow,\\n origin_champs_counters_=origin_champs_counters,\\n df_=df,\\n origin_list_=origin_list,\\n champions_list_=champions_list,\\n origin_counters_=origin_counters,\\n class_list_=class_list,\\n class_counters_=class_counters,\\n round_counter=CounterOcrResultsRound,\\n gold_counter=CounterOcrResultsGold,\\n ),\\n )\\n ButtonCal.grid(row=6, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"filling_list_with_counter_for_namedtuple(4)\\\",\\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\\n field_to_check=4,\\n input_list=champion_info,\\n origin_list_=origin_list,\\n class_list_=class_list,\\n origin_counters_=origin_counters,\\n class_counters_=class_counters,\\n df_=df,\\n ),\\n )\\n ButtonCal.grid(row=0, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"filling_list_with_counter_for_namedtuple(5)\\\",\\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\\n field_to_check=5,\\n input_list=champion_info,\\n origin_list_=origin_list,\\n class_list_=class_list,\\n origin_counters_=origin_counters,\\n class_counters_=class_counters,\\n df_=df,\\n ),\\n )\\n ButtonCal.grid(row=1, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"filling_list_with_counter_for_namedtuple(6)\\\",\\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\\n field_to_check=6,\\n input_list=champion_info,\\n origin_list_=origin_list,\\n class_list_=class_list,\\n origin_counters_=origin_counters,\\n class_counters_=class_counters,\\n df_=df,\\n ),\\n )\\n ButtonCal.grid(row=2, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"filling_list_with_counter_for_namedtuple(7)\\\",\\n command=lambda: dss.filling_list_with_counter_for_namedtuple(\\n field_to_check=7,\\n input_list=champion_info,\\n origin_list_=origin_list,\\n class_list_=class_list,\\n origin_counters_=origin_counters,\\n class_counters_=class_counters,\\n df_=df,\\n ),\\n )\\n ButtonCal.grid(row=3, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"append_counters_to_input_list(champion_info)\\\",\\n command=lambda: dss.append_counters_to_input_list(\\n input_list=champion_info,\\n origin_list_=origin_list,\\n class_list_=class_list,\\n origin_counters_=origin_counters,\\n class_counters_=class_counters,\\n df_=df,\\n ),\\n )\\n ButtonCal.grid(row=4, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"append_counters_to_input_list(champion_to_buy_info)\\\",\\n command=lambda: dss.append_counters_to_input_list(\\n input_list=champion_to_buy_info,\\n origin_list_=origin_list,\\n class_list_=class_list,\\n origin_counters_=origin_counters,\\n class_counters_=class_counters,\\n df_=df,\\n ),\\n )\\n ButtonCal.grid(row=5, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"calculate_card_position_on_screen(2)\\\",\\n command=lambda: dss.calculate_card_position_on_screen(\\n card_index=2,\\n X_FIRST_CHAMPION_CARD_=dss.X_FIRST_CHAMPION_CARD,\\n PADDING_BETWEEN_CHAMPION_CARDS_=dss.PADDING_BETWEEN_CHAMPION_CARDS,\\n W_CHAMPION_CARD_=dss.W_CHAMPION_CARD,\\n ),\\n )\\n ButtonCal.grid(row=0, column=3)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"build_list_of_champion_cards_rectangles()\\\",\\n command=lambda: dss.build_list_of_champion_cards_rectangles(\\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\\n Y_FIRST_CHAMPION_CARD_=dss.Y_FIRST_CHAMPION_CARD,\\n W_CHAMPION_CARD_=dss.W_CHAMPION_CARD,\\n H_CHAMPION_CARD_=dss.H_CHAMPION_CARD,\\n ),\\n )\\n ButtonCal.grid(row=1, column=3)\\n\\n Labeling = tk.Label(\\n new_window, text=\\\"Another cases below this row\\\", font=BOLDED_FONT\\n )\\n Labeling.grid(row=9, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"check_nonzero_counters()\\\",\\n command=lambda: dss.check_nonzero_counters(\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n ),\\n )\\n ButtonCal.grid(row=10, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"show_nonzero_counters()\\\",\\n command=lambda: dss.show_nonzero_counters(\\n tk_window=MainWindow,\\n origin_champs_counters_=origin_champs_counters,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n df_=df,\\n row_offset=0,\\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\\n SHIFT_BETWEEN_ORIGINS_=dss.SHIFT_BETWEEN_ORIGINS,\\n ),\\n )\\n ButtonCal.grid(row=11, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_classes_and_origins()\\\",\\n command=lambda: dss.update_classes_and_origins(\\n origin_list_=origin_list,\\n champions_list_=champions_list,\\n origin_counters_=origin_counters,\\n class_list_=class_list,\\n class_counters_=class_counters,\\n ),\\n )\\n ButtonCal.grid(row=12, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"show_points_for_nonzero_counters()\\\",\\n command=lambda: dss.show_points_for_nonzero_counters(\\n tk_window=MainWindow,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n df_=df,\\n row_offset=2,\\n show_mode=1,\\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\\n SHIFT_BETWEEN_ORIGINS_=dss.SHIFT_BETWEEN_ORIGINS,\\n ),\\n )\\n ButtonCal.grid(row=13, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"show_nonzero_counters_with_points()\\\",\\n command=lambda: dss.show_nonzero_counters_with_points(\\n tk_window=MainWindow,\\n origin_champs_counters_=origin_champs_counters,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n df_=df,\\n origin_list_=origin_list,\\n origin_counters_=origin_counters,\\n class_list_=class_list,\\n class_counters_=class_counters,\\n ),\\n )\\n ButtonCal.grid(row=14, column=0)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"reset_counters_in_list()\\\",\\n command=lambda: dss.reset_counters_in_list(\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy\\n ),\\n )\\n ButtonCal.grid(row=10, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_champions_to_buy_from_ocr_detection()\\\",\\n command=lambda: dss.update_champions_to_buy_from_ocr_detection(\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr__=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n ),\\n )\\n ButtonCal.grid(row=11, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"show_nonzero_counters_with_points_from_ocr()\\\",\\n command=lambda: dss.show_nonzero_counters_with_points_from_ocr(\\n tk_window=MainWindow,\\n origin_champs_counters_=origin_champs_counters,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n champions_list_=champions_list,\\n df_=df,\\n index_list=dss.update_champions_to_buy_from_ocr_detection(\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr__=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n )[1],\\n origin_list_=origin_list,\\n origin_counters_=origin_counters,\\n class_list_=class_list,\\n class_counters_=class_counters,\\n ),\\n )\\n ButtonCal.grid(row=12, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"build_list_of_champion_cards_rectangles()\\\",\\n command=lambda: dss.build_list_of_champion_cards_rectangles(\\n CARDS_TO_BUY_AMOUNT_=dss.CARDS_TO_BUY_AMOUNT,\\n Y_FIRST_CHAMPION_CARD_=dss.Y_FIRST_CHAMPION_CARD,\\n W_CHAMPION_CARD_=dss.W_CHAMPION_CARD,\\n H_CHAMPION_CARD_=dss.H_CHAMPION_CARD,\\n ),\\n )\\n ButtonCal.grid(row=13, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"draw_rectangles_show_points_show_buttons_reset_counters() scan&go\\\",\\n command=lambda: dss.draw_rectangles_show_points_show_buttons_reset_counters(\\n rgb_colours_list_=rgb_colours_list,\\n sorted_champions_to_buy_=dss.sorted_champions_to_buy,\\n champions_list_for_ocr_=champions_list_for_ocr,\\n origin_champs_counters_to_buy_=origin_champs_counters_to_buy,\\n reader_=reader,\\n tk_window=MainWindow,\\n origin_champs_counters_=origin_champs_counters,\\n df_=df,\\n origin_list_=origin_list,\\n champions_list_=champions_list,\\n origin_counters_=origin_counters,\\n class_list_=class_list,\\n class_counters_=class_counters,\\n round_counter=CounterOcrResultsRound,\\n gold_counter=CounterOcrResultsGold,\\n ),\\n )\\n ButtonCal.grid(row=14, column=1)\\n\\n ButtonCal = tk.Button(\\n new_window, text=\\\"update_curent_ss()\\\", command=lambda: dss.update_curent_ss()\\n )\\n ButtonCal.grid(row=10, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_curent_cropped_ss_with_rounds()\\\",\\n command=lambda: dss.update_curent_cropped_ss_with_rounds(),\\n )\\n ButtonCal.grid(row=11, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_ocr_results_round()\\\",\\n command=lambda: dss.update_ocr_results_round(\\n reader_=reader, round_counter=CounterOcrResultsRound\\n ),\\n )\\n ButtonCal.grid(row=12, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"full_state_update_champions_ocr()\\\",\\n command=lambda: dss.full_state_update_rounds_ocr(\\n reader_=reader, round_counter=CounterOcrResultsRound\\n ),\\n )\\n ButtonCal.grid(row=13, column=2)\\n\\n ButtonCal = tk.Button(\\n new_window, text=\\\"update_curent_ss()\\\", command=lambda: dss.update_curent_ss()\\n )\\n ButtonCal.grid(row=10, column=3)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_curent_cropped_ss_with_gold()\\\",\\n command=lambda: dss.update_curent_cropped_ss_with_gold(),\\n )\\n ButtonCal.grid(row=11, column=3)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"update_ocr_results_gold()\\\",\\n command=lambda: dss.update_ocr_results_gold(\\n reader_=reader,\\n gold_counter=CounterOcrResultsGold,\\n ),\\n )\\n ButtonCal.grid(row=12, column=3)\\n\\n ButtonCal = tk.Button(\\n new_window,\\n text=\\\"full_state_update_gold_ocr()\\\",\\n command=lambda: dss.full_state_update_gold_ocr(\\n reader_=reader,\\n gold_counter=CounterOcrResultsGold,\\n ),\\n )\\n ButtonCal.grid(row=13, column=3)\\n\\n logging.debug(\\\"Function create_new_window() end\\\")\",\n \"def click_add():\\n # TODO: 1. In frontend_script.py, create function \\\"create_window()\\\" that takes a Toplevel() as a parameter.\\n # TODO: 2. In this file, implement the code below\\n # new_window = Toplevel(root)\\n # frontend_script.create_window(new_window)\",\n \"def details_window(self, instance: Union[Nobleman, Location]):\\n window = tk.Toplevel()\\n window.title(instance.name)\\n window.protocol(\\\"WM_DELETE_WINDOW\\\",\\n partial(self.close_details_window, instance))\\n self.register_extra_window(instance, window)\\n self.generate_window_content(instance, window)\",\n \"def open_editor(self):\\n #Create dialogue box to configure empty words earch:\\n self.customiser = Toplevel(self.root)\\n self.customiser.title(\\\"Word Search Configuration\\\")\\n \\n #Widgets of dialogue box\\n self.controls = Frame(self.customiser)\\n self.controls.pack()\\n self.message = LabelFrame(self.customiser, text = \\\"Instructions:\\\")\\n self.message.pack()\\n self.words_frame = Frame(self.customiser)\\n self.words_frame.pack()\\n self.row_entry = Scale(self.controls, from_ = 2, to = 20, orient = HORIZONTAL)\\n self.row_entry.grid(row = 1, column = 2)\\n self.row_label = Label(self.controls, text = \\\"Rows:\\\", justify = RIGHT)\\n self.row_label.grid(row = 1, column = 1)\\n self.column_entry = Scale(self.controls, from_ = 2, to = 20, orient = HORIZONTAL)\\n self.column_entry.grid(row = 1, column = 4)\\n self.column_label = Label(self.controls, text = \\\"Columns:\\\", justify = RIGHT)\\n self.column_label.grid(row = 1, column = 3)\\n self.submit_specs = Button(self.customiser, text = \\\"Generate Grid\\\", command = (lambda: self.set_grid(int(self.row_entry.get()), int(self.column_entry.get()))))\\n self.submit_specs.pack()\\n self.instructions = Message(self.message, text = \\\"Use the sliders above to define the number of rows and columns for the empty word search. Enter the words to look for below.\\\", width = 350)\\n self.instructions.pack()\\n self.words_label = Label(self.words_frame, text = \\\"Words to find (separate with a space):\\\")\\n self.words_label.grid(row = 1, column = 1)\\n self.words_box = Entry(self.words_frame, width = 40)\\n self.words_box.grid(row = 1, column = 2)\\n \\n #Disable action button to prevent multiple configuration windows:\\n self.action_button.config(state = DISABLED)\",\n \"def launch(self) -> None:\\n # create the containers that contain the windows\\n self.create_right_left_containers()\\n # 1 - displays the left window\\n self.left_window = LeftWindow(self.frame_left)\\n # 2 - displays the menu bar\\n self.menubar = tk.Menu(self)\\n menus_to_display = Menu.setup_main_menus_architecture(self.list_instances_menus_tournament,\\n self.list_instances_menus_reports)\\n for elem in menus_to_display:\\n menu = tk.Menu(self.menubar, tearoff=0)\\n for el in elem['unfold']:\\n menu.add_command(label=el['label'], state=el['state'],\\n command=eval(el['function'], {'RightWindow': RightWindow, 'self': self, 'ct': ct,\\n 'ChooseTournamentForReport':\\n ChooseTournamentForReport}))\\n self.menubar.add_cascade(label=elem['name'], menu=menu)\\n self.config(menu=self.menubar)\",\n \"def setup(self):\\n self.ui.setup_window()\",\n \"def create_widgets(self):\\n #create first button\\n self.button1 = Button(self, text = \\\"Start\\\")\\n self.button1.bind\\n self.button1.grid()\",\n \"def create(self, verbose=False):\\r\\n # delete the window if its handle exists\\r\\n if cmds.window(self.window, exists=True):\\r\\n cmds.deleteUI(self.window)\\r\\n # initialize the window as a pane for docking\\r\\n self.window = cmds.loadUI(uiFile=self.uiFile, verbose=verbose)\\r\\n #layoutWin = cmds.paneLayout(configuration='single')\\r\\n # create a dockControl and parent the control to layoutWin\\r\\n cmds.dockControl(allowedArea='all', area='right', floating=False, \\r\\n height=cmds.window(self.window, query=True, height=True), \\r\\n content=self.window, label='Docked Cone Pointer Window')\\r\\n cmds.showWindow(self.window)\",\n \"def create_panel(self):\\n # Main Frame creation\\n frame1 = Frame(self.window)\\n frame1.pack(fill=\\\"both\\\")\\n tablayout = Notebook(frame1)\\n \\n ##### TRACKER #####\\n tab = Frame(tablayout) # creating 1st nested frame\\n tab.pack(fill=\\\"both\\\")\\n table = Frame(tab)\\n table.pack(fill=\\\"both\\\")\\n self.show_table(self.t.timeline[\\\"week\\\" + str(self.week)], table) # Grids the week with data\\n self.add_buttons(tab, table)\\n tablayout.add(tab, text=\\\"Current Week\\\") \\n \\n \\n ##### STATS #####\\n tab = Frame(tablayout) # creating 2nd nested frame\\n tab.pack(fill=\\\"both\\\")\\n self.stats.create_canvas(tab)\\n\\n\\n # once its packed you can add it to the window object under a title\\n tablayout.add(tab, text=\\\"Statistics\\\") \\n tablayout.pack(fill=\\\"both\\\") # once everything is done now you pack the tablayout\",\n \"def create_main_enviroment(self):\\n # self.layout=QGridLayout()\\n self.resize(900, 900)\\n self.centralWidget = CentralWidget(self) # CentralWidget(self)\\n self.setCentralWidget(self.centralWidget)\\n\\n # self.toolbar = QToolBar(self)\\n # self.addToolBar(self.toolbar)\\n\\n # self.setLayout(self.layout)\\n self.setWindowTitle(\\\"Fitting elastic constants\\\")\",\n \"def main():\\n\\tif mc.window( 'spiderWebCreatorUi_WIN', q = 1, ex = 1 ):\\n\\t\\tmc.deleteUI( 'spiderWebCreatorUi_WIN' )\\n\\tPyForm=spiderWebCreatorUi()\\n\\tPyForm.show()\",\n \"def createFrame(self):\\n \\n tkinterListBoxDialog.createFrame(self)\\n self.addFrameButtons()\",\n \"def initUI(self):\\n\\n self.wid = RosGenWidget()\\n self.setCentralWidget(self.wid)\\n menubar = self.menuBar()\\n fileMenu = menubar.addMenu('&Файл')\\n editMenu = menubar.addMenu('&Редактирование')\\n self.create_menu_par('Менеджер подписчиков и издателей', self.wid.show_manager, fileMenu, 'Ctrl+M')\\n self.create_menu_par('Очистить', self.wid.clear_all_lines, editMenu, 'Ctrl+D')\\n self.create_menu_par('Загрузить данные из...', self.wid.open_fileDialog, fileMenu, 'Ctrl+F')\\n self.create_menu_par('Сохранить как...', self.wid.save_fileDialog, fileMenu, 'Ctrl+S')\\n self.create_menu_par('Выход', self.exit_app, fileMenu, 'Esc')\\n self.statusbar = self.statusBar()\\n self.statusbar.showMessage('Ожидание данных')\\n self.wid.msg2Statusbar[str].connect(self.statusbar.showMessage)\\n self.setGeometry(600, 200, 700, 400)\\n self.setWindowTitle('Генератор шаблонов ROS-приложения')\\n self.show()\",\n \"def visualise(self):\\n self.w = VisualizeSetupBox(self.master, self._df)\\n self.master.wait_window(self.w.top)\",\n \"def window(*args, width: int = 200, height: int = 200, autosize: bool = False,\\n no_resize: bool = False, no_title_bar: bool = False, no_move: bool = False, no_scrollbar: bool = False,\\n no_collapse: bool = False, horizontal_scrollbar: bool = False, no_focus_on_appearing: bool = False,\\n no_bring_to_front_on_focus: bool = False, menubar: bool = False, no_close: bool = False,\\n no_background: bool = False, label: str = '', show: bool = True, collapsed: bool = False,\\n modal: bool = False, popup: bool = False,\\n on_close: Callable = None, min_size: List[int]=[32, 32], max_size: List[int] = [30000, 30000], id:str=''):\\n try:\\n\\n widget = internal_dpg.add_window(*args, width=width, height=height, autosize=autosize,\\n no_resize=no_resize, no_title_bar=no_title_bar, no_move=no_move,\\n no_scrollbar=no_scrollbar, no_collapse=no_collapse,\\n horizontal_scrollbar=horizontal_scrollbar,\\n no_focus_on_appearing=no_focus_on_appearing,\\n no_bring_to_front_on_focus=no_bring_to_front_on_focus,\\n menubar=menubar, no_close=no_close,\\n no_background=no_background, label=label, show=show, \\n collapsed=collapsed, on_close=on_close,\\n min_size=min_size, max_size=max_size, id=id, modal=modal,\\n popup=popup)\\n internal_dpg.push_container_stack(widget)\\n yield widget\\n\\n finally:\\n internal_dpg.pop_container_stack()\",\n \"def create_panel_widgets(self):\\r\\n self.panel_widgets[\\\"create_order_button\\\"] = tk.Button(\\r\\n master=self.container_widgets[\\\"panel_frame\\\"],\\r\\n command=lambda: self.create_order(),\\r\\n text=const.RECORD_WIDGET_CONFIG_VALUES[\\\"CREATE_ORDER_BUTTON\\\"][\\\"text\\\"],\\r\\n width=const.RECORD_WIDGET_CONFIG_VALUES[\\\"CREATE_ORDER_BUTTON\\\"][\\\"width\\\"],\\r\\n height=const.RECORD_WIDGET_CONFIG_VALUES[\\\"CREATE_ORDER_BUTTON\\\"][\\\"height\\\"])\\r\\n self.panel_widgets[\\\"create_order_button\\\"].grid(\\r\\n row=const.RECORD_WIDGET_CONFIG_VALUES[\\\"CREATE_ORDER_BUTTON\\\"][\\\"row\\\"],\\r\\n column=const.RECORD_WIDGET_CONFIG_VALUES[\\\"CREATE_ORDER_BUTTON\\\"][\\\"column\\\"])\\r\\n\\r\\n self.panel_widgets[\\\"show_menu_button\\\"] = tk.Button(\\r\\n self.container_widgets[\\\"panel_frame\\\"],\\r\\n command=lambda: MenuWindow(self.databases.menu),\\r\\n text=const.RECORD_WIDGET_CONFIG_VALUES[\\\"SHOW_MENU_BUTTON\\\"][\\\"text\\\"],\\r\\n width=const.RECORD_WIDGET_CONFIG_VALUES[\\\"SHOW_MENU_BUTTON\\\"][\\\"width\\\"],\\r\\n height=const.RECORD_WIDGET_CONFIG_VALUES[\\\"SHOW_MENU_BUTTON\\\"][\\\"height\\\"])\\r\\n self.panel_widgets[\\\"show_menu_button\\\"].grid(\\r\\n row=const.RECORD_WIDGET_CONFIG_VALUES[\\\"SHOW_MENU_BUTTON\\\"][\\\"row\\\"],\\r\\n column=const.RECORD_WIDGET_CONFIG_VALUES[\\\"SHOW_MENU_BUTTON\\\"][\\\"column\\\"])\\r\\n\\r\\n self.panel_widgets[\\\"show_orders_button\\\"] = tk.Button(\\r\\n self.container_widgets[\\\"panel_frame\\\"],\\r\\n command=lambda: self.open_archive(),\\r\\n text=const.RECORD_WIDGET_CONFIG_VALUES[\\\"OPEN_ARCHIVE_BUTTON\\\"][\\\"text\\\"],\\r\\n width=const.RECORD_WIDGET_CONFIG_VALUES[\\\"OPEN_ARCHIVE_BUTTON\\\"][\\\"width\\\"],\\r\\n height=const.RECORD_WIDGET_CONFIG_VALUES[\\\"OPEN_ARCHIVE_BUTTON\\\"][\\\"height\\\"])\\r\\n\\r\\n self.panel_widgets[\\\"show_orders_button\\\"].grid(\\r\\n row=const.RECORD_WIDGET_CONFIG_VALUES[\\\"OPEN_ARCHIVE_BUTTON\\\"][\\\"row\\\"],\\r\\n column=const.RECORD_WIDGET_CONFIG_VALUES[\\\"OPEN_ARCHIVE_BUTTON\\\"][\\\"column\\\"])\\r\\n\\r\\n self.panel_widgets[\\\"restore_orders_button\\\"] = tk.Button(\\r\\n self.container_widgets[\\\"panel_frame\\\"],\\r\\n command=lambda: self.restore_open_orders(),\\r\\n text=const.RECORD_WIDGET_CONFIG_VALUES[\\\"RESTORE_ORDERS_BUTTON\\\"][\\\"text\\\"],\\r\\n width=const.RECORD_WIDGET_CONFIG_VALUES[\\\"RESTORE_ORDERS_BUTTON\\\"][\\\"width\\\"],\\r\\n height=const.RECORD_WIDGET_CONFIG_VALUES[\\\"RESTORE_ORDERS_BUTTON\\\"][\\\"height\\\"])\\r\\n\\r\\n self.panel_widgets[\\\"restore_orders_button\\\"].grid(\\r\\n row=const.RECORD_WIDGET_CONFIG_VALUES[\\\"RESTORE_ORDERS_BUTTON\\\"][\\\"row\\\"],\\r\\n column=const.RECORD_WIDGET_CONFIG_VALUES[\\\"RESTORE_ORDERS_BUTTON\\\"][\\\"column\\\"])\",\n \"def __createWidgets(self):\\n # Widget canvas, used to draw rubik's cube\\n self.cv = Canvas(self.master)\\n self.cv['bg'] = 'white' # Background color\\n self.cv['height'] = '440' # Height of canvas\\n self.cv['width'] = '560' # Width of canvas\\n self.cv.place(x=0, y=0)\\n self.__drawCube()\",\n \"def show(self):\\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\\n print \\\"Show Window.\\\"\\n self.subWindow.show()\",\n \"def init_ui(self):\\n # Create GUI elements, set them in dict structure\\n labelwidth = 150\\n\\n # Add parameter line edit for Factor Tm to Tp\\n\\n # Add line edit with browsebutton for swan result folder\\n self.input_elements['hares folder'] = widgets.ExtendedLineEdit(\\n label='HARES uitvoerbestanden folder:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_hares_folder)\\n )\\n\\n\\n self.setLayout(QtWidgets.QVBoxLayout())\\n self.layout().setSpacing(10)\\n\\n for _, item in self.input_elements.items():\\n self.layout().addWidget(item)\\n\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n self.layout().addWidget(line)\\n\\n # OK and Cancel buttons\\n self.generateButton = QtWidgets.QPushButton('Start lezen uitvoerbestanden')\\n self.generateButton.setDefault(True)\\n self.generateButton.clicked.connect(self.generate)\\n\\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\\n self.cancelButton.setAutoDefault(False)\\n self.cancelButton.clicked.connect(self.cancel)\\n\\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\\n button_box.accepted.connect(QtWidgets.QDialog.accept)\\n\\n self.layout().addWidget(button_box)\",\n \"def gui(self):\\n return gui\",\n \"def initUI(self):\\n self.logger.debug('Setting up the Measurement GUI')\\n self.setWindowTitle(self.title)\\n\\n self.show()\\n\\n self.make_combobox_scanner()\\n self.make_combobox_movements()\\n self.make_combobox_configurate()\\n self.make_combobox_basic()\",\n \"def create_main_window_with_browser():\\n main_win = create_main_window()\\n return main_win.add_browser_tab()\",\n \"def make_widgets(self):\\n self.mode_select = Selector(**MODE_SELECT_SETTINGS)\\n self.bind_keys_to_modes()\\n self.layer_select = Selector(**LAYER_SELECT_SETTINGS)\\n self.check_boxes = CheckBoxArray(**CHECK_ARRAY_SETTINGS)\\n self.check_boxes.bind_key(pg.K_v, self.toggle_layer_visibility)\\n self.navs = [Button(**NAV_LEFT), Button(**NAV_RIGHT)]\\n self.save_button = Button(**SAVE_BUTTON)\\n self.load_button = Button(**LOAD_BUTTON)\\n self.new_button = Button(**NEW_BUTTON)\\n self.widgets = [self.mode_select, self.layer_select, self.check_boxes,\\n self.navs[0], self.navs[1],\\n self.save_button, self.load_button, self.new_button]\",\n \"def createApp(self):\\n app = self.app\\n window = self.window\\n window.show()\\n app.exec()\",\n \"def initUI(self) -> None:\\n ratio = 70\\n width_to_set = (ratio * self.get_current_window_info()[0]) / 100.0\\n height_to_set = (ratio * self.get_current_window_info()[1]) / 100.0\\n self.setGeometry(200, 100, width_to_set, height_to_set)\\n self.createTable()\\n # Add box layout, add table to box layout and add box layout to widget\\n self.layout = QVBoxLayout()\\n self.layout.addWidget(self.tableWidget)\\n self.setLayout(self.layout)\\n self.setWindowTitle('View files')\\n self.show()\",\n \"def widgets(self):\\n raise NotImplementedError(\\\"This method is not ready to be used yet\\\")\",\n \"def __init__(self):\\n self.defaultTheme = \\\"DarkAmber\\\"\\n self.version = 1.4\\n self.versionName = \\\"class update\\\"\\n self.title = \\\"Lms GUI default window\\\"\\n self.layout = [[sg.Text(\\\"This is the base window class layout.\\\")]]\\n self.elementJustification = 'c'\\n self.location=(500, 300)\\n self.running = True\\n self.window = None\\n self.event = \\\"\\\"\\n self.values = []\\n self.nextAction = None\",\n \"def start_GUI(self):\\n experiment_names = list(GUI.api.get_experiment_names())\\n #selected_exp = None #value picked in the list\\n\\n branch_log_dict = GUI.api.get_branching_indep_to_dep()\\n #Separate columns for a new trial and a new experiment\\n\\n col_new_trial = [[sg.Radio('New Trial', \\\"RADIO1\\\", default=True, enable_events = True, key=\\\"new_trial_radio\\\", metadata='not_disable')],\\n [sg.Text(text = \\\"Please pick your experiment from the list below:\\\")], \\n [sg.Listbox(values=experiment_names, size=(30, 6), key=\\\"list\\\", select_mode = sg.LISTBOX_SELECT_MODE_SINGLE, enable_events= True)]]\\n \\n\\n #metadata ahs true if we need to input filed\\n col_new_experiment = [[sg.Radio('New experiment', \\\"RADIO1\\\", enable_events=True, key=\\\"new_exp_radio\\\", metadata='not_disable')]]\\n col_new_experiment.extend(self.make_fields())#add fields to the form\\n layout = [[sg.Column(col_new_trial), sg.Column(col_new_experiment)], \\n [sg.Button(button_text= \\\"OK\\\", enable_events= True, key =\\\"OK\\\")]]\\n \\n window = sg.Window('New Data', layout, keep_on_top=True)#Creation of the window\\n while True:\\n event, values = window.read()\\n # End program if user closes window or\\n # presses the OK button\\n # you can use switch-case here instead of if statements\\n if event == sg.WIN_CLOSED:\\n #Indicate abort\\n return None, None, None, None\\n elif event == \\\"new_exp_radio\\\":#if new experiment is picked, then disable the elements for the new trial\\n #for evey field on which branching logic depends on, disable everything not selected\\n window['list'].update(disabled = True)\\n for row in col_new_experiment:\\n for elem in row:\\n if(elem.metadata != 'not_disable' and not isinstance(elem, sg.Text)):#do not block the radio button):\\n window[elem.Key].update(disabled = False)\\n \\n self.clear_disable_all(window, branch_log_dict, col_new_experiment)#we could just enable a few, instead\\n elif event == \\\"new_trial_radio\\\":#if new trial is picked, disable the elements for the new experiment, enable for the new trua\\n #disable everything in the form\\n for row in col_new_experiment:\\n for elem in row:\\n if(elem.metadata != 'not_disable' and not isinstance(elem, sg.Text)):#do not block the radio button and do not update textboxes\\n window[elem.Key].update(disabled = True)\\n #enable the listbox\\n \\n window['list'].update(disabled = False)\\n elif event == \\\"OK\\\":\\n field_missing = False\\n #Check if the listbox has a value or the form has a value\\n if values['new_exp_radio']:#we are doing new expriment\\n # printing_params = {\\\"paxton\\\":\\\"\\\"}\\n printing_params = {}\\n #Check the all the stuff in the form of the new experiment\\n for row in col_new_experiment:\\n if(field_missing):\\n break#do not check anymore\\n for elem in row:\\n if(elem.metadata != 'not_disable' and not isinstance(elem, sg.Text)):#do not check labels and the radio button\\n if (elem.metadata and values[elem.Key]== \\\"\\\"): #value ahs to be filled and not empty\\n field_missing = True\\n sg.popup_ok('Required fields are missing!')#if at least one field is empty, throw a popup and stop checking\\n break # Shows OK button\\n #if at least one field does not have a value, then we generate a popup\\n elif(values[elem.Key] != \\\"\\\"):#add to the dictonary of params\\n printing_params[elem.Key] = values[elem.Key]\\n \\n if not field_missing:\\n #if everything is filled, then validate\\n \\n #if user closes the popup, then the print is considered bad by default\\n is_valid, field_name = self.validate_fields(window, values)\\n if(is_valid):\\n print_result, folderPath = self.getPicturesPrintEval()\\n window.close()\\n #now, we also return print_result\\n return \\\"add_record\\\", printing_params, print_result, folderPath\\n else:\\n sg.popup_ok(\\\"The field could not be validated: \\\" + field_name)\\n \\n elif values['new_trial_radio']:#could use else\\n if values['list'] == []:\\n sg.popup_ok('Required fields are missing!')\\n continue#go to while loop\\n #we got here, so we now know the record_id of the experiment we want to do the new trial for\\n record_lst = GUI.api.get_elements(values['list'][0])\\n #create a new window with print quality + pictures\\n print_result, folderPath = self.getPicturesPrintEval()\\n window.close()\\n return \\\"add_trial\\\", record_lst, print_result, folderPath\\n elif event in branch_log_dict:#if branching logic is dependent on this element\\n #we could only enable/disable stuff affected by the element\\n self.enable_selected(window, copy.deepcopy(values), branch_log_dict, event)\\n self.disable_not_selected(window, copy.deepcopy(values), branch_log_dict, event)\",\n \"def __init__(self, title, dimensions, num_windows, fg = (255, 255, 255), bg = (0, 0, 0)):\\n self.fg = fg\\n self.bg = bg\\n self.offset = 0\\n self.screens = []\\n for i in range(num_windows):\\n screen = Screen(title, i, dimensions)\\n self.screens.append(screen)\\n screen.window.show()\",\n \"def createWidgets(self, dialogType):\\n # Create labels to identify the image being considered\\n self.magnitudeLabel = QtGui.QLabel('Gradient Magnitude')\\n self.directionLabel = QtGui.QLabel('Gradient Direction')\\n self.horizontalLabel = QtGui.QLabel('Horizontal Gradient')\\n self.verticalLabel = QtGui.QLabel('Vertical Gradient')\\n\\n # Create the buttons to show or save each image\\n self.magnitudeOption = QtGui.QPushButton(dialogType)\\n self.directionOption = QtGui.QPushButton(dialogType)\\n self.horizontalOption = QtGui.QPushButton(dialogType)\\n self.verticalOption = QtGui.QPushButton(dialogType)\\n\\n # Create a close button\\n self.closeButton = QtGui.QPushButton('Close')\\n\\n # Connect the closing button to the exit function\\n self.closeButton.clicked.connect(self.exit)\\n\\n # Connect each image option to the necessary function based on the\\n # dialog type\\n if dialogType == 'Show':\\n # Func is used to shorten and neaten the code\\n func = self.parent().showFunc\\n\\n # Connect each image with it's colourmap\\n self.magnitudeOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.smagnitude, 'gray'))\\n self.directionOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.sdirection, 'gist_rainbow'))\\n self.horizontalOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.shgradient, 'gray'))\\n self.verticalOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.svgradient, 'gray'))\\n else:\\n func = self.parent().saveFunc\\n\\n self.magnitudeOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.smagnitude))\\n self.directionOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.sdirection))\\n self.horizontalOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.shgradient))\\n self.verticalOption.clicked.connect(lambda: func(\\\\\\n self.parent().I.svgradient))\",\n \"def create_widgets(self):\\n root.title(\\\"Universal Converter\\\")\\n root.resizable(False, False)\\n root.config(bg=\\\"white\\\")\\n head_frame = Frame(root, bd=3, bg=\\\"Navy\\\", relief=GROOVE)\\n Label(head_frame, text=\\\"UNIVERSAL CONVERTER\\\", font=(\\\"Trebuchet MS\\\", 24, \\\"bold\\\"), fg=\\\"White\\\", bg=\\\"Navy\\\").pack(pady=50)\\n head_frame.grid(row=0, column=0, columnspan=4, ipadx=20, sticky=\\\"ew\\\")\\n Label(root, text=\\\" Choose the Converter \\\", font=(\\\"Trebuchet MS\\\", 16, \\\"bold\\\"), fg=\\\"Navy\\\", bg=\\\"White\\\").grid(row=2, column=0, columnspan=4, ipadx=20, ipady=20)\\n button_frame = Frame(root, bd=5, bg=\\\"Navy\\\", relief=FLAT)\\n self.measurements_list = [\\\"Angle\\\", \\\"Area\\\", \\\"Bit Byte\\\", \\\"Density\\\", \\\"Electric Current\\\", \\\"Energy\\\", \\\"Force\\\", \\\"Fuel Consumption\\\", \\\"Length\\\", \\\"Mass\\\", \\\"Power\\\", \\\"Pressure\\\", \\\"Speed\\\", \\\"Temperature\\\", \\\"Time\\\", \\\"Volume\\\"]\\n self.measurements_dict = {\\\"Angle\\\": self.angle, \\\"Area\\\": self.area, \\\"Bit Byte\\\": self.bitbyte, \\\"Density\\\": self.density, \\\"Electric Current\\\": self.electriccurrent, \\\"Energy\\\": self.energy, \\\"Force\\\": self.force, \\\"Fuel Consumption\\\": self.fuelconsumption, \\\"Length\\\": self.length, \\\"Mass\\\": self.mass, \\\"Power\\\": self.power, \\\"Pressure\\\": self.pressure, \\\"Speed\\\": self.speed, \\\"Temperature\\\": self.temperature, \\\"Time\\\": self.time, \\\"Volume\\\": self.volume}\\n for i in range(16):\\n self.button = Button(button_frame, text=self.measurements_list[i], font=(\\\"Trebuchet MS\\\", 12), width=13, fg=\\\"Navy\\\", bg=\\\"White\\\", relief=FLAT, overrelief=SOLID, bd=5, activebackground=\\\"Navy\\\", activeforeground=\\\"White\\\", command=self.measurements_dict[self.measurements_list[i]])\\n self.button.grid(row=i/4+4, column=i%4, ipady=15, ipadx=15, padx=2, pady=2)\\n button_frame.grid(row=3, column=0, columnspan=4, sticky=\\\"we\\\", padx=5, pady=5)\\n root.protocol(\\\"WM_DELETE_WINDOW\\\", self.callback) #When user will quit, program will show you the messagebox\",\n \"def __init__(self):\\n # Root window\\n self.root = tk.Tk()\\n self.root.title(\\\"Crossword\\\")\\n # Padding frame\\n self.frame = tk.Frame(self.root)\\n self.frame.pack(fill=\\\"both\\\", padx=PAD, pady=PAD)\\n # Initialize widget groups\\n self.header = HeaderView(self)\\n self.puzzle = PuzzleView(self)\\n self.clues = CluesView(self)\\n # Show widgets\\n self.header.show()\\n self.puzzle.show()\\n self.clues.show()\",\n \"def iniciaUI(self):\\n\\n self.setGeometry(100,100, 300, 200)\\n self.setWindowTitle(\\\"Formulario\\\")\\n self.displayWidgets()\\n\\n self.show()\",\n \"def init(self):\\n sg.theme(gui.app_theme)\\n self.window = sg.Window(\\n gui.app_title,\\n gui.create_layout(),\\n **gui.window_config,\\n )\\n gui.after_window_init(self.window)\",\n \"def display_window(self):\\n frame = tk.Frame(master=self.param_window)\\n frame.grid(padx=10, pady=20, columnspan=2)\\n tk.Label(master=frame, text=\\\"Enter simulation parameters\\\").pack()\\n\\n self.status_text = tk.StringVar()\\n self.status_text.set(\\\"Status message\\\")\\n \\n self.rows = 1\\n for input_key in self.inputs.keys():\\n input_dict = self.inputs[input_key]\\n \\n frame = tk.Frame(master=self.param_window)\\n frame.grid(row=self.rows, column=0, padx=10, pady=1)\\n input_dict['label'] = tk.Label(master=frame, text=input_dict['label'])\\n input_dict['label'].pack()\\n\\n frame = tk.Frame(master=self.param_window)\\n frame.grid(row=self.rows, column=1, padx=10, pady=1)\\n input_dict['entry'] = tk.Entry(master=frame, width=10)\\n input_dict['entry'].insert(0, input_dict['default'])\\n input_dict['entry'].pack()\\n \\n self.rows += 1\\n\\n frame = tk.Frame(master=self.param_window)\\n frame.grid(padx=10, pady=20, columnspan = 2)\\n self.submit_btn = tk.Button(master=frame, text=\\\"Submit\\\", width=10)\\n self.submit_btn.pack()\\n self.submit_btn.bind(\\\"<Button-1>\\\", self.submit_values)\\n\\n self.param_window.mainloop()\\n return self.parameters\",\n \"def init_ui(self):\\n self.master.title(\\\"Backbone\\\")\\n self.master.geometry(\\\"300x150\\\")\\n\\n self.pack(fill=BOTH, expand=1)\\n\\n self.btn_upload_file = Button(self, text=\\\"Upload file\\\", command=self.upload_file)\\n self.btn_upload_file.place(x=90, y=10)\\n\\n self.btn_create_training_file = Button(self, text=\\\"Create & upload training file\\\",\\n command=self.create_training_file)\\n self.btn_create_training_file.place(x=30, y=40)\\n\\n self.btn_run_algorithm = Button(self, text=\\\"Run algorithm\\\", command=self.run_algorithm)\\n self.btn_run_algorithm.place(x=80, y=70)\\n\\n self.btn_view_results = Button(self, text=\\\"View Results\\\", command=self.view_results)\\n self.btn_view_results.place(x=85, y=100)\",\n \"def populateUI():\\n \\n # Main form layout\\n form = cmds.formLayout()\\n\\n # Tab Layout\\n tabs = cmds.tabLayout(innerMarginWidth=5, innerMarginHeight=5)\\n # Form attachment config\\n cmds.formLayout( form, edit=True, attachForm=((tabs, 'top', 0), (tabs, 'left', 0), (tabs, 'bottom', 0), (tabs, 'right', 0)) )\\n\\n # The different Tabs on the window\\n spawnTab = SpawnObjectsTab()\\n roadTab = RoadRiverTab()\\n environmentTab = EnvironmentTab()\\n\\n # Tab creation\\n cmds.tabLayout( tabs, edit=True, tabLabel=((spawnTab, 'Spawn Buildings'), (roadTab, 'Create Roads / Rivers'), (environmentTab, \\\"Create Environment\\\") ))\",\n \"def build_window(self):\\n\\n form_frame = tk.Frame(self.window)\\n form_frame.pack(fill='x')\\n\\n tk.Label(form_frame, text=\\\"Url\\\").grid(row=0, column=0, sticky='W')\\n url = tk.StringVar()\\n self.url_entry = tk.Entry(form_frame, textvariable=url)\\n self.url_entry.grid(row=0, column=1, sticky='W')\\n\\n tk.Label(form_frame, text=\\\"Depth\\\").grid(row=1, column=0, sticky='W')\\n depth = tk.IntVar()\\n self.depth_entry = tk.Entry(form_frame, textvariable=depth)\\n self.depth_entry.grid(row=1, column=1, sticky='W')\\n\\n self.submit_button = tk.Button(form_frame, text=\\\"Submit\\\")\\n self.submit_button.bind('<Button-1>', self.send_entry_event)\\n self.submit_button.grid(row=2, column=0, columnspan=1, sticky='W')\\n\\n url_list_frame = tk.Frame(self.window)\\n url_list_frame.pack(fill='x')\\n\\n self.url_list = tk.Listbox(url_list_frame, selectmode=tk.SINGLE, font=self.font,\\n exportselection=False)\\n self.url_list.bind('<<ListboxSelect>>', self.selected_url_event)\\n self.url_list.pack(fill=tk.BOTH, expand=tk.YES)\",\n \"def layout(self):\\n menu = self.menuBar()\\n menu.setNativeMenuBar(False)\\n\\n file_menu = menu.addMenu(\\\"File\\\")\\n fitting_commands = menu.addMenu(\\\"Fitting\\\")\\n help_menu = menu.addMenu(\\\"Help\\\")\\n\\n prog_info = QAction(\\\"About\\\", self)\\n prog_info.triggered.connect(self.version)\\n help_menu.addAction(prog_info)\\n\\n doc_info = QAction(\\\"Documentation\\\", self)\\n doc_info.triggered.connect(self.docs)\\n help_menu.addAction(doc_info)\\n\\n fit_exp = QAction(\\\"Fit Experiments\\\", self)\\n fit_exp.setShortcut(\\\"Ctrl+F\\\")\\n fit_exp.triggered.connect(self.fit_exp)\\n fitting_commands.addAction(fit_exp)\\n\\n add_exp = QAction(\\\"Add Experiment\\\", self)\\n add_exp.setShortcut(\\\"Ctrl+Shift+N\\\")\\n add_exp.triggered.connect(self.add_file)\\n file_menu.addAction(add_exp)\\n\\n save_exp = QAction(\\\"Export Results\\\", self)\\n save_exp.setShortcut(\\\"Ctrl+S\\\")\\n save_exp.triggered.connect(self.save_file)\\n file_menu.addAction(save_exp)\\n\\n file_menu.addSeparator()\\n\\n new_exp = QAction(\\\"New Session\\\", self)\\n new_exp.setShortcut(\\\"Ctrl+N\\\")\\n new_exp.triggered.connect(self.new_exp)\\n file_menu.addAction(new_exp)\\n\\n close_window = QAction(\\\"Close Window\\\", self)\\n close_window.setShortcut(\\\"Ctrl+W\\\")\\n close_window.triggered.connect(self.close_program)\\n file_menu.addAction(close_window)\\n\\n # add shortcut actions to main window, for qt5 bug\\n self.addAction(add_exp)\\n self.addAction(fit_exp)\\n self.addAction(save_exp)\\n self.addAction(new_exp)\\n self.addAction(close_window)\\n self.addAction(doc_info)\\n self.addAction(prog_info)\\n\\n self._exp = Splitter(self)\\n self.setCentralWidget(self._exp)\\n\\n self.resize(1000, 600)\\n self.move(QApplication.desktop().screen().rect().center()-self.rect().center())\\n self.setWindowTitle('pytc')\\n self.show()\",\n \"def adv_new_window(self):\\n adv=workflow.advancedoptions_w.ADialog()\\n adv.exec_()\",\n \"def populateWindow(self):\\n if self.widget.abstractDb == None:\\n QtGui.QMessageBox.critical(self, self.tr('Error!'), self.tr('First select a database!'))\\n return\\n if isinstance(self.sender(), QPushButton):\\n sender = self.sender().text()\\n else:\\n sender = ''\\n dlg = FieldSetup(self.widget.abstractDb)\\n if sender != self.tr('Setup'):\\n dlg.loadReclassificationConf(self.reclassificationDict)\\n if sender != '':\\n result = dlg.exec_()\\n else:\\n result = 1\\n \\n if result == 1:\\n self.createButtonsOnInterface(dlg)\\n self.setEditButtonEnabled(True)\",\n \"def create_view(self):\\n title_label = Label(self, text='Upload, Preview, Describe and Visualize',\\n fg='blue', font=('Arial', 16))\\n title_label.pack(fill=BOTH, expand=True)\\n select_file_button = Button(self, background='White', text='Select Data File [.csv, .xlsx, .xls, .json, .txt]',\\n command=self.start_upload)\\n select_file_button.pack(padx=5, pady=10)\",\n \"def __init__(self):\\n self.root = tk.Tk()\\n self.root.minsize(width=150, height=150)\\n self.root.maxsize(height=500)\\n self.root.title(\\\"GUV analysis\\\")\\n self.root.iconbitmap(os.path.join(os.path.dirname(__file__), \\\"icon.ico\\\"))\\n self.window = tk.Frame(self.root)\\n self.window.pack(side=\\\"top\\\", fill=\\\"both\\\", expand=True)\\n\\n self.widgets = {}\\n self.images = {}\\n\\n self.widgets['lblTitle'] = tk.Label(self.window, text='GUV analysis tool', font=\\\"-weight bold -size 20\\\")\\n self.widgets['lblTitle'].grid(column=0, row=0, columnspan=3)\\n\\n self.images['newImg'] = tk.PhotoImage(file=os.path.join(os.path.dirname(__file__),'icon-new.png')).subsample(2,2)\\n self.widgets['btnNew'] = tk.Button(self.window, text='New analysis', image=self.images['newImg'], command=self.start_new_analysis, compound=tk.TOP, borderwidth=0)\\n self.widgets['btnNew'].grid(column=0, row=1, padx=10)\\n\\n self.images['openImg'] = PhotoImage_cd('icon-open.png').subsample(2,2)\\n self.widgets['btnOpen'] = tk.Button(self.window, text='Open existing analysis', command=self.reopen_existing_analysis, image=self.images['openImg'], compound=tk.TOP, borderwidth=0)\\n self.widgets['btnOpen'].grid(column=1, row=1, padx=10)\\n\\n self.images['closeImg'] = PhotoImage_cd('icon-close.png').subsample(2,2)\\n self.widgets['btnClose'] = tk.Button(self.window, text='Close program', command=self.root.quit, image=self.images['closeImg'], compound=tk.TOP, borderwidth=0)\\n self.widgets['btnClose'].grid(column=2, row=1, padx=10)\",\n \"def _init_ui(self):\\n hlayout = QtWidgets.QHBoxLayout()\\n\\n hlayout.addWidget(QtWidgets.QLabel('Kies een normtraject:'))\\n\\n self.section_combobox = QtWidgets.QComboBox()\\n self.section_combobox.setFixedWidth(60)\\n self._update_combobox()\\n\\n hlayout.addWidget(self.section_combobox)\\n\\n self.remove_button = QtWidgets.QPushButton('Verwijderen', clicked=self._del_flooddefence)\\n hlayout.addWidget(self.remove_button)\\n\\n vlayout = QtWidgets.QVBoxLayout()\\n vlayout.addLayout(hlayout)\\n\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n\\n vlayout.addWidget(line)\\n\\n self.close_button = QtWidgets.QPushButton('Sluiten', clicked=self.close)\\n vlayout.addWidget(self.close_button, 0, QtCore.Qt.AlignRight)\\n\\n self.setLayout(vlayout)\\n\\n self.setWindowTitle(\\\"HB Havens: normtrajecten\\\")\\n self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)\",\n \"def __init__(self, root):\\r\\n self.root = root\\r\\n self.root.geometry(\\\"400x300\\\")\\r\\n \\r\\n self.button_rename = tk.Button(self.root, text = \\\"New window\\\",\\r\\n command= self.new_winF).pack()\",\n \"def build_second_window():\\r\\n\\r\\n new_window = tk.Tk()\\r\\n windows.append(new_window)\\r\\n new_window.protocol(\\\"WM_DELETE_WINDOW\\\", new_round(new_window))\\r\\n\\r\\n ask = tk.Label(new_window, text='Would You Like To Play Again?', bg='Cyan')\\r\\n ask.pack(fill=tk.X)\\r\\n\\r\\n frame = tk.Frame(new_window)\\r\\n frame.pack()\\r\\n\\r\\n yes_button = tk.Button(frame, text='Yes', bg='green',\\r\\n command=new_round(new_window))\\r\\n yes_button.pack(side=tk.LEFT)\\r\\n\\r\\n no_button = tk.Button(frame, text='No', bg='red',\\r\\n command=close)\\r\\n no_button.pack(side=tk.LEFT)\",\n \"def add_widgets(self):\\n tkinter.Label(self.top_frame, text=\\\"File Path:\\\").grid(row=1, column=0)\\n self.data_path_entry = tkinter.Entry(self.top_frame)\\n self.data_path_entry.grid(row=1, column=1)\\n self.data_path_entry.insert(10, self.data_path)\\n # Create the Browse button\\n tkinter.Button(self.top_frame,\\n text=\\\"Browse...\\\",\\n command=self.get_file).grid(row=1, column=2)\\n # Create the Ok button\\n tkinter.Button(self.top_frame,\\n text=\\\"OK\\\",\\n command=self.save_configurations).grid(row=2, column=0, sticky=tkinter.W, pady=3)\\n # Create the Cancel button\\n tkinter.Button(self.top_frame,\\n text=\\\"Cancel\\\",\\n command=self.exit).grid(row=2, column=1, sticky=tkinter.E, pady=3)\",\n \"def _create_window(self):\\n wc = win32gui.WNDCLASS()\\n wc.lpfnWndProc = self._on_message\\n wc.lpszClassName = self.__class__.__name__\\n wc.hInstance = win32api.GetModuleHandle(None)\\n class_atom = win32gui.RegisterClass(wc)\\n return win32gui.CreateWindow(class_atom, self.__class__.__name__, 0, 0, 0, 0, 0, 0, 0, wc.hInstance, None)\",\n \"def __init__(self, parent=None):\\n super(MainWindow, self).__init__(parent)\\n self.setupUi(self)\\n \\n self.setWindowTitle(\\\"RPI HMI - pH Debug\\\") # Title creation\",\n \"def widgetSetup(self):\\n self.master.resizable(0, 0)\\n self.master.iconbitmap('logo.ico')\\n self.master.title(\\\"Ejercicio POO\\\")\\n\\n self.master.bind(\\\"<Return>\\\", lambda e: self.create())\\n self.master.bind(\\\"<Delete>\\\", lambda e: self.delete())\",\n \"def create_window(self):\\n self.course_name_var = tk.StringVar(self)\\n self.course_score_var = tk.StringVar(self)\\n self.course_category_var = tk.StringVar(self)\\n\\n self.course_name_var.trace(\\\"w\\\", self.filled)\\n self.course_score_var.trace(\\\"w\\\", self.filled)\\n self.course_category_var.trace(\\\"w\\\", self.filled)\\n\\n self.course_name_label = tk.Label(self, text='Course Name').grid(row=0, column=0)\\n self.course_name_entry = tk.Entry(self, textvariable=self.course_name_var).grid(row=0, column=1)\\n self.course_score_label = tk.Label(self, text='Course Score').grid(row=1, column=0)\\n self.course_score_entry = tk.Entry(self, textvariable=self.course_score_var).grid(row=1, column=1)\\n self.course_category_label = tk.Label(self, text='Course Category').grid(row=2, column=0)\\n self.course_category_option = tk.OptionMenu(self, self.course_category_var, *self.course_categories).grid(row=2, column=1)\\n self.course_is_weighted = tk.IntVar()\\n self.course_honors = tk.Checkbutton(self, text='Honors', onvalue= 1, variable=self.course_is_weighted).grid(row=3, column=0)\\n self.course_ap = tk.Checkbutton(self, text='AP', onvalue=2, variable=self.course_is_weighted).grid(row=3, column=1)\\n\\n self.button = tk.Button(self, text='Add Grade', command=self.add_course)\\n self.button.config(state='disabled')\\n self.button.grid(row=4, column=1, sticky='nesw')\",\n \"def _init_ui(self):\\n\\n hlayout = QtWidgets.QHBoxLayout()\\n\\n label = QtWidgets.QLabel('Kies een normtraject:')\\n\\n hlayout.addWidget(label)\\n\\n self.section_combobox = QtWidgets.QComboBox()\\n self.section_combobox.setFixedWidth(60)\\n self.section_ids = sorted([''] + io.geometry.import_section_ids(self.datadir))\\n self.section_combobox.addItems(self.section_ids)\\n\\n hlayout.addWidget(self.section_combobox)\\n\\n self.add_button = QtWidgets.QPushButton('Toevoegen', clicked=self._add_flooddefence)\\n\\n hlayout.addWidget(self.add_button)\\n\\n vlayout = QtWidgets.QVBoxLayout()\\n vlayout.addLayout(hlayout)\\n\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n\\n vlayout.addWidget(line)\\n\\n self.close_button = QtWidgets.QPushButton('Sluiten', clicked=self.close)\\n vlayout.addWidget(self.close_button, 0, QtCore.Qt.AlignRight)\\n\\n self.setLayout(vlayout)\\n\\n self.setWindowTitle(\\\"HB Havens: normtrajecten\\\")\\n self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)\",\n \"def createWidgets(self):\\n\\n # Phrase Label\\n self.phrase_lbl = ttk.Label(self, text=\\\"Phrase:\\\")\\n self.phrase_lbl.grid(row=0, column=0)\\n\\n # Phrase Entry\\n self.phrase_ent = ttk.Entry(self)\\n self.phrase_ent.grid(row=0, column=1)\\n\\n # City Label\\n self.city_lbl = ttk.Label(self, text=\\\"City:\\\")\\n self.city_lbl.grid(row=0, column=2)\\n\\n # City Entry\\n self.city_ent = ttk.Entry(self)\\n self.city_ent.grid(row=0, column=3)\\n\\n # Keyword Label\\n self.keyword_lbl = ttk.Label(self, text=\\\"Keyword:\\\")\\n self.keyword_lbl.grid(row=1, column=0)\\n\\n # Keyword Entry\\n self.keyword_ent = ttk.Entry(self)\\n self.keyword_ent.grid(row=1, column=1)\\n\\n # Add Button\\n self.add_btn = ttk.Button(self, text=\\\"Add\\\")\\n self.add_btn.grid(row=1, column=2)\\n self.add_btn[\\\"command\\\"] = lambda: self.addCity(self.city_ent.get())\\n \\n # Delete Button\\n self.delete_btn = ttk.Button(self, text=\\\"Delete\\\")\\n self.delete_btn.grid(row=1, column=3)\\n self.delete_btn[\\\"command\\\"] = lambda: self.deleteCity() \\n\\n # Reset Button\\n self.reset_btn = ttk.Button(self, text=\\\"Reset\\\")\\n self.reset_btn.grid(row=2, column=0)\\n self.reset_btn[\\\"command\\\"] = lambda: self.resetApp()\\n\\n # Create Button\\n self.create_btn = ttk.Button(self, text=\\\"Create\\\")\\n self.create_btn.grid(row=2, column=1)\\n self.create_btn[\\\"command\\\"] = lambda: self.createTXT() \\n\\n # Listbox\\n self.city_lbx = tk.Listbox(self)\\n self.city_lbx.grid(row=2, column=2, columnspan=2)\\n \\n # Directory Button\\n self.dir_btn = ttk.Button(self, text=\\\"Select Folder\\\")\\n self.dir_btn.grid(row=3, column=0)\\n self.dir_btn[\\\"command\\\"] = lambda: self.getDir()\\n\\n # Directory Label\\n self.dir_lbl = ttk.Label(self, text=\\\"No Folder Selected\\\")\\n self.dir_lbl.grid(row=3, column=1)\\n\\n # Status Label\\n self.stat_lbl = ttk.Label(self, text=\\\"\\\")\\n self.stat_lbl.grid(row=3, column=2) \\n\\n # Clear Button\\n self.clear_btn = ttk.Button(self, text=\\\"Clear\\\")\\n self.clear_btn.grid(row=3, column=3)\\n self.clear_btn[\\\"command\\\"] = lambda: self.clearCities()\",\n \"def _create_notebook(self):\\r\\n\\r\\n _notebook = gtk.Notebook()\\r\\n\\r\\n # Set the user's preferred gtk.Notebook tab position.\\r\\n if Configuration.TABPOS[2] == 'left':\\r\\n _notebook.set_tab_pos(gtk.POS_LEFT)\\r\\n elif Configuration.TABPOS[2] == 'right':\\r\\n _notebook.set_tab_pos(gtk.POS_RIGHT)\\r\\n elif Configuration.TABPOS[2] == 'top':\\r\\n _notebook.set_tab_pos(gtk.POS_TOP)\\r\\n else:\\r\\n _notebook.set_tab_pos(gtk.POS_BOTTOM)\\r\\n\\r\\n self._create_analyses_input_page(_notebook)\\r\\n\\r\\n for __, _dist in enumerate(self._lst_results):\\r\\n _dist.create_results_page()\\r\\n for __, _dist in enumerate(self._lst_plots):\\r\\n _dist.create_plot_page()\\r\\n\\r\\n return _notebook\",\n \"def _configureWindow(self):\\n if self._win_type == WindowType.IMMERSIVE:\\n pg.setConfigOptions(\\n foreground='d',\\n background=(_DARK_COLOUR if self._dark else _LIGHT_COLOUR))\\n self._win = pg.plot(title=\\\"Abstact Map Visualisation\\\")\\n self._plt = self._win.plotItem\\n self._plt.setAspectLocked(True, 1)\\n self._plt.hideAxis('left')\\n self._plt.hideAxis('bottom')\\n else: # DEFAULT\\n pg.setConfigOptions(foreground='k', background='w')\\n self._win = pg.plot(title=\\\"Abstact Map Visualisation\\\")\\n self._plt = self._win.plotItem\\n\\n # Set up the overlay objects as they are static\\n self._overlay_items = [\\n QtWidgets.QGraphicsRectItem(-_OVERLAY_WIDTH / 2,\\n -_OVERLAY_HEIGHT / 2, _OVERLAY_WIDTH,\\n _OVERLAY_HEIGHT)\\n ]\\n self._overlay_items[0].setBrush(pg.mkBrush(_OVERLAY_COLOUR))\\n self._overlay_items[0].setZValue(1000)\\n self._win.addItem(self._overlay_items[0])\\n self.toggleOverlay(enable=False)\\n\\n # Do any last settings in the window\\n # self._win.parentWidget().showMaximized()\\n limit = 30\\n self._win.setRange(xRange=[-limit, limit], yRange=[-limit, limit])\",\n \"def run_window(self) -> None:\\n\\n self.root.title('Spotify Recommender')\\n\\n sp_logo = ImageTk.PhotoImage(self._image)\\n label = tk.Label(self.root, image=sp_logo)\\n\\n # We need to save the reference to the image\\n label.image = sp_logo\\n label.grid()\\n\\n tk.Label(self.root, text='Enter the link of your Spotify playlist below : ',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid()\\n\\n self._link_entry.grid(ipadx=30)\\n\\n tk.Label(self.root, text=\\\"How adventurous are you feeling today?\\\",\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid()\\n\\n self._slider.grid()\\n\\n tk.Label(self.root, text='What do you want to name your new playlist? ',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid()\\n\\n self._new_playlist_name_entry.grid(ipadx=30)\\n\\n tk.Button(self.root, text='ENTER', command=self.get_user_input, padx=5,\\n pady=5, bg='#1DB954').grid()\\n\\n tk.Label(self.root, text='VISUALIZATION \\\\n Please choose a visualization option.',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid(pady=15)\\n\\n self._dimension_menu.grid()\\n\\n tk.Label(self.root, text='Please choose your first attribute',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid()\\n self._attribute1_menu.grid()\\n\\n tk.Label(self.root, text='Please choose your second different attribute',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid()\\n self._attribute2_menu.grid()\\n\\n tk.Label(self.root, text='Choose your third different attribute',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid()\\n self._attribute3_menu.grid()\\n\\n tk.Label(self.root, text='IF CHOSEN GRAPH: Enter an integer 1-100',\\n font=(\\\"Proxima nova\\\", \\\"9\\\", \\\"bold\\\")).grid()\\n self._graph_int_entry.grid()\\n\\n tk.Button(self.root, text='VISUALIZE', command=self.visualize, padx=5,\\n pady=5, bg='#1DB954').grid(pady=15)\",\n \"def _addWidgets(self):\\n self.temperatureToConvertLabel = tkinter.Label(self,\\n text='Temperature to Convert',\\n height=4).grid(row=0, column=0,\\n sticky=tkinter.W) # Add 'Temperature to Convert' Label\\n self.temperatureBox = tkinter.Entry(self,\\n textvariable=self.controller.temperatureToConvert,\\n width=15).grid(row=0, column=1) # Add 'Temperature to Convert' Entry\\n\\n self.temperatureBoxLabel = tkinter.Label(self,\\n textvariable=self.controller.temperatureBoxLabelVar).grid(row=0,\\n column=2,\\n sticky=tkinter.E) # Add 'Temperature to Convert' Units\\n\\n self.FtoCRadioButton = tkinter.Radiobutton(self,\\n text=self.controller.FAHRENHEIT + ' to ' + self.controller.CELSIUS,\\n variable=self.controller.conversionVar,\\n command=self.controller.conversionDirectionChanged,\\n value=self.controller.FtoC).grid(row=1, column=0,\\n sticky=tkinter.W) # Add Fahrenheit to Celsius Conversion Radio Button\\n\\n self.CtoFRadioButton = tkinter.Radiobutton(self,\\n text=self.controller.CELSIUS + ' to ' + self.controller.FAHRENHEIT,\\n variable=self.controller.conversionVar,\\n command=self.controller.conversionDirectionChanged,\\n value=self.controller.CtoF).grid(row=2, column=0,\\n sticky=tkinter.W) # Add Celsius to Fahrenheit Conversion Radio Button\\n\\n self.convertedTemperatureLabel = tkinter.Label(self,\\n text='Converted Temperature',\\n height=4).grid(row=3, column=0,\\n sticky=tkinter.W) # Add 'Converted Temperature' Label\\n self.convertedTemperatureBox = tkinter.Entry(self,\\n textvariable=self.controller.convertedTemperature,\\n width=15).grid(row=3,\\n column=1) # Add 'Converted Temperature' Entry\\n self.convertedTemperatureBoxLabel = tkinter.Label(self,\\n textvariable=self.controller.convertedTemperatureBoxLabelVar).grid(\\n row=3, column=2, sticky=tkinter.E) # Add 'Converted Temperature' Units\\n\\n self.convertButton = tkinter.Button(self,\\n text='Convert',\\n command=self.controller.convertPressed).grid(row=4, column=0,\\n sticky=tkinter.E) # Add 'Convert'Button\\n self.quitButton = tkinter.Button(self,\\n text='Quit',\\n command=self.controller.quit).grid(row=4, column=1,\\n sticky=tkinter.E) # Add 'Quit'Button\",\n \"def buildUI(self):\\n outside = QtWidgets.QVBoxLayout(self)\\n columns = QtWidgets.QHBoxLayout(self)\\n layout = QtWidgets.QVBoxLayout(self)\\n self.details_layout = QtWidgets.QVBoxLayout(self) #column with edit panel\\n self.restriction = QtWidgets.QWidget() #restricts size of details_layout\\n self.restriction.setLayout(self.details_layout)\\n self.restriction.setFixedWidth(200)\\n columns.addLayout(layout)\\n columns.addWidget(self.restriction)\\n outside.addLayout(columns)\\n\\n #tab widget\\n self.tabwidget = tabsWindow(self) #QtWidgets.QTabWidget(tabsClosable = True, movable = True)\\n layout.addWidget(self.tabwidget)\\n #add base tab\\n self.tabwidget.newTab(name =\\\"Untitled\\\", image = \\\"\\\")\\n\\n #add second column with details\\n self.updateDetails(\\\"edit\\\")\\n\\n #edit button\\n layout_btns = QtWidgets.QHBoxLayout()\\n editBtn = QtWidgets.QPushButton(\\\"Stop Editing\\\")\\n editBtn.clicked.connect(lambda: self.editChange(editBtn))\\n layout_btns.addWidget(editBtn)\\n\\n #save button\\n saveBtn = QtWidgets.QPushButton(\\\"Save\\\")\\n saveBtn.clicked.connect(self.save)\\n layout_btns.addWidget(saveBtn)\\n\\n #load button\\n loadBtn = QtWidgets.QPushButton(\\\"Load\\\")\\n loadBtn.clicked.connect(self.load)\\n layout_btns.addWidget(loadBtn)\\n\\n #close button\\n closeBtn = QtWidgets.QPushButton('Close')\\n closeBtn.clicked.connect(self.closeEvent)\\n layout_btns.addWidget(closeBtn)\\n\\n outside.addLayout(layout_btns) #add buttons to layout\",\n \"def create_ui(self):\\n main_sizer = wx.BoxSizer(wx.VERTICAL)\\n\\n self.text_ctrl = wx.TextCtrl(self, style=wx.TE_MULTILINE)\\n self.text_ctrl.Bind(wx.EVT_TEXT, self.on_text)\\n main_sizer.Add(self.text_ctrl, 1, wx.ALL | wx.EXPAND, 5)\\n\\n self.SetSizer(main_sizer)\",\n \"def build_window(self):\\n # Size config\\n self.root.geometry('{}x{}'.format(800, 450))\\n self.root.minsize(600, 400)\\n\\n # create all of the main containers\\n self.left_frame = Frame(self.root, bg='red', width=150, height=450, pady=3)\\n self.right_frame = Frame(self.root, bg='blue', width=650, height=450, pady=3)\\n\\n # layout all of the main containers\\n self.root.grid_rowconfigure(0, weight=1)\\n self.root.grid_columnconfigure(1, weight=1)\\n\\n self.left_frame.grid(row=0,column=0,sticky='ns')\\n self.right_frame.grid(row=0,column=1,sticky='nswe')\\n\\n # create all of the left containers\\n self.Username_Search_Frame = Frame(self.left_frame, bg='yellow', pady=3)\\n self.Username_Search_Frame.grid_rowconfigure(0, weight=1)\\n self.Username_Search_Frame.grid_columnconfigure(0, weight=1)\\n self.Username_label = Label(self.Username_Search_Frame, text=self.client.username)\\n self.Search_entry = Entry(self.Username_Search_Frame, text='Add people')\\n self.Search_entry.bind('<Return>', self.add_event)\\n self.Username_label.grid(row=0,column=0,sticky='nswe')\\n self.Search_entry.grid(row=1,column=0,sticky='nswe')\\n\\n self.Show_Friend_request_Frame = Frame(self.left_frame, bg='red', pady=3)\\n self.Show_button = Button(self.Show_Friend_request_Frame, text='Chats')\\n self.Show_button.bind('<Button-1>', self.show_event)\\n self.Show_button_label = Label(self.Show_Friend_request_Frame, text='Chats')\\n\\n self.Friend_request_button = Button(self.Show_Friend_request_Frame, text='Friend_request')\\n self.Friend_request_button.bind('<Button-1>', self.Friend_request_event)\\n self.Friend_request_button_label = Label(self.Show_Friend_request_Frame, text='Friend_request')\\n\\n self.Show_button_label.pack(side=LEFT, fill=BOTH, expand=YES)\\n self.Friend_request_button.pack(side=LEFT, fill=BOTH, expand=YES)\\n\\n self.logins_list_Frame = Frame(self.left_frame, bg='green', pady=3)\\n self.logins_list_Frame.grid_rowconfigure(0, weight=1)\\n self.logins_list_Frame.grid_columnconfigure(0, weight=1)\\n self.logins_list = Listbox(self.logins_list_Frame, selectmode=SINGLE, exportselection=False)\\n self.logins_list.bind('<<ListboxSelect>>', self.selected_login_event)\\n self.logins_list.pack(side=LEFT, fill=BOTH, expand=YES)\\n\\n self.friend_request_list = Listbox(self.logins_list_Frame, selectmode=SINGLE, exportselection=False)\\n self.friend_request_list.bind('<<ListboxSelect>>', self.select_friend_request)\\n #self.friend_request_list.pack(side=LEFT, fill=BOTH, expand=YES)\\n\\n self.Username_Search_Frame.grid(row=0,column=0,sticky='nswe')\\n self.Show_Friend_request_Frame.grid(row=1,column=0,sticky='nswe')\\n self.logins_list_Frame.grid(row=2,column=0,sticky='nswe')\\n\\n self.left_frame.grid_rowconfigure(2, weight=1)\\n self.left_frame.grid_columnconfigure(0, weight=1)\\n\\n\\n # create all of the right containers\\n self.Target_name_frame = Frame(self.right_frame, bg='yellow', pady=3)\\n self.Target_name_frame.grid_rowconfigure(0, weight=1)\\n self.Target_name_frame.grid_columnconfigure(0, weight=1)\\n self.Target = Label(self.Target_name_frame, text='Target_name')\\n self.Target.grid(row=0,column=0,sticky='nswe')\\n\\n self.Message_box_frame = Frame(self.right_frame, bg='black', pady=3)\\n self.message_list = Message_list(self.Message_box_frame)\\n self.message_list.show()\\n\\n self.Entry_frame = Frame(self.right_frame, bg='grey', height=100, pady=3)\\n self.Entry_frame.grid_rowconfigure(0, weight=1)\\n self.Entry_frame.grid_columnconfigure(0, weight=1)\\n self.Entry = Text(self.Entry_frame)\\n self.Entry.bind('<Return>', self.send_entry_event)\\n self.Entry.grid(row=0,column=0,sticky='nswe')\\n\\n self.Send_file_button = Button(self.right_frame, text='Send file')\\n self.Send_file_button.bind('<Button-1>', self.send_file_event)\\n self.Send_file_button.grid(row=3,column=0,sticky='nswe')\\n\\n self.Target_name_frame.grid(row=0,column=0,sticky='nswe')\\n self.Message_box_frame.grid(row=1,column=0,sticky='nswe')\\n self.Entry_frame.grid(row=2,column=0,sticky='nswe')\\n \\n\\n self.right_frame.grid_rowconfigure(1, weight=1)\\n self.right_frame.grid_columnconfigure(0, weight=1)\\n self.right_frame.grid_rowconfigure(2, weight=4)\\n self.right_frame.grid_columnconfigure(0, weight=1)\\n\\n self.root.protocol(\\\"WM_DELETE_WINDOW\\\", self.on_closing_event)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73238564","0.70476335","0.7020338","0.69660527","0.6964482","0.695962","0.6924835","0.67237866","0.6702971","0.6695231","0.6694868","0.6665668","0.666019","0.6648684","0.6624867","0.6576935","0.6558816","0.6556843","0.6536284","0.65104073","0.6472229","0.6463434","0.64361304","0.6434522","0.6388566","0.6384997","0.6373525","0.6361389","0.6342775","0.6317117","0.6304044","0.6293208","0.62919706","0.6268711","0.6246541","0.6236776","0.6232598","0.62182903","0.62067527","0.62048864","0.6182247","0.61712855","0.6163716","0.6147404","0.61306614","0.61222404","0.6115433","0.61077684","0.60951406","0.6093703","0.60859865","0.6068157","0.60657114","0.6060597","0.6055246","0.60466456","0.60414296","0.6038456","0.60267305","0.6020699","0.6015657","0.600373","0.5994116","0.5991991","0.59816116","0.59756935","0.59708387","0.59686744","0.59596485","0.59546894","0.59520024","0.5950734","0.5948543","0.59449524","0.5944659","0.59443456","0.59442353","0.5941657","0.59386384","0.59300107","0.59294206","0.59221876","0.5921097","0.59196514","0.59165305","0.5915584","0.5911157","0.5910842","0.5902698","0.59017026","0.5901244","0.5896863","0.58921766","0.588707","0.58814895","0.5876811","0.5874035","0.5872302","0.58682936","0.5866454"],"string":"[\n \"0.73238564\",\n \"0.70476335\",\n \"0.7020338\",\n \"0.69660527\",\n \"0.6964482\",\n \"0.695962\",\n \"0.6924835\",\n \"0.67237866\",\n \"0.6702971\",\n \"0.6695231\",\n \"0.6694868\",\n \"0.6665668\",\n \"0.666019\",\n \"0.6648684\",\n \"0.6624867\",\n \"0.6576935\",\n \"0.6558816\",\n \"0.6556843\",\n \"0.6536284\",\n \"0.65104073\",\n \"0.6472229\",\n \"0.6463434\",\n \"0.64361304\",\n \"0.6434522\",\n \"0.6388566\",\n \"0.6384997\",\n \"0.6373525\",\n \"0.6361389\",\n \"0.6342775\",\n \"0.6317117\",\n \"0.6304044\",\n \"0.6293208\",\n \"0.62919706\",\n \"0.6268711\",\n \"0.6246541\",\n \"0.6236776\",\n \"0.6232598\",\n \"0.62182903\",\n \"0.62067527\",\n \"0.62048864\",\n \"0.6182247\",\n \"0.61712855\",\n \"0.6163716\",\n \"0.6147404\",\n \"0.61306614\",\n \"0.61222404\",\n \"0.6115433\",\n \"0.61077684\",\n \"0.60951406\",\n \"0.6093703\",\n \"0.60859865\",\n \"0.6068157\",\n \"0.60657114\",\n \"0.6060597\",\n \"0.6055246\",\n \"0.60466456\",\n \"0.60414296\",\n \"0.6038456\",\n \"0.60267305\",\n \"0.6020699\",\n \"0.6015657\",\n \"0.600373\",\n \"0.5994116\",\n \"0.5991991\",\n \"0.59816116\",\n \"0.59756935\",\n \"0.59708387\",\n \"0.59686744\",\n \"0.59596485\",\n \"0.59546894\",\n \"0.59520024\",\n \"0.5950734\",\n \"0.5948543\",\n \"0.59449524\",\n \"0.5944659\",\n \"0.59443456\",\n \"0.59442353\",\n \"0.5941657\",\n \"0.59386384\",\n \"0.59300107\",\n \"0.59294206\",\n \"0.59221876\",\n \"0.5921097\",\n \"0.59196514\",\n \"0.59165305\",\n \"0.5915584\",\n \"0.5911157\",\n \"0.5910842\",\n \"0.5902698\",\n \"0.59017026\",\n \"0.5901244\",\n \"0.5896863\",\n \"0.58921766\",\n \"0.588707\",\n \"0.58814895\",\n \"0.5876811\",\n \"0.5874035\",\n \"0.5872302\",\n \"0.58682936\",\n \"0.5866454\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7192625"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":13288,"cells":{"query":{"kind":"string","value":"This function shows the window which holds the widget."},"document":{"kind":"string","value":"def show(self):\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Show Window.\"\n self.subWindow.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def show_window(self):\n self.show()","def show(self, window):\r\n\r\n return","def show(self):\n self.wid.show()","def show(self):\n self._window.show()","def show(self):\n self.Show()","def show(self):\n # * displays the window, after using either the iconify or the withdraw methods\n self.wm_deiconify()\n # * this method can be called after the event which needs to happen before the window event\n self.wait_window()","def show(self):\r\n\t\tself.frame.Show(True)","def show(self):\n self.frame.grid()\n self.visible = True","def show_window(self):\n self._window.grab_set()\n self._window.wait_window()","def show(self, parent=None):\n # Some Gui's don't like to process all events from a single \n # call to process events (Qt), and pumping the loop is not\n # reliable. Instead, we just schedule the call to set_visible \n # to occur after we start the event loop and with a priority \n # that is less than any relayouts the may be triggered by \n # pending events. This means that the layout queue should \n # finish processing, and then the window will be shown.\n self._prep_window()\n app = self.toolkit.app\n app.schedule(self.set_visible, (True,), priority=75)\n app.start_event_loop()","def showUI(cls):\r\n win = cls()\r\n win.create()\r\n return win","def show(self):\r\n self.wf.Show()","def show_gui():\n pass","def cb_main_window(self, event):\n self.main_frame.Show()","def Show(self):\r\n return Control.Show(self)","def show(self,window):\n self.showFunctions(window)","def showWindow(*args, **kwargs)->None:\n pass","def showBasic(self):\n self.setWindowIcon(QIcon(self.icon))\n self.setWindowTitle(self.title)\n self.setGeometry(*self.posXY, *self.windowSize)\n self.show()","def inicialUI(self):\r\n\r\n self.setGeometry(500, 500, 500, 500)\r\n self.setWindownTitle(\"Pesquisa\")\r\n self.displayWidgets()\r\n\r\n self.show()","def ShowMe(self, event):\n self.Show(True)","def showWindow(*args, **kwargs):\n\ttry:\n\t\targs[0].run()\n\texcept AttributeError: # Regular windows don't have run\n\t\targs[0].show()","def show_dialog(self, widget, data):\n\t\twidget.show()","def show(self):\n self.window.run_command(\"show_panel\", {\"panel\": self.full_name})","def show(self):\n\n self.serial = self.parent.board.serial\n self.deiconify() # Show window\n self.visible = True\n\n self.input_entry.focus()\n\n self.start_repl()","def show():\n from siding.addons import ui\n ui.show()","def iniciaUI(self):\n\n self.setGeometry(100,100, 300, 200)\n self.setWindowTitle(\"Formulario\")\n self.displayWidgets()\n\n self.show()","def show(self) -> None:\n show(self._layout)","def show(self):\n # This function has to be placed here (and not in the user.py script)\n self.showMaximized()\n visapp.run()","def Show(self, show=True):\r\n \r\n super(AuiDockingHintWindow, self).Show(show)\r\n if wx.Platform == '__WXMAC__':\r\n # Need to manually do layout since its a borderless frame.\r\n self.Layout()","def show(self):\n self._impl.show()","def window(main):\r\n main.title(\"BinCryptor 1.0\")\r\n main.update_idletasks()\r\n width = main.winfo_width() #Width of the current screen\r\n height = main.winfo_height() #Height of the current screen\r\n x = (main.winfo_screenwidth() // 2) - (width // 2)\r\n y = (main.winfo_screenheight() // 2) - (height // 2)\r\n main.geometry(f'{width}x{height}+{x}+{y}') #Adjusts the height and width\r","def XPShowWidget(inWidget):\n pass","def run(self):\n self.window.show()\n Gtk.main()","def display(self) -> None:\n self.root.display()","def iniciaUI(self):\n\n self.setGeometry(100,100, 250, 250)\n self.setWindowTitle(\"Login\")\n self.displayWidgets()\n\n self.show()","def show(self, center=True):\n if center:\n if self.master is None:\n refw = None\n else:\n refw = self.master.root\n centerWindows(self.root, dim=self.desiredDimensions(),\n refWindows=refw)\n self.root.deiconify()\n self.root.focus_set()\n if self.queue is not None:\n self._queueTimer = self.root.after(1000, self.__processQueue)\n self.root.mainloop()","def show_dialog(self):\n self.showMaximized()\n sys.exit(self.app.exec_())","def show(self):\n self.root.update()\n self.root.deiconify()","def __call__(self):\n self.show()","def window(*args, width: int = 200, height: int = 200, autosize: bool = False,\n no_resize: bool = False, no_title_bar: bool = False, no_move: bool = False, no_scrollbar: bool = False,\n no_collapse: bool = False, horizontal_scrollbar: bool = False, no_focus_on_appearing: bool = False,\n no_bring_to_front_on_focus: bool = False, menubar: bool = False, no_close: bool = False,\n no_background: bool = False, label: str = '', show: bool = True, collapsed: bool = False,\n modal: bool = False, popup: bool = False,\n on_close: Callable = None, min_size: List[int]=[32, 32], max_size: List[int] = [30000, 30000], id:str=''):\n try:\n\n widget = internal_dpg.add_window(*args, width=width, height=height, autosize=autosize,\n no_resize=no_resize, no_title_bar=no_title_bar, no_move=no_move,\n no_scrollbar=no_scrollbar, no_collapse=no_collapse,\n horizontal_scrollbar=horizontal_scrollbar,\n no_focus_on_appearing=no_focus_on_appearing,\n no_bring_to_front_on_focus=no_bring_to_front_on_focus,\n menubar=menubar, no_close=no_close,\n no_background=no_background, label=label, show=show, \n collapsed=collapsed, on_close=on_close,\n min_size=min_size, max_size=max_size, id=id, modal=modal,\n popup=popup)\n internal_dpg.push_container_stack(widget)\n yield widget\n\n finally:\n internal_dpg.pop_container_stack()","def open_generatorWindow(self):\n self.window = generatorWindow(self)\n self.hide()","def openWindow(self):\n # self.showSessionAct.setEnabled(False)\n self.musketeers_widget = MusketeersWidget(parent=self)\n self.setCentralWidget(self.musketeers_widget)\n self.saveGroupMenu = QAction('Save Group', self.fileMenu)\n self.fileMenu.addAction(self.saveGroupMenu)\n self.saveGroupMenu.triggered.connect(self.musketeers_widget.session_widget.save_group)","def _showMainWindow(self) -> None:\n if not self._main_dialog:\n self._main_dialog = self._createDialog(\"Thingiverse.qml\")\n self._main_dialog.show()\n self._service.updateSupportedFileTypes()\n self._service.search(\"ultimaker\")","def on_show(self, event):\r\n self.frame.Show()\r\n self.frame.Raise()","def showUI(cls):\r\n win = cls(uiFile)\r\n win.create()\r\n return win","def open_window():\n app = QApplication(sys.argv)\n window = MainWindow()\n window.show()\n sys.exit(app.exec_())","def run(cls):\n app = mayaMainWindow()\n \n widget = cls(parent=app)\n\n widget.setWindowFlags(widget.windowFlags() | QtCore.Qt.Window)\n\n if platform.system() == 'Darwin':\n # MacOS is special, and the QtCore.Qt.Window flag does not sort the windows properly,\n # so QtCore.Qt.Tool is added.\n widget.setWindowFlags(widget.windowFlags() | QtCore.Qt.Dialog)\n \n # Center the widget with Maya's main window.\n widget.move(app.frameGeometry().center() - QtCore.QRect(QtCore.QPoint(), widget.sizeHint()).center())\n \n widget.show()\n\n return widget","def show_editor(self):\r\n self.frame.Show()\r\n self.frame.Raise()","def _open_window(self):\r\n\t\t# Creating the window\r\n\t\tself._window = Window(self, Locations.RESTAL)","def display_gui_window(self, window_title):\r\n cv2.imshow(window_title, self.image)","def do_standalone_display(self):\n stage = clutter.Stage()\n stage.connect('destroy', clutter.main_quit)\n stage.connect('key-press-event', lambda x,y: clutter.main_quit())\n stage.set_fullscreen(True)\n stage.set_color(clutter.color_from_string('black'))\n stage.add(self.group)\n stage.show_all()\n clutter.main()","def show(root=None, debug=False, parent=None):\n\n try:\n module.window.close()\n del module.window\n except (RuntimeError, AttributeError):\n pass\n\n if debug is True:\n io.install()\n\n any_project = next(\n project for project in io.projects()\n if project.get(\"active\", True) is not False\n )\n\n api.Session[\"AVALON_PROJECT\"] = any_project[\"name\"]\n\n with tools_lib.application():\n window = Window(parent)\n window.setStyleSheet(style.load_stylesheet())\n window.show()\n window.refresh()\n\n module.window = window","def _create_window(self):\n self.window = Gtk.Window()\n self.window.set_title(\"Yapsy Example\")\n self.window.set_default_size(400, 400)\n self.window.connect(\"destroy\", lambda w: Gtk.main_quit())\n # PluginList() is a composite widget that shows all installed plugins\n # in a Gtk.TreeView. See widgets.py\n self._plugin_list = PluginList(self.window)\n box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)\n box.pack_start(self._plugin_list, True, True, 0)\n box.show_all()\n self.window.add(box)","def show(self):\n self.scene().show()","def run(self):\n self.window.mainloop()","def createWindow(self):\r\n\t\t# give the window a title\r\n\t\tself.parent.title( 'Acrobat Data Acquisition')\r\n\t\t# set the style\r\n\t\tself.style = ttk.Style()\r\n\t\tself.style.theme_use('default')\r\n\t\tself.pack(fill= tk.BOTH, expand=1)","def run(self):\n self.ui['main_window'].widgets['main'].show_all()\n gtk.main()","def createWindow(self):\n\n # create window, set basic attributes\n w = gtk.Window(gtk.WINDOW_TOPLEVEL)\n w.set_size_request(*self.__def_win_size__)\n w.set_decorated(False)\n #w.fullscreen()\n #w.unfullscreen()\n w.set_title(self.__name__)\n w.connect(\"destroy\", gtk.main_quit)\n\n # declare buttons and their associated handlers\n controls = (\n (\"open_button\", gtk.ToolButton(gtk.STOCK_OPEN), self.onPlay),\n (\"play_button\", gtk.ToolButton(gtk.STOCK_MEDIA_PLAY), self.onPlay),\n (\"stop_button\", gtk.ToolButton(gtk.STOCK_MEDIA_STOP), self.onStop),\n (\"quit_button\", gtk.ToolButton(gtk.STOCK_QUIT), gtk.main_quit)\n )\n\n # as well as the container in which to put them\n box = gtk.HButtonBox()\n\n # for every widget, connect to its clicked signal and add it\n # to the enclosing box\n for name, widget, handler in controls:\n widget.connect(\"clicked\", handler)\n box.pack_start(widget, True)\n setattr(self, name, widget)\n\n viewer = gtk.DrawingArea()\n viewer.modify_bg(gtk.STATE_NORMAL, viewer.style.black)\n\n # we will need this later\n self.xid = None\n\n # now finally do the top-level layout for the window\n layout = gtk.VBox(False)\n layout.pack_start(viewer)\n\n # subclasses can override childWidgets() to supply\n # custom controls\n layout.pack_start(self.customWidgets(), False, False)\n layout.pack_end(box, False, False)\n w.add(layout)\n w.show_all()\n\n # we want to return only the portion of the window which will\n # be used to display the video, not the whole top-level\n # window. a DrawingArea widget is, in fact, an X11 window.\n return viewer","def show(self):\r\n display(self.grid_part)","def displayWindow(self, login, name, window, useOldState = False):\n\t\twindow.setName(name)\n\t\twindow.setUser(login)\n\t\twindow.setWindowManager(self)\n\t\tself.__addWindow(login, name, window, useOldState)\n\t\tml = window.getManialink()\n\t\tself.displayMl(ml, name, login)","def widgets(self):\r\n self.setWindowTitle(\"PyCrypt\")\r\n self.setMinimumSize(QSize(500, 500))\r\n self.setMaximumSize(QSize(500, 500))\r\n# Adding the sub def for widgets etc\r\n self.add_menus_and_status()\r\n self.add_buttons()","def start(self):\n self.delegate.start_preview(fullscreen=False, window = (350, 10, self.size[0] - 350, self.size[1] - 10))","def showSettings(self):\n self.c.show()","def showEditorWindow(parent, title, allowEditting = True):\n frame = wx.Frame(parent, -1, title, size=(630, 320), style = wx.DEFAULT_FRAME_STYLE)\n panel = RichTextPanel(allowEditting, frame, -1)\n #frame.Fit()\n #frame.SetMinSize(frame.GetSize())\n frame.Show()\n return panel","def placeWindow(self):\r\n\t\t# window size\r\n\t\tw = 600\r\n\t\th = 300\r\n\t\t# find the screen size\r\n\t\tsw = self.parent.winfo_screenwidth()\r\n\t\tsh = self.parent.winfo_screenheight()\r\n\t\t# now define the location on the current screen\r\n\t\tx = (sw/2-0.5*w)\r\n\t\ty = (sh/2-0.5*h)\r\n\t\tself.parent.geometry('%dx%d+%d+%d' % (w, h, x, y))","def display(self):\n\t\tprint('The button in the window was clicked!')","def show(self):\n self.driver.send(self.canvas)","def ShowPane(self, window, show):\r\n\r\n p = self.GetPane(window)\r\n \r\n if p.IsOk():\r\n if p.IsNotebookPage():\r\n if show:\r\n \r\n notebook = self._notebooks[p.notebook_id]\r\n id = notebook.GetPageIndex(p.window)\r\n if id >= 0:\r\n notebook.SetSelection(id)\r\n self.ShowPane(notebook, True)\r\n \r\n else:\r\n p.Show(show)\r\n \r\n if p.frame:\r\n p.frame.Raise()\r\n \r\n self.Update()","def startWindow():\n\n m = mainWindow()\n\n # Show Window\n m.show()\n\n # Return to stay alive\n return m","def show():\n dialog = SkinIODialog(getMayaWindow())\n dialog.show()","def start(self) -> Gui:\n self.show()\n self.app.exec_()\n\n return self","def show(self) -> None:\n\t\tself.setIcon(self._icon)\n\t\tself.setText(self._subtitle)\n\t\tself.setInformativeText(self._message)\n\t\tself.setWindowTitle(self._title)\n\t\tself.exec()","def details_window(self, instance: Union[Nobleman, Location]):\n window = tk.Toplevel()\n window.title(instance.name)\n window.protocol(\"WM_DELETE_WINDOW\",\n partial(self.close_details_window, instance))\n self.register_extra_window(instance, window)\n self.generate_window_content(instance, window)","def main(self):\n\n self.window.show_all()\n gtk.main()","def abrir_demo(self, widget, data=None):\n\t\tself.w3.hide()\n\t\tself.w5.show_all()","def show_frame(self, cont):\n \n frame = self.frames[cont]\n frame.tkraise()","def show_frame(self, cont):\n\n frame = self.frames[cont]\n frame.tkraise()","def show_frame(self, container):\r\n\r\n frame = self.frames[container]\r\n\r\n frame.tkraise()","def get_help_window(self):\n self.gui.active_window.hide()\n\n self.associated_window = help_window.HelpWindow(self.gui)\n self.gui.active_window = self.associated_window\n\n self.gui.active_window.show()","def show_in_maya_panel(*args):\n from mliber_libs.maya_libs.maya_utils import show_as_panel\n show_as_panel(MainWidget())","def widget(self) -> tk.Frame:\r\n return self.main_frame","def maya_window():\n return to_qwidget(\"MayaWindow\")","def initialise_window(self):\n self.imageLabel.setBackgroundRole(QtGui.QPalette.Base)\n self.imageLabel.setScaledContents(True)\n self.scrollArea.setWidget(self.imageLabel)\n self.setCentralWidget(self.scrollArea)\n self.scrollArea.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) # Disable horizontal scrollbar.\n self.scrollArea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) # Disable vertical scrollbar.\n self.setWindowTitle(\"Robot Map\") # Set title.\n self.showFullScreen() # Make fullscreen.","def __init_window(self) -> pygame.Surface:\n pygame.display.set_caption(CAPTION)\n win = pygame.display.set_mode((WIDTH, HEIGHT))\n \n return win","def create_window(self, img, roi, name):\n\n self.window = SpinBalanceDialog()\n\n # call the user-implemented functionality\n self.window.main(img, roi)\n # show the window\n self.window.show()\n\n return self.window","def on_show_view(self):\n self.window.background_color = arcade.color.BLACK","def main():\n app = QtWidgets.QApplication(sys.argv)\n main = MainWindow()\n main.show()\n sys.exit(app.exec_())","def visualise(self):\n self.w = VisualizeSetupBox(self.master, self._df)\n self.master.wait_window(self.w.top)","def show(self):\n\n self.image.show()","def showSettingsWindow(self) -> None:\n if not self._settings_dialog:\n self._settings_dialog = self._createDialog(\"ThingiSettings.qml\")\n self._settings_dialog.show()","def display_object_on_canvas(self, tk_object, x, y):\n button1_window = self.canvas.create_window(\n x,\n y,\n anchor='nw',\n window=tk_object)","def display_object_on_canvas(self, tk_object, x, y):\n button1_window = self.canvas.create_window(\n x,\n y,\n anchor='nw',\n window=tk_object)","def display_object_on_canvas(self, tk_object, x, y):\n button1_window = self.canvas.create_window(\n x,\n y,\n anchor='nw',\n window=tk_object)","def show(self):\n self.present(orientations=ORIENTATIONS)\n # launch a background thread\n # we can not use ui.in_background here\n # because some dialogs would not open anymoe\n thr = threading.Thread(target=self.show_messages)\n thr.daemon = True\n thr.start()","def create_widget(self):\n self.widget = wxDockPane(self.parent_widget())","def show(self):\r\n wlight.lightController.redraw()","def showKey():\n\tnewWindow=topWindow(window)\n\t#Config Context Bar\n\tnewWindow.context.removePlaceholder(0)\n\t#Context commands\n\tnewWindow.context.updateContextButton(0,command=lambda n=newWindow: n.grab_release())\n\tnewWindow.context.updateContextButton(1,command=lambda n=newWindow: n.destroy())\n\t#Add Table\n\tnewTable=table(newWindow,\"Pod Templates\",False)\n\tnewTable.pack(fill=BOTH,expand=True)\n\t#Add the content to the table\n\tfor t in podTemplate.templateColours:\n\t\trowName=t+\" colour:\"\n\t\trowColour=podTemplate.templateColours[t]\n\t\tnewTable.addRow(rowName,t,rowColour)\n\n\tnewWindow.run()","def on_show_view(self):\n self.window.background_color = arcade.color.WHITE","def get_main_window():\n\n pass","def create(self, parent):\n self.widget = _QMainWindow(parent)"],"string":"[\n \"def show_window(self):\\n self.show()\",\n \"def show(self, window):\\r\\n\\r\\n return\",\n \"def show(self):\\n self.wid.show()\",\n \"def show(self):\\n self._window.show()\",\n \"def show(self):\\n self.Show()\",\n \"def show(self):\\n # * displays the window, after using either the iconify or the withdraw methods\\n self.wm_deiconify()\\n # * this method can be called after the event which needs to happen before the window event\\n self.wait_window()\",\n \"def show(self):\\r\\n\\t\\tself.frame.Show(True)\",\n \"def show(self):\\n self.frame.grid()\\n self.visible = True\",\n \"def show_window(self):\\n self._window.grab_set()\\n self._window.wait_window()\",\n \"def show(self, parent=None):\\n # Some Gui's don't like to process all events from a single \\n # call to process events (Qt), and pumping the loop is not\\n # reliable. Instead, we just schedule the call to set_visible \\n # to occur after we start the event loop and with a priority \\n # that is less than any relayouts the may be triggered by \\n # pending events. This means that the layout queue should \\n # finish processing, and then the window will be shown.\\n self._prep_window()\\n app = self.toolkit.app\\n app.schedule(self.set_visible, (True,), priority=75)\\n app.start_event_loop()\",\n \"def showUI(cls):\\r\\n win = cls()\\r\\n win.create()\\r\\n return win\",\n \"def show(self):\\r\\n self.wf.Show()\",\n \"def show_gui():\\n pass\",\n \"def cb_main_window(self, event):\\n self.main_frame.Show()\",\n \"def Show(self):\\r\\n return Control.Show(self)\",\n \"def show(self,window):\\n self.showFunctions(window)\",\n \"def showWindow(*args, **kwargs)->None:\\n pass\",\n \"def showBasic(self):\\n self.setWindowIcon(QIcon(self.icon))\\n self.setWindowTitle(self.title)\\n self.setGeometry(*self.posXY, *self.windowSize)\\n self.show()\",\n \"def inicialUI(self):\\r\\n\\r\\n self.setGeometry(500, 500, 500, 500)\\r\\n self.setWindownTitle(\\\"Pesquisa\\\")\\r\\n self.displayWidgets()\\r\\n\\r\\n self.show()\",\n \"def ShowMe(self, event):\\n self.Show(True)\",\n \"def showWindow(*args, **kwargs):\\n\\ttry:\\n\\t\\targs[0].run()\\n\\texcept AttributeError: # Regular windows don't have run\\n\\t\\targs[0].show()\",\n \"def show_dialog(self, widget, data):\\n\\t\\twidget.show()\",\n \"def show(self):\\n self.window.run_command(\\\"show_panel\\\", {\\\"panel\\\": self.full_name})\",\n \"def show(self):\\n\\n self.serial = self.parent.board.serial\\n self.deiconify() # Show window\\n self.visible = True\\n\\n self.input_entry.focus()\\n\\n self.start_repl()\",\n \"def show():\\n from siding.addons import ui\\n ui.show()\",\n \"def iniciaUI(self):\\n\\n self.setGeometry(100,100, 300, 200)\\n self.setWindowTitle(\\\"Formulario\\\")\\n self.displayWidgets()\\n\\n self.show()\",\n \"def show(self) -> None:\\n show(self._layout)\",\n \"def show(self):\\n # This function has to be placed here (and not in the user.py script)\\n self.showMaximized()\\n visapp.run()\",\n \"def Show(self, show=True):\\r\\n \\r\\n super(AuiDockingHintWindow, self).Show(show)\\r\\n if wx.Platform == '__WXMAC__':\\r\\n # Need to manually do layout since its a borderless frame.\\r\\n self.Layout()\",\n \"def show(self):\\n self._impl.show()\",\n \"def window(main):\\r\\n main.title(\\\"BinCryptor 1.0\\\")\\r\\n main.update_idletasks()\\r\\n width = main.winfo_width() #Width of the current screen\\r\\n height = main.winfo_height() #Height of the current screen\\r\\n x = (main.winfo_screenwidth() // 2) - (width // 2)\\r\\n y = (main.winfo_screenheight() // 2) - (height // 2)\\r\\n main.geometry(f'{width}x{height}+{x}+{y}') #Adjusts the height and width\\r\",\n \"def XPShowWidget(inWidget):\\n pass\",\n \"def run(self):\\n self.window.show()\\n Gtk.main()\",\n \"def display(self) -> None:\\n self.root.display()\",\n \"def iniciaUI(self):\\n\\n self.setGeometry(100,100, 250, 250)\\n self.setWindowTitle(\\\"Login\\\")\\n self.displayWidgets()\\n\\n self.show()\",\n \"def show(self, center=True):\\n if center:\\n if self.master is None:\\n refw = None\\n else:\\n refw = self.master.root\\n centerWindows(self.root, dim=self.desiredDimensions(),\\n refWindows=refw)\\n self.root.deiconify()\\n self.root.focus_set()\\n if self.queue is not None:\\n self._queueTimer = self.root.after(1000, self.__processQueue)\\n self.root.mainloop()\",\n \"def show_dialog(self):\\n self.showMaximized()\\n sys.exit(self.app.exec_())\",\n \"def show(self):\\n self.root.update()\\n self.root.deiconify()\",\n \"def __call__(self):\\n self.show()\",\n \"def window(*args, width: int = 200, height: int = 200, autosize: bool = False,\\n no_resize: bool = False, no_title_bar: bool = False, no_move: bool = False, no_scrollbar: bool = False,\\n no_collapse: bool = False, horizontal_scrollbar: bool = False, no_focus_on_appearing: bool = False,\\n no_bring_to_front_on_focus: bool = False, menubar: bool = False, no_close: bool = False,\\n no_background: bool = False, label: str = '', show: bool = True, collapsed: bool = False,\\n modal: bool = False, popup: bool = False,\\n on_close: Callable = None, min_size: List[int]=[32, 32], max_size: List[int] = [30000, 30000], id:str=''):\\n try:\\n\\n widget = internal_dpg.add_window(*args, width=width, height=height, autosize=autosize,\\n no_resize=no_resize, no_title_bar=no_title_bar, no_move=no_move,\\n no_scrollbar=no_scrollbar, no_collapse=no_collapse,\\n horizontal_scrollbar=horizontal_scrollbar,\\n no_focus_on_appearing=no_focus_on_appearing,\\n no_bring_to_front_on_focus=no_bring_to_front_on_focus,\\n menubar=menubar, no_close=no_close,\\n no_background=no_background, label=label, show=show, \\n collapsed=collapsed, on_close=on_close,\\n min_size=min_size, max_size=max_size, id=id, modal=modal,\\n popup=popup)\\n internal_dpg.push_container_stack(widget)\\n yield widget\\n\\n finally:\\n internal_dpg.pop_container_stack()\",\n \"def open_generatorWindow(self):\\n self.window = generatorWindow(self)\\n self.hide()\",\n \"def openWindow(self):\\n # self.showSessionAct.setEnabled(False)\\n self.musketeers_widget = MusketeersWidget(parent=self)\\n self.setCentralWidget(self.musketeers_widget)\\n self.saveGroupMenu = QAction('Save Group', self.fileMenu)\\n self.fileMenu.addAction(self.saveGroupMenu)\\n self.saveGroupMenu.triggered.connect(self.musketeers_widget.session_widget.save_group)\",\n \"def _showMainWindow(self) -> None:\\n if not self._main_dialog:\\n self._main_dialog = self._createDialog(\\\"Thingiverse.qml\\\")\\n self._main_dialog.show()\\n self._service.updateSupportedFileTypes()\\n self._service.search(\\\"ultimaker\\\")\",\n \"def on_show(self, event):\\r\\n self.frame.Show()\\r\\n self.frame.Raise()\",\n \"def showUI(cls):\\r\\n win = cls(uiFile)\\r\\n win.create()\\r\\n return win\",\n \"def open_window():\\n app = QApplication(sys.argv)\\n window = MainWindow()\\n window.show()\\n sys.exit(app.exec_())\",\n \"def run(cls):\\n app = mayaMainWindow()\\n \\n widget = cls(parent=app)\\n\\n widget.setWindowFlags(widget.windowFlags() | QtCore.Qt.Window)\\n\\n if platform.system() == 'Darwin':\\n # MacOS is special, and the QtCore.Qt.Window flag does not sort the windows properly,\\n # so QtCore.Qt.Tool is added.\\n widget.setWindowFlags(widget.windowFlags() | QtCore.Qt.Dialog)\\n \\n # Center the widget with Maya's main window.\\n widget.move(app.frameGeometry().center() - QtCore.QRect(QtCore.QPoint(), widget.sizeHint()).center())\\n \\n widget.show()\\n\\n return widget\",\n \"def show_editor(self):\\r\\n self.frame.Show()\\r\\n self.frame.Raise()\",\n \"def _open_window(self):\\r\\n\\t\\t# Creating the window\\r\\n\\t\\tself._window = Window(self, Locations.RESTAL)\",\n \"def display_gui_window(self, window_title):\\r\\n cv2.imshow(window_title, self.image)\",\n \"def do_standalone_display(self):\\n stage = clutter.Stage()\\n stage.connect('destroy', clutter.main_quit)\\n stage.connect('key-press-event', lambda x,y: clutter.main_quit())\\n stage.set_fullscreen(True)\\n stage.set_color(clutter.color_from_string('black'))\\n stage.add(self.group)\\n stage.show_all()\\n clutter.main()\",\n \"def show(root=None, debug=False, parent=None):\\n\\n try:\\n module.window.close()\\n del module.window\\n except (RuntimeError, AttributeError):\\n pass\\n\\n if debug is True:\\n io.install()\\n\\n any_project = next(\\n project for project in io.projects()\\n if project.get(\\\"active\\\", True) is not False\\n )\\n\\n api.Session[\\\"AVALON_PROJECT\\\"] = any_project[\\\"name\\\"]\\n\\n with tools_lib.application():\\n window = Window(parent)\\n window.setStyleSheet(style.load_stylesheet())\\n window.show()\\n window.refresh()\\n\\n module.window = window\",\n \"def _create_window(self):\\n self.window = Gtk.Window()\\n self.window.set_title(\\\"Yapsy Example\\\")\\n self.window.set_default_size(400, 400)\\n self.window.connect(\\\"destroy\\\", lambda w: Gtk.main_quit())\\n # PluginList() is a composite widget that shows all installed plugins\\n # in a Gtk.TreeView. See widgets.py\\n self._plugin_list = PluginList(self.window)\\n box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)\\n box.pack_start(self._plugin_list, True, True, 0)\\n box.show_all()\\n self.window.add(box)\",\n \"def show(self):\\n self.scene().show()\",\n \"def run(self):\\n self.window.mainloop()\",\n \"def createWindow(self):\\r\\n\\t\\t# give the window a title\\r\\n\\t\\tself.parent.title( 'Acrobat Data Acquisition')\\r\\n\\t\\t# set the style\\r\\n\\t\\tself.style = ttk.Style()\\r\\n\\t\\tself.style.theme_use('default')\\r\\n\\t\\tself.pack(fill= tk.BOTH, expand=1)\",\n \"def run(self):\\n self.ui['main_window'].widgets['main'].show_all()\\n gtk.main()\",\n \"def createWindow(self):\\n\\n # create window, set basic attributes\\n w = gtk.Window(gtk.WINDOW_TOPLEVEL)\\n w.set_size_request(*self.__def_win_size__)\\n w.set_decorated(False)\\n #w.fullscreen()\\n #w.unfullscreen()\\n w.set_title(self.__name__)\\n w.connect(\\\"destroy\\\", gtk.main_quit)\\n\\n # declare buttons and their associated handlers\\n controls = (\\n (\\\"open_button\\\", gtk.ToolButton(gtk.STOCK_OPEN), self.onPlay),\\n (\\\"play_button\\\", gtk.ToolButton(gtk.STOCK_MEDIA_PLAY), self.onPlay),\\n (\\\"stop_button\\\", gtk.ToolButton(gtk.STOCK_MEDIA_STOP), self.onStop),\\n (\\\"quit_button\\\", gtk.ToolButton(gtk.STOCK_QUIT), gtk.main_quit)\\n )\\n\\n # as well as the container in which to put them\\n box = gtk.HButtonBox()\\n\\n # for every widget, connect to its clicked signal and add it\\n # to the enclosing box\\n for name, widget, handler in controls:\\n widget.connect(\\\"clicked\\\", handler)\\n box.pack_start(widget, True)\\n setattr(self, name, widget)\\n\\n viewer = gtk.DrawingArea()\\n viewer.modify_bg(gtk.STATE_NORMAL, viewer.style.black)\\n\\n # we will need this later\\n self.xid = None\\n\\n # now finally do the top-level layout for the window\\n layout = gtk.VBox(False)\\n layout.pack_start(viewer)\\n\\n # subclasses can override childWidgets() to supply\\n # custom controls\\n layout.pack_start(self.customWidgets(), False, False)\\n layout.pack_end(box, False, False)\\n w.add(layout)\\n w.show_all()\\n\\n # we want to return only the portion of the window which will\\n # be used to display the video, not the whole top-level\\n # window. a DrawingArea widget is, in fact, an X11 window.\\n return viewer\",\n \"def show(self):\\r\\n display(self.grid_part)\",\n \"def displayWindow(self, login, name, window, useOldState = False):\\n\\t\\twindow.setName(name)\\n\\t\\twindow.setUser(login)\\n\\t\\twindow.setWindowManager(self)\\n\\t\\tself.__addWindow(login, name, window, useOldState)\\n\\t\\tml = window.getManialink()\\n\\t\\tself.displayMl(ml, name, login)\",\n \"def widgets(self):\\r\\n self.setWindowTitle(\\\"PyCrypt\\\")\\r\\n self.setMinimumSize(QSize(500, 500))\\r\\n self.setMaximumSize(QSize(500, 500))\\r\\n# Adding the sub def for widgets etc\\r\\n self.add_menus_and_status()\\r\\n self.add_buttons()\",\n \"def start(self):\\n self.delegate.start_preview(fullscreen=False, window = (350, 10, self.size[0] - 350, self.size[1] - 10))\",\n \"def showSettings(self):\\n self.c.show()\",\n \"def showEditorWindow(parent, title, allowEditting = True):\\n frame = wx.Frame(parent, -1, title, size=(630, 320), style = wx.DEFAULT_FRAME_STYLE)\\n panel = RichTextPanel(allowEditting, frame, -1)\\n #frame.Fit()\\n #frame.SetMinSize(frame.GetSize())\\n frame.Show()\\n return panel\",\n \"def placeWindow(self):\\r\\n\\t\\t# window size\\r\\n\\t\\tw = 600\\r\\n\\t\\th = 300\\r\\n\\t\\t# find the screen size\\r\\n\\t\\tsw = self.parent.winfo_screenwidth()\\r\\n\\t\\tsh = self.parent.winfo_screenheight()\\r\\n\\t\\t# now define the location on the current screen\\r\\n\\t\\tx = (sw/2-0.5*w)\\r\\n\\t\\ty = (sh/2-0.5*h)\\r\\n\\t\\tself.parent.geometry('%dx%d+%d+%d' % (w, h, x, y))\",\n \"def display(self):\\n\\t\\tprint('The button in the window was clicked!')\",\n \"def show(self):\\n self.driver.send(self.canvas)\",\n \"def ShowPane(self, window, show):\\r\\n\\r\\n p = self.GetPane(window)\\r\\n \\r\\n if p.IsOk():\\r\\n if p.IsNotebookPage():\\r\\n if show:\\r\\n \\r\\n notebook = self._notebooks[p.notebook_id]\\r\\n id = notebook.GetPageIndex(p.window)\\r\\n if id >= 0:\\r\\n notebook.SetSelection(id)\\r\\n self.ShowPane(notebook, True)\\r\\n \\r\\n else:\\r\\n p.Show(show)\\r\\n \\r\\n if p.frame:\\r\\n p.frame.Raise()\\r\\n \\r\\n self.Update()\",\n \"def startWindow():\\n\\n m = mainWindow()\\n\\n # Show Window\\n m.show()\\n\\n # Return to stay alive\\n return m\",\n \"def show():\\n dialog = SkinIODialog(getMayaWindow())\\n dialog.show()\",\n \"def start(self) -> Gui:\\n self.show()\\n self.app.exec_()\\n\\n return self\",\n \"def show(self) -> None:\\n\\t\\tself.setIcon(self._icon)\\n\\t\\tself.setText(self._subtitle)\\n\\t\\tself.setInformativeText(self._message)\\n\\t\\tself.setWindowTitle(self._title)\\n\\t\\tself.exec()\",\n \"def details_window(self, instance: Union[Nobleman, Location]):\\n window = tk.Toplevel()\\n window.title(instance.name)\\n window.protocol(\\\"WM_DELETE_WINDOW\\\",\\n partial(self.close_details_window, instance))\\n self.register_extra_window(instance, window)\\n self.generate_window_content(instance, window)\",\n \"def main(self):\\n\\n self.window.show_all()\\n gtk.main()\",\n \"def abrir_demo(self, widget, data=None):\\n\\t\\tself.w3.hide()\\n\\t\\tself.w5.show_all()\",\n \"def show_frame(self, cont):\\n \\n frame = self.frames[cont]\\n frame.tkraise()\",\n \"def show_frame(self, cont):\\n\\n frame = self.frames[cont]\\n frame.tkraise()\",\n \"def show_frame(self, container):\\r\\n\\r\\n frame = self.frames[container]\\r\\n\\r\\n frame.tkraise()\",\n \"def get_help_window(self):\\n self.gui.active_window.hide()\\n\\n self.associated_window = help_window.HelpWindow(self.gui)\\n self.gui.active_window = self.associated_window\\n\\n self.gui.active_window.show()\",\n \"def show_in_maya_panel(*args):\\n from mliber_libs.maya_libs.maya_utils import show_as_panel\\n show_as_panel(MainWidget())\",\n \"def widget(self) -> tk.Frame:\\r\\n return self.main_frame\",\n \"def maya_window():\\n return to_qwidget(\\\"MayaWindow\\\")\",\n \"def initialise_window(self):\\n self.imageLabel.setBackgroundRole(QtGui.QPalette.Base)\\n self.imageLabel.setScaledContents(True)\\n self.scrollArea.setWidget(self.imageLabel)\\n self.setCentralWidget(self.scrollArea)\\n self.scrollArea.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) # Disable horizontal scrollbar.\\n self.scrollArea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) # Disable vertical scrollbar.\\n self.setWindowTitle(\\\"Robot Map\\\") # Set title.\\n self.showFullScreen() # Make fullscreen.\",\n \"def __init_window(self) -> pygame.Surface:\\n pygame.display.set_caption(CAPTION)\\n win = pygame.display.set_mode((WIDTH, HEIGHT))\\n \\n return win\",\n \"def create_window(self, img, roi, name):\\n\\n self.window = SpinBalanceDialog()\\n\\n # call the user-implemented functionality\\n self.window.main(img, roi)\\n # show the window\\n self.window.show()\\n\\n return self.window\",\n \"def on_show_view(self):\\n self.window.background_color = arcade.color.BLACK\",\n \"def main():\\n app = QtWidgets.QApplication(sys.argv)\\n main = MainWindow()\\n main.show()\\n sys.exit(app.exec_())\",\n \"def visualise(self):\\n self.w = VisualizeSetupBox(self.master, self._df)\\n self.master.wait_window(self.w.top)\",\n \"def show(self):\\n\\n self.image.show()\",\n \"def showSettingsWindow(self) -> None:\\n if not self._settings_dialog:\\n self._settings_dialog = self._createDialog(\\\"ThingiSettings.qml\\\")\\n self._settings_dialog.show()\",\n \"def display_object_on_canvas(self, tk_object, x, y):\\n button1_window = self.canvas.create_window(\\n x,\\n y,\\n anchor='nw',\\n window=tk_object)\",\n \"def display_object_on_canvas(self, tk_object, x, y):\\n button1_window = self.canvas.create_window(\\n x,\\n y,\\n anchor='nw',\\n window=tk_object)\",\n \"def display_object_on_canvas(self, tk_object, x, y):\\n button1_window = self.canvas.create_window(\\n x,\\n y,\\n anchor='nw',\\n window=tk_object)\",\n \"def show(self):\\n self.present(orientations=ORIENTATIONS)\\n # launch a background thread\\n # we can not use ui.in_background here\\n # because some dialogs would not open anymoe\\n thr = threading.Thread(target=self.show_messages)\\n thr.daemon = True\\n thr.start()\",\n \"def create_widget(self):\\n self.widget = wxDockPane(self.parent_widget())\",\n \"def show(self):\\r\\n wlight.lightController.redraw()\",\n \"def showKey():\\n\\tnewWindow=topWindow(window)\\n\\t#Config Context Bar\\n\\tnewWindow.context.removePlaceholder(0)\\n\\t#Context commands\\n\\tnewWindow.context.updateContextButton(0,command=lambda n=newWindow: n.grab_release())\\n\\tnewWindow.context.updateContextButton(1,command=lambda n=newWindow: n.destroy())\\n\\t#Add Table\\n\\tnewTable=table(newWindow,\\\"Pod Templates\\\",False)\\n\\tnewTable.pack(fill=BOTH,expand=True)\\n\\t#Add the content to the table\\n\\tfor t in podTemplate.templateColours:\\n\\t\\trowName=t+\\\" colour:\\\"\\n\\t\\trowColour=podTemplate.templateColours[t]\\n\\t\\tnewTable.addRow(rowName,t,rowColour)\\n\\n\\tnewWindow.run()\",\n \"def on_show_view(self):\\n self.window.background_color = arcade.color.WHITE\",\n \"def get_main_window():\\n\\n pass\",\n \"def create(self, parent):\\n self.widget = _QMainWindow(parent)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8502241","0.8415356","0.8357775","0.79170626","0.77707803","0.7727727","0.75549763","0.7479209","0.74743026","0.74242014","0.73494244","0.7291545","0.7291496","0.7277171","0.7250763","0.7220816","0.7209948","0.7197237","0.71558094","0.71508753","0.7149055","0.710071","0.70878196","0.7020586","0.70109224","0.6998158","0.69935817","0.699034","0.6975775","0.6944106","0.69262576","0.68545216","0.68402296","0.68324715","0.68226224","0.6819842","0.68036354","0.67994255","0.6770729","0.6766373","0.67541975","0.6738552","0.6730794","0.6715815","0.67134106","0.6691368","0.6682257","0.6671601","0.6671164","0.66653925","0.66542363","0.6619227","0.6563152","0.6561355","0.6558311","0.65564376","0.6523735","0.651645","0.6504253","0.6503476","0.649713","0.64932114","0.64861315","0.6480166","0.64675254","0.64671797","0.6460309","0.6452027","0.6452003","0.64439285","0.6442335","0.6440329","0.64211893","0.6409852","0.64052784","0.64029723","0.6388339","0.6388035","0.6383537","0.63721454","0.63638544","0.63442826","0.63372767","0.63059676","0.6302789","0.63025385","0.62767154","0.6255209","0.6252756","0.624524","0.6229734","0.6229734","0.6229734","0.6211873","0.6206178","0.62053674","0.61952406","0.61949193","0.6177431","0.6175724"],"string":"[\n \"0.8502241\",\n \"0.8415356\",\n \"0.8357775\",\n \"0.79170626\",\n \"0.77707803\",\n \"0.7727727\",\n \"0.75549763\",\n \"0.7479209\",\n \"0.74743026\",\n \"0.74242014\",\n \"0.73494244\",\n \"0.7291545\",\n \"0.7291496\",\n \"0.7277171\",\n \"0.7250763\",\n \"0.7220816\",\n \"0.7209948\",\n \"0.7197237\",\n \"0.71558094\",\n \"0.71508753\",\n \"0.7149055\",\n \"0.710071\",\n \"0.70878196\",\n \"0.7020586\",\n \"0.70109224\",\n \"0.6998158\",\n \"0.69935817\",\n \"0.699034\",\n \"0.6975775\",\n \"0.6944106\",\n \"0.69262576\",\n \"0.68545216\",\n \"0.68402296\",\n \"0.68324715\",\n \"0.68226224\",\n \"0.6819842\",\n \"0.68036354\",\n \"0.67994255\",\n \"0.6770729\",\n \"0.6766373\",\n \"0.67541975\",\n \"0.6738552\",\n \"0.6730794\",\n \"0.6715815\",\n \"0.67134106\",\n \"0.6691368\",\n \"0.6682257\",\n \"0.6671601\",\n \"0.6671164\",\n \"0.66653925\",\n \"0.66542363\",\n \"0.6619227\",\n \"0.6563152\",\n \"0.6561355\",\n \"0.6558311\",\n \"0.65564376\",\n \"0.6523735\",\n \"0.651645\",\n \"0.6504253\",\n \"0.6503476\",\n \"0.649713\",\n \"0.64932114\",\n \"0.64861315\",\n \"0.6480166\",\n \"0.64675254\",\n \"0.64671797\",\n \"0.6460309\",\n \"0.6452027\",\n \"0.6452003\",\n \"0.64439285\",\n \"0.6442335\",\n \"0.6440329\",\n \"0.64211893\",\n \"0.6409852\",\n \"0.64052784\",\n \"0.64029723\",\n \"0.6388339\",\n \"0.6388035\",\n \"0.6383537\",\n \"0.63721454\",\n \"0.63638544\",\n \"0.63442826\",\n \"0.63372767\",\n \"0.63059676\",\n \"0.6302789\",\n \"0.63025385\",\n \"0.62767154\",\n \"0.6255209\",\n \"0.6252756\",\n \"0.624524\",\n \"0.6229734\",\n \"0.6229734\",\n \"0.6229734\",\n \"0.6211873\",\n \"0.6206178\",\n \"0.62053674\",\n \"0.61952406\",\n \"0.61949193\",\n \"0.6177431\",\n \"0.6175724\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71113247"},"document_rank":{"kind":"string","value":"21"}}},{"rowIdx":13289,"cells":{"query":{"kind":"string","value":"This function is triggered when the user tries to close the window. I'm not sure it fully works."},"document":{"kind":"string","value":"def closeEvent(self, event):\n print \"Window closed\"\n event.ignore()\n print \"Hide window.\"\n self.subWindow.hide()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __window_close(self):\n pass","def ev_windowclose(self, event: WindowEvent) -> None:","def __onclosing(self):\n self.window.destroy()","def onCloseWindow(self, event):\r\n\r\n self.Destroy()","def ev_windowclose(self, event: tcod.event.WindowEvent) -> T | None:","def closeEvent(self, event):\n log.info(\"Received window close event.\")\n self.main.app_is_exiting()\n super().closeEvent(event)\n return","def window_close(self, item, e=None):\n\tif self.handler:\n self.handler.win_close(\"about\", None)\n\treturn 1","def OnClose(self, event):\r\n pos.app.main.Exit()","def exit(self):\n if self.window:\n self.window.close()","def close(self):\n self.state = False\n self.mainwindow.sendMessage('a')\n print(\"closing \" + self.name)","def close_window(self):\n # Window - END\n self.root.destroy()","def close(self):\n\n\t\tself._window.close()","def OnClose(self, event):\n\n if not self.plot_deleted:\n pub.sendMessage( 'Close.%s' %self.GetLabel(), event=self )\n\n print(\"Window: '%s', closed by event: '%s'\" %( self.GetLabel(), event.__class__.__name__ ))\n self.Destroy()","def OnExit(self, event):\r\n self.Close(True)","def force_close(self):\n\n\t\tself._window.force_close()","def _onExit(self, event):\n self.Close(True)","def _on_close(self):\n self.shell_obj.closed()","def OnCloseWindow(self, event):\r\n self.data.close()\r\n sizes[self.data.__class__.__name__] = self.GetSizeTuple()\r\n self.Destroy()","def onClose (self):\n \n pass","def _close_window(self):\n render_window = self._iren.GetRenderWindow()\n render_window.Finalize()\n self._iren.TerminateApp()\n\n del render_window, self._iren, self._ren, self._renWin","def OnClose(self, event):\n self._is_open = False\n wx.PostEvent(self, wxDockPaneClosedEvent())","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def OnExit(self, event):\n self.Close(True)","def onQuit(self, event):\n\n\t\tself.onClose(None)","def close(event):\n event.widget.destroy()","def onBtnCloseClicked(self):\n self.close()","def cb_close(self, *args):\n Gtk.main_quit()","def _close(self, event):\n self.EndModal(wx.ID_OK)","def on_close(self, event):\n # Save pos and size\n x, y = self.GetPosition()\n width, height = self.GetSize()\n self.__config.set('window.x', x)\n self.__config.set('window.y', y)\n self.__config.set('window.width', width)\n self.__config.set('window.height', height)\n\n # Style\n style = self.GetWindowStyle()\n self.__config.set('window.style', style)\n\n self.__config.save()\n\n # Stop monitoring\n self.__cor.stop_monitor()\n\n # Kill graph as it seems to be stopping script from ending\n self.__graph = None\n\n # End\n event.Skip()","def on_closing_event(self):\n self.exit_event(None)","def __window_stop(self):\n pass","def OnClose(self, event):\n\t\tself.Show(False)","def close_UI(self):","def handle_close(self):\n self.active = False\n self.close()","def closeEvent(self, event):\n event.accept() # let the window close\n self.returnHome()","def close_pop_up_windows(self):\n self.button_click(self.DECLINE_BUTTON)\n self.button_click(self.CLOSE_POPUP_BUTTON)","def close_window() -> None:\n global _window\n\n if _window is None:\n return\n\n _window.close()\n _window = None\n\n # Have to do a garbage collection or Python will crash\n # if we do a lot of window open and closes. Like for\n # unit tests.\n gc.collect()","def onClose(self, event):\n pass","def onClose(self, event):\n pass","def onClose(self, event):\n pass","def on_main_win_close(self):\n child_list = self.nb.winfo_children()\n for i in range(len(child_list)):\n index = self.nb.index('current')\n if self.get_current().edit_modified():\n ans = mb.askyesnocancel('Confirm on close', 'Do you want to save this file?')\n if ans:\n if self.save_file():\n self.tab_close(index, child_list)\n else:\n return\n elif ans is False:\n self.tab_close(index, child_list)\n else:\n return\n else:\n self.tab_close(index, child_list)\n self.main_window.destroy()","def OnClose(self, event = None):\n ##Close.\n self.Hide()\n self.Destroy()","def onClose(self, event): \n \n self.Destroy()\n return","def close(self):\n self.window.destroy()\n self.buttons_window.destroy()","def ev_windowhidden(self, event: WindowEvent) -> None:","def web_view_close(self):\n self.webWindow.close()\n return","def closeEvent(self,event):\r\n title = self.windowTitle()\r\n if title[-1] == \"*\":\r\n msg = 'Are you sure you want to close the Text Editor without Saving the file?'\r\n reply = QMessageBox.question(self, 'Window Close',msg,\r\n QMessageBox.Yes | QMessageBox.No, QMessageBox.No)\r\n if reply == QMessageBox.Yes:\r\n sys.exit()\r\n else:\r\n event.ignore()","def back(self, _event=None):\n self.on_closingWindow()","def window_close():\n response = messagebox.askokcancel(title=\"Exit?\",\n message=\"Are you sure you want to close the program?\")\n if response == True:\n root.destroy() # Closes the window\n # Else: The program continues as normal","def callback_close(self, event=None):\n\n if self.show_var.get():\n self.master.program_config[\"startup_window\"] = False\n util.data.write_config(self.master.program_config)\n\n self.destroy()","def __on_close(self):\n # Release the resource and\n # close the windows\n LOGGER.info(\"closing...\")\n self.__quit.set()\n self.__detect.end()\n self.root.quit()","def exit_btn_callback(evt):\n print(\"Inside exit_btn_callback. Event object is: \", evt)\n mainwin.destroy()","def OnClose(self, event):\n self.Show(False)","def onExitButtonClicked(self, widget):\n self.getGtkTopObject().close()","def close(self):\n\n self.driver.close_window(self.handle)","def received_CLOSING(self):\n\n\t\tself.player_frame.notify_rival_closing()\n\t\tself.player_frame.master.go_to_previous_screen(False)","def quit_window(self, value=None):\n exit()","def _delete_window(self):\n sys.exit(99)","def closeEvent(self, event):\n self.is_active = False\n app._in_event_loop = False\n super()","def _quit():\r\n\twin.quit()\r\n\twin.destroy()\r\n\tquit()","def _handle_popup_close(self):\n self._refresh()","def leave_page(self):\n self.window.destroy()","def close(self, *obj):\n self._save_size()\n self.clean_up()\n self.uistate.gwm.close_track(self.track)\n self.opened = False\n self.parent_window.present()","def closeEvent(self, event) -> None:\n global dialog\n dialog = None","def on_close(self):\n print('[INFO] closing...')\n self.stopEvent.set()\n del self.tello\n self.root.quit()","def OnFrameClose(self, event):\r\n\t\tself.Hide()","def quit(self):\n\n self.main_window.destroy()","def delete_window(self):\r\n self.mw.eval('::ttk::CancelRepeat')\r\n SlTrace.lg(\"Closing windows\")\r\n ''' \r\n ActiveCheck.clear_active() # Disable activities\r\n if self.score_win is not None:\r\n self.score_win.destroy()\r\n self.score_win = None\r\n if self.mw is not None and self.mw.winfo_exists():\r\n self.mw.quit()\r\n self.mw.destroy()\r\n self.mw = None\r\n '''\r\n if self.on_exit is not None:\r\n self.on_exit()\r\n \r\n sys.exit() # Else quit\r","def close(self):\n print(\"CAUGHT CLOSE SIGNAL\")\n self.root.destroy()","def Quit(self, event):\n pass","def quit(self):\n self.window.quit()\n self.window.destroy()","def callback_destroy( self ):\r\n self.winRunning = False\r\n self.rootWin.destroy()\r\n exit()","def closeEvent(self, event):\n\n ## Check if exposure in progress\n if self.thread.isRunning():\n QtGui.QMessageBox.warning(self, \"Warning.\", \"Exposure in progress, unable to close program.\", QtGui.QMessageBox.Ok)\n event.ignore()\n\n ## Confirmation dialog for \n else:\n\n reply = QtGui.QMessageBox.question(self, 'Confirmation','Are you sure you want to shutdown the STA3800 controller?',\n QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,\n QtGui.QMessageBox.No)\n\n if reply == QtGui.QMessageBox.Yes: \n try:\n self.settings.setValue(\"DATA_DIRECTORY\", DATA_DIRECTORY)\n restore.guisave(self, self.settings)\n except:\n self.logger.warning(\"Failed to save settings to INI file.\")\n event.accept()\n else:\n event.ignore()","def outCloseEvent(self):\r\n pass","def handle_quit( self ):\n print \"bye!\"\n\n # really close the window\n return True","def closeEvent(self, event):\r\n self.isWinOpen=False\r\n time.sleep(0.1)\r\n event.accept()","def closeEvent(self, event):\n aqt.mw.reset()\n super().closeEvent(event)","def ev_windowfocuslost(self, event: WindowEvent) -> None:","def filemenu_Close(self):\n\n self.on_closing()","def closeEvent(self, event):\n self.is_active = False\n app._in_event_loop = False\n # It seems that interactor closes slower than the windows preventing from properly closing the interface.\n # The work-around is to wait a little bit\n time.sleep(0.1)\n super()","def on_closingWindow(self):\n if messagebox.askokcancel(\"Quit\",\n \"Do you want to quit grading the assignment?\\n File will be saved\",\n parent=window):\n self.submitAssignment()","def ev_windowleave(self, event: WindowEvent) -> None:","def close(self):\r\n t1 = time.time()\r\n self.driver.close()\r\n self.my_print(\"{0} Closed current window, Spend {1} seconds\".format(success, time.time() - t1))","def close_window() -> bool:\n global WINDOW\n global IMPL\n global ACTIVE_CALLBACK\n try:\n cast(PygletRenderer, IMPL).shutdown()\n cast(pyglet.window.Window, WINDOW).close()\n\n WINDOW = None\n IMPL = None\n ACTIVE_CALLBACK = update\n return True\n except Exception as e:\n unrealsdk.Log(e)\n return False","def closeEvent(self, event):\n\n sys.exit()","def closeEvent(self, event):\n sys.exit(0)","def on_close(self, handler):\n if handler:\n raise AttributeError(\n \"Cannot set on_close handler for the main window. Use the app on_exit handler instead\"\n )","def closeEvent(self, event):\n\n\t\tevent.ignore()\n\t\tself.hide()\n\t\tself.__sys_tray_icon.show()","def menu_quit (self,widget,data):\n\t\tself.window.delete_event()","def closeWindow(self):\n cmdId = self.executeCommand(Command.CLOSE)\n return cmdId","def closeEvent(self, event):\n self._parent.quit_application(event)","def exit_event(self, event):\n self.root.quit()","def closeEvent(self,event):\n\n try:\n if self.globalSession.running:\n event.ignore()\n return\n except:\n pass\n\n\n quit_msg = \"Are you sure you want to exit the program?\"\n reply = QtGui.QMessageBox.question(self, 'Message', \n quit_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)\n\n if reply == QtGui.QMessageBox.Yes:\n \n self.scanner.stopProcesses()\n self.globalSession.stopProgram = True\n\n try:\n self.globalSession.currentCapture.saveSession()\n self.statusTimer.stop()\n except AttributeError:\n pass # Gets thrown if no captures have been started when closing the program\n\n event.accept()\n else:\n event.ignore()","def if_quit(self):\n answer = helper.quit_popup()\n if answer:\n self.parent.destroy()","def onClose(self, *args):\n rospy.loginfo('Closing Cloud Map')\n self.root.quit()\n self.root.destroy()\n # rospy.signal_shutdown('Exited UI')","def closeEvent(self, event):\n logger.info('see here, we can just quit application')\n QtCore.QCoreApplication.quit()","def closeEvent(self, event):\n self.stop()\n QtGui.QWidget.closeEvent(self, event)","def OnClose(self):\n self.SaveData()\n self.destroy()"],"string":"[\n \"def __window_close(self):\\n pass\",\n \"def ev_windowclose(self, event: WindowEvent) -> None:\",\n \"def __onclosing(self):\\n self.window.destroy()\",\n \"def onCloseWindow(self, event):\\r\\n\\r\\n self.Destroy()\",\n \"def ev_windowclose(self, event: tcod.event.WindowEvent) -> T | None:\",\n \"def closeEvent(self, event):\\n log.info(\\\"Received window close event.\\\")\\n self.main.app_is_exiting()\\n super().closeEvent(event)\\n return\",\n \"def window_close(self, item, e=None):\\n\\tif self.handler:\\n self.handler.win_close(\\\"about\\\", None)\\n\\treturn 1\",\n \"def OnClose(self, event):\\r\\n pos.app.main.Exit()\",\n \"def exit(self):\\n if self.window:\\n self.window.close()\",\n \"def close(self):\\n self.state = False\\n self.mainwindow.sendMessage('a')\\n print(\\\"closing \\\" + self.name)\",\n \"def close_window(self):\\n # Window - END\\n self.root.destroy()\",\n \"def close(self):\\n\\n\\t\\tself._window.close()\",\n \"def OnClose(self, event):\\n\\n if not self.plot_deleted:\\n pub.sendMessage( 'Close.%s' %self.GetLabel(), event=self )\\n\\n print(\\\"Window: '%s', closed by event: '%s'\\\" %( self.GetLabel(), event.__class__.__name__ ))\\n self.Destroy()\",\n \"def OnExit(self, event):\\r\\n self.Close(True)\",\n \"def force_close(self):\\n\\n\\t\\tself._window.force_close()\",\n \"def _onExit(self, event):\\n self.Close(True)\",\n \"def _on_close(self):\\n self.shell_obj.closed()\",\n \"def OnCloseWindow(self, event):\\r\\n self.data.close()\\r\\n sizes[self.data.__class__.__name__] = self.GetSizeTuple()\\r\\n self.Destroy()\",\n \"def onClose (self):\\n \\n pass\",\n \"def _close_window(self):\\n render_window = self._iren.GetRenderWindow()\\n render_window.Finalize()\\n self._iren.TerminateApp()\\n\\n del render_window, self._iren, self._ren, self._renWin\",\n \"def OnClose(self, event):\\n self._is_open = False\\n wx.PostEvent(self, wxDockPaneClosedEvent())\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def OnExit(self, event):\\n self.Close(True)\",\n \"def onQuit(self, event):\\n\\n\\t\\tself.onClose(None)\",\n \"def close(event):\\n event.widget.destroy()\",\n \"def onBtnCloseClicked(self):\\n self.close()\",\n \"def cb_close(self, *args):\\n Gtk.main_quit()\",\n \"def _close(self, event):\\n self.EndModal(wx.ID_OK)\",\n \"def on_close(self, event):\\n # Save pos and size\\n x, y = self.GetPosition()\\n width, height = self.GetSize()\\n self.__config.set('window.x', x)\\n self.__config.set('window.y', y)\\n self.__config.set('window.width', width)\\n self.__config.set('window.height', height)\\n\\n # Style\\n style = self.GetWindowStyle()\\n self.__config.set('window.style', style)\\n\\n self.__config.save()\\n\\n # Stop monitoring\\n self.__cor.stop_monitor()\\n\\n # Kill graph as it seems to be stopping script from ending\\n self.__graph = None\\n\\n # End\\n event.Skip()\",\n \"def on_closing_event(self):\\n self.exit_event(None)\",\n \"def __window_stop(self):\\n pass\",\n \"def OnClose(self, event):\\n\\t\\tself.Show(False)\",\n \"def close_UI(self):\",\n \"def handle_close(self):\\n self.active = False\\n self.close()\",\n \"def closeEvent(self, event):\\n event.accept() # let the window close\\n self.returnHome()\",\n \"def close_pop_up_windows(self):\\n self.button_click(self.DECLINE_BUTTON)\\n self.button_click(self.CLOSE_POPUP_BUTTON)\",\n \"def close_window() -> None:\\n global _window\\n\\n if _window is None:\\n return\\n\\n _window.close()\\n _window = None\\n\\n # Have to do a garbage collection or Python will crash\\n # if we do a lot of window open and closes. Like for\\n # unit tests.\\n gc.collect()\",\n \"def onClose(self, event):\\n pass\",\n \"def onClose(self, event):\\n pass\",\n \"def onClose(self, event):\\n pass\",\n \"def on_main_win_close(self):\\n child_list = self.nb.winfo_children()\\n for i in range(len(child_list)):\\n index = self.nb.index('current')\\n if self.get_current().edit_modified():\\n ans = mb.askyesnocancel('Confirm on close', 'Do you want to save this file?')\\n if ans:\\n if self.save_file():\\n self.tab_close(index, child_list)\\n else:\\n return\\n elif ans is False:\\n self.tab_close(index, child_list)\\n else:\\n return\\n else:\\n self.tab_close(index, child_list)\\n self.main_window.destroy()\",\n \"def OnClose(self, event = None):\\n ##Close.\\n self.Hide()\\n self.Destroy()\",\n \"def onClose(self, event): \\n \\n self.Destroy()\\n return\",\n \"def close(self):\\n self.window.destroy()\\n self.buttons_window.destroy()\",\n \"def ev_windowhidden(self, event: WindowEvent) -> None:\",\n \"def web_view_close(self):\\n self.webWindow.close()\\n return\",\n \"def closeEvent(self,event):\\r\\n title = self.windowTitle()\\r\\n if title[-1] == \\\"*\\\":\\r\\n msg = 'Are you sure you want to close the Text Editor without Saving the file?'\\r\\n reply = QMessageBox.question(self, 'Window Close',msg,\\r\\n QMessageBox.Yes | QMessageBox.No, QMessageBox.No)\\r\\n if reply == QMessageBox.Yes:\\r\\n sys.exit()\\r\\n else:\\r\\n event.ignore()\",\n \"def back(self, _event=None):\\n self.on_closingWindow()\",\n \"def window_close():\\n response = messagebox.askokcancel(title=\\\"Exit?\\\",\\n message=\\\"Are you sure you want to close the program?\\\")\\n if response == True:\\n root.destroy() # Closes the window\\n # Else: The program continues as normal\",\n \"def callback_close(self, event=None):\\n\\n if self.show_var.get():\\n self.master.program_config[\\\"startup_window\\\"] = False\\n util.data.write_config(self.master.program_config)\\n\\n self.destroy()\",\n \"def __on_close(self):\\n # Release the resource and\\n # close the windows\\n LOGGER.info(\\\"closing...\\\")\\n self.__quit.set()\\n self.__detect.end()\\n self.root.quit()\",\n \"def exit_btn_callback(evt):\\n print(\\\"Inside exit_btn_callback. Event object is: \\\", evt)\\n mainwin.destroy()\",\n \"def OnClose(self, event):\\n self.Show(False)\",\n \"def onExitButtonClicked(self, widget):\\n self.getGtkTopObject().close()\",\n \"def close(self):\\n\\n self.driver.close_window(self.handle)\",\n \"def received_CLOSING(self):\\n\\n\\t\\tself.player_frame.notify_rival_closing()\\n\\t\\tself.player_frame.master.go_to_previous_screen(False)\",\n \"def quit_window(self, value=None):\\n exit()\",\n \"def _delete_window(self):\\n sys.exit(99)\",\n \"def closeEvent(self, event):\\n self.is_active = False\\n app._in_event_loop = False\\n super()\",\n \"def _quit():\\r\\n\\twin.quit()\\r\\n\\twin.destroy()\\r\\n\\tquit()\",\n \"def _handle_popup_close(self):\\n self._refresh()\",\n \"def leave_page(self):\\n self.window.destroy()\",\n \"def close(self, *obj):\\n self._save_size()\\n self.clean_up()\\n self.uistate.gwm.close_track(self.track)\\n self.opened = False\\n self.parent_window.present()\",\n \"def closeEvent(self, event) -> None:\\n global dialog\\n dialog = None\",\n \"def on_close(self):\\n print('[INFO] closing...')\\n self.stopEvent.set()\\n del self.tello\\n self.root.quit()\",\n \"def OnFrameClose(self, event):\\r\\n\\t\\tself.Hide()\",\n \"def quit(self):\\n\\n self.main_window.destroy()\",\n \"def delete_window(self):\\r\\n self.mw.eval('::ttk::CancelRepeat')\\r\\n SlTrace.lg(\\\"Closing windows\\\")\\r\\n ''' \\r\\n ActiveCheck.clear_active() # Disable activities\\r\\n if self.score_win is not None:\\r\\n self.score_win.destroy()\\r\\n self.score_win = None\\r\\n if self.mw is not None and self.mw.winfo_exists():\\r\\n self.mw.quit()\\r\\n self.mw.destroy()\\r\\n self.mw = None\\r\\n '''\\r\\n if self.on_exit is not None:\\r\\n self.on_exit()\\r\\n \\r\\n sys.exit() # Else quit\\r\",\n \"def close(self):\\n print(\\\"CAUGHT CLOSE SIGNAL\\\")\\n self.root.destroy()\",\n \"def Quit(self, event):\\n pass\",\n \"def quit(self):\\n self.window.quit()\\n self.window.destroy()\",\n \"def callback_destroy( self ):\\r\\n self.winRunning = False\\r\\n self.rootWin.destroy()\\r\\n exit()\",\n \"def closeEvent(self, event):\\n\\n ## Check if exposure in progress\\n if self.thread.isRunning():\\n QtGui.QMessageBox.warning(self, \\\"Warning.\\\", \\\"Exposure in progress, unable to close program.\\\", QtGui.QMessageBox.Ok)\\n event.ignore()\\n\\n ## Confirmation dialog for \\n else:\\n\\n reply = QtGui.QMessageBox.question(self, 'Confirmation','Are you sure you want to shutdown the STA3800 controller?',\\n QtGui.QMessageBox.Yes | QtGui.QMessageBox.No,\\n QtGui.QMessageBox.No)\\n\\n if reply == QtGui.QMessageBox.Yes: \\n try:\\n self.settings.setValue(\\\"DATA_DIRECTORY\\\", DATA_DIRECTORY)\\n restore.guisave(self, self.settings)\\n except:\\n self.logger.warning(\\\"Failed to save settings to INI file.\\\")\\n event.accept()\\n else:\\n event.ignore()\",\n \"def outCloseEvent(self):\\r\\n pass\",\n \"def handle_quit( self ):\\n print \\\"bye!\\\"\\n\\n # really close the window\\n return True\",\n \"def closeEvent(self, event):\\r\\n self.isWinOpen=False\\r\\n time.sleep(0.1)\\r\\n event.accept()\",\n \"def closeEvent(self, event):\\n aqt.mw.reset()\\n super().closeEvent(event)\",\n \"def ev_windowfocuslost(self, event: WindowEvent) -> None:\",\n \"def filemenu_Close(self):\\n\\n self.on_closing()\",\n \"def closeEvent(self, event):\\n self.is_active = False\\n app._in_event_loop = False\\n # It seems that interactor closes slower than the windows preventing from properly closing the interface.\\n # The work-around is to wait a little bit\\n time.sleep(0.1)\\n super()\",\n \"def on_closingWindow(self):\\n if messagebox.askokcancel(\\\"Quit\\\",\\n \\\"Do you want to quit grading the assignment?\\\\n File will be saved\\\",\\n parent=window):\\n self.submitAssignment()\",\n \"def ev_windowleave(self, event: WindowEvent) -> None:\",\n \"def close(self):\\r\\n t1 = time.time()\\r\\n self.driver.close()\\r\\n self.my_print(\\\"{0} Closed current window, Spend {1} seconds\\\".format(success, time.time() - t1))\",\n \"def close_window() -> bool:\\n global WINDOW\\n global IMPL\\n global ACTIVE_CALLBACK\\n try:\\n cast(PygletRenderer, IMPL).shutdown()\\n cast(pyglet.window.Window, WINDOW).close()\\n\\n WINDOW = None\\n IMPL = None\\n ACTIVE_CALLBACK = update\\n return True\\n except Exception as e:\\n unrealsdk.Log(e)\\n return False\",\n \"def closeEvent(self, event):\\n\\n sys.exit()\",\n \"def closeEvent(self, event):\\n sys.exit(0)\",\n \"def on_close(self, handler):\\n if handler:\\n raise AttributeError(\\n \\\"Cannot set on_close handler for the main window. Use the app on_exit handler instead\\\"\\n )\",\n \"def closeEvent(self, event):\\n\\n\\t\\tevent.ignore()\\n\\t\\tself.hide()\\n\\t\\tself.__sys_tray_icon.show()\",\n \"def menu_quit (self,widget,data):\\n\\t\\tself.window.delete_event()\",\n \"def closeWindow(self):\\n cmdId = self.executeCommand(Command.CLOSE)\\n return cmdId\",\n \"def closeEvent(self, event):\\n self._parent.quit_application(event)\",\n \"def exit_event(self, event):\\n self.root.quit()\",\n \"def closeEvent(self,event):\\n\\n try:\\n if self.globalSession.running:\\n event.ignore()\\n return\\n except:\\n pass\\n\\n\\n quit_msg = \\\"Are you sure you want to exit the program?\\\"\\n reply = QtGui.QMessageBox.question(self, 'Message', \\n quit_msg, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)\\n\\n if reply == QtGui.QMessageBox.Yes:\\n \\n self.scanner.stopProcesses()\\n self.globalSession.stopProgram = True\\n\\n try:\\n self.globalSession.currentCapture.saveSession()\\n self.statusTimer.stop()\\n except AttributeError:\\n pass # Gets thrown if no captures have been started when closing the program\\n\\n event.accept()\\n else:\\n event.ignore()\",\n \"def if_quit(self):\\n answer = helper.quit_popup()\\n if answer:\\n self.parent.destroy()\",\n \"def onClose(self, *args):\\n rospy.loginfo('Closing Cloud Map')\\n self.root.quit()\\n self.root.destroy()\\n # rospy.signal_shutdown('Exited UI')\",\n \"def closeEvent(self, event):\\n logger.info('see here, we can just quit application')\\n QtCore.QCoreApplication.quit()\",\n \"def closeEvent(self, event):\\n self.stop()\\n QtGui.QWidget.closeEvent(self, event)\",\n \"def OnClose(self):\\n self.SaveData()\\n self.destroy()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.88118833","0.8732062","0.83870757","0.8189104","0.8009371","0.80067825","0.7978525","0.7954626","0.7857697","0.77236134","0.772265","0.7715848","0.76946735","0.76637465","0.7650199","0.7618164","0.75708306","0.7559188","0.75585526","0.7537625","0.7533761","0.7532475","0.7532475","0.7532475","0.7532475","0.75247526","0.75217277","0.75215036","0.74885213","0.7437582","0.74272865","0.74079907","0.7396764","0.73813426","0.7370314","0.7359642","0.7359097","0.73540264","0.7332883","0.73261803","0.73261803","0.73261803","0.7322648","0.7319799","0.73077583","0.7303958","0.7297922","0.72945225","0.7269744","0.7256072","0.72456914","0.7245448","0.72453517","0.7219646","0.71969324","0.71599203","0.71538436","0.7151506","0.7140376","0.7129983","0.71243334","0.7098666","0.7098534","0.70946366","0.7086384","0.7085103","0.70763016","0.7072325","0.7067559","0.7065715","0.7062907","0.7058375","0.7058238","0.7047684","0.704472","0.70401263","0.7038752","0.7037742","0.7037583","0.70327973","0.7017602","0.7017555","0.70112807","0.70112646","0.70065635","0.69973296","0.69822484","0.6976354","0.69762075","0.69745183","0.6970521","0.696519","0.6963612","0.694705","0.69283473","0.692342","0.69198895","0.6907155","0.6905311","0.6900499"],"string":"[\n \"0.88118833\",\n \"0.8732062\",\n \"0.83870757\",\n \"0.8189104\",\n \"0.8009371\",\n \"0.80067825\",\n \"0.7978525\",\n \"0.7954626\",\n \"0.7857697\",\n \"0.77236134\",\n \"0.772265\",\n \"0.7715848\",\n \"0.76946735\",\n \"0.76637465\",\n \"0.7650199\",\n \"0.7618164\",\n \"0.75708306\",\n \"0.7559188\",\n \"0.75585526\",\n \"0.7537625\",\n \"0.7533761\",\n \"0.7532475\",\n \"0.7532475\",\n \"0.7532475\",\n \"0.7532475\",\n \"0.75247526\",\n \"0.75217277\",\n \"0.75215036\",\n \"0.74885213\",\n \"0.7437582\",\n \"0.74272865\",\n \"0.74079907\",\n \"0.7396764\",\n \"0.73813426\",\n \"0.7370314\",\n \"0.7359642\",\n \"0.7359097\",\n \"0.73540264\",\n \"0.7332883\",\n \"0.73261803\",\n \"0.73261803\",\n \"0.73261803\",\n \"0.7322648\",\n \"0.7319799\",\n \"0.73077583\",\n \"0.7303958\",\n \"0.7297922\",\n \"0.72945225\",\n \"0.7269744\",\n \"0.7256072\",\n \"0.72456914\",\n \"0.7245448\",\n \"0.72453517\",\n \"0.7219646\",\n \"0.71969324\",\n \"0.71599203\",\n \"0.71538436\",\n \"0.7151506\",\n \"0.7140376\",\n \"0.7129983\",\n \"0.71243334\",\n \"0.7098666\",\n \"0.7098534\",\n \"0.70946366\",\n \"0.7086384\",\n \"0.7085103\",\n \"0.70763016\",\n \"0.7072325\",\n \"0.7067559\",\n \"0.7065715\",\n \"0.7062907\",\n \"0.7058375\",\n \"0.7058238\",\n \"0.7047684\",\n \"0.704472\",\n \"0.70401263\",\n \"0.7038752\",\n \"0.7037742\",\n \"0.7037583\",\n \"0.70327973\",\n \"0.7017602\",\n \"0.7017555\",\n \"0.70112807\",\n \"0.70112646\",\n \"0.70065635\",\n \"0.69973296\",\n \"0.69822484\",\n \"0.6976354\",\n \"0.69762075\",\n \"0.69745183\",\n \"0.6970521\",\n \"0.696519\",\n \"0.6963612\",\n \"0.694705\",\n \"0.69283473\",\n \"0.692342\",\n \"0.69198895\",\n \"0.6907155\",\n \"0.6905311\",\n \"0.6900499\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7644354"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":13290,"cells":{"query":{"kind":"string","value":"This class stores the sub UIs involved in creating experiments, it also provides the basic control and framework for the revealing and hiding the correct UIs."},"document":{"kind":"string","value":"def __init__(self,subWindow,currentExperiment):\n super(AmoebaCreateExperiment,self).__init__()\n self.stage = 0\n self.currentExperiment = currentExperiment\n #self.XMLWriter = ExperimentXMLWriter()\n self.XMLWriter = Amoeba_experiment()\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Create new experiment.\"\n\n self.subWindow = subWindow\n\n #Create a scroll bar for the summary area\n self.layout = QVBoxLayout()\n\n #Create the widgets\n self.SetFundamentalParameters = AmoebaSetFundamentalParameters()\n self.ShowAllInstruments = AmoebaShowAllInstuments()\n self.LinkInstruments = LinkInstrumentsForm()\n\n self.next = QPushButton(\"Next\")\n self.next.clicked.connect(self.next_pressed)\n\n #Add to the scroll widget\n self.layout.addWidget(self.SetFundamentalParameters)\n self.layout.addWidget(self.ShowAllInstruments)\n self.layout.addWidget(self.LinkInstruments)\n self.layout.addWidget(self.next)\n\n #Add the Widgets to the Subwindow\n self.setLayout(self.layout)\n\n #Hide all the widgets that will later be revealed.\n self.SetFundamentalParameters.hide()\n self.LinkInstruments.hide()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_ui(self, parent):\n view = View(\n Item(name=\"text\",\n show_label=False,\n editor=ImageTraitEditor(\n image=ImageResource(self.obj.name,\n search_path=[self.obj.parent.absolute_path]) )),\n id=\"puddle.image_editor.image_editor\",\n kind=\"live\", resizable=True)\n\n ui = self.edit_traits(view=view, parent=parent, kind=\"subpanel\")\n\n return ui","def createUserInterface(self):\n\n\t\tself.__layout = self.__parent.createUserInterface()\n\n\t\tstep_label = qt.QLabel( 'Choose the volume you would like to threshold. If you are calculating a subtraction map, check the \\\"Calculate Subtraction Map\\\" box and select a post-contrast image.' )\n\t\tstep_label.setWordWrap(True)\n\t\tself.__primaryGroupBox = qt.QGroupBox()\n\t\tself.__primaryGroupBox.setTitle('Information')\n\t\tself.__primaryGroupBoxLayout = qt.QFormLayout(self.__primaryGroupBox)\n\n\t\tself.__subtractionMappingGroupBox = qt.QGroupBox()\n\t\tself.__subtractionMappingGroupBox.setTitle('Volume Selection')\n\t\tself.__subtractionMappingGroupBoxLayout = qt.QFormLayout(self.__subtractionMappingGroupBox)\n\n\t\tbaselineScanLabel = qt.QLabel( 'Primary / Pre-Contrast Image:' )\n\t\tself.__baselineVolumeSelector = slicer.qMRMLNodeComboBox()\n\t\tself.__baselineVolumeSelector.toolTip = \"Select the volume you wish to threshold. If you are calculating a subtraction map, this will be the pre-contrast scan.\"\n\t\tself.__baselineVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']\n\t\tself.__baselineVolumeSelector.setMRMLScene(slicer.mrmlScene)\n\t\tself.__baselineVolumeSelector.addEnabled = 0\n\n\t\tsubtractionMappingLabel = qt.QLabel( 'Calculate Subtraction Map:' )\n\t\tself.__enableSubtractionMapping = qt.QCheckBox()\n\t\tself.__enableSubtractionMapping.checked = False\n\t\tself.__enableSubtractionMapping.setToolTip(\"Check if you would like to calculate a subtraction map\")\n\t\tself.__enableSubtractionMapping.connect('clicked()', self.setSubtractionMapping)\n\n\t\tfollowupScanLabel = qt.QLabel( 'Post-Contrast Image:' )\n\t\tself.__followupVolumeSelector = slicer.qMRMLNodeComboBox()\n\t\tself.__followupVolumeSelector.toolTip = \"Choose the post-contrast scan\"\n\t\tself.__followupVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']\n\t\tself.__followupVolumeSelector.setMRMLScene(slicer.mrmlScene)\n\t\tself.__followupVolumeSelector.addEnabled = 0\n\t\tself.__followupVolumeSelector.enabled = 0\n\n\t\tself.__layout.addRow(self.__primaryGroupBox)\n\t\tself.__primaryGroupBoxLayout.addRow( step_label )\n\t\tself.__subtractionMappingGroupBoxLayout.addRow( baselineScanLabel, self.__baselineVolumeSelector )\n\n\t\tself.__layout.addRow(self.__subtractionMappingGroupBox)\n\t\tself.__subtractionMappingGroupBoxLayout.addRow( subtractionMappingLabel, self.__enableSubtractionMapping )\n\t\tself.__subtractionMappingGroupBoxLayout.addRow( followupScanLabel, self.__followupVolumeSelector )\n\n\t\tself.updateWidgetFromParameters(self.parameterNode())\n\n\t\t# This timer is a trick to wait for buttons to load BEFORE deleting them.\n\t\tqt.QTimer.singleShot(0, self.killButton)","def ui(self):\n return ui","def additional_ui(self):\n return _UI_DEF","def init_ui(self):\n raise NotImplementedError","def init_ui(self):\n raise NotImplementedError","def build_UI(self):\n\n #Common local coordinates to change the UI positions\n common_x = 0\n common_y = 5\n\n #Create the Main Title\n self.titleFont = font.Font(family = FONTS[\"lucida grande\"], size = 30)\n self.title = cGUIf.get_TextLabel(self,\n \"File Converter App \",\n self.titleFont,\n 135 + common_x,\n 40 + common_y)\n\n #Add the \"Main Icon\"\n self.mainIcon = cGUIf.get_ImgLabel(self,\n self.__pics[\"main_icon\"],\n 280 + common_x,\n 125 + common_y)\n\n\n #Create a subtitle that says \"options\"\n self.subtitleFont = font.Font(family = FONTS[\"courier new\"], size = 22)\n self.subtitle = cGUIf.get_TextLabel(self,\n \"Options\",\n self.subtitleFont,\n 240 + common_x,\n 195 + common_y)\n\n #Create a label that says \"Image Conversion\"\n self.conversionFont = font.Font(family = FONTS[\"times new roman\"], size = 15)\n self.imageConversionLabel = cGUIf.get_TextLabel(self,\n \" Image\\n Conversion\",\n self.conversionFont,\n 60 + common_x,\n 285 + common_y)\n\n #Create a button for Image Conversion\n self.imageButton = cGUIf.get_Button(self,\n \"\",\n lambda : self.switch_frames(\"image_frame\"),\n 190 + common_x,\n 270 + common_y)\n self.imageButton.configure(image = self.__pics[\"image_icon\"])\n\n #Create a label that says \"Audio Conversion\"\n self.audioConversionLabel = cGUIf.get_TextLabel(self,\n \" Audio\\n Conversion\",\n self.conversionFont,\n 440 + common_x,\n 285 + common_y)\n\n #Create a button for Audio Conversion\n self.audioButton = cGUIf.get_Button(self,\n \"\",\n lambda : self.switch_frames(\"audio_frame\"),\n 340 + common_x,\n 270 + common_y)\n self.audioButton.configure(image = self.__pics[\"audio_icon\"])\n\n #Create a label that says \"Doc Conversion\"\n self.docConversionLabel = cGUIf.get_TextLabel(self,\n \" Doc\\n Conversion\",\n self.conversionFont,\n 60 + common_x,\n 410 + common_y)\n\n\n #Create a button for Doc Conversion\n self.docButton = cGUIf.get_Button(self,\n \"\",\n lambda : self.switch_frames(\"doc_frame\"),\n 190 + common_x,\n 400 + common_y)\n self.docButton.configure(image = self.__pics[\"doc_icon\"])\n\n\n #Create a label that says \"Video Conversion\"\n self.videoConversionLabel = cGUIf.get_TextLabel(self,\n \" Video\\n Conversion\",\n self.conversionFont,\n 440 + common_x,\n 410 + common_y)\n\n #Create a button for Video Conversion\n self.videoButton = cGUIf.get_Button(self,\n \"\",\n lambda : self.switch_frames(\"video_frame\"),\n 340 + common_x,\n 400 + common_y)\n self.videoButton.configure(image = self.__pics[\"video_icon\"])","def extend_ui(self):\n for name, tab in self.build_general_tabs().items():\n scroll = self.build_tab()\n self.add_tab(\"General\", name, scroll)\n self.fill_tab(\"General\", name, tab)\n for name, tab in self.build_display_tabs().items():\n scroll = self.build_tab()\n self.add_tab(\"Display\", name, scroll)\n self.fill_tab(\"Display\", name, tab)\n for name, tab in self.build_data_tabs().items():\n scroll = self.build_tab()\n self.add_tab(\"Data\", name, scroll)\n self.fill_tab(\"Data\", name, tab)","def init_ui(self):\n raise NotImplementedError(\"This is an abstract method.\")","def setup_additional_ui(self):\n\n #set title\n self.setWindowTitle(self.title)\n\n #set question\n self.lbl_question.setText(self.question)\n\n #set_remember_choice\n self.set_remember_choice(self.chkbx_remember_choice.isChecked())","def prepare_UI(self):","def __setup_ui_controls(self, list_of_names):\n\n ##################################################\n self.scene.append_to_caption('<h3>Scene Settings</h3>\\n')\n # Button to reset camera\n reset_button = button(\n bind=self.__reset_camera, text=\"Reset Camera\")\n self.__ui_controls.btn_reset = reset_button\n self.scene.append_to_caption('\\t')\n\n screenshot_button = button(bind=self.__screenshot, text=\"Take Screenshot\")\n self.__ui_controls.btn_ss = screenshot_button\n self.scene.append_to_caption('\\n')\n\n camera_lock_checkbox = checkbox(bind=self.__camera_lock_checkbox, text=\"Camera Lock\",\n checked=self.__camera_lock)\n self.__ui_controls.chkbox_cam = camera_lock_checkbox\n self.scene.append_to_caption('\\t')\n\n grid_relative_checkbox = checkbox(\n bind=self.__grid_relative_checkbox,\n text=\"Grid Relative\", checked=self.__grid_relative)\n self.__ui_controls.chkbox_rel = grid_relative_checkbox\n\n self.scene.append_to_caption('\\t')\n # Checkbox for grid visibility\n checkbox_grid_visibility = checkbox(\n bind=self.__grid_visibility_checkbox, text=\"Grid Visibility\",\n checked=self.__grid_visibility)\n self.__ui_controls.chkbox_grid = checkbox_grid_visibility\n self.scene.append_to_caption('\\n')\n\n ##################################################\n self.scene.append_to_caption('<h3>Robot</h3>\\n')\n # Drop down for robots / joints in frame\n menu_robots_list = menu(bind=self.__menu_item_chosen, choices=list_of_names)\n if not len(list_of_names) == 0:\n menu_robots_list.index = self.__selected_robot\n self.__ui_controls.menu_robots = menu_robots_list\n self.scene.append_to_caption('\\t')\n\n # Button to delete the selected robot\n delete_button = button(bind=self.__del_robot, text=\"Delete Robot\")\n self.__ui_controls.btn_del = delete_button\n self.scene.append_to_caption('\\t')\n\n # Button to clear the robots in screen\n clear_button = button(bind=self.clear_scene, text=\"Clear Scene\")\n self.__ui_controls.btn_clr = clear_button\n self.scene.append_to_caption('\\n')\n\n ##################################################\n self.scene.append_to_caption('<h3>Characteristics</h3>\\n')\n # Checkbox for reference frame visibilities\n if len(self.__robots) == 0:\n reference_checkbox = checkbox(\n bind=self.__reference_frame_checkbox,\n text=\"Show Reference Frames\", checked=True)\n else:\n chk = self.__robots[self.__selected_robot].ref_shown\n reference_checkbox = checkbox(\n bind=self.__reference_frame_checkbox,\n text=\"Show Reference Frames\", checked=chk)\n self.__ui_controls.chkbox_ref = reference_checkbox\n self.scene.append_to_caption('\\t')\n\n # Checkbox for robot visibility\n if len(self.__robots) == 0:\n robot_vis_checkbox = checkbox(\n bind=self.__robot_visibility_checkbox,\n text=\"Show Robot\", checked=True)\n else:\n chk = self.__robots[self.__selected_robot].rob_shown\n robot_vis_checkbox = checkbox(\n bind=self.__robot_visibility_checkbox,\n text=\"Show Robot\", checked=chk)\n self.__ui_controls.chkbox_rob = robot_vis_checkbox\n self.scene.append_to_caption('\\n')\n\n # Slider for robot opacity\n self.scene.append_to_caption('Robot Opacity:')\n if len(self.__robots) == 0:\n opacity_slider = slider(bind=self.__opacity_slider, value=1)\n else:\n opc = self.__robots[self.__selected_robot].opacity\n opacity_slider = slider(bind=self.__opacity_slider, value=opc)\n self.__ui_controls.sld_opc = opacity_slider\n self.scene.append_to_caption('\\n')\n\n ##################################################\n # Control manual\n controls_str = '<h3>Controls</h3><br>' \\\n '<b>PAN</b><br>' \\\n 'W , S | <i>forward / backward</i><br>' \\\n 'A , D | <i>left / right</i><br>' \\\n 'SPACE , SHIFT | <i>up / down</i><br>' \\\n '<b>ROTATE</b><br>' \\\n 'CTRL + LMB | <i>free spin</i><br>' \\\n 'ARROWS KEYS | <i>rotate direction</i><br>' \\\n 'Q , E | <i>roll left / right</i><br>' \\\n '<b>ZOOM</b></br>' \\\n 'MOUSEWHEEL | <i>zoom in / out</i>'\n\n self.scene.append_to_caption(controls_str)","def controls_setup(self):\n\n self.drain_types = container.AdminDashboardSubmodule(\n self, alias=\"Drain Types Submodule\",\n css_selector='tr.CodeDrainType')\n self.depot_types = container.AdminDashboardSubmodule(\n self, alias=\"Depot Types Submodule\",\n css_selector='tr.CodeJobType')\n self.file_types = container.AdminDashboardSubmodule(\n self, alias=\"File Types Submodule\",\n css_selector='tr.CodeFileType')\n self.job_types = container.AdminDashboardSubmodule(\n self, alias=\"Job Types Submodule\",\n css_selector='tr.CodeJobType')\n self.paving_colours = container.AdminDashboardSubmodule(\n self, alias=\"Paving Colours Submodule\",\n css_selector='tr.CodePavingColour')\n self.paving_types = container.AdminDashboardSubmodule(\n self, alias=\"Paving Types Submodule\",\n css_selector='tr.CodePavingType')\n self.repair_types = container.AdminDashboardSubmodule(\n self, alias=\"Repair Types Submodule\",\n css_selector='tr.CodeRepairType')\n self.subbie_types = container.AdminDashboardSubmodule(\n self, alias=\"Subbie Types Submodule\",\n css_selector='tr.CodeSubbieType')\n self.task_types = container.AdminDashboardSubmodule(\n self, alias=\"Task Types Submodule\",\n css_selector='tr.CodeTaskType')","def createUI(self):\n\n q.getQItem(windowID, QtWidgets.QWidget)\n cmds.setParent(q.fullPath)\n\n # ################################################\n # Active Render Layer\n\n # cmds.separator(height=12, style='none')\n addFrameLayout(\n '%s_frameLayoutLayers' % windowID,\n 'Visible Render Layer', collapsable=False,\n labelVisible=False,\n marginHeight=0\n )\n\n addRowLayout(\n '%s_rowLayoutActiveRenderLayer' % windowID,\n 4,\n columnAlign4=('left', 'left', 'right', 'right'),\n columnAttach4=('left', 'both', 'right', 'right'),\n columnWidth4=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\n )\n )\n\n\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\n image='RS_create_layer', size=(21, 21))\n addOptionMenu('%s_selectActiveLayer' % windowID,\n 'Active Layer ', (), rsSelectActiveLayer)\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\n rsOpenRenderSetupWindow, image='render_setup.png',\n size=(21, 21))\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\n size=(21, 21))\n\n # ################################################\n # Work Render Layers\n\n cmds.setParent(q.fullPath)\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\n 'Work Render Layer', collapsable=False,\n labelVisible=False, marginHeight=0)\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\n columnAlign3=('left', 'left', 'right'),\n columnAttach3=('left', 'both', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\n\n cmds.separator()\n addOptionMenu('%s_selectVisibleLayer' % windowID,\n 'Visible Layer ', (), rsSelectVisibleLayer)\n cmds.separator()\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=12, style='none')\n\n # ################################################\n # Collections\n\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\n labelVisible=False, marginHeight=0)\n\n addRowLayout(\n '%s_rowLayout02' % windowID,\n 6,\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\n columnWidth6=(\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\n )\n )\n\n addButton('rsAddCollection', 'Add', rsAddCollection)\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\n image='selectObject.png', size=(21, 21))\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\n size=(21, 21), image='QR_rename.png')\n addButton('rsDuplicateShader', 'Duplicate Shader',\n duplicateShader, size=(21, 21), image='newPreset.png')\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\n image='QR_refresh.png')\n\n # ###########################\n # Filter List\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout03' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\n\n addTextField('%s_filterShaderList' % windowID, 'Search',\n rsFilterShaderList_off, rsFilterShaderList_off,\n window.updateUI)\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\n\n # ###########################\n # The shaders scroll list\n\n cmds.setParent('%s_frameLayout02' % windowID)\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\n + 12)\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\n rsShaderScrollList_doubleClick,\n rsShaderScrollList_onSelect,\n rsShaderScrollList_deleteKey)\n\n # Add popup menu:\n\n cmds.popupMenu('rsShaderScrollListPopupMenu',\n parent='%s_ShaderScrollList' % windowID,\n allowOptionBoxes=False, markingMenu=True,\n postMenuCommand=postMenuCommand)\n cmds.menuItem('%s_popupMenuItem02' % windowID,\n label='Duplicate Shader', command=duplicateShader)\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem04' % windowID,\n label='Graph Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem03' % windowID,\n label='Select Shader')\n cmds.menuItem(divider=True)\n cmds.menuItem('%s_popupMenuItem05' % windowID,\n label='Select Assigned Shapes')\n cmds.menuItem('%s_popupMenuItem06' % windowID,\n label='Select Assigned Transforms')\n\n # ##################################################\n # Arnold Property Overrides\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout20' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n addRowLayout('%s_rowLayout05' % windowID, 2,\n columnAlign2=('left', 'both'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\n 'Apply Arnold Property Overrides', 'plainLabelFont')\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\n rsArnoldPropertyOverridesCheckBox,\n rsArnoldPropertyOverridesCheckBox)\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\n style='none')\n\n # Column Layout to toggle\n\n cmds.setParent('%s_columnLayout20' % windowID)\n cmds.columnLayout(\n '%s_columnLayout02' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n\n addCheckboxes('%s_columnLayout02' % windowID)\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\n visible=False)\n\n # #################################################\n # Shader Override\n\n cmds.setParent('%s_frameLayout02' % windowID)\n cmds.columnLayout(\n '%s_columnLayout21' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('left', 0),\n adjustableColumn=False,\n rowSpacing=0,\n )\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n addRowLayout('%s_rowLayout06' % windowID, 2,\n columnAlign2=('left', 'right'),\n columnAttach2=('left', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\n 'plainLabelFont')\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\n style='none')\n\n cmds.setParent('%s_columnLayout21' % windowID)\n cmds.columnLayout(\n '%s_columnLayout03' % windowID,\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\n columnAlign='left',\n columnAttach=('both', 4),\n adjustableColumn=True,\n rowSpacing=0,\n )\n cmds.setParent('%s_columnLayout03' % windowID)\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\n rsShaderOverridesMenu)\n\n global selectedShaderOverride\n\n # default selection\n\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\n visible=False)\n\n # #################################################\n\n cmds.setParent(q.fullPath)\n cmds.separator(height=10, style='none')\n\n # #################################################\n # Extras\n\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\n collapsable=True, marginHeight=0,\n labelVisible=False)\n\n # #################################################\n # Add & Assign Shader Groups\n\n addFrameLayout(\n '%s_frameLayout05' % windowID,\n 'Add & Assign Shader Groups',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=False,\n labelVisible=True,\n )\n\n # Add the renamer window\n\n self.gwCustomRenamer = CustomRenamer()\n self.gwCustomRenamer.createUI()\n\n # #################################################\n # AutoConnect\n\n cmds.setParent('%s_frameLayout50' % windowID)\n\n addFrameLayout(\n '%s_frameLayout03' % windowID,\n 'Adobe Connector',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\n 'left'), columnAttach3=('both', 'both', 'both'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addButton('updateConnections', '> Update Connections <',\n updateConnections)\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\n addButton('editTexture', 'Edit Texture', editTexture)\n\n # After Effects\n\n cmds.setParent('%s_frameLayout03' % windowID)\n addRowLayout('%s_rowLayout11' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'both'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\n addText('%s_text90' % windowID, 'Send to After Effects:')\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\n\n # #################################################\n # Render Setup /\n # Output settings\n\n cmds.setParent('%s_frameLayout50' % windowID)\n addFrameLayout(\n '%s_frameLayout04' % windowID,\n 'Output Settings',\n collapsable=True,\n marginWidth=0,\n marginHeight=0,\n collapse=True,\n labelVisible=True,\n )\n addRowLayout('%s_rowLayout08' % windowID, 1,\n columnAlign1='center', columnAttach1='both',\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\n addButton('%s_revealOutputDirectory' % windowID,\n 'Output path not set yet', rsRevealOutputDirectory)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout09' % windowID, 3,\n columnAlign3=('left', 'right', 'right'),\n columnAttach3=('left', 'right', 'right'),\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\n\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\n rsSelectOutputTemplate)\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\n rsSelectOutputVersion)\n cmds.menuItem(label='v001')\n\n cmds.setParent('%s_rowLayout09' % windowID)\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\n rsIncrementOutputVersion, size=(21, 21))\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout10' % windowID, 2,\n columnAlign2=('left', 'left'),\n columnAttach2=('both', 'right'),\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\n rsOutputTemplatesMenu)\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\n rsSetFPSMenu)\n\n cmds.setParent('%s_frameLayout04' % windowID)\n addRowLayout('%s_rowLayout12' % windowID, 4,\n columnAlign4=('right', 'left', 'right', 'left'),\n columnAttach4=('both', 'both', 'both', 'both'),\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\n\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\n setInFrame, setInFrame)\n\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\n setOutFrame, setOutFrame)","def __init__(self, ui: UI):\n super().__init__(ui)","def _setup_ui(self):\n\n self.window = ui.Widget()\n self.window.dimensions = ui.normalize_dimension((\n 0, 0,\n self.normalized_screen_resolution[0],\n self.normalized_screen_resolution[1]\n ))\n self.window.background_color = ImageColor.getcolor('#000000', 'RGB')\n\n interface_frame = ui.Widget(parent=self.window)\n interface_frame.dimensions = ui.normalize_dimension((\n self.preview_renderer.window[2],\n 0,\n self.normalized_screen_resolution[0] - self.preview_renderer.window[2],\n self.normalized_screen_resolution[1]\n ))\n interface_frame.background_color = ImageColor.getcolor('#ffffff', 'RGB')\n\n number = ui.LabelWidget(\"\",\n name=NAME_GET_STARTED,\n parent=interface_frame,\n align=\"center\",\n font_color=(0, 0, 0, 255))\n number.dimensions = (\n 5, 5,\n interface_frame.width - 10,\n interface_frame.height - 10\n )","def additional_ui(self):\n return '''<ui>\n <menubar name=\"MenuBar\">\n <menu action=\"FileMenu\">\n <placeholder name=\"LocalExport\">\n <menuitem action=\"ExportTab\"/>\n </placeholder>\n </menu>\n <menu action=\"EditMenu\">\n <placeholder name=\"CommonEdit\">\n <menuitem action=\"Add\"/>\n <menuitem action=\"Edit\"/>\n <menuitem action=\"Remove\"/>\n <menuitem action=\"Merge\"/>\n </placeholder>\n <menuitem action=\"FilterEdit\"/>\n </menu>\n <menu action=\"BookMenu\">\n <placeholder name=\"AddEditBook\">\n <menuitem action=\"AddBook\"/>\n <menuitem action=\"EditBook\"/>\n </placeholder>\n </menu>\n <menu action=\"GoMenu\">\n <placeholder name=\"CommonGo\">\n <menuitem action=\"Back\"/>\n <menuitem action=\"Forward\"/>\n <separator/>\n </placeholder>\n </menu>\n </menubar>\n <toolbar name=\"ToolBar\">\n <placeholder name=\"CommonNavigation\">\n <toolitem action=\"Back\"/> \n <toolitem action=\"Forward\"/> \n </placeholder>\n <placeholder name=\"CommonEdit\">\n <toolitem action=\"Add\"/>\n <toolitem action=\"Edit\"/>\n <toolitem action=\"Remove\"/>\n <toolitem action=\"Merge\"/>\n </placeholder>\n <separator/>\n <toolitem action=\"OpenMedia\"/>\n </toolbar>\n <popup name=\"Popup\">\n <menuitem action=\"Back\"/>\n <menuitem action=\"Forward\"/>\n <separator/>\n <menuitem action=\"OpenMedia\"/>\n <menuitem action=\"OpenContainingFolder\"/>\n <separator/>\n <menuitem action=\"Add\"/>\n <menuitem action=\"Edit\"/>\n <menuitem action=\"Remove\"/>\n <menuitem action=\"Merge\"/>\n <separator/>\n <menu name=\"QuickReport\" action=\"QuickReport\"/>\n </popup>\n </ui>'''","def __init__(self, parent, id=-1, title=\"\", name=\"\"):\n wx.Frame.__init__(self, parent, id=id, title=title,\n pos=wx.DefaultPosition, size=(1800,830), name=name) #1000,875\n\n self.menubar = wx.MenuBar()\n self.SetMenuBar(self.menubar)\n\n views_menu = wx.Menu()\n self.views_default_id = wx.NewId()\n views_menu.Append(self.views_default_id, \"&Default\\tCtrl-D\",\n \"Activate default view layout.\", wx.ITEM_NORMAL)\n\n self.views_max_image_id = wx.NewId()\n views_menu.Append(self.views_max_image_id, \"&Axial-Sagittal-Coronal View\\tCtrl-M\",\n \"Activate maximum image view size layout.\",\n wx.ITEM_NORMAL)\n\t\t\n self.views_contour_view_id = wx.NewId()\n views_menu.Append(self.views_contour_view_id, \"&Contour Uncertainty view\\tCtrl-C\",\n \"Activate contour uncertainty view size layout.\",\n wx.ITEM_NORMAL)\n\n self.views_voxel_view_id = wx.NewId()\n views_menu.Append(self.views_voxel_view_id, \"&Voxel Uncertainty view\\tCtrl-V\",\n \"Activate voxel uncertainty view size layout.\",\n wx.ITEM_NORMAL)\n\n self.menubar.Append(views_menu, \"&Views\")\n\t\t\n\t\t\n help_menu = wx.Menu()\n help_about_id = wx.NewId()\n help_menu.Append(help_about_id, \"&About\\tCtrl-0\",\n \"Info about application.\", wx.ITEM_NORMAL)\n\t\t\t\t\t\t \n self.menubar.Append(help_menu, \"&Help\")\n\t\t\n # tell FrameManager to manage this frame\n self._mgr = wx.aui.AuiManager()\n self._mgr.SetManagedWindow(self)\n\n self._mgr.AddPane(self._create_patients_pane(), wx.aui.AuiPaneInfo().\n Name(\"patient\").Caption(\"Patient Data\").\n Left().\n BestSize(wx.Size(600,400)).\n MinimizeButton(True).MaximizeButton(True))\n\n\t\t\n self._mgr.AddPane(self._create_controls_pane(), wx.aui.AuiPaneInfo().\n Name(\"control\").Caption(\"Dose Plan Explorer\").\n Bottom().\n BestSize(wx.Size(600,400)).\n MinimizeButton(True).MaximizeButton(True))\n\t\t\t\t\t\t \n self._mgr.AddPane(self._create_axial_slices_pane(), wx.aui.AuiPaneInfo().\n Name(\"axial\").Caption(\"Axial\").\n Center().\n BestSize(wx.Size(400,400)).\n CloseButton(False).MaximizeButton(True))\n\t\t\t\t\t\t \n self._mgr.AddPane(self._create_3D_pane(), wx.aui.AuiPaneInfo().\n Name(\"3dview\").Caption(\"3D Dose Plan\").\n Left().\n BestSize(wx.Size(1000,800)).\n MinimizeButton(True).MaximizeButton(True))\n\n self._mgr.AddPane(self._create_sagittal_slices_pane(), wx.aui.AuiPaneInfo().\n Name(\"sagittal\").Caption(\"Sagittal\").\n Right().\n BestSize(wx.Size(400,400)).\n MinimizeButton(True).MaximizeButton(True))\n\n\n self._mgr.AddPane(self._create_coronal_slices_pane(), wx.aui.AuiPaneInfo().\n Name(\"coronal\").Caption(\"Coronal\").\n Right().\n BestSize(wx.Size(400,400)).\n MinimizeButton(True).MaximizeButton(True))\n\n self._mgr.AddPane(self._create_barplot_pane(), wx.aui.AuiPaneInfo().\n Name(\"overview\").Caption(\"Probability Overview\").\n Bottom().\n BestSize(wx.Size(1000,800)).\n MinimizeButton(True).MaximizeButton(True))\n\t\t\t\t\t\t \n self._mgr.AddPane(self._create_probs_pane(), wx.aui.AuiPaneInfo().\n Name(\"probs\").Caption(\"Probabilities for Dose Plans\").\n Bottom().\n BestSize(wx.Size(1000,800)).\n MinimizeButton(True).MaximizeButton(True))\t\t\t\t \t\t\t\t\t\t \n\t\t\t\t\t\t \n self._mgr.AddPane(self._create_distplot_pane(), wx.aui.AuiPaneInfo().\n Name(\"distplot\").Caption(\"Exploration of dose distribution\").\n Bottom().\n BestSize(wx.Size(1000,800)).\n MinimizeButton(True).MaximizeButton(True))\n\t\t\t\t\t\t \n self._mgr.AddPane(self._create_scatterplot_pane(), wx.aui.AuiPaneInfo().\n Name(\"scatterplot\").Caption(\"Variability scatterplot\").\n Bottom().\n BestSize(wx.Size(1000,800)).\n MinimizeButton(True).MaximizeButton(True))\n\t\t\n\n self.SetMinSize(wx.Size(400, 300))\n\n # first we save this default perspective with all panes\n # visible\n self._perspectives = {}\n self._mgr.GetPane(\"doseplan\").Hide()\n self._mgr.GetPane(\"scatterplot\").Hide()\n self._mgr.GetPane(\"3dview\").Hide()\n self._mgr.GetPane(\"distplot\").Hide()\n self._perspectives['default'] = self._mgr.SavePerspective()\n\n #------------- Show maximum image view ------------------#\n\t\t\n\t\t#Show axial,coronal and sagittal panes\n self._mgr.GetPane(\"axial\").Show()\n self._mgr.GetPane(\"coronal\").Show()\n self._mgr.GetPane(\"sagittal\").Show()\n\n\t\t#Hide all the others\t\t\n self._mgr.GetPane(\"patient\").Hide()\t\t\n self._mgr.GetPane(\"control\").Hide()\n self._mgr.GetPane(\"overview\").Hide()\n self._mgr.GetPane(\"probs\").Hide()\n self._mgr.GetPane(\"3dview\").Hide()\n self._mgr.GetPane(\"scatterplot\").Hide()\n self._mgr.GetPane(\"distplot\").Hide()\n # save the perspective again\n self._perspectives['max_image'] = self._mgr.SavePerspective()\n\n #------------- Show contour uncertainty view ------------------#\n\t\t\n\t\t#Show axial, coronal, sagittal, control, overview and probabilities panes\n self._mgr.GetPane(\"axial\").Show()\n self._mgr.GetPane(\"coronal\").Right()\n self._mgr.GetPane(\"coronal\").Show()\n self._mgr.GetPane(\"sagittal\").Right()\n self._mgr.GetPane(\"sagittal\").Show()\n self._mgr.GetPane(\"control\").Show()\n self._mgr.GetPane(\"overview\").Show()\n self._mgr.GetPane(\"probs\").Show()\n\t\t\n\t\t#Hide all the others\n self._mgr.GetPane(\"patient\").Hide()\n self._mgr.GetPane(\"3dview\").Hide()\n self._mgr.GetPane(\"scatterplot\").Hide()\n self._mgr.GetPane(\"distplot\").Hide()\n\t\t\n self._perspectives['contour_view'] = self._mgr.SavePerspective()\n\t\t\n #------------- Show voxel uncertainty view ------------------#\t\t\n\t\t\n\t\t#Show 3dview, scatterplot, axial and distplot panes\n self._mgr.GetPane(\"axial\").Left().Center()\n self._mgr.GetPane(\"axial\").Show()\n self._mgr.GetPane(\"3dview\").Left().Center()\n self._mgr.GetPane(\"3dview\").Show()\n self._mgr.GetPane(\"distplot\").Right()\n self._mgr.GetPane(\"distplot\").Show()\n self._mgr.GetPane(\"scatterplot\").Right()\n self._mgr.GetPane(\"scatterplot\").Show()\n\t\t\n self._mgr.GetPane(\"patient\").Hide()\n self._mgr.GetPane(\"control\").Hide()\n self._mgr.GetPane(\"coronal\").Hide()\n self._mgr.GetPane(\"sagittal\").Hide()\n self._mgr.GetPane(\"probs\").Hide()\n self._mgr.GetPane(\"overview\").Hide()\n\t\t\n self._perspectives['voxel_view'] = self._mgr.SavePerspective()\n\t\t\n # and put back the default perspective / view\n self._mgr.LoadPerspective(self._perspectives['default'])\n\n # finally tell the AUI manager to do everything that we've\n # asked\n self._mgr.Update()\n\t\t\n\t\t#Bind the events\n self.Bind(wx.EVT_MENU, self.onAbout, id = help_about_id)\n\t\n self.patients = {}\n self.contours = {}\n\t\t\n #sns.plt.close(self.figure)\n\t\t\t\t\t\t\n self.CreateStatusBar()\n self.SetStatusText(\"Status information can be find here...\")\n\t\t\n self.new_pat = None\n self.aboutbox = None\n\t\t\n self.tracer = vtk.vtkImageTracerWidget()\n self.tracer.SetCaptureRadius(10.5)\n self.tracer.GetGlyphSource().SetColor(1, 0, 0)\n self.tracer.GetGlyphSource().SetScale(1.0) # set the size of the glyph handle\n\t\t\n # Set the initial rotation of the glyph if desired. The default glyph\n # set internally by the widget is a '+' so rotating 45 deg. gives a 'x'\n self.tracer.GetGlyphSource().SetRotationAngle(90.0)\n self.tracer.GetGlyphSource().Modified()\n self.tracer.GetLineProperty().SetColor(1,0,0)\n self.tracer.SetPriority(1)\n self.tracer.AutoCloseOn()\n self.tracer.IsClosed()\n\t\t\n self.dc = None\n self.cursor_dist = None","def init_ui(self):\n # Create GUI elements, set them in dict structure\n labelwidth = 150\n\n # Add parameter line edit for Factor Tm to Tp\n self.input_elements['factor Tm Tp'] = widgets.ParameterInputLine(\n label='Factor Tm naar Tp:',\n labelwidth=labelwidth,\n unitlabel='(NVT: Tp aanwezig)' if 'Tp' in self.hydraulic_loads.columns else '',\n validator=QtGui.QDoubleValidator(0.01, 99.99, 20),\n )\n\n if 'Tp' in self.hydraulic_loads.columns or self.parent_tab.step != 'I1':\n self.input_elements['factor Tm Tp'].set_enabled(False)\n\n # Add line edit with browsebutton for Master template\n self.input_elements['mastertemplate'] = widgets.ExtendedLineEdit(\n label='Master template bestand:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_master_template)\n )\n\n # Add line edit with browsebutton for depth file\n self.input_elements['depthfile'] = widgets.ExtendedLineEdit(\n label='Bathymetry bestand:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_bathymetry_file)\n )\n\n # Add line edit with browsebutton for swan result folder\n self.input_elements['swanfolder'] = widgets.ExtendedLineEdit(\n label='SWAN uitvoer folder:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_swan_folder)\n )\n\n\n self.setLayout(QtWidgets.QVBoxLayout())\n self.layout().setSpacing(10)\n\n for _, item in self.input_elements.items():\n self.layout().addWidget(item)\n\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n self.layout().addWidget(line)\n\n # OK and Cancel buttons\n self.generateButton = QtWidgets.QPushButton('Genereer invoer')\n self.generateButton.setDefault(True)\n self.generateButton.clicked.connect(self.generate)\n\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\n self.cancelButton.setAutoDefault(False)\n self.cancelButton.clicked.connect(self.cancel)\n\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\n button_box.accepted.connect(QtWidgets.QDialog.accept)\n\n self.layout().addWidget(button_box)","def __init__(self):\r\n super().__init__()\r\n self.init_ui()","def _initUI(self) -> None:\n self._createActions()\n self._addActionsToMoveButtons()\n self._createToolBar()\n self._createStatusBar()\n self._createMainContextMenu()","def controls_setup(self):\n\n self.new_items = element.TopMenuLink(self, alias='New Items Menu',\n css_selector='#browse > li:nth-child(1) > a')\n if self.fixed:\n self.jewelry = element.TopMenuLink(self, alias='Jewelry Menu',\n css_selector='#browse > li:nth-child(2) > a')\n self.artwork = element.TopMenuLink(self, alias='Artwork Menu',\n css_selector='#browse > li:nth-child(3) > a')\n self.homeware = element.TopMenuLink(self, alias='Homeware Menu',\n css_selector='#browse > li:nth-child(4) > a')\n self.clothing = element.TopMenuLink(self, alias='Clothing Menu',\n css_selector='#browse > li:nth-child(5) > a')\n self.vintage = element.TopMenuLink(self, alias='Vintage Menu',\n css_selector='#browse > li:nth-child(6) > a')\n self.food = element.TopMenuLink(self, alias='Food Menu',\n css_selector='#browse > li:nth-child(7) > a')\n self.rings = element.SubMenuLink(self, alias='Jewelry->Rings Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(1) > a')\n self.necklaces = element.SubMenuLink(self, alias='Jewelry->Necklaces Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(2) > a')\n self.bracelets = element.SubMenuLink(self, alias='Jewelry->Bracelets Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(3) > a')\n self.earrings = element.SubMenuLink(self, alias='Jewelry->Earrings Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(4) > a')\n self.broaches = element.SubMenuLink(self, alias='Jewelry->Broaches and Pins Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(5) > a')\n self.wall_art = element.SubMenuLink(self, alias='Artwork->Wall Art Submenu',\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(1) > a')\n self.ceramics = element.SubMenuLink(self, alias='Jewelry->Ceramics Submenu',\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(2) > a')\n self.sculpture = element.SubMenuLink(self, alias='Jewelry->Sculpture Submenu',\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(3) > a')\n self.living = element.SubMenuLink(self, alias='Homeware->Living Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(1) > a')\n self.furniture = element.SubMenuLink(self, alias='Homeware->Furniture Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(2) > a')\n self.kitchen = element.SubMenuLink(self, alias='Homeware->Kitchen Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(3) > a')\n self.lighting = element.SubMenuLink(self, alias='Homeware->Lighting Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(4) > a')\n self.outdoor = element.SubMenuLink(self, alias='Homeware->Outdoor Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(5) > a')\n self.organize = element.SubMenuLink(self, alias='Homeware->Organize Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(6) > a')\n self.party = element.SubMenuLink(self, alias='Homeware->Party Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(7) > a')\n self.sub_food = element.SubMenuLink(self, alias='Homeware->Food Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(8) > a')\n self.pets = element.SubMenuLink(self, alias='Homeware->For Pets Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(9) > a')\n self.women = element.SubMenuLink(self, alias='Clothing->Women Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(1) > a')\n self.men = element.SubMenuLink(self, alias='Clothing->Men Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(2) > a')\n self.kids = element.SubMenuLink(self, alias='Clothing->Kids Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(3) > a')\n self.pet_lovers = element.SubMenuLink(self, alias='Clothing->Pet Lovers Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(4) > a')\n self.antiques = element.SubMenuLink(self, alias='Vintage->Antiques Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(1) > a')\n self.accessories = element.SubMenuLink(self, alias='Vintage->Accessories Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(2) > a')\n self.sub_clothing = element.SubMenuLink(self, alias='Vintage->Clothing Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(3) > a')\n self.sub_homeware = element.SubMenuLink(self, alias='Vintage->Homeware Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(4) > a')\n self.toys = element.SubMenuLink(self, alias='Vintage->Toys Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(5) > a')\n self.books = element.SubMenuLink(self, alias='Vintage->Books Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(6) > a')\n else:\n self.menus = []","def additional_ui(self):\n return '''<ui>\n <menubar name=\"MenuBar\">\n <menu action=\"FileMenu\">\n <placeholder name=\"LocalExport\">\n <menuitem action=\"ExportTab\"/>\n </placeholder>\n </menu>\n <menu action=\"BookMenu\">\n <placeholder name=\"AddEditBook\">\n <menuitem action=\"AddBook\"/>\n <menuitem action=\"EditBook\"/>\n </placeholder>\n </menu>\n <menu action=\"GoMenu\">\n <placeholder name=\"CommonGo\">\n <menuitem action=\"Back\"/>\n <menuitem action=\"Forward\"/>\n <separator/>\n </placeholder>\n </menu>\n <menu action=\"EditMenu\">\n <placeholder name=\"CommonEdit\">\n <menuitem action=\"Add\"/>\n <menuitem action=\"Edit\"/>\n <menuitem action=\"Remove\"/>\n <menuitem action=\"Merge\"/>\n </placeholder>\n <menuitem action=\"FilterEdit\"/>\n </menu>\n </menubar>\n <toolbar name=\"ToolBar\">\n <placeholder name=\"CommonNavigation\">\n <toolitem action=\"Back\"/> \n <toolitem action=\"Forward\"/> \n </placeholder>\n <placeholder name=\"CommonEdit\">\n <toolitem action=\"Add\"/>\n <toolitem action=\"Edit\"/>\n <toolitem action=\"Remove\"/>\n <toolitem action=\"Merge\"/>\n </placeholder>\n </toolbar>\n <popup name=\"Popup\">\n <menuitem action=\"Back\"/>\n <menuitem action=\"Forward\"/>\n <separator/>\n <menuitem action=\"Add\"/>\n <menuitem action=\"Edit\"/>\n <menuitem action=\"Remove\"/>\n <menuitem action=\"Merge\"/>\n <separator/>\n <menu name=\"QuickReport\" action=\"QuickReport\"/>\n </popup>\n </ui>'''","def _createView(self):\n\n items = []\n\n if self.showProgressBar:\n items.append(Item('progress', show_label=False,\n editor=ProgressEditor(callback=self._seek)))\n\n # Controls\n items.append(\n alignCenter(\n Item('backwardButton', style='custom',\n enabled_when='not object.running and object.mainloopRunning '\n +'and object.sensors and object.iteration > 1'),\n Item('runButton', style='custom',\n enabled_when='object.pause and not object.done'),\n Item('pauseButton', style='custom',\n enabled_when='not (object.pause or object.done)'),\n Item('stepButton', style='custom',\n enabled_when='object.pause and not object.done'),\n show_labels=False,\n orientation='horizontal'\n ))\n\n # Repeat button and pause target buttons\n items.append(\n alignCenter(\n Item('repeatButton', show_label=False,\n enabled_when='not object.running and object.mainloopRunning '\n 'and object.iteration > 0'),\n Item('nextTargetButton', show_label=False,\n editor=ButtonEditor(label_value='targetButtonLabel'),\n enabled_when='not object.running and object.mainloopRunning '\n 'and object.pauseTarget'),\n Item('customTargetButton', show_label=False,\n enabled_when='not object.running and object.mainloopRunning')\n ))\n\n # Speed control\n items.append(Item('speed', style='custom', show_label=False,\n editor=EnumEditor(cols=1, values={\n 1 : '1: Slow (update on every iteration)',\n 10 : '2: Medium (update every 10 iterations)',\n 100 : '3: Fast (update every 100 iterations)'\n })\n ))\n\n\n items.extend([\n Group(\n Item('pauseAtNextStep'),\n show_left=False\n ),\n alignLeft(\n Item('stopButton', show_label=False, enabled_when='object.iteration')\n )\n ])\n\n self.traits_view = View(*items)","def _initUI(self):\n\n self.setWindowTitle(\"HB Havens: onzekerheden\")\n self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)\n\n hlayout = QtWidgets.QHBoxLayout()\n\n vlayout = QtWidgets.QVBoxLayout()\n\n # Radio buttons\n #----------------------------------------------------------------\n self.button1 = QtWidgets.QRadioButton('Onzekerheden uit steunpunt overnemen')\n self.button2 = QtWidgets.QRadioButton('Onzekerheden uit havenmodel overnemen')\n self.button3 = QtWidgets.QRadioButton('Combinatie van bovenstaande gebruiken')\n\n vlayout.addWidget(self.button1)\n vlayout.addWidget(self.button2)\n vlayout.addWidget(self.button3)\n vlayout.addItem(QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Expanding))\n\n hlayout.addLayout(vlayout)\n\n vlayout = QtWidgets.QVBoxLayout()\n # Model uncertainties support location\n #----------------------------------------------------------------\n label = QtWidgets.QLabel()\n label.setText('Modelonzekerheden in steunpunt:')\n vlayout.addWidget(label)\n\n self.supportloc_unc_table = widgets.DataFrameWidget(self.supportloc_unc)\n self.supportloc_unc_table.fixed_fit_to_content(90)\n vlayout.addWidget(self.supportloc_unc_table)\n\n label = QtWidgets.QLabel()\n label.setText('Modelonzekerheden in havenmodel (zelf invullen):')\n vlayout.addWidget(label)\n\n self.harbor_unc_table = widgets.DataFrameWidget(self.harbor_unc, editing_enabled=True)\n self.harbor_unc_table.fixed_fit_to_content(90)\n vlayout.addWidget(self.harbor_unc_table)\n\n label = QtWidgets.QLabel()\n label.setText('Gecombineerde modelonzekerheid (berekenen):')\n vlayout.addWidget(label)\n\n calc_button = QtWidgets.QPushButton('Berekenen')\n calc_button.clicked.connect(self._calc_combined_uncertainty)\n vlayout.addWidget(calc_button)\n\n self.combined_unc_table = widgets.DataFrameWidget(self.combined_unc)\n self.combined_unc_table.fixed_fit_to_content(90)\n vlayout.addWidget(self.combined_unc_table)\n\n for table in [self.supportloc_unc_table, self.harbor_unc_table, self.combined_unc_table]:\n table.setShowGrid(True)\n table.setAlternatingRowColors(False)\n\n hlayout.addLayout(vlayout)\n\n vlayout = QtWidgets.QVBoxLayout()\n vlayout.addLayout(hlayout)\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n vlayout.addWidget(line)\n\n\n # Buttons\n #----------------------------------------------------------------\n hbox = QtWidgets.QHBoxLayout()\n hbox.addItem(QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Maximum))\n # Add ok/close\n self.closebutton = QtWidgets.QPushButton('Sluiten')\n self.closebutton.clicked.connect(self.close)\n hbox.addWidget(self.closebutton)\n # Add ok/close\n self.savebutton = QtWidgets.QPushButton('Opslaan')\n self.savebutton.clicked.connect(self._save)\n hbox.addWidget(self.savebutton)\n\n vlayout.addLayout(hbox)\n\n # Add layout to widget\n self.setLayout(vlayout)\n self.layout().setSpacing(10)","def init_ui(self):\n self.panel_sizer = wx.BoxSizer(wx.VERTICAL)\n self.figure_bmp = wx.StaticBitmap(self, wx.ID_ANY,\n bitmap=self.controller.empty_bitmap(self.bitmap_width,\n self.bitmap_height),\n pos=wx.DefaultPosition, size=wx.DefaultSize)\n self.panel_sizer.Add(self.figure_bmp, ui_defaults.ctrl_pct, wx.CENTER,\n ui_defaults.widget_margin)\n self.SetSizerAndFit(self.panel_sizer)","def __init__(self, napari_viewer: napari.Viewer):\n super().__init__()\n self.viewer = napari_viewer\n # data classes\n self.ims_pixel_map: Optional[PixelMapIMS] = None\n self.microscopy_image: Optional[MicroRegImage] = None\n self.micro_image_names: Optional[List[str, ...]] = None\n self.image_transformer: ImageTransform = ImageTransform()\n self.last_transform: np.ndarray = np.eye(3)\n self.output_size: Optional[Tuple[int, int]] = None\n\n # private attrs\n self._micro_rot = 0\n self._ims_rot = 0\n\n # controller widgets\n self._data: DataControl = DataControl(self)\n self._ims_c: IMSControl = IMSControl(self)\n self._tform_c: TformControl = TformControl(self)\n self._save_c: SaveControl = SaveControl(self)\n\n # layout widgets in GUI\n self.setLayout(QVBoxLayout())\n self.layout().addWidget(self._data.data_frame)\n self.layout().addWidget(self._ims_c.ims_ctrl_frame)\n self.layout().addWidget(self._tform_c.tform_ctrl_frame)\n self.layout().addWidget(self._save_c.save_ctrl_frame)\n self.layout().addStretch(1)\n\n # button actions for widgets\n # data reading\n self._data.ims_d.add_ims_data.clicked.connect(self.read_ims_data)\n self._data.ims_d.delete_btn.clicked.connect(self._delete_ims_roi)\n self._data.micro_d.add_micro_data.clicked.connect(self.read_micro_data)\n\n # ims canvas control\n self._ims_c.ims_ctl.do_padding_btn.clicked.connect(self._pad_ims_canvas)\n self._ims_c.ims_ctl.micron_check.clicked.connect(\n lambda: self._set_pad_by(\"micron\")\n )\n self._ims_c.ims_ctl.pixel_check.clicked.connect(\n lambda: self._set_pad_by(\"pixel\")\n )\n\n # transform control\n self._tform_c.tform_ctl.reset_transform.clicked.connect(self.reset_transform)\n self._tform_c.tform_ctl.run_transform.clicked.connect(self.run_transformation)\n self._tform_c.rot_ctl.rot_mi_90cw.clicked.connect(\n lambda: self._rotate_modality(\"microscopy\", -90)\n )\n self._tform_c.rot_ctl.rot_mi_90ccw.clicked.connect(\n lambda: self._rotate_modality(\"microscopy\", 90)\n )\n self._tform_c.rot_ctl.rot_mi_180cw.clicked.connect(\n lambda: self._rotate_modality(\"microscopy\", 180)\n )\n self._tform_c.rot_ctl.rot_mi_180ccw.clicked.connect(\n lambda: self._rotate_modality(\"microscopy\", 180)\n )\n self._tform_c.rot_ctl.rot_ims_90cw.clicked.connect(\n lambda: self._rotate_modality(\"ims\", -90)\n )\n self._tform_c.rot_ctl.rot_ims_90ccw.clicked.connect(\n lambda: self._rotate_modality(\"ims\", 90)\n )\n # self.tform_c.rot_ctl.rot_ims_180cw.clicked.connect(\n # lambda: self._rotate_modality(\"ims\", 180)\n # )\n # self.tform_c.rot_ctl.rot_ims_180ccw.clicked.connect(\n # lambda: self._rotate_modality(\"ims\", 180)\n # )\n\n # save control\n self._save_c.save_ctl.reset_data.clicked.connect(self.reset_data)\n self._save_c.save_ctl.save_data.clicked.connect(self.save_data)\n\n # update spatial resolutions\n self._ims_res_timer = QTimer()\n self._ims_res_timer.setSingleShot(True)\n self._ims_res_timer.timeout.connect(self._set_ims_res)\n self._data.ims_d.res_info_input.textChanged.connect(self._ims_res_timing)\n\n self._micro_res_timer = QTimer()\n self._micro_res_timer.setSingleShot(True)\n self._micro_res_timer.timeout.connect(self._set_micro_res)\n self._data.micro_d.res_info_input.textChanged.connect(self._micro_res_timing)\n\n # start with certain buttons disabled\n self._save_c.save_ctl.save_data.setEnabled(False)\n self._tform_c.tform_ctl.run_transform.setEnabled(False)","def build_ui(self):\n self.ui = UI_procstep.Ui_Form()#.Ui_USGSContactInfoWidgetMain()\n self.ui.setupUi(self)\n self.setup_dragdrop(self)\n\n self.proc_step = RepeatingElement(which='tab',\n tab_label='Step', add_text='Additional Step',\n widget=ProcessStep, remove_text='Remove Step', italic_text='Processing Steps Taken')\n\n #self.proc_step = RepeatingElement(params=params, which='tab', tab_label='Source',)\n self.proc_step.add_another()\n self.ui.widget_procstep.layout().addWidget(self.proc_step)","def __init__(self, parent=None):\n super(Representative, self).__init__(parent)\n self.setupUi(self)","def create_page(self, parent):\n ui = self.edit_traits(parent=parent, kind=\"subpanel\")\n return ui.control","def __init__(self, scenario_controller):\n super(Ui, self).__init__()\n\n self.scenarioController = scenario_controller\n\n\n # determine if application is a script file or frozen exe\n\n if getattr(sys, 'frozen', False):\n relative_ui_path = 'AssetsV1/MainUI.ui'\n main_ui_path = os.path.dirname(sys.executable)\n\n elif __file__:\n relative_ui_path = 'MainUI.ui'\n main_ui_path = os.path.dirname(__file__)\n\n # needs to point to MainUi.ui file\n complete_ui_path = os.path.join(main_ui_path, relative_ui_path)\n\n uic.loadUi(complete_ui_path, self)\n\n self.timeline = MyTimelineWidget(self, self.scenarioController)\n self.tabWidget.setTabsClosable(True)\n self.tabs = self.tabWidget\n self.tabs.currentChanged.connect(self.current_tab_changed) \n self.tabs.tabCloseRequested.connect(self.close_current_tab)\n\n self.showMaximized()\n\n all_subsystem_names = self.scenarioController.getAvailableSubsystemNames()\n\n self.clearMenuOptions(self.menuOpen)\n self.clearMenuOptions(self.menuFile)\n self.setMenuOptions(self.menuFile, ['Save', 'Save As', 'Save As Scenario'], self.saveMenuHandler)\n self.setMenuOptionsWithParams(self.menuNew, all_subsystem_names, self.newSubsystemHandler)\n self.setMenuOptions(self.menuOpen, ['Open Command File', 'Open Scenario'], self.openMenuHandler)\n\n self.show()\n self.timeline.show()","def init_ui(self):\n # Create GUI elements, set them in dict structure\n labelwidth = 150\n\n # Add parameter line edit for Factor Tm to Tp\n\n # Add line edit with browsebutton for swan result folder\n self.input_elements['hares folder'] = widgets.ExtendedLineEdit(\n label='HARES uitvoerbestanden folder:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_hares_folder)\n )\n\n\n self.setLayout(QtWidgets.QVBoxLayout())\n self.layout().setSpacing(10)\n\n for _, item in self.input_elements.items():\n self.layout().addWidget(item)\n\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n self.layout().addWidget(line)\n\n # OK and Cancel buttons\n self.generateButton = QtWidgets.QPushButton('Start lezen uitvoerbestanden')\n self.generateButton.setDefault(True)\n self.generateButton.clicked.connect(self.generate)\n\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\n self.cancelButton.setAutoDefault(False)\n self.cancelButton.clicked.connect(self.cancel)\n\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\n button_box.accepted.connect(QtWidgets.QDialog.accept)\n\n self.layout().addWidget(button_box)","def process_widgets(self):\r\n\r\n self.runmode_menu.add_radiobutton(label=\"Graphical User Interface\", value=0, variable=self.gui_menu_var,\r\n command=self.disable_debugging_mode)\r\n self.runmode_menu.add_radiobutton(label=\"Command Line Interface\", value=1, variable=self.gui_menu_var,\r\n command=lambda gui=self: load_cli(self))\r\n self.runmode_menu.add_radiobutton(label=\"Debugging Mode (GUI + CLI)\", value=2, variable=self.gui_menu_var,\r\n command=self.enable_debugging_mode)\r\n\r\n # Placing all the submenus\r\n self.filemenu.add_cascade(label=\"Run Mode\", menu=self.runmode_menu)\r\n self.menubar.add_cascade(label=\"File\", menu=self.filemenu)\r\n\r\n self.config(menu=self.menubar) # Indicating that the \"menubar\" variable is the filemenu of the application\r\n\r\n self.folder_frame.pack()\r\n\r\n # self.folder_locator.pack(side=LEFT, padx=10, pady=10)\r\n\r\n self.media_folder_label.pack(side=LEFT, padx=10, pady=10)\r\n\r\n self.folder_button.pack(side=LEFT)\r\n\r\n self.path_frame_parent.pack(side=LEFT)\r\n\r\n self.search_frame.pack()\r\n\r\n self.search_frame.pack()\r\n self.search_entry.grid(row=0, column=0, padx=10, pady=20)\r\n self.search_button.grid(row=0, column=1, padx=5)\r\n # self.advanced_search_button.grid(row=0, column=2, padx=5)\r\n\r\n self.media_frame.pack()\r\n\r\n self.button_frame.pack()","def create_gui(self):\n\n selectors_widgets = list()\n\n for n in range(4):\n\n selectors_widgets.append(wd.Dropdown(\n options={'': 0, 'Orange': 1, 'Red': 2, 'Blue': 3, 'Green': 4},\n value=0,\n disabled=False,\n layout={'width': '148px'}\n ))\n\n self.confirm_button.on_click(\n self.create_combination_and_rate_function())\n self.user_interact.children = [self.selectors, self.confirm_button]\n\n self.selectors.children = selectors_widgets","def root_wdgt(self):\n self.summarize()\n modes = ['Global', 'Single-Image']\n\n def logic(mode):\n # cache the widget later\n if mode == modes[0]:\n if self.global_walk is None:\n self.global_walk = self.global_walk_specifier()\n ipy_display(self.global_walk)\n elif mode == modes[1]:\n self.image_view = self.single_image_selector()\n # if self.image_view is None:\n # self.image_view = self.single_image_selector()\n # ipy_display(self.image_view)\n\n UI = interactive(\n logic, mode=widgets.ToggleButtons(options=modes, value=modes[0])\n )\n UI.children[-1].layout.height = '1000px'\n ipy_display(UI)","def init_ui(self):\n self.master.title(\"Backbone\")\n self.master.geometry(\"300x150\")\n\n self.pack(fill=BOTH, expand=1)\n\n self.btn_upload_file = Button(self, text=\"Upload file\", command=self.upload_file)\n self.btn_upload_file.place(x=90, y=10)\n\n self.btn_create_training_file = Button(self, text=\"Create & upload training file\",\n command=self.create_training_file)\n self.btn_create_training_file.place(x=30, y=40)\n\n self.btn_run_algorithm = Button(self, text=\"Run algorithm\", command=self.run_algorithm)\n self.btn_run_algorithm.place(x=80, y=70)\n\n self.btn_view_results = Button(self, text=\"View Results\", command=self.view_results)\n self.btn_view_results.place(x=85, y=100)","def __init__(self):\n self.root = tk.Tk()\n self.root.minsize(width=150, height=150)\n self.root.maxsize(height=500)\n self.root.title(\"GUV analysis\")\n self.root.iconbitmap(os.path.join(os.path.dirname(__file__), \"icon.ico\"))\n self.window = tk.Frame(self.root)\n self.window.pack(side=\"top\", fill=\"both\", expand=True)\n\n self.widgets = {}\n self.images = {}\n\n self.widgets['lblTitle'] = tk.Label(self.window, text='GUV analysis tool', font=\"-weight bold -size 20\")\n self.widgets['lblTitle'].grid(column=0, row=0, columnspan=3)\n\n self.images['newImg'] = tk.PhotoImage(file=os.path.join(os.path.dirname(__file__),'icon-new.png')).subsample(2,2)\n self.widgets['btnNew'] = tk.Button(self.window, text='New analysis', image=self.images['newImg'], command=self.start_new_analysis, compound=tk.TOP, borderwidth=0)\n self.widgets['btnNew'].grid(column=0, row=1, padx=10)\n\n self.images['openImg'] = PhotoImage_cd('icon-open.png').subsample(2,2)\n self.widgets['btnOpen'] = tk.Button(self.window, text='Open existing analysis', command=self.reopen_existing_analysis, image=self.images['openImg'], compound=tk.TOP, borderwidth=0)\n self.widgets['btnOpen'].grid(column=1, row=1, padx=10)\n\n self.images['closeImg'] = PhotoImage_cd('icon-close.png').subsample(2,2)\n self.widgets['btnClose'] = tk.Button(self.window, text='Close program', command=self.root.quit, image=self.images['closeImg'], compound=tk.TOP, borderwidth=0)\n self.widgets['btnClose'].grid(column=2, row=1, padx=10)","def ui_setup(self):\n loader = QUiLoader()\n file = QFile('./user_interface/form/main_window.ui')\n file.open(QFile.ReadOnly)\n self._window = loader.load(file)\n file.close()\n\n status_bar = QStatusBar(self._window)\n status_bar.showMessage(__copyright__)\n self._window.setStatusBar(status_bar)\n self._window.setWindowIcon(QIcon('./user_interface/media/bucketing_icon.jpeg'))\n self._window.setWindowTitle('PySide2 Project - Basic UI Framework')\n\n self._option_panel = OptionPanel()\n self._option_panel.add_button('DekBan', './user_interface/media/dekban.png')\n self._option_panel.add_button('Charlie', './user_interface/media/charlie.jpeg')\n self._option_panel.add_button('Simon', './user_interface/media/Simon.jpeg')\n\n # Add widget to main layout\n main_layout = self._window.main_layout\n main_layout.itemAtPosition(0, 0).setAlignment(QtCore.Qt.AlignCenter)\n main_layout.itemAtPosition(0, 1).setAlignment(QtCore.Qt.AlignVCenter)\n main_layout.addWidget(self._option_panel, 2, 0, 1, 1)\n\n # Add page widget to stack\n self._pages['item'] = ItemWidget()\n self._pages['text1'] = TextPage(text=PAUSE_TEXT)\n self._pages['text2'] = TextPage(text=STOP_TEXT)\n\n for index, name in enumerate(self._pages):\n print('pages {} : {} page'.format(index, name))\n self._window.widget_stack.addWidget(self._pages[name].widget)\n\n self._window.widget_stack.setCurrentIndex(0)\n\n # Build up signal / slot\n self._option_panel.currentItemChanged.connect(self.set_page)","def build_ui(self):\n\n self.frame.columnconfigure(0, pad=20)\n self.frame.columnconfigure(1, pad=20)\n\n\n self.frame.rowconfigure(0, pad=3)\n self.frame.rowconfigure(1, pad=3)\n self.frame.rowconfigure(2, pad=3)\n\n p1_label = Label(self.frame)\n p1_label[\"text\"] = \"Player 1\"\n p1_label.grid(row=0, column=0)\n\n p2_label = Label(self.frame)\n p2_label[\"text\"] = \"Player 2\"\n p2_label.grid(row=0, column=1)\n\n self.lb1 = Listbox(self.frame)\n for script in self.ai_list:\n self.lb1.insert(END, script)\n self.lb1.grid(row=1, column=0)\n\n self.lb1.selection_set(0)\n self.lb1[\"exportselection\"] = 0\n\n self.lb2 = Listbox(self.frame)\n for script in self.ai_list:\n self.lb2.insert(END, script)\n self.lb2.grid(row=1, column=1)\n\n self.lb2.selection_set(0)\n self.lb2[\"exportselection\"] = 0\n\n start_game_button = Button(self.frame)\n start_game_button[\"text\"] = \"Start Game\"\n start_game_button[\"command\"] = self.start_game\n start_game_button.grid(row=2, column=0)\n\n self.check_box = Checkbutton(self.frame, text=\"Draw UI\",variable=self.ui_draw)\n self.check_box.grid(row=2,column=1)\n\n self.frame.pack()","def __setup_ui_controls(self):\n self.scene.append_to_caption('\\n')\n\n # Button to reset camera\n btn_reset = button(\n bind=self.__reset_camera, text=\"Reset Camera\")\n self.__ui_controls.btn_reset = btn_reset\n self.scene.append_to_caption('\\t')\n\n chkbox_cam = checkbox(\n bind=self.__camera_lock_checkbox,\n text=\"Camera Lock\", checked=self.__camera_lock)\n self.__ui_controls.chkbox_cam = chkbox_cam\n self.scene.append_to_caption('\\t')\n\n chkbox_rel = checkbox(\n bind=self.__grid_relative_checkbox,\n text=\"Grid Relative\", checked=self.__grid_relative)\n self.__ui_controls.chkbox_rel = chkbox_rel\n self.scene.append_to_caption('\\n\\n')\n\n # Button to clear the screen\n btn_clr = button(bind=self.clear_scene, text=\"Clear Scene\")\n self.__ui_controls.btn_clear = btn_clr\n self.scene.append_to_caption('\\n\\n')\n\n # Checkbox for grid visibility\n chkbox_grid = checkbox(\n bind=self.__grid_visibility_checkbox, text=\"Grid Visibility\",\n checked=self.__grid_visibility)\n self.__ui_controls.chkbox_grid = chkbox_grid\n self.scene.append_to_caption('\\t')\n\n # Prevent the space bar from toggling the active checkbox/button/etc\n # (default browser behaviour)\n self.scene.append_to_caption('''\n <script type=\"text/javascript\">\n $(document).keyup(function(event) {\n if(event.which === 32) {\n event.preventDefault();\n }\n });\n </script>''')\n # https://stackoverflow.com/questions/22280139/prevent-space-button-from-triggering-any-other-button-click-in-jquery\n\n # Control manual\n controls_str = '<br><b>Controls</b><br>' \\\n '<b>PAN</b><br>' \\\n 'SHFT + LMB | <i>free pan</i><br>' \\\n 'W , S | <i>up / down</i><br>' \\\n 'A , D | <i>left / right</i><br>' \\\n '<b>ROTATE</b><br>' \\\n 'ARROWS KEYS | <i>rotate direction</i><br>' \\\n 'Q , E | <i>roll left / right</i><br>' \\\n '<b>ZOOM</b></br>' \\\n 'MOUSEWHEEL | <i>zoom in / out</i><br>' \\\n '<script type=\"text/javascript\">var arrow_keys_handler = function(e) {switch(e.keyCode){ case 37: case 39: case 38: case 40: case 32: e.preventDefault(); break; default: break;}};window.addEventListener(\"keydown\", arrow_keys_handler, false);</script>' # noqa\n # Disable the arrow keys from scrolling in the browser\n # https://stackoverflow.com/questions/8916620/disable-arrow-key-scrolling-in-users-browser\n self.scene.append_to_caption(controls_str)","def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/generic.png')\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\n\n\t\t# USB\n self.usb_button = pyxbmct.RadioButton('')\n self.placeControl(self.usb_button, 9, 3, rowspan=2, columnspan=4)\n self.connect(self.usb_button, self.usb_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'usb', 2) == 1:\n self.usb_button.setSelected(True)\n else:\n self.usb_button.setSelected(False)\n usb = pyxbmct.Image(addonfolder+artsfolder+'/usb.png')\n self.placeControl(usb, 9, 3, rowspan=2, columnspan=4)\n\n\t\t# PCI-X\n self.pcix_button = pyxbmct.RadioButton('')\n self.placeControl(self.pcix_button, 9, 9, rowspan=2, columnspan=4)\n self.connect(self.pcix_button, self.pcix_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'pcix', 2) == 1:\n self.pcix_button.setSelected(True)\n else:\n self.pcix_button.setSelected(False)\n pcix = pyxbmct.Image(addonfolder+artsfolder+'/pcix.png')\n self.placeControl(pcix, 9, 9, rowspan=2, columnspan=4)\n\n\t\t# Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.closepage())","def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/tvh.png')\n self.placeControl(image, 0, 0, rowspan=9, columnspan=16)\n\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/installaddons.png')\n self.placeControl(image, 8, 6, rowspan=4, columnspan=4)\n\n\t\t# Tvheadend button\n self.tvh_button = pyxbmct.Button('TVHEADEND')\n self.placeControl(self.tvh_button, 10, 11, rowspan=1, columnspan=3)\n self.connect(self.tvh_button, lambda: self.installaddons('service.tvheadend42', 'service.tvheadend43'))\n\n\t\t# Tvheadend HTSP Client button\n self.htsp_button = pyxbmct.Button('HTSP CLIENT')\n self.placeControl(self.htsp_button, 10, 2, rowspan=1, columnspan=3)\n self.connect(self.htsp_button, lambda: self.installaddon('pvr.hts'))\n\n\t\t# Start button\n self.start_button = pyxbmct.Button('START')\n self.placeControl(self.start_button, 12, 7, rowspan=1, columnspan=2)\n self.connect(self.start_button, lambda: self.page('service.tvheadend42', 'service.tvheadend43', 'pvr.hts'))\n\n\t\t# Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.closepage())","def set_ui(self):\n\n self.setLayout(self.horizon_layout)\n self.setWindowTitle(\"数据采集\")\n self.setWindowIcon(self.Icon)\n self.setWindowState(Qt.WindowMaximized)\n # self.resize(self._size_of_x, self._size_of_y)\n\n # //-set left\n self.horizon_left_layout1.addWidget(self.ECG)\n self.horizon_left_layout1.addWidget(self.ECGWin)\n self.horizon_left_layout2.addWidget(self.Respiration)\n self.horizon_left_layout2.addWidget(self.RespirationWin)\n self.horizon_left_layout3.addWidget(self.PulseWave)\n self.horizon_left_layout3.addWidget(self.PulseWaveWin)\n # self.horizon_left_layout4.addWidget(self.SpO2)\n # self.horizon_left_layout4.addWidget(self.SpO2Win)\n\n # self.vertical_left_layout.addStretch(1)\n self.vertical_left_layout.addLayout(self.horizon_left_layout1)\n # self.vertical_left_layout.addStretch(1)\n self.vertical_left_layout.addLayout(self.horizon_left_layout2)\n # self.vertical_left_layout.addStretch(1)\n self.vertical_left_layout.addLayout(self.horizon_left_layout3)\n # self.vertical_left_layout.addStretch(1)\n # self.vertical_left_layout.addLayout(self.horizon_left_layout4)\n # self.vertical_left_layout.addStretch(1)\n\n # //-set right\n # self.vertical_right_layout.addStretch(1)\n self.vertical_right_layout.addWidget(self.save)\n self.vertical_right_layout.addWidget(self.clear)\n self.vertical_right_layout.addWidget(self.receive)\n self.vertical_right_layout.addStretch(1)\n self.vertical_right_layout.addWidget(self.exit)\n # self.vertical_right_layout.addStretch(1)\n\n # //-set layout\n # self.horizon_layout.addStretch(0)\n self.horizon_layout.addLayout(self.vertical_left_layout)\n # self.horizon_layout.addStretch(0)\n # self.horizon_layout.addWidget(self.dataWin)\n self.horizon_layout.addLayout(self.vertical_right_layout)","def _init_ui(self):\n # Create GUI elements, set them in dict structure\n inf_symbol = u'\\u221E'\n gamma_symbol = u'\\u03B3'\n unicode_squared = u'\\u00B9'\n labelwidth=175\n\n if len(self.waterlevels) > 100:\n raise NotImplementedError('More than 100 water levels where discovered in the hydraulic loads. The method with PHAROS is not implemented for this number of loads. Recalculate the wave conditions at given water levels, or pick a method without PHAROS.')\n\n self.input_elements['hydraulic loads'] = {\n 'Hs_max': widgets.ParameterLabel(\n label='Max. significante golfhoogte:',\n labelwidth=labelwidth,\n value='{:.3f}'.format(self.Hs_max),\n unit='m'\n ),\n # 'Tp_max': widgets.ParameterLabel(\n # label='Maximale piekperiode',\n # labelwidth=150\n # ),\n 'factor Tm Tp': widgets.ParameterInputLine(\n label='Factor Tm naar Tp:',\n labelwidth=labelwidth,\n validator=QtGui.QDoubleValidator(0.01, 99.99, 20),\n ),\n 'water depth for wave length': widgets.ParameterInputLine(\n label='Waterdiepte voor golflengte:',\n labelwidth=labelwidth,\n unitlabel='m',\n validator=QtGui.QDoubleValidator(0.00, np.inf, 20),\n ),\n }\n\n self.input_elements['wave directions'] = {\n 'lowest': widgets.ParameterInputLine(\n label='Laagste waarde [0-360]:',\n labelwidth=labelwidth,\n unitlabel='graden (nautisch)',\n validator=QtGui.QDoubleValidator(0.00, 360.00, 20),\n ),\n 'highest': widgets.ParameterInputLine(\n label='Hoogste waarde [0-360]:',\n labelwidth=labelwidth,\n unitlabel='graden (nautisch)',\n validator=QtGui.QDoubleValidator(0.00, 360.00, 20),\n ),\n 'bin size': widgets.ParameterInputLine(\n label='Klassegrootte [1-360]:',\n labelwidth=labelwidth,\n unitlabel='graden',\n validator=QtGui.QDoubleValidator(1.00, 360.00, 20),\n )\n }\n\n self.input_elements['frequencies'] = {\n 'lowest': widgets.ParameterInputLine(\n label='Ondergrens [{:.3f} - {:.3f}]:'.format(*self.f_range),\n labelwidth=labelwidth,\n unitlabel='Hz',\n validator=QtGui.QDoubleValidator(self.f_range[0] - 0.01, self.f_range[1] + 0.01, 20),\n ),\n 'highest': widgets.ParameterInputLine(\n label='Bovengrens [{:.3f} - {:.3f}]:'.format(*self.f_range),\n labelwidth=labelwidth,\n unitlabel='Hz',\n validator=QtGui.QDoubleValidator(self.f_range[0] - 0.01, self.f_range[1] + 0.01, 20),\n ),\n 'number of bins': widgets.ParameterInputLine(\n label='Aantal klassen [1-50]:',\n labelwidth=labelwidth,\n validator=QtGui.QIntValidator(1, 50),\n ),\n 'scale': widgets.ComboboxInputLine(\n label='Frequentie schaal:',\n labelwidth=labelwidth,\n items=['lineair', 'logaritmisch'],\n )\n }\n\n self.input_elements['2d wave spectrum'] = {\n 'spread': widgets.ParameterInputLine(\n label='Spreiding [10-70]:',\n labelwidth=labelwidth,\n unitlabel='graden',\n validator=QtGui.QDoubleValidator(10.0, 70.0, 20),\n ),\n 'gamma': widgets.ParameterInputLine(\n label='JONSWAP peak\\nenhancement factor {} [1-7]:'.format(gamma_symbol),\n labelwidth=labelwidth,\n unitlabel='',\n validator=QtGui.QDoubleValidator(1.00, 7.00, 20),\n ),\n 'min energy': widgets.ParameterInputLine(\n label='Signaleringswaarde energie [0-{}]:'.format(inf_symbol),\n labelwidth=labelwidth,\n unitlabel='m{}s/degree'.format(unicode_squared),\n validator=QtGui.QDoubleValidator(0.00, 2.00, 20),\n )\n }\n\n self.input_elements['paths'] = {\n 'pharos folder': widgets.ExtendedLineEdit(\n label='Uitvoermap:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton(\n '...',\n clicked=self._load_pharos_folder\n )\n ),\n 'schematisation folder': widgets.ExtendedLineEdit(\n label='Schematisatiemap:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton(\n '...',\n clicked=self._load_schematisations_folder\n )\n )\n }\n\n self.input_elements['water levels'] = {\n 'checked': widgets.CheckBoxInput(\n labels=self.waterlevels,\n nrows=max(2, len(self.waterlevels) // 20),\n unitlabel='m + NAP'\n )\n }\n\n delta = u'\\u0394'\n self.input_elements['transformation'] = {\n 'dx': widgets.ParameterInputLine(\n label='{}x [RD + {}x = lokaal]:'.format(delta, delta),\n labelwidth=labelwidth,\n ),\n 'dy': widgets.ParameterInputLine(\n label='{}y [RD + {}y = lokaal]:'.format(delta, delta),\n labelwidth=labelwidth,\n )\n }\n\n\n # Define titles for groups\n titles = {\n 'hydraulic loads': 'Hydraulische belastingen',\n 'wave directions': 'Golfrichtingen',\n 'frequencies': 'Frequenties',\n '2d wave spectrum': '2D golfspectrum',\n 'paths': 'Paden',\n 'water levels': 'Te simuleren waterstanden',\n 'transformation': 'Transformatie voor coordinatenstelsel'\n }\n\n\n # Create base layout\n self.setLayout(QtWidgets.QVBoxLayout())\n # self.layout().setSpacing(10)\n\n for tag, title in titles.items():\n if tag in self.input_elements:\n group_layout = QtWidgets.QVBoxLayout()\n for _, item in self.input_elements[tag].items():\n group_layout.addWidget(item)\n\n # Add groupbox with title\n groupbox = QtWidgets.QGroupBox(title)\n groupbox.setLayout(group_layout)\n self.layout().addWidget(groupbox)\n\n\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n self.layout().addWidget(line)\n\n # OK and Cancel buttons\n\n self.generate_button = QtWidgets.QPushButton('Genereer tabel')\n self.generate_button.setDefault(True)\n # self.generate_button.setEnabled(False)\n self.generate_button.clicked.connect(self.generate)\n\n self.cancel_button = QtWidgets.QPushButton('Annuleren')\n self.cancel_button.setAutoDefault(False)\n self.cancel_button.clicked.connect(self.cancel)\n\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\n button_box.addButton(self.generate_button, QtWidgets.QDialogButtonBox.ActionRole)\n button_box.addButton(self.cancel_button, QtWidgets.QDialogButtonBox.RejectRole)\n\n button_box.accepted.connect(QtWidgets.QDialog.accept)\n # button_box.rejected.connect(QtWidgets.QDialog.reject)\n\n self.layout().addWidget(button_box)","def buildUI(self):\n\n if cmds.window(\"pyART_AddToCanvasWIN\", exists=True):\n cmds.deleteUI(\"pyART_AddToCanvasWIN\", wnd=True)\n\n # create the main window\n self.mainWin = QtWidgets.QMainWindow(self.pickerUI)\n\n # create the main widget\n self.mainWidget = QtWidgets.QWidget()\n self.mainWin.setCentralWidget(self.mainWidget)\n\n # create the mainLayout\n self.layout = QtWidgets.QVBoxLayout(self.mainWidget)\n\n # load stylesheet\n styleSheetFile = utils.returnNicePath(self.toolsPath, \"Core/Scripts/Interfaces/StyleSheets/animPicker.qss\")\n f = open(styleSheetFile, \"r\")\n self.style = f.read()\n f.close()\n\n self.mainWin.setStyleSheet(self.style)\n\n self.mainWin.setMinimumSize(QtCore.QSize(250, 400))\n self.mainWin.setMaximumSize(QtCore.QSize(250, 400))\n self.mainWin.resize(250, 400)\n\n # set qt object name\n self.mainWin.setObjectName(\"pyART_AddToCanvasWIN\")\n self.mainWin.setWindowTitle(\"Add Module To Canvas\")\n\n # label, listWidget, button\n label = QtWidgets.QLabel(\"Available Modules:\")\n label.setProperty(\"boldFont\", True)\n self.layout.addWidget(label)\n\n self.moduleList = QtWidgets.QListWidget()\n self.moduleList.setMaximumSize(230, 300)\n self.moduleList.setMinimumSize(230, 300)\n self.layout.addWidget(self.moduleList)\n\n # add modules to listWidget\n self.addModulesToList()\n\n # create add button\n button = QtWidgets.QPushButton(\"Add Selected To Canvas\")\n self.layout.addWidget(button)\n button.setObjectName(\"blueButton\")\n button.clicked.connect(self.addSelectedToCanvas)\n\n # show ui\n self.mainWin.show()","def InitGUI(cls):\n SensorGUI = {}\n for subCls,instnts in cls.__sensors__.iteritems():\n print(\"Creating GUI for Sensor: '%s'\" %(subCls.__name__))\n SensorGUI[subCls.__name__] = SensorFrame(sensors = instnts ,\n title = subCls.__name__ )\n\n return SensorGUI","def setup_main_menus_architecture(instances_tournament, instances_report) -> list:\n return [{'name': \"tournoi actuel\",\n 'unfold': [{'label': elem.label, 'state': elem.state,\n 'function': \"lambda i= ['\" + elem.name + \"', self.frame_right, \"\n \"self.list_instances_menus_tournament]: \"\n \"RightWindow.display_right_window(i)\"}\n for elem in instances_tournament]},\n {'name': \"générer les rapports\",\n 'unfold': [{'label': elem.label, 'state': elem.state,\n 'function': \"lambda i= '\" +\n elem.name + \"': ChooseTournamentForReport(self.frame_right, i)\"}\n for elem in instances_report]}]","def update_views():\n # replace Supervisor main entry\n here = os.path.abspath(os.path.dirname(__file__))\n # set main page\n VIEWS['index.html'] = {'template': os.path.join(here, 'ui/index.html'),\n 'view': SupvisorsView}\n # set address /processpage\n VIEWS['procaddress.html'] = {'template': os.path.join(\n here, 'ui/procaddress.html'),\n 'view': ProcAddressView}\n # set address/host page\n VIEWS['hostaddress.html'] = {'template': os.path.join(\n here, 'ui/hostaddress.html'),\n 'view': HostAddressView}\n # set application page\n VIEWS['application.html'] = {'template': os.path.join(\n here, 'ui/application.html'),\n 'view': ApplicationView}\n # set fake page to export images\n VIEWS['process_cpu.png'] = {'template': os.path.join(\n here, 'ui/empty.html'),\n 'view': ProcessCpuImageView}\n VIEWS['process_mem.png'] = {'template': os.path.join(\n here, 'ui/empty.html'),\n 'view': ProcessMemoryImageView}\n VIEWS['address_cpu.png'] = {'template': os.path.join(\n here, 'ui/empty.html'),\n 'view': AddressCpuImageView}\n VIEWS['address_mem.png'] = {'template': os.path.join(\n here, 'ui/empty.html'),\n 'view': AddressMemoryImageView}\n VIEWS['address_io.png'] = {'template': os.path.join(\n here, 'ui/empty.html'),\n 'view': AddressNetworkImageView}","def _buildUi(self):\r\n # units\r\n self.units_label = QtGui.QLabel('Units: ')\r\n self.units_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\r\n self.imperial_button = QtGui.QRadioButton('imperial')\r\n self.metric_button = QtGui.QRadioButton('metric')\r\n\r\n self.unit_buttons_group = QtGui.QButtonGroup()\r\n self.unit_buttons_group.addButton(self.imperial_button)\r\n self.unit_buttons_group.addButton(self.metric_button)\r\n self.unit_buttons_group.setExclusive(True)\r\n\r\n # age\r\n self.age_label = QtGui.QLabel('Age: ')\r\n self.age_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\r\n self.age_field = QtGui.QDoubleSpinBox()\r\n self.age_field.setFixedWidth(70)\r\n self.age_field.setRange(1, 200)\r\n self.age_field.setSingleStep(1)\r\n self.age_field.setValue(self._age)\r\n\r\n # height\r\n self.height_label = QtGui.QLabel('Height: ')\r\n self.height_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\r\n self.height_field = QtGui.QDoubleSpinBox()\r\n self.height_field.setFixedWidth(70)\r\n self.height_field.setRange(1, 1000)\r\n self.height_field.setSingleStep(0.1)\r\n self.height_field.setValue(self._height)\r\n self.height_units_label = QtGui.QLabel()\r\n\r\n # weight\r\n self.weight_label = QtGui.QLabel('Weight: ')\r\n self.weight_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\r\n self.weight_field = QtGui.QDoubleSpinBox()\r\n self.weight_field.setFixedWidth(70)\r\n self.weight_field.setRange(1, 2000)\r\n self.weight_field.setSingleStep(0.1)\r\n self.weight_field.setValue(self._weight)\r\n self.weight_units_label = QtGui.QLabel()\r\n\r\n # body fat\r\n self.bodyFat_label = QtGui.QLabel('Body Fat %: ')\r\n self.bodyFat_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\r\n self.bodyFat_field = QtGui.QDoubleSpinBox()\r\n self.bodyFat_field.setFixedWidth(70)\r\n self.bodyFat_field.setRange(1, 100)\r\n self.bodyFat_field.setSingleStep(0.1)\r\n self.bodyFat_field.setValue(self._body_fat)\r\n\r\n # gender\r\n self.gender_label = QtGui.QLabel('Gender: ')\r\n self.gender_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\r\n self.gender_combobox = QtGui.QComboBox()\r\n self.gender_combobox.addItems(GENDERS)\r\n\r\n # data display\r\n self.calculate_button = QtGui.QPushButton('Calculate ...')\r\n self.calculate_button.setFixedHeight(35)\r\n self.feedback_field = QtGui.QTextEdit()\r\n\r\n # data entry lyout\r\n self.data_entry_grid = QtGui.QGridLayout()\r\n self.data_entry_grid.setSpacing(4)\r\n self.data_entry_grid.setContentsMargins(6, 6, 6, 6)\r\n self.data_entry_grid.addWidget(self.age_label, 0, 0, 1, 1)\r\n self.data_entry_grid.addWidget(self.age_field, 0, 1, 1, 1)\r\n self.data_entry_grid.addWidget(self.height_label, 1, 0, 1, 1)\r\n self.data_entry_grid.addWidget(self.height_field, 1, 1, 1, 1)\r\n self.data_entry_grid.addWidget(self.height_units_label, 1, 2, 1, 1)\r\n self.data_entry_grid.addWidget(self.weight_label, 2, 0, 1, 1)\r\n self.data_entry_grid.addWidget(self.weight_field, 2, 1, 1, 1)\r\n self.data_entry_grid.addWidget(self.weight_units_label, 2, 2, 1, 1)\r\n self.data_entry_grid.addWidget(self.bodyFat_label, 3, 0, 1, 1)\r\n self.data_entry_grid.addWidget(self.bodyFat_field, 3, 1, 1, 1)\r\n self.data_entry_grid.addWidget(self.gender_label, 4, 0, 1, 1)\r\n self.data_entry_grid.addWidget(self.gender_combobox, 4, 1, 1, 1)\r\n self.data_entry_grid.addWidget(self.units_label, 5, 0, 1, 1)\r\n self.data_entry_grid.addWidget(self.imperial_button, 5, 1, 1, 1)\r\n self.data_entry_grid.addWidget(self.metric_button, 5, 2, 1, 1)\r\n\r\n self.data_entry_grid.setColumnStretch(0, 0)\r\n self.data_entry_grid.setColumnStretch(1, 0)\r\n self.data_entry_grid.setColumnStretch(2, 0)\r\n self.data_entry_grid.setColumnStretch(3, 1)\r\n\r\n # main layout\r\n self.main_layout = QtGui.QVBoxLayout()\r\n self.main_layout.addLayout(self.data_entry_grid)\r\n self.main_layout.addWidget(self.calculate_button)\r\n self.main_layout.addWidget(self.feedback_field)\r\n self.setLayout(self.main_layout)","def __init__(self, ui_file, controller):\n super(InputDeviceView, self).__init__()\n self._controller = controller\n self._controller.accepted_cb = self._accepted_cb\n self._controller.finished_cb = self._finished_cb\n self._controller.rejected_cb = self._rejected_cb\n self._controller.current_gait_cb = self._current_gait_cb\n\n self._always_enabled_buttons = []\n\n # Extend the widget with all attributes and children from UI file\n loadUi(ui_file, self)\n\n self.refresh_button.clicked.connect(self._update_possible_gaits)\n\n self._create_buttons()\n self._update_possible_gaits()","def initUI(self):\n language_help = _('''<h4>Language code.</h4>\n<p>This will be transmitted as part of the requst sent to the\nsites. As some sites only support one language, this is also used to\ndecide where to send the requests. Use a standard language code\nhere. Using invalid values or codes of unsupported languages will\nresult in no downloads. Do <em>not</em> use domain codes (E.g. use\n<code>zh</code> rather than <code>cn</code> for Chinese.)</p>''')\n self.setWindowTitle(_('Anki – Download audio'))\n self.setWindowIcon(QIcon(\":/icons/anki.png\"))\n layout = QVBoxLayout()\n self.setLayout(layout)\n edit_word_head = QLabel()\n kanji_et = _('''\\\n<h4>Requests to send to the download sites</h4>\n<p>In the split edit fields, set the kanji on the left, the\nkana on the right.</p>\n''')\n base_et = _('''\\\n<h4>Requests to send to the download sites</h4>\n<p>In split edit fields, set the expression (base) on the left, the\nreading (ruby) on the right.</p>\n''')\n single_et = _('''\\\n<h4>Requests to send to the download sites</h4>\n''')\n # Now decide which help text to show.\n # First, decide if we have any split fields.\n if any(f_data.split for f_data in self.field_data_list):\n if self.language_code and self.language_code.startswith('ja'):\n # Japanese\n edit_word_head.setText(kanji_et)\n else:\n # Chinese should not happen at the moment\n edit_word_head.setText(base_et)\n else:\n edit_word_head.setText(single_et)\n layout.addWidget(edit_word_head)\n self.create_data_rows(layout)\n line = QFrame(self)\n line.setFrameShape(QFrame.HLine)\n line.setFrameShadow(QFrame.Sunken)\n layout.addWidget(line)\n lcode_head = QLabel(_('''<h4>Language code</h4>'''))\n layout.addWidget(lcode_head)\n lang_hlayout = QHBoxLayout()\n lc_label = QLabel(_('Language code:'), self)\n lang_hlayout.addWidget(lc_label)\n lc_label.setToolTip(language_help)\n self.language_code_lineedit = QLineEdit(self)\n try:\n self.language_code_lineedit.setText(self.language_code)\n except:\n self.language_code_lineedit.setText(default_audio_language_code)\n lang_hlayout.addWidget(self.language_code_lineedit)\n self.language_code_lineedit.setToolTip(language_help)\n layout.addLayout(lang_hlayout)\n dialog_buttons = QDialogButtonBox(self)\n dialog_buttons.addButton(QDialogButtonBox.Cancel)\n dialog_buttons.addButton(QDialogButtonBox.Ok)\n dialog_buttons.accepted.connect(self.accept)\n dialog_buttons.rejected.connect(self.reject)\n layout.addWidget(dialog_buttons)","def update_views():\n # replace Supervisor main entry\n here = path.abspath(path.dirname(__file__))\n # set main page\n VIEWS['index.html'] = {'template': path.join(here, 'ui/index.html'), 'view': SupvisorsView}\n # set address /processpage\n VIEWS['procaddress.html'] = {'template': path.join(here, 'ui/procaddress.html'), 'view': ProcAddressView}\n # set address/host page\n VIEWS['hostaddress.html'] = {'template': path.join(here, 'ui/hostaddress.html'), 'view': HostAddressView}\n # set application page\n VIEWS['application.html'] = {'template': path.join(here, 'ui/application.html'), 'view': ApplicationView}\n # set fake page to export images\n VIEWS['process_cpu.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': ProcessCpuImageView}\n VIEWS['process_mem.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': ProcessMemoryImageView}\n VIEWS['address_cpu.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': AddressCpuImageView}\n VIEWS['address_mem.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': AddressMemoryImageView}\n VIEWS['address_io.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': AddressNetworkImageView}","def loadUi(uifile, baseinstance=None, custom_widgets=None):\n return _loadUi(uifile, baseinstance, custom_widgets)","def setup_gui(self):\n # if there are more than 1 visualizer we need to assure that there\n # will not be tag conflicts\n BaseRealTimeVisualizer.setup_gui_lock.acquire()\n # look for valid tag\n dpg.create_context()\n\n self.id = 0\n while dpg.does_item_exist(f'main_window_{self.id}'):\n self.id += 1\n\n with dpg.texture_registry(show=False):\n dpg.add_dynamic_texture(\n width=self.width,\n height=self.height,\n default_value=np.zeros((self.width, self.height, 3)),\n tag=f'input_image_texture_{self.id}',\n )\n\n with dpg.window(\n tag=f'main_window_{self.id}',\n no_title_bar=True,\n autosize=True\n ):\n dpg.add_image(\n texture_tag=f'input_image_texture_{self.id}',\n tag=f'image_render_{self.id}',\n pos=(_PADDING, _PADDING)\n )\n\n dpg.set_global_font_scale(_FONT_SCALE)\n\n if self.id == 0:\n dpg.set_primary_window(f'main_window_{self.id}', True)\n dpg.create_viewport(\n title=self.title,\n width=self.width + _PADDING*2,\n height=self.height + _PADDING*2,\n resizable=True\n )\n dpg.setup_dearpygui()\n dpg.show_viewport()\n elif self.id == 1:\n dpg.set_primary_window('main_window_0', False)\n\n BaseRealTimeVisualizer.setup_gui_lock.release()","def buildUI(self):\n outside = QtWidgets.QVBoxLayout(self)\n columns = QtWidgets.QHBoxLayout(self)\n layout = QtWidgets.QVBoxLayout(self)\n self.details_layout = QtWidgets.QVBoxLayout(self) #column with edit panel\n self.restriction = QtWidgets.QWidget() #restricts size of details_layout\n self.restriction.setLayout(self.details_layout)\n self.restriction.setFixedWidth(200)\n columns.addLayout(layout)\n columns.addWidget(self.restriction)\n outside.addLayout(columns)\n\n #tab widget\n self.tabwidget = tabsWindow(self) #QtWidgets.QTabWidget(tabsClosable = True, movable = True)\n layout.addWidget(self.tabwidget)\n #add base tab\n self.tabwidget.newTab(name =\"Untitled\", image = \"\")\n\n #add second column with details\n self.updateDetails(\"edit\")\n\n #edit button\n layout_btns = QtWidgets.QHBoxLayout()\n editBtn = QtWidgets.QPushButton(\"Stop Editing\")\n editBtn.clicked.connect(lambda: self.editChange(editBtn))\n layout_btns.addWidget(editBtn)\n\n #save button\n saveBtn = QtWidgets.QPushButton(\"Save\")\n saveBtn.clicked.connect(self.save)\n layout_btns.addWidget(saveBtn)\n\n #load button\n loadBtn = QtWidgets.QPushButton(\"Load\")\n loadBtn.clicked.connect(self.load)\n layout_btns.addWidget(loadBtn)\n\n #close button\n closeBtn = QtWidgets.QPushButton('Close')\n closeBtn.clicked.connect(self.closeEvent)\n layout_btns.addWidget(closeBtn)\n\n outside.addLayout(layout_btns) #add buttons to layout","def loadUI(self,factory={'GLOB':Glob,'BOOK':Book,'SCPT':Scpt,'CELL':Cell}):\n FileRep.loadUI(self,factory)","def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/k.png')\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\n\n\t\t# KI Plus\n self.k1plus_button = pyxbmct.RadioButton('')\n self.placeControl(self.k1plus_button, 8, 1, rowspan=2, columnspan=4)\n self.connect(self.k1plus_button, self.k1plus_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'k1plus', 2) == 1:\n self.k1plus_button.setSelected(True)\n else:\n self.k1plus_button.setSelected(False)\n k1plus = pyxbmct.Image(addonfolder+artsfolder+'/k1plus.png')\n self.placeControl(k1plus, 8, 1, rowspan=2, columnspan=4)\n\n\t\t# KI Pro\n self.k1pro_button = pyxbmct.RadioButton('')\n self.placeControl(self.k1pro_button, 11, 6, rowspan=2, columnspan=4)\n self.connect(self.k1pro_button, self.k1pro_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'k1pro', 2) == 1:\n self.k1pro_button.setSelected(True)\n else:\n self.k1pro_button.setSelected(False)\n k1pro = pyxbmct.Image(addonfolder+artsfolder+'/k1pro.png')\n self.placeControl(k1pro, 11, 6, rowspan=2, columnspan=4)\n\n\t\t# KII Pro\n self.k2pro_button = pyxbmct.RadioButton('')\n self.placeControl(self.k2pro_button, 8, 6, rowspan=2, columnspan=4)\n self.connect(self.k2pro_button, self.k2pro_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'k2pro', 2) == 1:\n self.k2pro_button.setSelected(True)\n else:\n self.k2pro_button.setSelected(False)\n k2pro = pyxbmct.Image(addonfolder+artsfolder+'/k2pro.png')\n self.placeControl(k2pro, 8, 6, rowspan=2, columnspan=4)\n\n\t\t# KIII Pro\n self.k3pro_button = pyxbmct.RadioButton('')\n self.placeControl(self.k3pro_button, 8, 11, rowspan=2, columnspan=4)\n self.connect(self.k3pro_button, self.k3pro_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'k3pro', 2) == 1:\n self.k3pro_button.setSelected(True)\n else:\n self.k3pro_button.setSelected(False)\n k3pro = pyxbmct.Image(addonfolder+artsfolder+'/k3pro.png')\n self.placeControl(k3pro, 8, 11, rowspan=2, columnspan=4)\n\n\t\t# Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.closepage())","def _initUI(self, folder):\n\n vlayout = QtWidgets.QVBoxLayout()\n\n # Pharos schematisaties\n #----------------------------------------------------------------\n\n schematisationsFrame = QtWidgets.QGroupBox()\n schematisationsFrame.setTitle('Kies Pharos schematisaties')\n\n self.listSchematisations = QtWidgets.QListView()\n\n # Create an empty model for the list's data\n schematisationModel = QtGui.QStandardItemModel(self.listSchematisations)\n\n schematisations = self.pharos.pharosio.getSchematisations(folder)\n for schematisation in schematisations:\n # create an item with a caption\n item = QtGui.QStandardItem(schematisation)\n # Add a checkbox to it\n item.setCheckable(True)\n # Set default true\n item.setCheckState(QtCore.Qt.Checked)\n # Add the item to the model\n schematisationModel.appendRow(item)\n\n # Apply the model to the list view\n self.listSchematisations.setModel(schematisationModel)\n\n ## Show the window and run the app\n vlayout.addWidget(self.listSchematisations)\n\n schematisationsFrame.setLayout(vlayout)\n\n\n # Water levels\n #----------------------------------------------------------------\n waterlevelsframe = QtWidgets.QGroupBox()\n waterlevelsframe.setTitle('Kies waterstanden')\n\n vlayout = QtWidgets.QVBoxLayout()\n self.listWaterlevels = QtWidgets.QListView()\n # Create an empty model for the list's data\n waterlevelsModel = QtGui.QStandardItemModel(self.listWaterlevels)\n\n for waterlevel in self.waterlevels:\n # create an item with a caption\n item = QtGui.QStandardItem(str(waterlevel.round(2)))\n # Add a checkbox to it\n item.setCheckable(True)\n # Set default true\n item.setCheckState(QtCore.Qt.Checked)\n # Add the item to the model\n waterlevelsModel.appendRow(item)\n\n # Apply the model to the list view\n self.listWaterlevels.setModel(waterlevelsModel)\n\n vlayout.addWidget(self.listWaterlevels)\n\n waterlevelsframe.setLayout(vlayout)\n\n vbox = QtWidgets.QVBoxLayout()\n vbox.addWidget(schematisationsFrame)\n vbox.addWidget(waterlevelsframe)\n\n self.setLayout(vbox)\n\n # OK and Cancel buttons\n\n self.generateButton = QtWidgets.QPushButton('OK')\n self.generateButton.setDefault(True)\n self.generateButton.clicked.connect(self.ok)\n\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\n self.cancelButton.setAutoDefault(False)\n self.cancelButton.clicked.connect(self.cancel)\n\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\n\n button_box.accepted.connect(QtWidgets.QDialog.accept)\n # button_box.rejected.connect(QtWidgets.QDialog.reject)\n\n self.layout().addWidget(button_box)","def __init__(self):\n self.view = GuiView(self)\n return","def __init__(self, base_image=None, subject=None, subjects_dir=None,\n verbose=None):\n # initialize QMainWindow class\n super(SliceBrowser, self).__init__()\n\n self._verbose = verbose\n # if bad/None subject, will raise an informative error when loading MRI\n subject = os.environ.get('SUBJECT') if subject is None else subject\n subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)\n self._subject_dir = op.join(subjects_dir, subject)\n self._load_image_data(base_image=base_image)\n\n # GUI design\n\n # Main plots: make one plot for each view; sagittal, coronal, axial\n self._plt_grid = QGridLayout()\n self._figs = list()\n for i in range(3):\n canvas, fig = _make_slice_plot()\n self._plt_grid.addWidget(canvas, i // 2, i % 2)\n self._figs.append(fig)\n self._renderer = _get_renderer(\n name='Slice Browser', size=(400, 400), bgcolor='w')\n self._plt_grid.addWidget(self._renderer.plotter, 1, 1)\n\n self._set_ras([0., 0., 0.], update_plots=False)\n\n self._plot_images()\n\n self._configure_ui()","def initCentralUic(self):\n self.initFileTableWidget()\n self.initViewerStack()\n self.splitter.setSizes([150, 850])","def controls_setup(self):\n\n self.subbie_name = element.Link(self, css_selector='th:nth-child(1) > a', alias=\"Admin Subbie Name Link\")\n self.type = element.Caption(self, css_selector='td:nth-child(2)', alias=\"Subbie Type\")\n self.username = element.Caption(self, css_selector='td:nth-child(3)', alias=\"Username\")\n self.email = element.Caption(self, css_selector='td:nth-child(4)', alias=\"Email\")\n self.active_start_date = element.Link(self, css_selector='td:nth-child(5)', alias=\"Active Start Date Text\")\n self.active_end_date = element.Link(self, css_selector='td:nth-child(6)', alias=\"Active End Date Text\")","def setUI(self):\n \n l = QtGui.QLabel(\"Open file:\")\n browseButton = QtGui.QPushButton(\"Browse\")\n analyzeButton = QtGui.QPushButton(\"Analyse\")\n self.filelabel = QtGui.QLabel(\"\")\n self.messageLabel = QtGui.QLabel(\"\")\n \n #camera intrasec values\n self.fxlabel = QtGui.QLabel('focal x')\n self.fylabel = QtGui.QLabel('focal y')\n self.dist1label = QtGui.QLabel('K1')\n self.dist2label = QtGui.QLabel('K2')\n self.dist3label = QtGui.QLabel('P1')\n self.dist4label = QtGui.QLabel('P2')\n\n #set layout\n self.grid = QtGui.QGridLayout()\n a = self.grid.addWidget\n a(l, 0,0)\n a(browseButton, 0,2)\n a(self.filelabel,0,1)\n a(self.messageLabel, 1,0,1,4)\n a(analyzeButton, 2,0,1,4)\n\n a(self.fxlabel, 3,0)\n a(self.fylabel, 3,1)\n a(self.dist1label, 4,0)\n a(self.dist2label, 5,0)\n a(self.dist3label, 6,0)\n a(self.dist4label, 7,0)\n\n self.setLayout(self.grid)\n\n\n #connect signals to methods\n self.connect(browseButton, QtCore.SIGNAL('clicked()'), self.onOpenFileClicked)\n self.connect(analyzeButton, QtCore.SIGNAL('clicked()'), self.startAnalyze)","def _setupUi(self, widget):\n \n widget._setup_vertical_layout()\n widget._setup_horizontal_layout()\n widget._setup_vertical_layout()\n for field in self._fields:\n if field=='channel_idx':\n widget._exit_layout()\n widget._setup_vertical_layout()\n choices = None\n if hasattr(self, field + 's'):\n choices = self.__getattribute__(field + 's')\n widget._setup_gui_element(field, choices)\n widget._exit_layout()\n widget._exit_layout()\n self._setup_fetch_buttons(widget)","def __init__(self, baseinstance, customWidgets=None):\n\n QUiLoader.__init__(self, baseinstance)\n\n self.baseinstance = baseinstance\n\n if customWidgets is None:\n self.customWidgets = {}\n else:\n self.customWidgets = customWidgets","def _load_ui(self):\n load_ui(\"about_dlg.ui\", self)\n\n self.title_label = self.findChild(QLabel, \"title_label\")\n self.title_label.setText(f\"Friendly Pics 2 v{__version__}\")\n\n self.runtime_env_label = self.findChild(QLabel, \"runtime_env_label\")\n if is_mac_app_bundle():\n self.runtime_env_label.setText(\"Running as MacOS app bundle\")\n elif is_pyinstaller_bundle():\n self.runtime_env_label.setText(\"Running as a pyinstaller binary\")\n else:\n self.runtime_env_label.setText(\"Running under conventional Python environment\")\n\n self.gui_settings_label = self.findChild(QLabel, \"gui_settings_label\")\n self.gui_settings_label.setText(f\"<b>GUI Settings:</b> {self._settings.fileName()}\")\n\n self.gui_settings_clear_button = self.findChild(QPushButton, \"gui_settings_clear_button\")\n self.gui_settings_clear_button.clicked.connect(self._clear_gui_settings)\n\n self.app_settings_label = self.findChild(QLabel, \"app_settings_label\")\n self.app_settings_label.setText(f\"<b>App Settings:</b> {self._app_settings.path}\")\n\n # Center the about box on the parent window\n parent_geom = self.parent().geometry()\n self.move(parent_geom.center() - self.rect().center())","def __init__(self, parent=None):\n super(Inj, self).__init__(parent)\n self.setupUi(self)","def inicialUI(self):\r\n\r\n self.setGeometry(500, 500, 500, 500)\r\n self.setWindownTitle(\"Pesquisa\")\r\n self.displayWidgets()\r\n\r\n self.show()","def setup(self):\n self.ui_manager.purge_ui_elements()\n y_slot = self.window.height // 12\n\n ui_input_box = arcade.gui.UIInputBox(\n center_x=self.window.width // 2,\n center_y=y_slot * 7,\n width=250\n )\n ui_input_box.set_style_attrs(\n bg_color=(66, 179, 208),\n bg_color_hover=(112, 212, 238),\n bg_color_focus=(255, 228, 14)\n )\n ui_input_box.text = self.name\n ui_input_box.cursor_index = len(ui_input_box.text)\n self.ui_manager.add_ui_element(ui_input_box)\n\n button = buttons.ExitButton(\n 'Exit',\n center_x=self.window.width // 2,\n center_y=y_slot * 1,\n width=250\n )\n button.set_style_attrs(\n bg_color=(51, 139, 57),\n bg_color_hover=(135, 21, 25),\n bg_color_press=(122, 21, 24),\n )\n self.ui_manager.add_ui_element(button)\n\n button = buttons.AuthorButton(\"Author\",\n center_x=self.window.width // 2,\n center_y=y_slot * 2,\n width=250,\n user=ui_input_box\n )\n button.set_style_attrs(\n bg_color=(51, 139, 57),\n bg_color_hover=(88, 196, 96),\n bg_color_press=(28, 71, 32),\n )\n self.ui_manager.add_ui_element(button)\n\n button = buttons.ResultButton(\"Results\",\n center_x=self.window.width // 2,\n center_y=y_slot * 3,\n width=250,\n user=ui_input_box,\n level = \"level1\"\n )\n button.set_style_attrs(\n bg_color=(51, 139, 57),\n bg_color_hover=(88, 196, 96),\n bg_color_press=(28, 71, 32),\n )\n self.ui_manager.add_ui_element(button)\n\n button = buttons.RulesButton(\"Rules\",\n center_x=self.window.width // 2,\n center_y=y_slot * 4,\n width=250,\n user=ui_input_box\n )\n button.set_style_attrs(\n bg_color=(51, 139, 57),\n bg_color_hover=(88, 196, 96),\n bg_color_press=(28, 71, 32),\n )\n self.ui_manager.add_ui_element(button)\n\n button = buttons.LevelButton(\"Play level 1\",\n center_x=self.window.width // 2,\n center_y=y_slot * 6,\n width=250,\n user=ui_input_box,\n level=\"level1\"\n )\n button.set_style_attrs(\n bg_color=(51, 139, 57),\n bg_color_hover=(88, 196, 96),\n bg_color_press=(28, 71, 32),\n )\n self.ui_manager.add_ui_element(button)\n\n button = buttons.LevelButton(\"Play level 2\",\n center_x=self.window.width // 2,\n center_y=y_slot * 5,\n width=250,\n user=ui_input_box,\n level = \"level2\"\n )\n button.set_style_attrs(\n bg_color=(51, 139, 57),\n bg_color_hover=(88, 196, 96),\n bg_color_press=(28, 71, 32),\n )\n self.ui_manager.add_ui_element(button)","def setup(self):\n ScriptedLoadableModuleWidget.setup(self)\n try:\n self.reloadCollapsibleButton.collapsed = True\n except:\n pass\n # Instantiate and connect widgets ...\n #\n \n # Inputs volume selectors\n DataCollButtom = ctk.ctkCollapsibleButton()\n DataCollButtom.text = \"Input Volumes\"\n self.layout.addWidget(DataCollButtom)\n self.InputOutput_Layout = qt.QFormLayout(DataCollButtom)\n self.setupAnatomicalRef()\n self.setupLL_Native()\n self.setupLL_Enhanced()\n\n # Apply Buttons\n self.setRefreshViewsAndCheckButtonButton()\n self.setT1Button()\n\n # Statistics section widgets\n Statistics = ctk.ctkCollapsibleButton()\n Statistics.text = \"Statistics\"\n Statistics.collapsed = True\n self.layout.addWidget(Statistics)\n self.Statistics_Layout = qt.QFormLayout(Statistics)\n self.Stats = statistics()\n self.Stats.setupSegmentationSelector(self.Statistics_Layout,self.layout)\n\n # ECV section widgets\n ECVcollButton = ctk.ctkCollapsibleButton()\n ECVcollButton.text = \"ECV Mapping\"\n ECVcollButton.collapsed = True\n self.layout.addWidget(ECVcollButton)\n self.ECVcollButton_Layout = qt.QFormLayout(ECVcollButton)\n self.setECVScalarVolume()\n self.setupSpinBoxControllers()\n self.setECVButton()\n\n # Threshold Controllers \n ThCollButton = ctk.ctkCollapsibleButton()\n ThCollButton.text = \"Threshold controlers\"\n ThCollButton.collapsed = True\n self.layout.addWidget(ThCollButton)\n self.Th_Layout = qt.QFormLayout(ThCollButton)\n self.ThSlider_LLN = DoubleSlider(self.Th_Layout, self.SetThreshold)\n self.ThSlider_LLN.SetupDoubleSliderControl(WidgetName = 'T1-Native Threshold')\n self.ThSlider_LLE = DoubleSlider(self.Th_Layout, self.SetThreshold)\n self.ThSlider_LLE.SetupDoubleSliderControl(WidgetName = 'T1-Enhanced Threshold')\n self.ThSlider_ECV = DoubleSlider(self.Th_Layout, self.SetThreshold)\n self.ThSlider_ECV.SetupDoubleSliderControl(WidgetName = 'ECV Mapping')\n\n self.onCheckbuttonChecked()\n self.setupConnections()","def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/tvh.png')\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\n\n\t\t# Label information\n image = pyxbmct.Image(addonfolder+artsfolder+'/users.png')\n self.placeControl(image, 8, 1, rowspan=1, columnspan=14)\n\t\t\n\t\t# Username input\n image = pyxbmct.Image(addonfolder+artsfolder+'/username.png')\n self.placeControl(image, 10, 1, rowspan=1, columnspan=3)\n self.username_input = pyxbmct.Edit('')\n self.placeControl(self.username_input, 10, 4, rowspan=1, columnspan=4)\n\n\t\t# Password input\n image = pyxbmct.Image(addonfolder+artsfolder+'/password.png')\n self.placeControl(image, 11, 1, rowspan=1, columnspan=3)\n self.password_input = pyxbmct.Edit('', isPassword=True)\n self.placeControl(self.password_input, 11, 4, rowspan=1, columnspan=4)\n\n\t\t# Next button\n self.next_button = pyxbmct.Button('Next')\n self.placeControl(self.next_button, 13, 14, rowspan=1, columnspan=1)\n # Connect close button\n self.connect(self.next_button, lambda: self.page())\n\t\t\n\t\t# Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.closepage())","def html_viewer(i):\n\n i['module_uoa']='experiment.tune.compiler.flags'\n i['module_cfg']=copy.deepcopy(cfg)\n i['module_work']=copy.deepcopy(work)\n return ck.access(i)","def populateTabs(self):\n frameworks = self.data['frameworks']\n for fw in frameworks:\n frameworkElements = frameworks[fw]\n for element in frameworkElements:\n\n ui = self.framework2gui[fw].get(element)\n\n if isinstance(ui, QComboBox):\n ui.clear()\n ui.setView(QListView())\n for i, deviceName in enumerate(frameworks[fw][element]):\n ui.addItem(deviceName)\n if frameworks[fw]['deviceName'] == deviceName:\n ui.setCurrentIndex(i)\n\n elif isinstance(ui, QLineEdit):\n ui.setText(f'{frameworks[fw][element]}')\n\n elif isinstance(ui, QCheckBox):\n ui.setChecked(frameworks[fw][element])\n\n elif isinstance(ui, QDoubleSpinBox):\n ui.setValue(frameworks[fw][element])\n return True","def initGui(self):\r\n\r\n # Create help action \r\n self.helpAction = QAction( QIcon(\":/plugins/layercombinations/about.png\"), u\"Help\", self.iface.mainWindow())\r\n # connect the action \r\n self.helpAction.triggered.connect( self.showHelp )\r\n # Add menu item\r\n self.iface.addPluginToMenu(u\"&Layer Combinations\", self.helpAction)\r\n\r\n # Create the action that allows to change the widget type\r\n self.changeWidgetAction = QAction(\"Change widget type\", self.iface.mainWindow())\r\n self.changeWidgetAction.triggered.connect( self.changeWidget )\r\n self.iface.addPluginToMenu(u\"&Layer Combinations\", self.changeWidgetAction)\r\n\r\n # Create the action that will toggle the plugin panel\r\n self.action = QAction(QIcon(\":/plugins/layercombinations/icon.png\"), \"Show/hide the Layer Combinations widgets\", self.iface.mainWindow())\r\n self.action.triggered.connect( self.widget.toggle )\r\n # Add toolbar button and menu item\r\n self.iface.addToolBarIcon(self.action)\r\n self.iface.addPluginToMenu(u\"&Layer Combinations\", self.action)\r\n\r\n\r\n # Add the widget to the mainWindow\r\n self.widget.addToiFace(self.iface)","def __init__(self, viewer: geoviewer.GeoGraphViewer) -> None:\n super().__init__(viewer=viewer)\n\n # Creating individual (sub-)widgets\n visibility_widget = RadioVisibilityWidget(viewer=self.viewer)\n metrics_widget = MetricsWidget(viewer=self.viewer)\n settings_widget = SettingsWidget(viewer=self.viewer)\n\n viewer_height = int(viewer.layout.height.replace(\"px\", \"\"))\n metrics_widget.layout.height = \"{}px\".format(viewer_height * 0.3)\n\n if self.viewer.small_screen:\n view_tab = [visibility_widget]\n else:\n view_tab = [visibility_widget, widget_utils.HRULE, metrics_widget]\n\n # Create combined widget, each key corresponds to a tab\n combined_widget_dict = dict()\n combined_widget_dict[\"View\"] = widgets.VBox(view_tab)\n if self.viewer.small_screen:\n combined_widget_dict[\"Metrics\"] = metrics_widget\n combined_widget_dict[\"Settings\"] = settings_widget\n combined_widget_dict[\"Log\"] = self.log_handler.out\n\n combined_widget = widgets.Tab()\n combined_widget.children = list(combined_widget_dict.values())\n for i, title in enumerate(combined_widget_dict):\n combined_widget.set_title(i, title)\n\n self.children = [combined_widget]","def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/osc.png')\n self.placeControl(image, 0, 0, rowspan=7, columnspan=16)\n\n\t\t# Label information\n image = pyxbmct.Image(addonfolder+artsfolder+'/readers.png')\n self.placeControl(image, 7, 1, rowspan=1, columnspan=14)\n\t\t\n\t\t# Hostname input\n image = pyxbmct.Image(addonfolder+artsfolder+'/hostname.png')\n self.placeControl(image, 9, 0, rowspan=1, columnspan=4)\n self.hostname_input = pyxbmct.Edit('')\n self.placeControl(self.hostname_input, 9, 4, rowspan=1, columnspan=5)\n\n\t\t# Port input\n image = pyxbmct.Image(addonfolder+artsfolder+'/port.png')\n self.placeControl(image, 12, 1, rowspan=1, columnspan=3)\n self.port_input = pyxbmct.Edit('')\n self.placeControl(self.port_input, 12, 4, rowspan=1, columnspan=2)\n\n\t\t# Username input\n image = pyxbmct.Image(addonfolder+artsfolder+'/username.png')\n self.placeControl(image, 10, 1, rowspan=1, columnspan=3)\n self.username_input = pyxbmct.Edit('')\n self.placeControl(self.username_input, 10, 4, rowspan=1, columnspan=4)\n\t\t\n\t\t# Password input\n image = pyxbmct.Image(addonfolder+artsfolder+'/password.png')\n self.placeControl(image, 11, 1, rowspan=1, columnspan=3)\n self.password_input = pyxbmct.Edit('', isPassword=True)\n self.placeControl(self.password_input, 11, 4, rowspan=1, columnspan=4)\n\n\t\t# Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.page(Readers))","def create_widgets(self):","def __init__(self, controller):\n super().__init__(controller)\n\n # The hovered input when entering this View.\n self.first_inp = \"s\"\n\n # Initialize selected variable.\n self.selected = None\n\n # Make background graphics.\n self.make_background_graphics()\n\n # Make Buttons.\n self.make_buttons()\n\n # Make the information box. This explains each Button.\n self.make_info_box()\n\n # Initializes popup.\n self.make_popup()\n\n # Map of input to functions.\n enter = self.graphics.ENTER_KEY\n self.controls = {\n # Pressing \"q\" will go back to the main menu.\n \"q\": lambda: Action(\"goto main menu view\", []),\n\n # Movement keys.\n \"w\": lambda: self.move_cursor(Direction.U),\n \"a\": lambda: self.move_cursor(Direction.L),\n \"s\": lambda: self.move_cursor(Direction.D),\n \"d\": lambda: self.move_cursor(Direction.R),\n\n # Repeat the last valid input.\n enter: self.repeat_last_valid_input,\n\n # Click the selected UIElement.\n \"m\": self.click\n }","def _ui_content(self):\n\n # Cleat the tree\n self.clear()\n\n # Set the font\n font = QtGui.QFont()\n font.setPointSize(11)\n\n # Add the id sets and set items\n for id_set, id_dict in sorted(self.scnData.items()):\n tree_item = QtGui.QTreeWidgetItem(self)\n\n tree_item.setText(0, id_set)\n tree_item.setFont(0, font)\n\n icon_folder = os.path.dirname(os.path.abspath(__file__))\n icon_path = os.path.join(icon_folder, \"icons\", \"IdSet.png\")\n\n tree_item.setIcon(0, QtGui.QIcon(icon_path))\n\n tree_item.setData(0, QtCore.Qt.UserRole, \"set\")\n tree_item.setData(1, QtCore.Qt.UserRole, id_set)\n\n for id_color, id_objects in sorted(id_dict.items()):\n if id_color != \"Holdout\":\n self._add_id_color(id_objects,\n id_color,\n tree_item)\n\n self._add_id_color(id_dict[\"Holdout\"], \"Holdout\", tree_item)\n\n return","def __init__(self, parent, config, twirlpath):\r\n\t\tself._init_ctrls(parent)\r\n\r\n\t\t# Merely hide frame if the close window [X] button used\r\n\t\tself.Bind(wx.EVT_CLOSE, self.OnFrameClose)\r\n\r\n\t\t# Load config data and make temporary copy, updates not passed\r\n\t\t# to main copy until user pressed OK so as to not cause any\r\n\t\t# intervening image downloads to be based on intermediate values\r\n\t\tself._config = config\r\n\t\tself._configtmp = ConfigOps()\r\n\t\tself._configtmp.update(config)\r\n\r\n\t\t# Set local config variables\r\n\t\tself._twirlpath = twirlpath\r\n\t\tself._password = \"\"\r\n\r\n\t\t# Set program icon\r\n\t\tself.SetIcon(icons.getTwirlIcon())\r\n\r\n\t\t# Generate list containing icons\r\n\t\ticonlist = wx.ImageList(16, 16)\r\n\t\ticonyellowstar = iconlist.Add(icons.getYellowStarBitmap())\r\n\t\ticonuser = iconlist.Add(icons.getUserBitmap())\r\n\t\ticonwrench = iconlist.Add(icons.getWrenchBitmap())\r\n\t\ticoninfo = iconlist.Add(icons.getInfoBitmap())\r\n\r\n\t\t# Assign icon list to notebook, then assign icons\r\n\t\t# to individual pages\r\n\t\tself.notebookApp.AssignImageList(iconlist)\r\n\t\tself.notebookApp.SetPageImage(0, iconyellowstar)\r\n\t\tself.notebookApp.SetPageImage(1, iconuser)\r\n\t\tself.notebookApp.SetPageImage(2, iconwrench)\r\n\t\tself.notebookApp.SetPageImage(3, iconinfo)","def initGui(self):\n self.sketchButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'sketch.svg'),\n text=self.tr('Sketch on map'),\n callback=self.sketchAction,\n parent=self.iface.mainWindow(),\n object_name='mSketchAction')\n self.penButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'pen.svg'),\n text=self.tr('Draw line on map'),\n callback=self.penAction,\n parent=self.iface.mainWindow(),\n object_name='mPenAction')\n self.canvasButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'canvas.svg'),\n text=self.tr('Color and width canvas'),\n callback=None,\n parent=self.iface.mainWindow())\n self.eraseButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'erase.svg'),\n text=self.tr('Erase sketches'),\n callback=self.eraseAction,\n parent=self.iface.mainWindow(),\n object_name='mEraseAction')\n self.removeButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'remove.svg'),\n text=self.tr('Remove all sketches'),\n callback=self.removeSketchesAction,\n parent=self.iface.mainWindow(),\n object_name='mRemoveAllSketches')\n self.noteButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'note.svg'),\n text=self.tr('Add text annotations to sketches'),\n callback=None,\n parent=self.iface.mainWindow(),\n object_name='mAddTextAnnotations')\n self.convertButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'toLayer.svg'),\n text=self.tr('Convert annotations to Memory Layer'),\n callback=self.toMemoryLayerAction,\n parent=self.iface.mainWindow(),\n object_name='mConvertAnnotationsToMemoryLayer')\n self.saveButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'inbox.svg'),\n text=self.tr('Save sketches to file'),\n callback=self.saveAction,\n parent=self.iface.mainWindow(),\n object_name='mSaveSketchesToFile')\n self.loadButton = self.add_action(\n path.join(self.plugin_dir, 'icons', 'outbox.svg'),\n text=self.tr('Load sketches from file'),\n callback=self.loadAction,\n parent=self.iface.mainWindow(),\n object_name='mLoadSketchesFromFile')\n self.canvasButton.setMenu(self.canvasMenu())\n self.noteButton.setCheckable(True)\n self.penButton.setCheckable(True)\n self.sketchButton.setCheckable(True)\n self.eraseButton.setCheckable(True)\n self.geoSketches = []\n self.dumLayer = QgsVectorLayer(\"Point?crs=EPSG:4326\", \"temporary_points\", \"memory\")\n self.pressed = None\n self.previousPoint = None\n self.previousMoved = None\n self.gestures = 0\n self.points = 0\n self.currentColor = QColor(\"#aa0000\")\n self.currentWidth = 5\n self.annotation = sketchNoteDialog(self.iface)\n self.annotatatedSketch = None\n self.sketchEnabled(None)\n self.iface.projectRead.connect(self.projectReadAction)\n self.iface.newProjectCreated.connect(self.newProjectCreatedAction)\n QgsProject.instance().legendLayersAdded.connect(self.notSavedProjectAction)","def __init__(self):\n super(QTUIProject, self).__init__()\n self.setupUi(self)\n self.assignWidgets()\n self.show()\n self.SlotsJsonName = \"Slots Assets Folder\"\n self.BingoJsonName = \"Bingo Assets Folder\"","def initUI(self):\n self.logger.debug('Setting up the Measurement GUI')\n self.setWindowTitle(self.title)\n\n self.show()\n\n self.make_combobox_scanner()\n self.make_combobox_movements()\n self.make_combobox_configurate()\n self.make_combobox_basic()","def initAppletDrawerUic(self):\n with Tracer(traceLogger):\n # Load the ui file (find it in our own directory)\n localDir = os.path.split(__file__)[0]+'/'\n # (We don't pass self here because we keep the drawer ui in a separate object.)\n self.drawer = uic.loadUi(localDir+\"/dataSelectionDrawer.ui\")\n\n # Set up our handlers\n self.drawer.addFileButton.clicked.connect(self.handleAddFileButtonClicked)\n self.drawer.addFileButton.setIcon( QIcon(ilastikIcons.AddSel) )\n\n self.drawer.addMassButton.clicked.connect(self.handleMassAddButtonClicked)\n self.drawer.addMassButton.setIcon( QIcon(ilastikIcons.AddSel) )\n\n self.drawer.addStackButton.clicked.connect(self.handleAddStackButtonClicked)\n self.drawer.addStackButton.setIcon( QIcon(ilastikIcons.AddSel) )\n\n self.drawer.addStackFilesButton.clicked.connect(self.handleAddStackFilesButtonClicked)\n self.drawer.addStackFilesButton.setIcon( QIcon(ilastikIcons.AddSel) )\n\n self.drawer.removeFileButton.setEnabled(False)\n self.drawer.removeFileButton.clicked.connect(self.handleRemoveButtonClicked)\n self.drawer.removeFileButton.setIcon( QIcon(ilastikIcons.RemSel) )","def _icons(self):","def _setup_ui(self):\n from functools import partial\n\n self.setStyleSheet(\n \"\"\"\n QLabel[labelField=\"true\"] {\n font-weight: bold;\n }\n \"\"\"\n )\n\n # The main layout\n self.main_layout = QtWidgets.QVBoxLayout(self)\n self.main_layout.setContentsMargins(0, 0, 0, 0)\n\n # the form layout\n self.form_layout = QtWidgets.QFormLayout()\n self.form_layout.setLabelAlignment(\n QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing | QtCore.Qt.AlignVCenter\n )\n\n # store roles\n label_role = QtWidgets.QFormLayout.LabelRole\n field_role = QtWidgets.QFormLayout.FieldRole\n\n self.main_layout.addLayout(self.form_layout)\n\n i = -1\n\n # Reviewer\n i += 1\n reviewer_name_label = QtWidgets.QLabel(self)\n reviewer_name_label.setText(\"Reviewer\")\n self.form_layout.setWidget(i, label_role, reviewer_name_label)\n\n self.reviewer_name_widget = QtWidgets.QLabel(self)\n self.form_layout.setWidget(i, field_role, self.reviewer_name_widget)\n\n # Task Name field\n i += 1\n task_name_label = QtWidgets.QLabel(self)\n task_name_label.setText(\"Task\")\n self.form_layout.setWidget(i, label_role, task_name_label)\n\n self.task_name_widget = QtWidgets.QLabel(self)\n self.form_layout.setWidget(i, field_role, self.task_name_widget)\n\n # # Version Info field\n # from anima.ui.widgets.version import VersionDetailsWidget\n # self.latest_version_widget = VersionDetailsWidget(parent=self)\n # self.main_layout.insertWidget(0, self.latest_version_widget)\n\n # Review Type Field\n i += 1\n review_type_label = QtWidgets.QLabel(self)\n review_type_label.setText(\"Review Type\")\n self.form_layout.setWidget(i, label_role, review_type_label)\n\n self.review_type_widget = ReviewTypeWidget(self)\n self.review_type_widget.currentIndexChanged.connect(\n partial(self.review_type_changed_callback)\n )\n\n self.form_layout.setWidget(i, field_role, self.review_type_widget)\n\n # Timing Field\n i += 1\n effort_label = QtWidgets.QLabel(self)\n effort_label.setText(\"Timing\")\n self.form_layout.setWidget(i, label_role, effort_label)\n\n effort_layout = QtWidgets.QHBoxLayout()\n self.form_layout.setLayout(i, field_role, effort_layout)\n\n from anima.ui.widgets.timing import ScheduleTimingWidget\n from anima import defaults\n\n self.timing_widget = ScheduleTimingWidget(\n self, timing_resolution=defaults.timing_resolution\n )\n self.timing_widget.setEnabled(False)\n # set the default to 1 hour\n self.timing_widget.set_schedule_info(timing=1, unit=\"h\")\n effort_layout.addWidget(self.timing_widget)\n\n # Description Field\n i += 1\n description_label = QtWidgets.QLabel(self)\n description_label.setText(\"Description\")\n self.form_layout.setWidget(i, label_role, description_label)\n\n self.description_widget = QtWidgets.QTextEdit(self)\n self.form_layout.setWidget(i, field_role, self.description_widget)","def initUI(self):\n # Setting the main layout as Vertical.\n self.mainLayout = QHBoxLayout()\n\n # Create title.\n self.title = QLabel(self.__name + \" : \")\n\n # Add description as tooltip.\n self.title.setToolTip(self.__description)\n\n # Add title to main layout.\n self.mainLayout.addWidget(self.title)\n\n # Create ComboBox.\n self.dropDown = QComboBox()\n\n # Add datas to drop down.\n self.dropDown.addItems(self.__datas)\n\n # Set default index to dropdown.\n self.dropDown.setCurrentIndex(self.__currentValue)\n\n # Connect dropdown with update method.\n self.dropDown.currentIndexChanged.connect(self.changeCurrentValue)\n\n # Add ComboBox to main layout.\n self.mainLayout.addWidget(self.dropDown)\n\n # Add the main layout to the window.\n self.setLayout(self.mainLayout)","def __init__(self):\n\t\tself.walltime_edit = urwid.Edit( ('editcp',\"walltime=\"), \"200:00:00\" )\n\t\tself.nodes_edit = urwid.IntEdit( ('editcp', \"nodes=\"), 0 )\n\t\tself.myri_ppn_edit = urwid.IntEdit( ('editcp', \"myri:ppn=\"), 4)\n\t\tself.workdir_edit = urwid.Edit( (\"editcp\", \"WORKDIR(-d) \"), '~/qjob_output')\n\t\tself.runtime_output_checkbox = urwid.CheckBox(\"See output while running\")\n\t\tself.other_options_edit = urwid.Edit( (\"editcp\", \"others:\"), '-q cmb -j oe -S /bin/bash')\n\t\tself.source_bash_profile_checkbox = urwid.CheckBox(\"source ~/.bash_profile\")\n\t\tself.source_bash_profile_checkbox.set_state(True)\n\t\tself.just_write_down_checkbox = urwid.CheckBox(\"Write jobfile. No submission.\")\n\t\tself.jobname_prefix_edit = urwid.Edit( (\"editcp\", \"jobname_prefix:\"), '~/qjob/job')\n\t\tself.jobnumber_edit = urwid.IntEdit( (\"editcp\", \"job number:\"), 0)\n\t\tself.job_content_reset_button = urwid.Button(\"Job Content Reset\", self.job_content_reset)\n\t\tself.exit_button = urwid.Button(\"Exit\", self.program_exit)\n\t\tself.job_edit = urwid.Edit( ('editcp',\"\"), multiline=True )\n\t\t\n\t\tself.items = [\n\t\turwid.Padding(\n\t\t\turwid.Columns(\n\t\t\t\t[\n\t\t\t\turwid.AttrWrap( self.walltime_edit, 'editbx', 'editfc' ),\n\t\t\t\turwid.AttrWrap( self.nodes_edit, 'editbx', 'editfc'),\n\t\t\t\turwid.AttrWrap( self.myri_ppn_edit, 'editbx', 'editfc'),\n\t\t\t\t],\n\t\t\t\t2 ), \n\t\t\t('fixed left',2), ('fixed right',2)),\n\t\tblank,\n\t\turwid.Padding(\n\t\t\turwid.Columns(\n\t\t\t\t[\n\t\t\t\turwid.AttrWrap( self.workdir_edit, 'editbx', 'editfc' ), \n\t\t\t\turwid.AttrWrap( self.runtime_output_checkbox, 'buttn', 'buttnf'),\n\t\t\t\t],\n\t\t\t\t2),\n\t\t\t('fixed left',2), ('fixed right',2)),\n\t\tblank,\n\t\turwid.Padding(\n\t\t\turwid.AttrWrap( self.other_options_edit, 'editbx', 'editfc' ), ('fixed left',2), ('fixed right',2)),\n\t\tblank,\n\t\turwid.Padding(\n\t\t\turwid.GridFlow(\n\t\t\t\t[\n\t\t\t\turwid.AttrWrap( self.source_bash_profile_checkbox, 'buttn','buttnf'),\n\t\t\t\turwid.AttrWrap( self.just_write_down_checkbox, 'buttn', 'buttnf'),\n\t\t\t\turwid.AttrWrap( self.jobname_prefix_edit, 'editbx', 'editfc' ),\n\t\t\t\turwid.AttrWrap( self.jobnumber_edit, 'editbx', 'editfc' ),\n\t\t\t\turwid.AttrWrap(self.job_content_reset_button, 'buttn', 'buttnf'),\n\t\t\t\turwid.AttrWrap(self.exit_button, 'buttn', 'buttnf'),\n\t\t\t\t],\n\t\t\t\t34, 2, 1, 'left'),\n\t\t\t('fixed left',2), ('fixed right',2)),\n\t\tblank,\n\t\turwid.Padding(\n\t\t\turwid.Pile(\n\t\t\t[\n\t\t\turwid.Text('One line one job. One job with >1 commands put on one line, separated by ;'),\n\t\t\turwid.AttrWrap(self.job_edit, 'editbx', 'editfc'),\n\t\t\t], 1),\n\t\t\t('fixed left',2), ('fixed right',2) )\n\t\t\t\n\t\t]\n\t\t\n\t\tself.listbox = urwid.ListBox( self.items )\n\t\t\n\t\tinstruct = urwid.Text(\"Job submission program based on Urwid. F8 to submit, F12 to quit.\")\n\t\theader = urwid.AttrWrap( instruct, 'header' )\n\t\t\n\t\tself.footer_text = urwid.Text(\"Mar 15th, 2008 by Yu Huang\")\n\t\tfooter = urwid.AttrWrap(self.footer_text, 'footer')\n\t\t\n\t\tself.top_frame = urwid.Frame(urwid.AttrWrap(self.listbox, 'body'), header, footer)","def __init__(self, parent):\r\n Frame.__init__(self, parent) \r\n \r\n self.parent = parent\r\n self.initUI()","def init_ui(self):\n self.parent.title(\"Roku Player Controller\")\n self.style.theme_use(\"default\")","def _create_analyses_input_page(self, notebook): # pylint: disable=R0914\r\n\r\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\r\n # Build-up the containers for the tab. #\r\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\r\n _hbox = gtk.HPaned()\r\n\r\n _fixed = gtk.Fixed()\r\n\r\n _frame = Widgets.make_frame(label=_(u\"Analysis Inputs\"))\r\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)\r\n _frame.add(_fixed)\r\n\r\n _hbox.pack1(_frame, True, True)\r\n\r\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\r\n # Place the widgets used to display analysis input information. #\r\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\r\n # Load the gtk.ComboBox() widgets.\r\n _results = [[u\"MCF\"], [u\"Kaplan-Meier\"], [_(u\"NHPP - Power Law\")],\r\n [u\"NHPP - Loglinear\"], [_(u\"Exponential\")],\r\n [_(u\"Lognormal\")], [_(u\"Normal\")], [u\"Weibull\"],\r\n [\"WeiBayes\"]]\r\n Widgets.load_combo(self.cmbDistribution, _results)\r\n _results = [[_(u\"Lower One-Sided\")], [_(u\"Upper One-Sided\")],\r\n [_(u\"Two-Sided\")]]\r\n Widgets.load_combo(self.cmbConfType, _results)\r\n _results = [[_(u\"Crow (NHPP Only)\")], [_(u\"Duane (NHPP Only)\")],\r\n [_(u\"Fisher Matrix\")], [_(u\"Likelihood\")],\r\n [_(u\"Bootstrap\")]]\r\n Widgets.load_combo(self.cmbConfMethod, _results)\r\n _results = [[\"MLE\"], [_(u\"Regression\")]]\r\n Widgets.load_combo(self.cmbFitMethod, _results)\r\n\r\n # Create the labels for the left half of the right side.\r\n _labels = [_(u\"Assembly:\"), _(u\"Description:\"), _(u\"Distribution:\"),\r\n _(\"Fit Method:\"), _(u\"Confidence:\"), _(u\"Confidence Type:\"),\r\n _(\"Confidence Method:\")]\r\n (_x_pos1, _y_pos1) = Widgets.make_labels(_labels, _fixed, 5, 5)\r\n _x_pos1 += 55\r\n\r\n # Create the labels for the right half of the right side.\r\n _labels = [_(u\"Start Time:\"), _(u\"End Time:\"), _(u\"Step Interval:\"),\r\n _(u\"Start Date:\"), _(u\"End Date:\")]\r\n (_x_pos2,\r\n _y_pos2) = Widgets.make_labels(_labels, _fixed, _x_pos1 + 215, 5)\r\n _x_pos2 += _x_pos1\r\n _x_pos2 += 275\r\n\r\n # Place widgets on the left side.\r\n _fixed.put(self.cmbAssembly, _x_pos1, _y_pos1[0])\r\n _fixed.put(self.txtDescription, _x_pos1, _y_pos1[1])\r\n _fixed.put(self.cmbDistribution, _x_pos1, _y_pos1[2])\r\n _fixed.put(self.cmbFitMethod, _x_pos1, _y_pos1[3])\r\n _fixed.put(self.txtConfidence, _x_pos1, _y_pos1[4])\r\n _fixed.put(self.cmbConfType, _x_pos1, _y_pos1[5])\r\n _fixed.put(self.cmbConfMethod, _x_pos1, _y_pos1[6])\r\n\r\n # Place widgets on the right side.\r\n _fixed.put(self.txtStartTime, _x_pos2, _y_pos2[0])\r\n _fixed.put(self.txtEndTime, _x_pos2, _y_pos2[1])\r\n _fixed.put(self.txtRelPoints, _x_pos2, _y_pos2[2])\r\n _fixed.put(self.txtStartDate, _x_pos2, _y_pos2[3])\r\n _fixed.put(self.btnStartDate, _x_pos2 + 105, _y_pos2[3])\r\n _fixed.put(self.txtEndDate, _x_pos2, _y_pos2[4])\r\n _fixed.put(self.btnEndDate, _x_pos2 + 105, _y_pos2[4])\r\n _fixed.put(self.chkGroup, _x_pos2, _y_pos2[4] + 30)\r\n _fixed.put(self.chkParts, _x_pos2, _y_pos2[4] + 60)\r\n\r\n _fixed.show_all()\r\n\r\n # Insert the tab.\r\n _label = gtk.Label()\r\n _label.set_markup(\"<span weight='bold'>\" +\r\n _(u\"Analysis\\nInputs\") + \"</span>\")\r\n _label.set_alignment(xalign=0.5, yalign=0.5)\r\n _label.set_justify(gtk.JUSTIFY_CENTER)\r\n _label.show_all()\r\n _label.set_tooltip_text(_(u\"Displays analysis inputs for the selected \"\r\n u\"dataset.\"))\r\n notebook.insert_page(_hbox, tab_label=_label, position=-1)\r\n\r\n return False","def create_risk_analysis_page(self, notebook):\r\n\r\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\r\n # Build-up the containers for the tab. #\r\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\r\n _hpaned = gtk.HPaned()\r\n self.pack1(_hpaned, resize=True, shrink=True)\r\n\r\n # Create the organizational risk pane.\r\n _fixed = gtk.Fixed()\r\n\r\n _scrollwindow = gtk.ScrolledWindow()\r\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\r\n _scrollwindow.add_with_viewport(_fixed)\r\n\r\n _frame = Widgets.make_frame(label=_(u\"Organization\"))\r\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\r\n _frame.add(_scrollwindow)\r\n\r\n _hpaned.pack1(_frame, True, True)\r\n\r\n _labels = [_(u\"1. There are separate design and coding \"\r\n u\"organizations.\"),\r\n _(u\"2. There is an independent software test \"\r\n u\"organization.\"),\r\n _(u\"3. There is an independent software quality \"\r\n u\"assurance organization.\"),\r\n _(u\"4. There is an independent software configuration \"\r\n u\"management organization.\"),\r\n _(u\"5. There is an independent software verification \"\r\n u\"and validation organization.\"),\r\n _(u\"6. A structured programming team will develop the \"\r\n u\"software.\"),\r\n _(u\"7. The educational level of the software team members \"\r\n u\"is above average.\"),\r\n _(u\"8. The experience level of the software team members \"\r\n u\"is above average.\")]\r\n (_x_pos,\r\n _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\r\n _x_pos += 125\r\n\r\n _fixed.put(self.chkDevEnvQ1, _x_pos, _y_pos[0])\r\n _fixed.put(self.chkDevEnvQ2, _x_pos, _y_pos[1])\r\n _fixed.put(self.chkDevEnvQ3, _x_pos, _y_pos[2])\r\n _fixed.put(self.chkDevEnvQ4, _x_pos, _y_pos[3])\r\n _fixed.put(self.chkDevEnvQ5, _x_pos, _y_pos[4])\r\n _fixed.put(self.chkDevEnvQ6, _x_pos, _y_pos[5])\r\n _fixed.put(self.chkDevEnvQ7, _x_pos, _y_pos[6])\r\n _fixed.put(self.chkDevEnvQ8, _x_pos, _y_pos[7])\r\n\r\n # Create the methods risk pane.\r\n _fixed = gtk.Fixed()\r\n\r\n _scrollwindow = gtk.ScrolledWindow()\r\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\r\n _scrollwindow.add_with_viewport(_fixed)\r\n\r\n _frame = Widgets.make_frame(label=_(u\"Methods\"))\r\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\r\n _frame.add(_scrollwindow)\r\n\r\n _hpaned.pack2(_frame, True, True)\r\n\r\n _labels = [_(u\"1. Standards are defined and will be enforced.\"),\r\n _(u\"2. Software will be developed using a higher order \"\r\n u\"language.\"),\r\n _(u\"3. The development process will include formal \"\r\n u\"reviews (PDR, CDR, etc.).\"),\r\n _(u\"4. The development process will include frequent \"\r\n u\"walkthroughs.\"),\r\n _(u\"5. Development will take a top-down and \"\r\n u\"structured approach.\"),\r\n _(u\"6. Unit development folders will be used.\"),\r\n _(u\"7. A software development library will be used.\"),\r\n _(u\"8. A formal change and error reporting process \"\r\n u\"will be used.\"),\r\n _(u\"9. Progress and status will routinely be \"\r\n u\"reported.\")]\r\n (__, _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\r\n\r\n _fixed.put(self.chkDevEnvQ9, _x_pos, _y_pos[0])\r\n _fixed.put(self.chkDevEnvQ10, _x_pos, _y_pos[1])\r\n _fixed.put(self.chkDevEnvQ11, _x_pos, _y_pos[2])\r\n _fixed.put(self.chkDevEnvQ12, _x_pos, _y_pos[3])\r\n _fixed.put(self.chkDevEnvQ13, _x_pos, _y_pos[4])\r\n _fixed.put(self.chkDevEnvQ14, _x_pos, _y_pos[5])\r\n _fixed.put(self.chkDevEnvQ15, _x_pos, _y_pos[6])\r\n _fixed.put(self.chkDevEnvQ16, _x_pos, _y_pos[7])\r\n _fixed.put(self.chkDevEnvQ17, _x_pos, _y_pos[8])\r\n\r\n # Create the documentation risk pane.\r\n _hpaned = gtk.HPaned()\r\n self.pack2(_hpaned, resize=True, shrink=True)\r\n\r\n _fixed = gtk.Fixed()\r\n\r\n _scrollwindow = gtk.ScrolledWindow()\r\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\r\n _scrollwindow.add_with_viewport(_fixed)\r\n\r\n _frame = Widgets.make_frame(label=_(u\"Documentation\"))\r\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\r\n _frame.add(_scrollwindow)\r\n\r\n _hpaned.pack1(_frame, True, True)\r\n\r\n _labels = [_(u\" 1. System requirements specifications will be \"\r\n u\"documented.\"),\r\n _(u\" 2. Software requirements specifications will be \"\r\n u\"documented.\"),\r\n _(u\" 3. Interface design specifications will be \"\r\n u\"documented.\"),\r\n _(u\" 4. Software design specification will be \"\r\n u\"documented.\"),\r\n _(u\" 5. Test plans, procedures, and reports will be \"\r\n u\"documented.\"),\r\n _(u\" 6. The software development plan will be \"\r\n u\"documented.\"),\r\n _(u\" 7. The software quality assurance plan will be \"\r\n u\"documented.\"),\r\n _(u\" 8. The software configuration management plan will \"\r\n u\"be documented.\"),\r\n _(u\" 9. A requirements traceability matrix will be \"\r\n u\"used.\"),\r\n _(u\"10. The software version description will be \"\r\n u\"documented.\"),\r\n _(u\"11. All software discrepancies will be \"\r\n u\"documented.\")]\r\n (__, _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\r\n\r\n _fixed.put(self.chkDevEnvQ18, _x_pos, _y_pos[0])\r\n _fixed.put(self.chkDevEnvQ19, _x_pos, _y_pos[1])\r\n _fixed.put(self.chkDevEnvQ20, _x_pos, _y_pos[2])\r\n _fixed.put(self.chkDevEnvQ21, _x_pos, _y_pos[3])\r\n _fixed.put(self.chkDevEnvQ22, _x_pos, _y_pos[4])\r\n _fixed.put(self.chkDevEnvQ23, _x_pos, _y_pos[5])\r\n _fixed.put(self.chkDevEnvQ24, _x_pos, _y_pos[6])\r\n _fixed.put(self.chkDevEnvQ25, _x_pos, _y_pos[7])\r\n _fixed.put(self.chkDevEnvQ26, _x_pos, _y_pos[8])\r\n _fixed.put(self.chkDevEnvQ27, _x_pos, _y_pos[9])\r\n _fixed.put(self.chkDevEnvQ28, _x_pos, _y_pos[10])\r\n\r\n # Create the tools and test techniques risk pane.\r\n _fixed = gtk.Fixed()\r\n\r\n _scrollwindow = gtk.ScrolledWindow()\r\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\r\n _scrollwindow.add_with_viewport(_fixed)\r\n\r\n _frame = Widgets.make_frame(label=_(u\"Tools & Test Techniques\"))\r\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\r\n _frame.add(_scrollwindow)\r\n\r\n _hpaned.pack2(_frame, True, True)\r\n\r\n _labels = [_(u\" 1. The software language requirements will be \"\r\n u\"specified.\"),\r\n _(u\" 2. Formal program design language will be used.\"),\r\n _(u\" 3. Program design graphical techniques \"\r\n u\"(flowcharts, HIPO, etc.) will be used.\"),\r\n _(u\" 4. Simulation/emulation tools will be used.\"),\r\n _(u\" 5. Configuration management tools will be used.\"),\r\n _(u\" 6. A code auditing tool will be used.\"),\r\n _(u\" 7. A data flow analyzer will be used.\"),\r\n _(u\" 8. A programmer's workbench will be used.\"),\r\n _(u\" 9. Measurement tools will be used.\"),\r\n _(u\"10. Software code reviews will be used.\"),\r\n _(u\"11. Software branch testing will be used.\"),\r\n _(u\"12. Random testing will be used.\"),\r\n _(u\"13. Functional testing will be used.\"),\r\n _(u\"14. Error and anomaly detection testing will be \"\r\n u\"used.\"),\r\n _(u\"15. Structure analysis will be used.\")]\r\n (__, _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\r\n\r\n _fixed.put(self.chkDevEnvQ29, _x_pos, _y_pos[0])\r\n _fixed.put(self.chkDevEnvQ30, _x_pos, _y_pos[1])\r\n _fixed.put(self.chkDevEnvQ31, _x_pos, _y_pos[2])\r\n _fixed.put(self.chkDevEnvQ32, _x_pos, _y_pos[3])\r\n _fixed.put(self.chkDevEnvQ33, _x_pos, _y_pos[4])\r\n _fixed.put(self.chkDevEnvQ34, _x_pos, _y_pos[5])\r\n _fixed.put(self.chkDevEnvQ35, _x_pos, _y_pos[6])\r\n _fixed.put(self.chkDevEnvQ36, _x_pos, _y_pos[7])\r\n _fixed.put(self.chkDevEnvQ37, _x_pos, _y_pos[8])\r\n _fixed.put(self.chkDevEnvQ38, _x_pos, _y_pos[9])\r\n _fixed.put(self.chkDevEnvQ39, _x_pos, _y_pos[10])\r\n _fixed.put(self.chkDevEnvQ40, _x_pos, _y_pos[11])\r\n _fixed.put(self.chkDevEnvQ41, _x_pos, _y_pos[12])\r\n _fixed.put(self.chkDevEnvQ42, _x_pos, _y_pos[13])\r\n _fixed.put(self.chkDevEnvQ43, _x_pos, _y_pos[14])\r\n\r\n _label = gtk.Label()\r\n _label.set_markup(\"<span weight='bold'>\" +\r\n _(u\"Development\\nEnvironment\") +\r\n \"</span>\")\r\n _label.set_alignment(xalign=0.5, yalign=0.5)\r\n _label.set_justify(gtk.JUSTIFY_CENTER)\r\n _label.set_angle(0)\r\n _label.show_all()\r\n _label.set_tooltip_text(_(u\"Assesses risk due to the development \"\r\n u\"environment.\"))\r\n notebook.insert_page(self, tab_label=_label, position=-1)\r\n\r\n return False","def __create_ui(self):\n vbox = gtk.VBox()\n\n # Create the viewable area of the file browser\n self.__view_port = gtk.ScrolledWindow()\n self.__view_port.set_policy(gtk.POLICY_AUTOMATIC,\n gtk.POLICY_AUTOMATIC)\n # Create the tree view and add it to the viewable area\n self.__tree_view = ProjectTreeView()\n self.__project_explorer = ProjectExplorer(self.window, self.__tree_view)\n self.__tree_view.connect('button_press_event',\n self.__on_treeview_button_press_event)\n self.__project_explorer.set_repository()\n self.__view_port.add(self.__tree_view)\n # Create the toolbar\n hbox = gtk.HBox()\n toolbar = gtk.Toolbar()\n toolbar.set_style(gtk.TOOLBAR_ICONS)\n toolbar.set_icon_size(gtk.ICON_SIZE_MENU)\n back = gtk.ToolButton(gtk.STOCK_GO_UP)\n back.connect('clicked', self.__on_back_clicked)\n toolbar.insert(back, 0)\n toolbar.insert(gtk.SeparatorToolItem(), 1)\n refresh = gtk.ToolButton(gtk.STOCK_REFRESH)\n refresh.connect('clicked', self.__on_refresh_clicked)\n toolbar.insert(refresh, 2)\n hbox.pack_start(toolbar, True, True, 0)\n vbox.pack_start(hbox, False, False, 0)\n vbox.pack_start(self.__view_port, True, True, 0)\n\n # Setup the create the buttons for:\n # New File, New Folder\n # ----------------------------------------------------------------------\n hbox1 = gtk.VBox()\n toolbar_actions = gtk.Toolbar()\n toolbar_actions.set_style(gtk.TOOLBAR_ICONS)\n toolbar_actions.set_icon_size(gtk.ICON_SIZE_MENU)\n new_file = gtk.ToolButton(gtk.STOCK_NEW)\n new_file.connect('clicked', self.__on_new_file_clicked_cb)\n toolbar_actions.insert(new_file, 0)\n new_dir = gtk.ToolButton(gtk.STOCK_OPEN) # TODO: use a custom icon\n new_dir.connect('clicked', self.__on_new_dir_clicked_cb)\n toolbar_actions.insert(new_dir, 1)\n hbox1.pack_start(gtk.HSeparator(), True, True, 0)\n hbox1.pack_start(toolbar_actions, True, True, 0)\n vbox.pack_end(hbox1, False, False, 0)\n # ----------------------------------------------------------------------\n vbox.show_all()\n # Attach the project explorer to GMate's side panel\n self.__side_panel = self.window.get_side_panel()\n self.__side_panel.add_tab(vbox, msg0005, gtk.STOCK_HARDDISK)","def initUI(self):\n\t\t#de button om het spel te beginnen\n\t\tself.playButton = QtGui.QPushButton(\"Play\", self)\n\t\tself.playButton.clicked.connect(self.playField)\n\t\tself.playButton.setStyleSheet(\"background-color: red;border-style: outset; border-radius:5px; font: bold 18px;\")\n\t\tself.playButton.move(210,100)\n\t\tself.playButton.resize(150, 50)\n\t\t\n\t\t#zakje chips\n\t\tself.chips = QtGui.QPixmap(\"chips.png\")\n\t\tself.lbl = QtGui.QLabel(self)\n\t\tself.lbl.setPixmap(self.chips)\n\t\tself.lbl.move(410, 300)\n\t\t\n\t\t#1 zak chips is nooit genoeg voor de heavy breathing cat\n\t\tself.chips2 = QtGui.QPixmap(\"chips.png\")\n\t\tself.lbl2 = QtGui.QLabel(self)\n\t\tself.lbl2.setPixmap(self.chips)\n\t\tself.lbl2.move(30, 30)\n\t\t\n\t\t#pikachu in een sailor pakje, want battleships\n\t\tself.pikachu = QtGui.QPixmap(\"pikachu.png\")\n\t\tself.lbl3 = QtGui.QLabel(self)\n\t\tself.lbl3.setPixmap(self.pikachu)\n\t\tself.lbl3.move(400,0)\n\t\t\n\t\t#een kat kan natuurlijk niet ontbreken\n\t\tself.kat = QtGui.QPixmap(\"hb2.jpeg\")\n\t\tself.lblKat = QtGui.QLabel(self)\n\t\tself.lblKat.setPixmap(self.kat)\n\t\tself.lblKat.move(0,230)\n\t\t\n\t\t#ons super vette logo #swek\n\t\tself.battlechipsPlaatje = QtGui.QPixmap(\"battleships.png\")\n\t\tself.lblbattle = QtGui.QLabel(self)\n\t\tself.lblbattle.setPixmap(self.battlechipsPlaatje)\n\t\tself.lblbattle.move(180,10)\n\t\t\n\t\t#le window\n\t\tself.setGeometry(150, 150, 600, 600)\n\t\tself.setWindowTitle(\"Menu\")\n\t\tself.setStyleSheet(\"background-color: #8e8f94\")\n\t\tself.show()","def controls_setup(self):\n self.dashboard = element.Link(self, class_name='menu-dashboard', alias='Dashboard Menu')\n # catalogue and sub-menus\n self.catalogue = element.LinkButton(self, class_name='menu-catalogue', alias='Catalogue Menu')\n self.products = element.Link(self, class_name='submenu-products', alias='Catalogue->Products Menu')\n self.product_types = element.Link(self, class_name='submenu-product-types',\n alias='Catalogue->Product Types Menu')\n self.categories = element.Link(self, class_name='submenu-categories', alias='Catalogue->Categories Menu')\n self.ranges = element.Link(self, class_name='submenu-ranges', alias='Catalogue->Ranges Menu')\n self.stock_alerts = element.Link(self, class_name='submenu-low-stock-alerts',\n alias='Catalogue->Low Stock Alerts Menu')\n # fulfilment and sub-menus\n self.fulfilment = element.LinkButton(self, class_name='menu-fulfilment', alias='Fulfilment Menu')\n self.orders = element.Link(self, class_name='submenu-orders', alias='Fulfilment->Orders Menu')\n self.statistics = element.Link(self, class_name='submenu-statistics', alias='Fulfilment->Statistics Menu')\n self.partners = element.Link(self, class_name='submenu-partners', alias='Fulfilment->Partners Menu')\n # customers and sub-menus\n self.customers = element.LinkButton(self, class_name='menu-customers', alias='Customers Menu')\n self.customers_submenu = element.Link(self, class_name='submenu-customers', alias='Customers->Customers Menu')\n self.deleted_accounts = element.Link(self, class_name='submenu-deleted_accounts',\n alias='Customers->Deleted Accounts Menu')\n self.stock_alert_requests = element.Link(self, class_name='submenu-stock-alert-requests-customers',\n alias='Customers->Stock Alert Requests Menu')\n # offers and sub-menus\n self.offers = element.LinkButton(self, class_name='menu-offers', alias='Offers Menu')\n self.offers_submenu = element.Link(self, class_name='submenu-offers', alias='Offers->Offers Menu')\n self.vouchers = element.Link(self, class_name='submenu-vouchers', alias='Offers->Vouchers Menu')\n # content and sub-menus\n self.content_menu = element.LinkButton(self, class_name='menu-content', alias='Content Menu')\n self.pages = element.Link(self, class_name='menu-pages', alias='Content->Pages Menu')\n self.announcements = element.Link(self, class_name='menu-announcements', alias='Content->Announcements Menu')\n self.reviews = element.Link(self, class_name='menu-reviews', alias='Content->Reviews Menu')\n\n self.reports = element.Link(self, class_name='menu-reports', alias='Reports Menu')\n self.store_info = element.LinkButton(self, css_selector='.dropdown.store > a', alias='Store Info Menu')\n self.partner_store = []","def create_sliders(self):\n self.create_contrast_slider()\n self.create_crop_sliders()","def initGui(self):\n self.network_layer_notifier = QgepLayerNotifier(\n self.iface.mainWindow(), [\"vw_network_node\", \"vw_network_segment\"]\n )\n self.wastewater_networkelement_layer_notifier = QgepLayerNotifier(\n self.iface.mainWindow(), [\"vw_wastewater_node\", \"vw_qgep_reach\"]\n )\n self.toolbarButtons = []\n\n # Create toolbar button\n self.profileAction = QAction(\n QIcon(os.path.join(plugin_root_path(), \"icons/wastewater-profile.svg\")),\n self.tr(\"Profile\"),\n self.iface.mainWindow(),\n )\n self.profileAction.setWhatsThis(self.tr(\"Reach trace\"))\n self.profileAction.setEnabled(False)\n self.profileAction.setCheckable(True)\n self.profileAction.triggered.connect(self.profileToolClicked)\n\n self.downstreamAction = QAction(\n QIcon(os.path.join(plugin_root_path(), \"icons/wastewater-downstream.svg\")),\n self.tr(\"Downstream\"),\n self.iface.mainWindow(),\n )\n self.downstreamAction.setWhatsThis(self.tr(\"Downstream reaches\"))\n self.downstreamAction.setEnabled(False)\n self.downstreamAction.setCheckable(True)\n self.downstreamAction.triggered.connect(self.downstreamToolClicked)\n\n self.upstreamAction = QAction(\n QIcon(os.path.join(plugin_root_path(), \"icons/wastewater-upstream.svg\")),\n self.tr(\"Upstream\"),\n self.iface.mainWindow(),\n )\n self.upstreamAction.setWhatsThis(self.tr(\"Upstream reaches\"))\n self.upstreamAction.setEnabled(False)\n self.upstreamAction.setCheckable(True)\n self.upstreamAction.triggered.connect(self.upstreamToolClicked)\n\n self.wizardAction = QAction(\n QIcon(os.path.join(plugin_root_path(), \"icons/wizard.svg\")),\n \"Wizard\",\n self.iface.mainWindow(),\n )\n self.wizardAction.setWhatsThis(self.tr(\"Create new manholes and reaches\"))\n self.wizardAction.setEnabled(False)\n self.wizardAction.setCheckable(True)\n self.wizardAction.triggered.connect(self.wizard)\n\n self.connectNetworkElementsAction = QAction(\n QIcon(\n os.path.join(\n plugin_root_path(), \"icons/link-wastewater-networkelement.svg\"\n )\n ),\n QApplication.translate(\"qgepplugin\", \"Connect wastewater networkelements\"),\n self.iface.mainWindow(),\n )\n self.connectNetworkElementsAction.setEnabled(False)\n self.connectNetworkElementsAction.setCheckable(True)\n self.connectNetworkElementsAction.triggered.connect(self.connectNetworkElements)\n\n self.refreshNetworkTopologyAction = QAction(\n QIcon(os.path.join(plugin_root_path(), \"icons/refresh-network.svg\")),\n \"Refresh network topology\",\n self.iface.mainWindow(),\n )\n self.refreshNetworkTopologyAction.setWhatsThis(\n self.tr(\"Refresh network topology\")\n )\n self.refreshNetworkTopologyAction.setEnabled(False)\n self.refreshNetworkTopologyAction.setCheckable(False)\n self.refreshNetworkTopologyAction.triggered.connect(\n self.refreshNetworkTopologyActionClicked\n )\n\n self.aboutAction = QAction(self.tr(\"About\"), self.iface.mainWindow())\n self.aboutAction.triggered.connect(self.about)\n\n self.settingsAction = QAction(self.tr(\"Settings\"), self.iface.mainWindow())\n self.settingsAction.triggered.connect(self.showSettings)\n\n self.importAction = QAction(\n QIcon(os.path.join(plugin_root_path(), \"icons/interlis_import.svg\")),\n self.tr(\"Import from interlis\"),\n self.iface.mainWindow(),\n )\n self.importAction.setWhatsThis(self.tr(\"Import from interlis\"))\n self.importAction.setEnabled(False)\n self.importAction.setCheckable(False)\n self.importAction.triggered.connect(self.actionImportClicked)\n\n self.exportAction = QAction(\n QIcon(os.path.join(plugin_root_path(), \"icons/interlis_export.svg\")),\n self.tr(\"Export to interlis\"),\n self.iface.mainWindow(),\n )\n self.exportAction.setWhatsThis(self.tr(\"Export from interlis\"))\n self.exportAction.setEnabled(False)\n self.exportAction.setCheckable(False)\n self.exportAction.triggered.connect(self.actionExportClicked)\n\n self.datamodelInitToolAction = QAction(\n self.tr(\"Datamodel tool\"), self.iface.mainWindow()\n )\n self.datamodelInitToolAction.triggered.connect(self.showDatamodelInitTool)\n\n # Add toolbar button and menu item\n self.toolbar = QToolBar(QApplication.translate(\"qgepplugin\", \"QGEP\"))\n self.toolbar.addAction(self.profileAction)\n self.toolbar.addAction(self.upstreamAction)\n self.toolbar.addAction(self.downstreamAction)\n self.toolbar.addAction(self.wizardAction)\n self.toolbar.addAction(self.refreshNetworkTopologyAction)\n self.toolbar.addAction(self.connectNetworkElementsAction)\n\n self.iface.addPluginToMenu(\"&QGEP\", self.profileAction)\n self.iface.addPluginToMenu(\"&QGEP\", self.settingsAction)\n self.iface.addPluginToMenu(\"&QGEP\", self.aboutAction)\n\n admin_mode = QSettings().value(\"/QGEP/AdminMode\", False)\n # seems QGIS loads True as \"true\" on restart ?!\n if admin_mode and admin_mode != \"false\":\n self.toolbar.addAction(self.importAction)\n self.toolbar.addAction(self.exportAction)\n self.iface.addPluginToMenu(\"&QGEP\", self.datamodelInitToolAction)\n\n self.iface.addToolBar(self.toolbar)\n\n # Local array of buttons to enable / disable based on context\n self.toolbarButtons.append(self.profileAction)\n self.toolbarButtons.append(self.upstreamAction)\n self.toolbarButtons.append(self.downstreamAction)\n self.toolbarButtons.append(self.wizardAction)\n self.toolbarButtons.append(self.refreshNetworkTopologyAction)\n self.toolbarButtons.append(self.importAction)\n self.toolbarButtons.append(self.exportAction)\n\n self.network_layer_notifier.layersAvailable.connect(self.onLayersAvailable)\n self.network_layer_notifier.layersUnavailable.connect(self.onLayersUnavailable)\n\n # Init the object maintaining the network\n self.network_analyzer = QgepGraphManager()\n self.network_analyzer.message_emitted.connect(\n self.iface.messageBar().pushMessage\n )\n # Create the map tool for profile selection\n self.profile_tool = QgepProfileMapTool(\n self.iface, self.profileAction, self.network_analyzer\n )\n self.profile_tool.profileChanged.connect(self.onProfileChanged)\n\n self.upstream_tree_tool = QgepTreeMapTool(\n self.iface, self.upstreamAction, self.network_analyzer\n )\n self.upstream_tree_tool.setDirection(\"upstream\")\n self.upstream_tree_tool.treeChanged.connect(self.onTreeChanged)\n self.downstream_tree_tool = QgepTreeMapTool(\n self.iface, self.downstreamAction, self.network_analyzer\n )\n self.downstream_tree_tool.setDirection(\"downstream\")\n self.downstream_tree_tool.treeChanged.connect(self.onTreeChanged)\n\n self.maptool_connect_networkelements = QgepMapToolConnectNetworkElements(\n self.iface, self.connectNetworkElementsAction\n )\n\n self.wastewater_networkelement_layer_notifier.layersAvailableChanged.connect(\n self.connectNetworkElementsAction.setEnabled\n )\n\n self.processing_provider = QgepProcessingProvider()\n QgsApplication.processingRegistry().addProvider(self.processing_provider)\n\n self.network_layer_notifier.layersAdded([])","def __init__(self, contr: widgets.base_controller,\n parent: widgets.base_widget,\n idstr: str,\n attrdct: dict,\n jsel,\n titletext: str,\n helptext: str) -> None:\n super().__init__(contr, parent, idstr, attrdct, jsel)\n self.wcstatus: wcstatus.WCstatus = contr.wcstatus\n self.addClass(\"w3-container\")\n self.addClass('switchview-cls')\n self.setAttribute('height', '80%')\n self.setAttribute('width', '100%')\n self.h1 = html.h1text(self, titletext)\n help_attrdct = {'class': 'w3-container'}\n self.helptext = html.spanhelptext(self, \"addhelptext\", help_attrdct, helptext)","def test_ui_class_instantiates_ui_object(self):\n self.assertEqual(type(self.ui), UI, \"Does not create a ui object\")","def set_controls(self):\n # Image control\n image = pyxbmct.Image(addonfolder+artsfolder+'/wplay.png')\n self.placeControl(image, 0, 0, rowspan=10, columnspan=16)\n\n # LNB1\n self.wplnb1_button = pyxbmct.RadioButton('')\n self.placeControl(self.wplnb1_button, 11, 1, rowspan=1, columnspan=4)\n self.connect(self.wplnb1_button, self.wplnb1_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'wplnb1', 2) == 1:\n self.wplnb1_button.setSelected(True)\n else:\n self.wplnb1_button.setSelected(False)\n lnb1 = pyxbmct.Image(addonfolder+artsfolder+'/lnb1.png')\n self.placeControl(lnb1, 11, 1, rowspan=1, columnspan=4)\n\n # LNB2\n self.wplnb2_button = pyxbmct.RadioButton('')\n self.placeControl(self.wplnb2_button, 11, 6, rowspan=1, columnspan=4)\n self.connect(self.wplnb2_button, self.wplnb2_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'wplnb2', 2) == 1:\n self.wplnb2_button.setSelected(True)\n else:\n self.wplnb2_button.setSelected(False)\n lnb2 = pyxbmct.Image(addonfolder+artsfolder+'/lnb2.png')\n self.placeControl(lnb2, 11, 6, rowspan=1, columnspan=4)\n\n # LNB1/LNB2\n self.wplnboth_button = pyxbmct.RadioButton('')\n self.placeControl(self.wplnboth_button, 11, 11, rowspan=1, columnspan=4)\n self.connect(self.wplnboth_button, self.wplnboth_button_update)\n if tools.return_data('TVHWIZARD', 'STRING', 'wplnboth', 2) == 1:\n self.wplnboth_button.setSelected(True)\n else:\n self.wplnboth_button.setSelected(False)\n both = pyxbmct.Image(addonfolder+artsfolder+'/both.png')\n self.placeControl(both, 11, 11, rowspan=1, columnspan=4)\n\n # Close button\n self.close_button = pyxbmct.Button('Exit')\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\n self.connect(self.close_button, lambda: self.closepage())"],"string":"[\n \"def create_ui(self, parent):\\n view = View(\\n Item(name=\\\"text\\\",\\n show_label=False,\\n editor=ImageTraitEditor(\\n image=ImageResource(self.obj.name,\\n search_path=[self.obj.parent.absolute_path]) )),\\n id=\\\"puddle.image_editor.image_editor\\\",\\n kind=\\\"live\\\", resizable=True)\\n\\n ui = self.edit_traits(view=view, parent=parent, kind=\\\"subpanel\\\")\\n\\n return ui\",\n \"def createUserInterface(self):\\n\\n\\t\\tself.__layout = self.__parent.createUserInterface()\\n\\n\\t\\tstep_label = qt.QLabel( 'Choose the volume you would like to threshold. If you are calculating a subtraction map, check the \\\\\\\"Calculate Subtraction Map\\\\\\\" box and select a post-contrast image.' )\\n\\t\\tstep_label.setWordWrap(True)\\n\\t\\tself.__primaryGroupBox = qt.QGroupBox()\\n\\t\\tself.__primaryGroupBox.setTitle('Information')\\n\\t\\tself.__primaryGroupBoxLayout = qt.QFormLayout(self.__primaryGroupBox)\\n\\n\\t\\tself.__subtractionMappingGroupBox = qt.QGroupBox()\\n\\t\\tself.__subtractionMappingGroupBox.setTitle('Volume Selection')\\n\\t\\tself.__subtractionMappingGroupBoxLayout = qt.QFormLayout(self.__subtractionMappingGroupBox)\\n\\n\\t\\tbaselineScanLabel = qt.QLabel( 'Primary / Pre-Contrast Image:' )\\n\\t\\tself.__baselineVolumeSelector = slicer.qMRMLNodeComboBox()\\n\\t\\tself.__baselineVolumeSelector.toolTip = \\\"Select the volume you wish to threshold. If you are calculating a subtraction map, this will be the pre-contrast scan.\\\"\\n\\t\\tself.__baselineVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']\\n\\t\\tself.__baselineVolumeSelector.setMRMLScene(slicer.mrmlScene)\\n\\t\\tself.__baselineVolumeSelector.addEnabled = 0\\n\\n\\t\\tsubtractionMappingLabel = qt.QLabel( 'Calculate Subtraction Map:' )\\n\\t\\tself.__enableSubtractionMapping = qt.QCheckBox()\\n\\t\\tself.__enableSubtractionMapping.checked = False\\n\\t\\tself.__enableSubtractionMapping.setToolTip(\\\"Check if you would like to calculate a subtraction map\\\")\\n\\t\\tself.__enableSubtractionMapping.connect('clicked()', self.setSubtractionMapping)\\n\\n\\t\\tfollowupScanLabel = qt.QLabel( 'Post-Contrast Image:' )\\n\\t\\tself.__followupVolumeSelector = slicer.qMRMLNodeComboBox()\\n\\t\\tself.__followupVolumeSelector.toolTip = \\\"Choose the post-contrast scan\\\"\\n\\t\\tself.__followupVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']\\n\\t\\tself.__followupVolumeSelector.setMRMLScene(slicer.mrmlScene)\\n\\t\\tself.__followupVolumeSelector.addEnabled = 0\\n\\t\\tself.__followupVolumeSelector.enabled = 0\\n\\n\\t\\tself.__layout.addRow(self.__primaryGroupBox)\\n\\t\\tself.__primaryGroupBoxLayout.addRow( step_label )\\n\\t\\tself.__subtractionMappingGroupBoxLayout.addRow( baselineScanLabel, self.__baselineVolumeSelector )\\n\\n\\t\\tself.__layout.addRow(self.__subtractionMappingGroupBox)\\n\\t\\tself.__subtractionMappingGroupBoxLayout.addRow( subtractionMappingLabel, self.__enableSubtractionMapping )\\n\\t\\tself.__subtractionMappingGroupBoxLayout.addRow( followupScanLabel, self.__followupVolumeSelector )\\n\\n\\t\\tself.updateWidgetFromParameters(self.parameterNode())\\n\\n\\t\\t# This timer is a trick to wait for buttons to load BEFORE deleting them.\\n\\t\\tqt.QTimer.singleShot(0, self.killButton)\",\n \"def ui(self):\\n return ui\",\n \"def additional_ui(self):\\n return _UI_DEF\",\n \"def init_ui(self):\\n raise NotImplementedError\",\n \"def init_ui(self):\\n raise NotImplementedError\",\n \"def build_UI(self):\\n\\n #Common local coordinates to change the UI positions\\n common_x = 0\\n common_y = 5\\n\\n #Create the Main Title\\n self.titleFont = font.Font(family = FONTS[\\\"lucida grande\\\"], size = 30)\\n self.title = cGUIf.get_TextLabel(self,\\n \\\"File Converter App \\\",\\n self.titleFont,\\n 135 + common_x,\\n 40 + common_y)\\n\\n #Add the \\\"Main Icon\\\"\\n self.mainIcon = cGUIf.get_ImgLabel(self,\\n self.__pics[\\\"main_icon\\\"],\\n 280 + common_x,\\n 125 + common_y)\\n\\n\\n #Create a subtitle that says \\\"options\\\"\\n self.subtitleFont = font.Font(family = FONTS[\\\"courier new\\\"], size = 22)\\n self.subtitle = cGUIf.get_TextLabel(self,\\n \\\"Options\\\",\\n self.subtitleFont,\\n 240 + common_x,\\n 195 + common_y)\\n\\n #Create a label that says \\\"Image Conversion\\\"\\n self.conversionFont = font.Font(family = FONTS[\\\"times new roman\\\"], size = 15)\\n self.imageConversionLabel = cGUIf.get_TextLabel(self,\\n \\\" Image\\\\n Conversion\\\",\\n self.conversionFont,\\n 60 + common_x,\\n 285 + common_y)\\n\\n #Create a button for Image Conversion\\n self.imageButton = cGUIf.get_Button(self,\\n \\\"\\\",\\n lambda : self.switch_frames(\\\"image_frame\\\"),\\n 190 + common_x,\\n 270 + common_y)\\n self.imageButton.configure(image = self.__pics[\\\"image_icon\\\"])\\n\\n #Create a label that says \\\"Audio Conversion\\\"\\n self.audioConversionLabel = cGUIf.get_TextLabel(self,\\n \\\" Audio\\\\n Conversion\\\",\\n self.conversionFont,\\n 440 + common_x,\\n 285 + common_y)\\n\\n #Create a button for Audio Conversion\\n self.audioButton = cGUIf.get_Button(self,\\n \\\"\\\",\\n lambda : self.switch_frames(\\\"audio_frame\\\"),\\n 340 + common_x,\\n 270 + common_y)\\n self.audioButton.configure(image = self.__pics[\\\"audio_icon\\\"])\\n\\n #Create a label that says \\\"Doc Conversion\\\"\\n self.docConversionLabel = cGUIf.get_TextLabel(self,\\n \\\" Doc\\\\n Conversion\\\",\\n self.conversionFont,\\n 60 + common_x,\\n 410 + common_y)\\n\\n\\n #Create a button for Doc Conversion\\n self.docButton = cGUIf.get_Button(self,\\n \\\"\\\",\\n lambda : self.switch_frames(\\\"doc_frame\\\"),\\n 190 + common_x,\\n 400 + common_y)\\n self.docButton.configure(image = self.__pics[\\\"doc_icon\\\"])\\n\\n\\n #Create a label that says \\\"Video Conversion\\\"\\n self.videoConversionLabel = cGUIf.get_TextLabel(self,\\n \\\" Video\\\\n Conversion\\\",\\n self.conversionFont,\\n 440 + common_x,\\n 410 + common_y)\\n\\n #Create a button for Video Conversion\\n self.videoButton = cGUIf.get_Button(self,\\n \\\"\\\",\\n lambda : self.switch_frames(\\\"video_frame\\\"),\\n 340 + common_x,\\n 400 + common_y)\\n self.videoButton.configure(image = self.__pics[\\\"video_icon\\\"])\",\n \"def extend_ui(self):\\n for name, tab in self.build_general_tabs().items():\\n scroll = self.build_tab()\\n self.add_tab(\\\"General\\\", name, scroll)\\n self.fill_tab(\\\"General\\\", name, tab)\\n for name, tab in self.build_display_tabs().items():\\n scroll = self.build_tab()\\n self.add_tab(\\\"Display\\\", name, scroll)\\n self.fill_tab(\\\"Display\\\", name, tab)\\n for name, tab in self.build_data_tabs().items():\\n scroll = self.build_tab()\\n self.add_tab(\\\"Data\\\", name, scroll)\\n self.fill_tab(\\\"Data\\\", name, tab)\",\n \"def init_ui(self):\\n raise NotImplementedError(\\\"This is an abstract method.\\\")\",\n \"def setup_additional_ui(self):\\n\\n #set title\\n self.setWindowTitle(self.title)\\n\\n #set question\\n self.lbl_question.setText(self.question)\\n\\n #set_remember_choice\\n self.set_remember_choice(self.chkbx_remember_choice.isChecked())\",\n \"def prepare_UI(self):\",\n \"def __setup_ui_controls(self, list_of_names):\\n\\n ##################################################\\n self.scene.append_to_caption('<h3>Scene Settings</h3>\\\\n')\\n # Button to reset camera\\n reset_button = button(\\n bind=self.__reset_camera, text=\\\"Reset Camera\\\")\\n self.__ui_controls.btn_reset = reset_button\\n self.scene.append_to_caption('\\\\t')\\n\\n screenshot_button = button(bind=self.__screenshot, text=\\\"Take Screenshot\\\")\\n self.__ui_controls.btn_ss = screenshot_button\\n self.scene.append_to_caption('\\\\n')\\n\\n camera_lock_checkbox = checkbox(bind=self.__camera_lock_checkbox, text=\\\"Camera Lock\\\",\\n checked=self.__camera_lock)\\n self.__ui_controls.chkbox_cam = camera_lock_checkbox\\n self.scene.append_to_caption('\\\\t')\\n\\n grid_relative_checkbox = checkbox(\\n bind=self.__grid_relative_checkbox,\\n text=\\\"Grid Relative\\\", checked=self.__grid_relative)\\n self.__ui_controls.chkbox_rel = grid_relative_checkbox\\n\\n self.scene.append_to_caption('\\\\t')\\n # Checkbox for grid visibility\\n checkbox_grid_visibility = checkbox(\\n bind=self.__grid_visibility_checkbox, text=\\\"Grid Visibility\\\",\\n checked=self.__grid_visibility)\\n self.__ui_controls.chkbox_grid = checkbox_grid_visibility\\n self.scene.append_to_caption('\\\\n')\\n\\n ##################################################\\n self.scene.append_to_caption('<h3>Robot</h3>\\\\n')\\n # Drop down for robots / joints in frame\\n menu_robots_list = menu(bind=self.__menu_item_chosen, choices=list_of_names)\\n if not len(list_of_names) == 0:\\n menu_robots_list.index = self.__selected_robot\\n self.__ui_controls.menu_robots = menu_robots_list\\n self.scene.append_to_caption('\\\\t')\\n\\n # Button to delete the selected robot\\n delete_button = button(bind=self.__del_robot, text=\\\"Delete Robot\\\")\\n self.__ui_controls.btn_del = delete_button\\n self.scene.append_to_caption('\\\\t')\\n\\n # Button to clear the robots in screen\\n clear_button = button(bind=self.clear_scene, text=\\\"Clear Scene\\\")\\n self.__ui_controls.btn_clr = clear_button\\n self.scene.append_to_caption('\\\\n')\\n\\n ##################################################\\n self.scene.append_to_caption('<h3>Characteristics</h3>\\\\n')\\n # Checkbox for reference frame visibilities\\n if len(self.__robots) == 0:\\n reference_checkbox = checkbox(\\n bind=self.__reference_frame_checkbox,\\n text=\\\"Show Reference Frames\\\", checked=True)\\n else:\\n chk = self.__robots[self.__selected_robot].ref_shown\\n reference_checkbox = checkbox(\\n bind=self.__reference_frame_checkbox,\\n text=\\\"Show Reference Frames\\\", checked=chk)\\n self.__ui_controls.chkbox_ref = reference_checkbox\\n self.scene.append_to_caption('\\\\t')\\n\\n # Checkbox for robot visibility\\n if len(self.__robots) == 0:\\n robot_vis_checkbox = checkbox(\\n bind=self.__robot_visibility_checkbox,\\n text=\\\"Show Robot\\\", checked=True)\\n else:\\n chk = self.__robots[self.__selected_robot].rob_shown\\n robot_vis_checkbox = checkbox(\\n bind=self.__robot_visibility_checkbox,\\n text=\\\"Show Robot\\\", checked=chk)\\n self.__ui_controls.chkbox_rob = robot_vis_checkbox\\n self.scene.append_to_caption('\\\\n')\\n\\n # Slider for robot opacity\\n self.scene.append_to_caption('Robot Opacity:')\\n if len(self.__robots) == 0:\\n opacity_slider = slider(bind=self.__opacity_slider, value=1)\\n else:\\n opc = self.__robots[self.__selected_robot].opacity\\n opacity_slider = slider(bind=self.__opacity_slider, value=opc)\\n self.__ui_controls.sld_opc = opacity_slider\\n self.scene.append_to_caption('\\\\n')\\n\\n ##################################################\\n # Control manual\\n controls_str = '<h3>Controls</h3><br>' \\\\\\n '<b>PAN</b><br>' \\\\\\n 'W , S | <i>forward / backward</i><br>' \\\\\\n 'A , D | <i>left / right</i><br>' \\\\\\n 'SPACE , SHIFT | <i>up / down</i><br>' \\\\\\n '<b>ROTATE</b><br>' \\\\\\n 'CTRL + LMB | <i>free spin</i><br>' \\\\\\n 'ARROWS KEYS | <i>rotate direction</i><br>' \\\\\\n 'Q , E | <i>roll left / right</i><br>' \\\\\\n '<b>ZOOM</b></br>' \\\\\\n 'MOUSEWHEEL | <i>zoom in / out</i>'\\n\\n self.scene.append_to_caption(controls_str)\",\n \"def controls_setup(self):\\n\\n self.drain_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"Drain Types Submodule\\\",\\n css_selector='tr.CodeDrainType')\\n self.depot_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"Depot Types Submodule\\\",\\n css_selector='tr.CodeJobType')\\n self.file_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"File Types Submodule\\\",\\n css_selector='tr.CodeFileType')\\n self.job_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"Job Types Submodule\\\",\\n css_selector='tr.CodeJobType')\\n self.paving_colours = container.AdminDashboardSubmodule(\\n self, alias=\\\"Paving Colours Submodule\\\",\\n css_selector='tr.CodePavingColour')\\n self.paving_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"Paving Types Submodule\\\",\\n css_selector='tr.CodePavingType')\\n self.repair_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"Repair Types Submodule\\\",\\n css_selector='tr.CodeRepairType')\\n self.subbie_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"Subbie Types Submodule\\\",\\n css_selector='tr.CodeSubbieType')\\n self.task_types = container.AdminDashboardSubmodule(\\n self, alias=\\\"Task Types Submodule\\\",\\n css_selector='tr.CodeTaskType')\",\n \"def createUI(self):\\n\\n q.getQItem(windowID, QtWidgets.QWidget)\\n cmds.setParent(q.fullPath)\\n\\n # ################################################\\n # Active Render Layer\\n\\n # cmds.separator(height=12, style='none')\\n addFrameLayout(\\n '%s_frameLayoutLayers' % windowID,\\n 'Visible Render Layer', collapsable=False,\\n labelVisible=False,\\n marginHeight=0\\n )\\n\\n addRowLayout(\\n '%s_rowLayoutActiveRenderLayer' % windowID,\\n 4,\\n columnAlign4=('left', 'left', 'right', 'right'),\\n columnAttach4=('left', 'both', 'right', 'right'),\\n columnWidth4=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.775,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075\\n )\\n )\\n\\n\\n addButton('%s_addNewLayer' % windowID, 'New', rsAddNewLayer,\\n image='RS_create_layer', size=(21, 21))\\n addOptionMenu('%s_selectActiveLayer' % windowID,\\n 'Active Layer ', (), rsSelectActiveLayer)\\n addButton('rsOpenRenderSetupWindow', 'Render Setup',\\n rsOpenRenderSetupWindow, image='render_setup.png',\\n size=(21, 21))\\n addButton('rsOpenUnifiedRenderGlobals', 'Render Globals',\\n rsOpenUnifiedRenderGlobals, image='render_setup.png',\\n size=(21, 21))\\n\\n # ################################################\\n # Work Render Layers\\n\\n cmds.setParent(q.fullPath)\\n addFrameLayout('%s_frameLayoutLayersB' % windowID,\\n 'Work Render Layer', collapsable=False,\\n labelVisible=False, marginHeight=0)\\n addRowLayout('%s_rowLayoutVisibleRenderLayer' % windowID, 3,\\n columnAlign3=('left', 'left', 'right'),\\n columnAttach3=('left', 'both', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.075, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.85,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075))\\n\\n cmds.separator()\\n addOptionMenu('%s_selectVisibleLayer' % windowID,\\n 'Visible Layer ', (), rsSelectVisibleLayer)\\n cmds.separator()\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=12, style='none')\\n\\n # ################################################\\n # Collections\\n\\n addFrameLayout('%s_frameLayout02' % windowID, 'Collections',\\n labelVisible=False, marginHeight=0)\\n\\n addRowLayout(\\n '%s_rowLayout02' % windowID,\\n 6,\\n columnAlign6=('left', 'left', 'left', 'left', 'left', 'left'),\\n columnAttach6=('both', 'both', 'right', 'right', 'right', 'right'),\\n columnWidth6=(\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.18,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.415,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.075,\\n )\\n )\\n\\n addButton('rsAddCollection', 'Add', rsAddCollection)\\n addButton('rsRemoveCollection', 'Remove', rsRemoveCollection)\\n addButton('rsSelectShapes', 'Select Shapes', rsSelectShapes,\\n image='selectObject.png', size=(21, 21))\\n addButton('rsRenameShader', 'Rename Shader', rsRenameShader,\\n size=(21, 21), image='QR_rename.png')\\n addButton('rsDuplicateShader', 'Duplicate Shader',\\n duplicateShader, size=(21, 21), image='newPreset.png')\\n addButton('rsRefreshUI', 'Refresh', rsRefreshUI, size=(21, 21),\\n image='QR_refresh.png')\\n\\n # ###########################\\n # Filter List\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout03' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.6, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.42))\\n\\n addTextField('%s_filterShaderList' % windowID, 'Search',\\n rsFilterShaderList_off, rsFilterShaderList_off,\\n window.updateUI)\\n addOptionMenu('rsShaderGroups', '|', (), rsShaderGroups)\\n\\n # ###########################\\n # The shaders scroll list\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n addRowLayout('%s_rowLayout04' % windowID, 1, columnAlign1='both', columnAttach1='both', columnWidth1=WINDOW_WIDTH\\n + 12)\\n addTextScrollList('%s_ShaderScrollList' % windowID, (),\\n rsShaderScrollList_doubleClick,\\n rsShaderScrollList_onSelect,\\n rsShaderScrollList_deleteKey)\\n\\n # Add popup menu:\\n\\n cmds.popupMenu('rsShaderScrollListPopupMenu',\\n parent='%s_ShaderScrollList' % windowID,\\n allowOptionBoxes=False, markingMenu=True,\\n postMenuCommand=postMenuCommand)\\n cmds.menuItem('%s_popupMenuItem02' % windowID,\\n label='Duplicate Shader', command=duplicateShader)\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem04' % windowID,\\n label='Graph Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem03' % windowID,\\n label='Select Shader')\\n cmds.menuItem(divider=True)\\n cmds.menuItem('%s_popupMenuItem05' % windowID,\\n label='Select Assigned Shapes')\\n cmds.menuItem('%s_popupMenuItem06' % windowID,\\n label='Select Assigned Transforms')\\n\\n # ##################################################\\n # Arnold Property Overrides\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout20' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n addRowLayout('%s_rowLayout05' % windowID, 2,\\n columnAlign2=('left', 'both'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_textArnoldPropertyOverridesLabel' % windowID,\\n 'Apply Arnold Property Overrides', 'plainLabelFont')\\n addCheckBox('rsArnoldPropertyOverridesCheckBox', '',\\n rsArnoldPropertyOverridesCheckBox,\\n rsArnoldPropertyOverridesCheckBox)\\n cmds.separator(parent='%s_columnLayout20' % windowID, height=4,\\n style='none')\\n\\n # Column Layout to toggle\\n\\n cmds.setParent('%s_columnLayout20' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout02' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n\\n addCheckboxes('%s_columnLayout02' % windowID)\\n cmds.columnLayout('%s_columnLayout02' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n # Shader Override\\n\\n cmds.setParent('%s_frameLayout02' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout21' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('left', 0),\\n adjustableColumn=False,\\n rowSpacing=0,\\n )\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n addRowLayout('%s_rowLayout06' % windowID, 2,\\n columnAlign2=('left', 'right'),\\n columnAttach2=('left', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.75, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.25))\\n addText('%s_shaderOverrideLabel' % windowID, 'Shader Override',\\n 'plainLabelFont')\\n addCheckBox('%s_shaderOverrideCheckbox' % windowID, '',\\n rsShaderOverrideCheckbox, rsShaderOverrideCheckbox)\\n cmds.separator(parent='%s_columnLayout21' % windowID, height=4,\\n style='none')\\n\\n cmds.setParent('%s_columnLayout21' % windowID)\\n cmds.columnLayout(\\n '%s_columnLayout03' % windowID,\\n width=WINDOW_WIDTH - FRAME_MARGIN * 2,\\n columnAlign='left',\\n columnAttach=('both', 4),\\n adjustableColumn=True,\\n rowSpacing=0,\\n )\\n cmds.setParent('%s_columnLayout03' % windowID)\\n addOptionMenu('%s_optionMenu02' % windowID, 'Select: ', (),\\n rsShaderOverridesMenu)\\n\\n global selectedShaderOverride\\n\\n # default selection\\n\\n selectedShaderOverride = SHADER_OVERRIDE_OPTIONS[0]['ui']\\n cmds.columnLayout('%s_columnLayout03' % windowID, edit=True,\\n visible=False)\\n\\n # #################################################\\n\\n cmds.setParent(q.fullPath)\\n cmds.separator(height=10, style='none')\\n\\n # #################################################\\n # Extras\\n\\n addFrameLayout('%s_frameLayout50' % windowID, 'Extras',\\n collapsable=True, marginHeight=0,\\n labelVisible=False)\\n\\n # #################################################\\n # Add & Assign Shader Groups\\n\\n addFrameLayout(\\n '%s_frameLayout05' % windowID,\\n 'Add & Assign Shader Groups',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=False,\\n labelVisible=True,\\n )\\n\\n # Add the renamer window\\n\\n self.gwCustomRenamer = CustomRenamer()\\n self.gwCustomRenamer.createUI()\\n\\n # #################################################\\n # AutoConnect\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n\\n addFrameLayout(\\n '%s_frameLayout03' % windowID,\\n 'Adobe Connector',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout07', 3, columnAlign3=('left', 'left',\\n 'left'), columnAttach3=('both', 'both', 'both'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addButton('updateConnections', '> Update Connections <',\\n updateConnections)\\n addButton('uvSnapshot', 'UV Snapshot', uvSnapshot)\\n addButton('editTexture', 'Edit Texture', editTexture)\\n\\n # After Effects\\n\\n cmds.setParent('%s_frameLayout03' % windowID)\\n addRowLayout('%s_rowLayout11' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'both'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.4, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.6))\\n addText('%s_text90' % windowID, 'Send to After Effects:')\\n addButton('makeCompButton', 'Send to After Effects', rsMakeComp)\\n\\n # #################################################\\n # Render Setup /\\n # Output settings\\n\\n cmds.setParent('%s_frameLayout50' % windowID)\\n addFrameLayout(\\n '%s_frameLayout04' % windowID,\\n 'Output Settings',\\n collapsable=True,\\n marginWidth=0,\\n marginHeight=0,\\n collapse=True,\\n labelVisible=True,\\n )\\n addRowLayout('%s_rowLayout08' % windowID, 1,\\n columnAlign1='center', columnAttach1='both',\\n columnWidth1=WINDOW_WIDTH - FRAME_MARGIN * 2)\\n addButton('%s_revealOutputDirectory' % windowID,\\n 'Output path not set yet', rsRevealOutputDirectory)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout09' % windowID, 3,\\n columnAlign3=('left', 'right', 'right'),\\n columnAttach3=('left', 'right', 'right'),\\n columnWidth3=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.8, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.14,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.06))\\n\\n addOptionMenu('%s_optionMenu05' % windowID, '', (),\\n rsSelectOutputTemplate)\\n addOptionMenu('%s_outputVersionMenu' % windowID, '', (),\\n rsSelectOutputVersion)\\n cmds.menuItem(label='v001')\\n\\n cmds.setParent('%s_rowLayout09' % windowID)\\n addButton('%s_incrementOutputVersionButton' % windowID, '+1',\\n rsIncrementOutputVersion, size=(21, 21))\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout10' % windowID, 2,\\n columnAlign2=('left', 'left'),\\n columnAttach2=('both', 'right'),\\n columnWidth2=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.7, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.3))\\n addOptionMenu('%s_optionMenu03' % windowID, 'Format:', (),\\n rsOutputTemplatesMenu)\\n addOptionMenu('%s_optionMenu06' % windowID, '', (),\\n rsSetFPSMenu)\\n\\n cmds.setParent('%s_frameLayout04' % windowID)\\n addRowLayout('%s_rowLayout12' % windowID, 4,\\n columnAlign4=('right', 'left', 'right', 'left'),\\n columnAttach4=('both', 'both', 'both', 'both'),\\n columnWidth4=((WINDOW_WIDTH - FRAME_MARGIN * 2)\\n * 0.50, (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.20,\\n (WINDOW_WIDTH - FRAME_MARGIN * 2) * 0.15))\\n\\n addText('%s_setInFrameLabel' % windowID, 'In Frame ')\\n addTextField('%s_setInFrame' % windowID, '', setInFrame,\\n setInFrame, setInFrame)\\n\\n addText('%s_setOutFrameLabel' % windowID, 'Out Frame ')\\n addTextField('%s_setOutFrame' % windowID, '', setOutFrame,\\n setOutFrame, setOutFrame)\",\n \"def __init__(self, ui: UI):\\n super().__init__(ui)\",\n \"def _setup_ui(self):\\n\\n self.window = ui.Widget()\\n self.window.dimensions = ui.normalize_dimension((\\n 0, 0,\\n self.normalized_screen_resolution[0],\\n self.normalized_screen_resolution[1]\\n ))\\n self.window.background_color = ImageColor.getcolor('#000000', 'RGB')\\n\\n interface_frame = ui.Widget(parent=self.window)\\n interface_frame.dimensions = ui.normalize_dimension((\\n self.preview_renderer.window[2],\\n 0,\\n self.normalized_screen_resolution[0] - self.preview_renderer.window[2],\\n self.normalized_screen_resolution[1]\\n ))\\n interface_frame.background_color = ImageColor.getcolor('#ffffff', 'RGB')\\n\\n number = ui.LabelWidget(\\\"\\\",\\n name=NAME_GET_STARTED,\\n parent=interface_frame,\\n align=\\\"center\\\",\\n font_color=(0, 0, 0, 255))\\n number.dimensions = (\\n 5, 5,\\n interface_frame.width - 10,\\n interface_frame.height - 10\\n )\",\n \"def additional_ui(self):\\n return '''<ui>\\n <menubar name=\\\"MenuBar\\\">\\n <menu action=\\\"FileMenu\\\">\\n <placeholder name=\\\"LocalExport\\\">\\n <menuitem action=\\\"ExportTab\\\"/>\\n </placeholder>\\n </menu>\\n <menu action=\\\"EditMenu\\\">\\n <placeholder name=\\\"CommonEdit\\\">\\n <menuitem action=\\\"Add\\\"/>\\n <menuitem action=\\\"Edit\\\"/>\\n <menuitem action=\\\"Remove\\\"/>\\n <menuitem action=\\\"Merge\\\"/>\\n </placeholder>\\n <menuitem action=\\\"FilterEdit\\\"/>\\n </menu>\\n <menu action=\\\"BookMenu\\\">\\n <placeholder name=\\\"AddEditBook\\\">\\n <menuitem action=\\\"AddBook\\\"/>\\n <menuitem action=\\\"EditBook\\\"/>\\n </placeholder>\\n </menu>\\n <menu action=\\\"GoMenu\\\">\\n <placeholder name=\\\"CommonGo\\\">\\n <menuitem action=\\\"Back\\\"/>\\n <menuitem action=\\\"Forward\\\"/>\\n <separator/>\\n </placeholder>\\n </menu>\\n </menubar>\\n <toolbar name=\\\"ToolBar\\\">\\n <placeholder name=\\\"CommonNavigation\\\">\\n <toolitem action=\\\"Back\\\"/> \\n <toolitem action=\\\"Forward\\\"/> \\n </placeholder>\\n <placeholder name=\\\"CommonEdit\\\">\\n <toolitem action=\\\"Add\\\"/>\\n <toolitem action=\\\"Edit\\\"/>\\n <toolitem action=\\\"Remove\\\"/>\\n <toolitem action=\\\"Merge\\\"/>\\n </placeholder>\\n <separator/>\\n <toolitem action=\\\"OpenMedia\\\"/>\\n </toolbar>\\n <popup name=\\\"Popup\\\">\\n <menuitem action=\\\"Back\\\"/>\\n <menuitem action=\\\"Forward\\\"/>\\n <separator/>\\n <menuitem action=\\\"OpenMedia\\\"/>\\n <menuitem action=\\\"OpenContainingFolder\\\"/>\\n <separator/>\\n <menuitem action=\\\"Add\\\"/>\\n <menuitem action=\\\"Edit\\\"/>\\n <menuitem action=\\\"Remove\\\"/>\\n <menuitem action=\\\"Merge\\\"/>\\n <separator/>\\n <menu name=\\\"QuickReport\\\" action=\\\"QuickReport\\\"/>\\n </popup>\\n </ui>'''\",\n \"def __init__(self, parent, id=-1, title=\\\"\\\", name=\\\"\\\"):\\n wx.Frame.__init__(self, parent, id=id, title=title,\\n pos=wx.DefaultPosition, size=(1800,830), name=name) #1000,875\\n\\n self.menubar = wx.MenuBar()\\n self.SetMenuBar(self.menubar)\\n\\n views_menu = wx.Menu()\\n self.views_default_id = wx.NewId()\\n views_menu.Append(self.views_default_id, \\\"&Default\\\\tCtrl-D\\\",\\n \\\"Activate default view layout.\\\", wx.ITEM_NORMAL)\\n\\n self.views_max_image_id = wx.NewId()\\n views_menu.Append(self.views_max_image_id, \\\"&Axial-Sagittal-Coronal View\\\\tCtrl-M\\\",\\n \\\"Activate maximum image view size layout.\\\",\\n wx.ITEM_NORMAL)\\n\\t\\t\\n self.views_contour_view_id = wx.NewId()\\n views_menu.Append(self.views_contour_view_id, \\\"&Contour Uncertainty view\\\\tCtrl-C\\\",\\n \\\"Activate contour uncertainty view size layout.\\\",\\n wx.ITEM_NORMAL)\\n\\n self.views_voxel_view_id = wx.NewId()\\n views_menu.Append(self.views_voxel_view_id, \\\"&Voxel Uncertainty view\\\\tCtrl-V\\\",\\n \\\"Activate voxel uncertainty view size layout.\\\",\\n wx.ITEM_NORMAL)\\n\\n self.menubar.Append(views_menu, \\\"&Views\\\")\\n\\t\\t\\n\\t\\t\\n help_menu = wx.Menu()\\n help_about_id = wx.NewId()\\n help_menu.Append(help_about_id, \\\"&About\\\\tCtrl-0\\\",\\n \\\"Info about application.\\\", wx.ITEM_NORMAL)\\n\\t\\t\\t\\t\\t\\t \\n self.menubar.Append(help_menu, \\\"&Help\\\")\\n\\t\\t\\n # tell FrameManager to manage this frame\\n self._mgr = wx.aui.AuiManager()\\n self._mgr.SetManagedWindow(self)\\n\\n self._mgr.AddPane(self._create_patients_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"patient\\\").Caption(\\\"Patient Data\\\").\\n Left().\\n BestSize(wx.Size(600,400)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\n\\t\\t\\n self._mgr.AddPane(self._create_controls_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"control\\\").Caption(\\\"Dose Plan Explorer\\\").\\n Bottom().\\n BestSize(wx.Size(600,400)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\t\\t\\t\\t\\t\\t \\n self._mgr.AddPane(self._create_axial_slices_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"axial\\\").Caption(\\\"Axial\\\").\\n Center().\\n BestSize(wx.Size(400,400)).\\n CloseButton(False).MaximizeButton(True))\\n\\t\\t\\t\\t\\t\\t \\n self._mgr.AddPane(self._create_3D_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"3dview\\\").Caption(\\\"3D Dose Plan\\\").\\n Left().\\n BestSize(wx.Size(1000,800)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\n self._mgr.AddPane(self._create_sagittal_slices_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"sagittal\\\").Caption(\\\"Sagittal\\\").\\n Right().\\n BestSize(wx.Size(400,400)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\n\\n self._mgr.AddPane(self._create_coronal_slices_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"coronal\\\").Caption(\\\"Coronal\\\").\\n Right().\\n BestSize(wx.Size(400,400)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\n self._mgr.AddPane(self._create_barplot_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"overview\\\").Caption(\\\"Probability Overview\\\").\\n Bottom().\\n BestSize(wx.Size(1000,800)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\t\\t\\t\\t\\t\\t \\n self._mgr.AddPane(self._create_probs_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"probs\\\").Caption(\\\"Probabilities for Dose Plans\\\").\\n Bottom().\\n BestSize(wx.Size(1000,800)).\\n MinimizeButton(True).MaximizeButton(True))\\t\\t\\t\\t \\t\\t\\t\\t\\t\\t \\n\\t\\t\\t\\t\\t\\t \\n self._mgr.AddPane(self._create_distplot_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"distplot\\\").Caption(\\\"Exploration of dose distribution\\\").\\n Bottom().\\n BestSize(wx.Size(1000,800)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\t\\t\\t\\t\\t\\t \\n self._mgr.AddPane(self._create_scatterplot_pane(), wx.aui.AuiPaneInfo().\\n Name(\\\"scatterplot\\\").Caption(\\\"Variability scatterplot\\\").\\n Bottom().\\n BestSize(wx.Size(1000,800)).\\n MinimizeButton(True).MaximizeButton(True))\\n\\t\\t\\n\\n self.SetMinSize(wx.Size(400, 300))\\n\\n # first we save this default perspective with all panes\\n # visible\\n self._perspectives = {}\\n self._mgr.GetPane(\\\"doseplan\\\").Hide()\\n self._mgr.GetPane(\\\"scatterplot\\\").Hide()\\n self._mgr.GetPane(\\\"3dview\\\").Hide()\\n self._mgr.GetPane(\\\"distplot\\\").Hide()\\n self._perspectives['default'] = self._mgr.SavePerspective()\\n\\n #------------- Show maximum image view ------------------#\\n\\t\\t\\n\\t\\t#Show axial,coronal and sagittal panes\\n self._mgr.GetPane(\\\"axial\\\").Show()\\n self._mgr.GetPane(\\\"coronal\\\").Show()\\n self._mgr.GetPane(\\\"sagittal\\\").Show()\\n\\n\\t\\t#Hide all the others\\t\\t\\n self._mgr.GetPane(\\\"patient\\\").Hide()\\t\\t\\n self._mgr.GetPane(\\\"control\\\").Hide()\\n self._mgr.GetPane(\\\"overview\\\").Hide()\\n self._mgr.GetPane(\\\"probs\\\").Hide()\\n self._mgr.GetPane(\\\"3dview\\\").Hide()\\n self._mgr.GetPane(\\\"scatterplot\\\").Hide()\\n self._mgr.GetPane(\\\"distplot\\\").Hide()\\n # save the perspective again\\n self._perspectives['max_image'] = self._mgr.SavePerspective()\\n\\n #------------- Show contour uncertainty view ------------------#\\n\\t\\t\\n\\t\\t#Show axial, coronal, sagittal, control, overview and probabilities panes\\n self._mgr.GetPane(\\\"axial\\\").Show()\\n self._mgr.GetPane(\\\"coronal\\\").Right()\\n self._mgr.GetPane(\\\"coronal\\\").Show()\\n self._mgr.GetPane(\\\"sagittal\\\").Right()\\n self._mgr.GetPane(\\\"sagittal\\\").Show()\\n self._mgr.GetPane(\\\"control\\\").Show()\\n self._mgr.GetPane(\\\"overview\\\").Show()\\n self._mgr.GetPane(\\\"probs\\\").Show()\\n\\t\\t\\n\\t\\t#Hide all the others\\n self._mgr.GetPane(\\\"patient\\\").Hide()\\n self._mgr.GetPane(\\\"3dview\\\").Hide()\\n self._mgr.GetPane(\\\"scatterplot\\\").Hide()\\n self._mgr.GetPane(\\\"distplot\\\").Hide()\\n\\t\\t\\n self._perspectives['contour_view'] = self._mgr.SavePerspective()\\n\\t\\t\\n #------------- Show voxel uncertainty view ------------------#\\t\\t\\n\\t\\t\\n\\t\\t#Show 3dview, scatterplot, axial and distplot panes\\n self._mgr.GetPane(\\\"axial\\\").Left().Center()\\n self._mgr.GetPane(\\\"axial\\\").Show()\\n self._mgr.GetPane(\\\"3dview\\\").Left().Center()\\n self._mgr.GetPane(\\\"3dview\\\").Show()\\n self._mgr.GetPane(\\\"distplot\\\").Right()\\n self._mgr.GetPane(\\\"distplot\\\").Show()\\n self._mgr.GetPane(\\\"scatterplot\\\").Right()\\n self._mgr.GetPane(\\\"scatterplot\\\").Show()\\n\\t\\t\\n self._mgr.GetPane(\\\"patient\\\").Hide()\\n self._mgr.GetPane(\\\"control\\\").Hide()\\n self._mgr.GetPane(\\\"coronal\\\").Hide()\\n self._mgr.GetPane(\\\"sagittal\\\").Hide()\\n self._mgr.GetPane(\\\"probs\\\").Hide()\\n self._mgr.GetPane(\\\"overview\\\").Hide()\\n\\t\\t\\n self._perspectives['voxel_view'] = self._mgr.SavePerspective()\\n\\t\\t\\n # and put back the default perspective / view\\n self._mgr.LoadPerspective(self._perspectives['default'])\\n\\n # finally tell the AUI manager to do everything that we've\\n # asked\\n self._mgr.Update()\\n\\t\\t\\n\\t\\t#Bind the events\\n self.Bind(wx.EVT_MENU, self.onAbout, id = help_about_id)\\n\\t\\n self.patients = {}\\n self.contours = {}\\n\\t\\t\\n #sns.plt.close(self.figure)\\n\\t\\t\\t\\t\\t\\t\\n self.CreateStatusBar()\\n self.SetStatusText(\\\"Status information can be find here...\\\")\\n\\t\\t\\n self.new_pat = None\\n self.aboutbox = None\\n\\t\\t\\n self.tracer = vtk.vtkImageTracerWidget()\\n self.tracer.SetCaptureRadius(10.5)\\n self.tracer.GetGlyphSource().SetColor(1, 0, 0)\\n self.tracer.GetGlyphSource().SetScale(1.0) # set the size of the glyph handle\\n\\t\\t\\n # Set the initial rotation of the glyph if desired. The default glyph\\n # set internally by the widget is a '+' so rotating 45 deg. gives a 'x'\\n self.tracer.GetGlyphSource().SetRotationAngle(90.0)\\n self.tracer.GetGlyphSource().Modified()\\n self.tracer.GetLineProperty().SetColor(1,0,0)\\n self.tracer.SetPriority(1)\\n self.tracer.AutoCloseOn()\\n self.tracer.IsClosed()\\n\\t\\t\\n self.dc = None\\n self.cursor_dist = None\",\n \"def init_ui(self):\\n # Create GUI elements, set them in dict structure\\n labelwidth = 150\\n\\n # Add parameter line edit for Factor Tm to Tp\\n self.input_elements['factor Tm Tp'] = widgets.ParameterInputLine(\\n label='Factor Tm naar Tp:',\\n labelwidth=labelwidth,\\n unitlabel='(NVT: Tp aanwezig)' if 'Tp' in self.hydraulic_loads.columns else '',\\n validator=QtGui.QDoubleValidator(0.01, 99.99, 20),\\n )\\n\\n if 'Tp' in self.hydraulic_loads.columns or self.parent_tab.step != 'I1':\\n self.input_elements['factor Tm Tp'].set_enabled(False)\\n\\n # Add line edit with browsebutton for Master template\\n self.input_elements['mastertemplate'] = widgets.ExtendedLineEdit(\\n label='Master template bestand:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_master_template)\\n )\\n\\n # Add line edit with browsebutton for depth file\\n self.input_elements['depthfile'] = widgets.ExtendedLineEdit(\\n label='Bathymetry bestand:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_bathymetry_file)\\n )\\n\\n # Add line edit with browsebutton for swan result folder\\n self.input_elements['swanfolder'] = widgets.ExtendedLineEdit(\\n label='SWAN uitvoer folder:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_swan_folder)\\n )\\n\\n\\n self.setLayout(QtWidgets.QVBoxLayout())\\n self.layout().setSpacing(10)\\n\\n for _, item in self.input_elements.items():\\n self.layout().addWidget(item)\\n\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n self.layout().addWidget(line)\\n\\n # OK and Cancel buttons\\n self.generateButton = QtWidgets.QPushButton('Genereer invoer')\\n self.generateButton.setDefault(True)\\n self.generateButton.clicked.connect(self.generate)\\n\\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\\n self.cancelButton.setAutoDefault(False)\\n self.cancelButton.clicked.connect(self.cancel)\\n\\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\\n button_box.accepted.connect(QtWidgets.QDialog.accept)\\n\\n self.layout().addWidget(button_box)\",\n \"def __init__(self):\\r\\n super().__init__()\\r\\n self.init_ui()\",\n \"def _initUI(self) -> None:\\n self._createActions()\\n self._addActionsToMoveButtons()\\n self._createToolBar()\\n self._createStatusBar()\\n self._createMainContextMenu()\",\n \"def controls_setup(self):\\n\\n self.new_items = element.TopMenuLink(self, alias='New Items Menu',\\n css_selector='#browse > li:nth-child(1) > a')\\n if self.fixed:\\n self.jewelry = element.TopMenuLink(self, alias='Jewelry Menu',\\n css_selector='#browse > li:nth-child(2) > a')\\n self.artwork = element.TopMenuLink(self, alias='Artwork Menu',\\n css_selector='#browse > li:nth-child(3) > a')\\n self.homeware = element.TopMenuLink(self, alias='Homeware Menu',\\n css_selector='#browse > li:nth-child(4) > a')\\n self.clothing = element.TopMenuLink(self, alias='Clothing Menu',\\n css_selector='#browse > li:nth-child(5) > a')\\n self.vintage = element.TopMenuLink(self, alias='Vintage Menu',\\n css_selector='#browse > li:nth-child(6) > a')\\n self.food = element.TopMenuLink(self, alias='Food Menu',\\n css_selector='#browse > li:nth-child(7) > a')\\n self.rings = element.SubMenuLink(self, alias='Jewelry->Rings Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(1) > a')\\n self.necklaces = element.SubMenuLink(self, alias='Jewelry->Necklaces Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(2) > a')\\n self.bracelets = element.SubMenuLink(self, alias='Jewelry->Bracelets Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(3) > a')\\n self.earrings = element.SubMenuLink(self, alias='Jewelry->Earrings Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(4) > a')\\n self.broaches = element.SubMenuLink(self, alias='Jewelry->Broaches and Pins Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(5) > a')\\n self.wall_art = element.SubMenuLink(self, alias='Artwork->Wall Art Submenu',\\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(1) > a')\\n self.ceramics = element.SubMenuLink(self, alias='Jewelry->Ceramics Submenu',\\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(2) > a')\\n self.sculpture = element.SubMenuLink(self, alias='Jewelry->Sculpture Submenu',\\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(3) > a')\\n self.living = element.SubMenuLink(self, alias='Homeware->Living Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(1) > a')\\n self.furniture = element.SubMenuLink(self, alias='Homeware->Furniture Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(2) > a')\\n self.kitchen = element.SubMenuLink(self, alias='Homeware->Kitchen Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(3) > a')\\n self.lighting = element.SubMenuLink(self, alias='Homeware->Lighting Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(4) > a')\\n self.outdoor = element.SubMenuLink(self, alias='Homeware->Outdoor Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(5) > a')\\n self.organize = element.SubMenuLink(self, alias='Homeware->Organize Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(6) > a')\\n self.party = element.SubMenuLink(self, alias='Homeware->Party Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(7) > a')\\n self.sub_food = element.SubMenuLink(self, alias='Homeware->Food Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(8) > a')\\n self.pets = element.SubMenuLink(self, alias='Homeware->For Pets Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(9) > a')\\n self.women = element.SubMenuLink(self, alias='Clothing->Women Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(1) > a')\\n self.men = element.SubMenuLink(self, alias='Clothing->Men Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(2) > a')\\n self.kids = element.SubMenuLink(self, alias='Clothing->Kids Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(3) > a')\\n self.pet_lovers = element.SubMenuLink(self, alias='Clothing->Pet Lovers Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(4) > a')\\n self.antiques = element.SubMenuLink(self, alias='Vintage->Antiques Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(1) > a')\\n self.accessories = element.SubMenuLink(self, alias='Vintage->Accessories Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(2) > a')\\n self.sub_clothing = element.SubMenuLink(self, alias='Vintage->Clothing Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(3) > a')\\n self.sub_homeware = element.SubMenuLink(self, alias='Vintage->Homeware Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(4) > a')\\n self.toys = element.SubMenuLink(self, alias='Vintage->Toys Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(5) > a')\\n self.books = element.SubMenuLink(self, alias='Vintage->Books Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(6) > a')\\n else:\\n self.menus = []\",\n \"def additional_ui(self):\\n return '''<ui>\\n <menubar name=\\\"MenuBar\\\">\\n <menu action=\\\"FileMenu\\\">\\n <placeholder name=\\\"LocalExport\\\">\\n <menuitem action=\\\"ExportTab\\\"/>\\n </placeholder>\\n </menu>\\n <menu action=\\\"BookMenu\\\">\\n <placeholder name=\\\"AddEditBook\\\">\\n <menuitem action=\\\"AddBook\\\"/>\\n <menuitem action=\\\"EditBook\\\"/>\\n </placeholder>\\n </menu>\\n <menu action=\\\"GoMenu\\\">\\n <placeholder name=\\\"CommonGo\\\">\\n <menuitem action=\\\"Back\\\"/>\\n <menuitem action=\\\"Forward\\\"/>\\n <separator/>\\n </placeholder>\\n </menu>\\n <menu action=\\\"EditMenu\\\">\\n <placeholder name=\\\"CommonEdit\\\">\\n <menuitem action=\\\"Add\\\"/>\\n <menuitem action=\\\"Edit\\\"/>\\n <menuitem action=\\\"Remove\\\"/>\\n <menuitem action=\\\"Merge\\\"/>\\n </placeholder>\\n <menuitem action=\\\"FilterEdit\\\"/>\\n </menu>\\n </menubar>\\n <toolbar name=\\\"ToolBar\\\">\\n <placeholder name=\\\"CommonNavigation\\\">\\n <toolitem action=\\\"Back\\\"/> \\n <toolitem action=\\\"Forward\\\"/> \\n </placeholder>\\n <placeholder name=\\\"CommonEdit\\\">\\n <toolitem action=\\\"Add\\\"/>\\n <toolitem action=\\\"Edit\\\"/>\\n <toolitem action=\\\"Remove\\\"/>\\n <toolitem action=\\\"Merge\\\"/>\\n </placeholder>\\n </toolbar>\\n <popup name=\\\"Popup\\\">\\n <menuitem action=\\\"Back\\\"/>\\n <menuitem action=\\\"Forward\\\"/>\\n <separator/>\\n <menuitem action=\\\"Add\\\"/>\\n <menuitem action=\\\"Edit\\\"/>\\n <menuitem action=\\\"Remove\\\"/>\\n <menuitem action=\\\"Merge\\\"/>\\n <separator/>\\n <menu name=\\\"QuickReport\\\" action=\\\"QuickReport\\\"/>\\n </popup>\\n </ui>'''\",\n \"def _createView(self):\\n\\n items = []\\n\\n if self.showProgressBar:\\n items.append(Item('progress', show_label=False,\\n editor=ProgressEditor(callback=self._seek)))\\n\\n # Controls\\n items.append(\\n alignCenter(\\n Item('backwardButton', style='custom',\\n enabled_when='not object.running and object.mainloopRunning '\\n +'and object.sensors and object.iteration > 1'),\\n Item('runButton', style='custom',\\n enabled_when='object.pause and not object.done'),\\n Item('pauseButton', style='custom',\\n enabled_when='not (object.pause or object.done)'),\\n Item('stepButton', style='custom',\\n enabled_when='object.pause and not object.done'),\\n show_labels=False,\\n orientation='horizontal'\\n ))\\n\\n # Repeat button and pause target buttons\\n items.append(\\n alignCenter(\\n Item('repeatButton', show_label=False,\\n enabled_when='not object.running and object.mainloopRunning '\\n 'and object.iteration > 0'),\\n Item('nextTargetButton', show_label=False,\\n editor=ButtonEditor(label_value='targetButtonLabel'),\\n enabled_when='not object.running and object.mainloopRunning '\\n 'and object.pauseTarget'),\\n Item('customTargetButton', show_label=False,\\n enabled_when='not object.running and object.mainloopRunning')\\n ))\\n\\n # Speed control\\n items.append(Item('speed', style='custom', show_label=False,\\n editor=EnumEditor(cols=1, values={\\n 1 : '1: Slow (update on every iteration)',\\n 10 : '2: Medium (update every 10 iterations)',\\n 100 : '3: Fast (update every 100 iterations)'\\n })\\n ))\\n\\n\\n items.extend([\\n Group(\\n Item('pauseAtNextStep'),\\n show_left=False\\n ),\\n alignLeft(\\n Item('stopButton', show_label=False, enabled_when='object.iteration')\\n )\\n ])\\n\\n self.traits_view = View(*items)\",\n \"def _initUI(self):\\n\\n self.setWindowTitle(\\\"HB Havens: onzekerheden\\\")\\n self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)\\n\\n hlayout = QtWidgets.QHBoxLayout()\\n\\n vlayout = QtWidgets.QVBoxLayout()\\n\\n # Radio buttons\\n #----------------------------------------------------------------\\n self.button1 = QtWidgets.QRadioButton('Onzekerheden uit steunpunt overnemen')\\n self.button2 = QtWidgets.QRadioButton('Onzekerheden uit havenmodel overnemen')\\n self.button3 = QtWidgets.QRadioButton('Combinatie van bovenstaande gebruiken')\\n\\n vlayout.addWidget(self.button1)\\n vlayout.addWidget(self.button2)\\n vlayout.addWidget(self.button3)\\n vlayout.addItem(QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Expanding))\\n\\n hlayout.addLayout(vlayout)\\n\\n vlayout = QtWidgets.QVBoxLayout()\\n # Model uncertainties support location\\n #----------------------------------------------------------------\\n label = QtWidgets.QLabel()\\n label.setText('Modelonzekerheden in steunpunt:')\\n vlayout.addWidget(label)\\n\\n self.supportloc_unc_table = widgets.DataFrameWidget(self.supportloc_unc)\\n self.supportloc_unc_table.fixed_fit_to_content(90)\\n vlayout.addWidget(self.supportloc_unc_table)\\n\\n label = QtWidgets.QLabel()\\n label.setText('Modelonzekerheden in havenmodel (zelf invullen):')\\n vlayout.addWidget(label)\\n\\n self.harbor_unc_table = widgets.DataFrameWidget(self.harbor_unc, editing_enabled=True)\\n self.harbor_unc_table.fixed_fit_to_content(90)\\n vlayout.addWidget(self.harbor_unc_table)\\n\\n label = QtWidgets.QLabel()\\n label.setText('Gecombineerde modelonzekerheid (berekenen):')\\n vlayout.addWidget(label)\\n\\n calc_button = QtWidgets.QPushButton('Berekenen')\\n calc_button.clicked.connect(self._calc_combined_uncertainty)\\n vlayout.addWidget(calc_button)\\n\\n self.combined_unc_table = widgets.DataFrameWidget(self.combined_unc)\\n self.combined_unc_table.fixed_fit_to_content(90)\\n vlayout.addWidget(self.combined_unc_table)\\n\\n for table in [self.supportloc_unc_table, self.harbor_unc_table, self.combined_unc_table]:\\n table.setShowGrid(True)\\n table.setAlternatingRowColors(False)\\n\\n hlayout.addLayout(vlayout)\\n\\n vlayout = QtWidgets.QVBoxLayout()\\n vlayout.addLayout(hlayout)\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n vlayout.addWidget(line)\\n\\n\\n # Buttons\\n #----------------------------------------------------------------\\n hbox = QtWidgets.QHBoxLayout()\\n hbox.addItem(QtWidgets.QSpacerItem(0, 0, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Maximum))\\n # Add ok/close\\n self.closebutton = QtWidgets.QPushButton('Sluiten')\\n self.closebutton.clicked.connect(self.close)\\n hbox.addWidget(self.closebutton)\\n # Add ok/close\\n self.savebutton = QtWidgets.QPushButton('Opslaan')\\n self.savebutton.clicked.connect(self._save)\\n hbox.addWidget(self.savebutton)\\n\\n vlayout.addLayout(hbox)\\n\\n # Add layout to widget\\n self.setLayout(vlayout)\\n self.layout().setSpacing(10)\",\n \"def init_ui(self):\\n self.panel_sizer = wx.BoxSizer(wx.VERTICAL)\\n self.figure_bmp = wx.StaticBitmap(self, wx.ID_ANY,\\n bitmap=self.controller.empty_bitmap(self.bitmap_width,\\n self.bitmap_height),\\n pos=wx.DefaultPosition, size=wx.DefaultSize)\\n self.panel_sizer.Add(self.figure_bmp, ui_defaults.ctrl_pct, wx.CENTER,\\n ui_defaults.widget_margin)\\n self.SetSizerAndFit(self.panel_sizer)\",\n \"def __init__(self, napari_viewer: napari.Viewer):\\n super().__init__()\\n self.viewer = napari_viewer\\n # data classes\\n self.ims_pixel_map: Optional[PixelMapIMS] = None\\n self.microscopy_image: Optional[MicroRegImage] = None\\n self.micro_image_names: Optional[List[str, ...]] = None\\n self.image_transformer: ImageTransform = ImageTransform()\\n self.last_transform: np.ndarray = np.eye(3)\\n self.output_size: Optional[Tuple[int, int]] = None\\n\\n # private attrs\\n self._micro_rot = 0\\n self._ims_rot = 0\\n\\n # controller widgets\\n self._data: DataControl = DataControl(self)\\n self._ims_c: IMSControl = IMSControl(self)\\n self._tform_c: TformControl = TformControl(self)\\n self._save_c: SaveControl = SaveControl(self)\\n\\n # layout widgets in GUI\\n self.setLayout(QVBoxLayout())\\n self.layout().addWidget(self._data.data_frame)\\n self.layout().addWidget(self._ims_c.ims_ctrl_frame)\\n self.layout().addWidget(self._tform_c.tform_ctrl_frame)\\n self.layout().addWidget(self._save_c.save_ctrl_frame)\\n self.layout().addStretch(1)\\n\\n # button actions for widgets\\n # data reading\\n self._data.ims_d.add_ims_data.clicked.connect(self.read_ims_data)\\n self._data.ims_d.delete_btn.clicked.connect(self._delete_ims_roi)\\n self._data.micro_d.add_micro_data.clicked.connect(self.read_micro_data)\\n\\n # ims canvas control\\n self._ims_c.ims_ctl.do_padding_btn.clicked.connect(self._pad_ims_canvas)\\n self._ims_c.ims_ctl.micron_check.clicked.connect(\\n lambda: self._set_pad_by(\\\"micron\\\")\\n )\\n self._ims_c.ims_ctl.pixel_check.clicked.connect(\\n lambda: self._set_pad_by(\\\"pixel\\\")\\n )\\n\\n # transform control\\n self._tform_c.tform_ctl.reset_transform.clicked.connect(self.reset_transform)\\n self._tform_c.tform_ctl.run_transform.clicked.connect(self.run_transformation)\\n self._tform_c.rot_ctl.rot_mi_90cw.clicked.connect(\\n lambda: self._rotate_modality(\\\"microscopy\\\", -90)\\n )\\n self._tform_c.rot_ctl.rot_mi_90ccw.clicked.connect(\\n lambda: self._rotate_modality(\\\"microscopy\\\", 90)\\n )\\n self._tform_c.rot_ctl.rot_mi_180cw.clicked.connect(\\n lambda: self._rotate_modality(\\\"microscopy\\\", 180)\\n )\\n self._tform_c.rot_ctl.rot_mi_180ccw.clicked.connect(\\n lambda: self._rotate_modality(\\\"microscopy\\\", 180)\\n )\\n self._tform_c.rot_ctl.rot_ims_90cw.clicked.connect(\\n lambda: self._rotate_modality(\\\"ims\\\", -90)\\n )\\n self._tform_c.rot_ctl.rot_ims_90ccw.clicked.connect(\\n lambda: self._rotate_modality(\\\"ims\\\", 90)\\n )\\n # self.tform_c.rot_ctl.rot_ims_180cw.clicked.connect(\\n # lambda: self._rotate_modality(\\\"ims\\\", 180)\\n # )\\n # self.tform_c.rot_ctl.rot_ims_180ccw.clicked.connect(\\n # lambda: self._rotate_modality(\\\"ims\\\", 180)\\n # )\\n\\n # save control\\n self._save_c.save_ctl.reset_data.clicked.connect(self.reset_data)\\n self._save_c.save_ctl.save_data.clicked.connect(self.save_data)\\n\\n # update spatial resolutions\\n self._ims_res_timer = QTimer()\\n self._ims_res_timer.setSingleShot(True)\\n self._ims_res_timer.timeout.connect(self._set_ims_res)\\n self._data.ims_d.res_info_input.textChanged.connect(self._ims_res_timing)\\n\\n self._micro_res_timer = QTimer()\\n self._micro_res_timer.setSingleShot(True)\\n self._micro_res_timer.timeout.connect(self._set_micro_res)\\n self._data.micro_d.res_info_input.textChanged.connect(self._micro_res_timing)\\n\\n # start with certain buttons disabled\\n self._save_c.save_ctl.save_data.setEnabled(False)\\n self._tform_c.tform_ctl.run_transform.setEnabled(False)\",\n \"def build_ui(self):\\n self.ui = UI_procstep.Ui_Form()#.Ui_USGSContactInfoWidgetMain()\\n self.ui.setupUi(self)\\n self.setup_dragdrop(self)\\n\\n self.proc_step = RepeatingElement(which='tab',\\n tab_label='Step', add_text='Additional Step',\\n widget=ProcessStep, remove_text='Remove Step', italic_text='Processing Steps Taken')\\n\\n #self.proc_step = RepeatingElement(params=params, which='tab', tab_label='Source',)\\n self.proc_step.add_another()\\n self.ui.widget_procstep.layout().addWidget(self.proc_step)\",\n \"def __init__(self, parent=None):\\n super(Representative, self).__init__(parent)\\n self.setupUi(self)\",\n \"def create_page(self, parent):\\n ui = self.edit_traits(parent=parent, kind=\\\"subpanel\\\")\\n return ui.control\",\n \"def __init__(self, scenario_controller):\\n super(Ui, self).__init__()\\n\\n self.scenarioController = scenario_controller\\n\\n\\n # determine if application is a script file or frozen exe\\n\\n if getattr(sys, 'frozen', False):\\n relative_ui_path = 'AssetsV1/MainUI.ui'\\n main_ui_path = os.path.dirname(sys.executable)\\n\\n elif __file__:\\n relative_ui_path = 'MainUI.ui'\\n main_ui_path = os.path.dirname(__file__)\\n\\n # needs to point to MainUi.ui file\\n complete_ui_path = os.path.join(main_ui_path, relative_ui_path)\\n\\n uic.loadUi(complete_ui_path, self)\\n\\n self.timeline = MyTimelineWidget(self, self.scenarioController)\\n self.tabWidget.setTabsClosable(True)\\n self.tabs = self.tabWidget\\n self.tabs.currentChanged.connect(self.current_tab_changed) \\n self.tabs.tabCloseRequested.connect(self.close_current_tab)\\n\\n self.showMaximized()\\n\\n all_subsystem_names = self.scenarioController.getAvailableSubsystemNames()\\n\\n self.clearMenuOptions(self.menuOpen)\\n self.clearMenuOptions(self.menuFile)\\n self.setMenuOptions(self.menuFile, ['Save', 'Save As', 'Save As Scenario'], self.saveMenuHandler)\\n self.setMenuOptionsWithParams(self.menuNew, all_subsystem_names, self.newSubsystemHandler)\\n self.setMenuOptions(self.menuOpen, ['Open Command File', 'Open Scenario'], self.openMenuHandler)\\n\\n self.show()\\n self.timeline.show()\",\n \"def init_ui(self):\\n # Create GUI elements, set them in dict structure\\n labelwidth = 150\\n\\n # Add parameter line edit for Factor Tm to Tp\\n\\n # Add line edit with browsebutton for swan result folder\\n self.input_elements['hares folder'] = widgets.ExtendedLineEdit(\\n label='HARES uitvoerbestanden folder:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_hares_folder)\\n )\\n\\n\\n self.setLayout(QtWidgets.QVBoxLayout())\\n self.layout().setSpacing(10)\\n\\n for _, item in self.input_elements.items():\\n self.layout().addWidget(item)\\n\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n self.layout().addWidget(line)\\n\\n # OK and Cancel buttons\\n self.generateButton = QtWidgets.QPushButton('Start lezen uitvoerbestanden')\\n self.generateButton.setDefault(True)\\n self.generateButton.clicked.connect(self.generate)\\n\\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\\n self.cancelButton.setAutoDefault(False)\\n self.cancelButton.clicked.connect(self.cancel)\\n\\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\\n button_box.accepted.connect(QtWidgets.QDialog.accept)\\n\\n self.layout().addWidget(button_box)\",\n \"def process_widgets(self):\\r\\n\\r\\n self.runmode_menu.add_radiobutton(label=\\\"Graphical User Interface\\\", value=0, variable=self.gui_menu_var,\\r\\n command=self.disable_debugging_mode)\\r\\n self.runmode_menu.add_radiobutton(label=\\\"Command Line Interface\\\", value=1, variable=self.gui_menu_var,\\r\\n command=lambda gui=self: load_cli(self))\\r\\n self.runmode_menu.add_radiobutton(label=\\\"Debugging Mode (GUI + CLI)\\\", value=2, variable=self.gui_menu_var,\\r\\n command=self.enable_debugging_mode)\\r\\n\\r\\n # Placing all the submenus\\r\\n self.filemenu.add_cascade(label=\\\"Run Mode\\\", menu=self.runmode_menu)\\r\\n self.menubar.add_cascade(label=\\\"File\\\", menu=self.filemenu)\\r\\n\\r\\n self.config(menu=self.menubar) # Indicating that the \\\"menubar\\\" variable is the filemenu of the application\\r\\n\\r\\n self.folder_frame.pack()\\r\\n\\r\\n # self.folder_locator.pack(side=LEFT, padx=10, pady=10)\\r\\n\\r\\n self.media_folder_label.pack(side=LEFT, padx=10, pady=10)\\r\\n\\r\\n self.folder_button.pack(side=LEFT)\\r\\n\\r\\n self.path_frame_parent.pack(side=LEFT)\\r\\n\\r\\n self.search_frame.pack()\\r\\n\\r\\n self.search_frame.pack()\\r\\n self.search_entry.grid(row=0, column=0, padx=10, pady=20)\\r\\n self.search_button.grid(row=0, column=1, padx=5)\\r\\n # self.advanced_search_button.grid(row=0, column=2, padx=5)\\r\\n\\r\\n self.media_frame.pack()\\r\\n\\r\\n self.button_frame.pack()\",\n \"def create_gui(self):\\n\\n selectors_widgets = list()\\n\\n for n in range(4):\\n\\n selectors_widgets.append(wd.Dropdown(\\n options={'': 0, 'Orange': 1, 'Red': 2, 'Blue': 3, 'Green': 4},\\n value=0,\\n disabled=False,\\n layout={'width': '148px'}\\n ))\\n\\n self.confirm_button.on_click(\\n self.create_combination_and_rate_function())\\n self.user_interact.children = [self.selectors, self.confirm_button]\\n\\n self.selectors.children = selectors_widgets\",\n \"def root_wdgt(self):\\n self.summarize()\\n modes = ['Global', 'Single-Image']\\n\\n def logic(mode):\\n # cache the widget later\\n if mode == modes[0]:\\n if self.global_walk is None:\\n self.global_walk = self.global_walk_specifier()\\n ipy_display(self.global_walk)\\n elif mode == modes[1]:\\n self.image_view = self.single_image_selector()\\n # if self.image_view is None:\\n # self.image_view = self.single_image_selector()\\n # ipy_display(self.image_view)\\n\\n UI = interactive(\\n logic, mode=widgets.ToggleButtons(options=modes, value=modes[0])\\n )\\n UI.children[-1].layout.height = '1000px'\\n ipy_display(UI)\",\n \"def init_ui(self):\\n self.master.title(\\\"Backbone\\\")\\n self.master.geometry(\\\"300x150\\\")\\n\\n self.pack(fill=BOTH, expand=1)\\n\\n self.btn_upload_file = Button(self, text=\\\"Upload file\\\", command=self.upload_file)\\n self.btn_upload_file.place(x=90, y=10)\\n\\n self.btn_create_training_file = Button(self, text=\\\"Create & upload training file\\\",\\n command=self.create_training_file)\\n self.btn_create_training_file.place(x=30, y=40)\\n\\n self.btn_run_algorithm = Button(self, text=\\\"Run algorithm\\\", command=self.run_algorithm)\\n self.btn_run_algorithm.place(x=80, y=70)\\n\\n self.btn_view_results = Button(self, text=\\\"View Results\\\", command=self.view_results)\\n self.btn_view_results.place(x=85, y=100)\",\n \"def __init__(self):\\n self.root = tk.Tk()\\n self.root.minsize(width=150, height=150)\\n self.root.maxsize(height=500)\\n self.root.title(\\\"GUV analysis\\\")\\n self.root.iconbitmap(os.path.join(os.path.dirname(__file__), \\\"icon.ico\\\"))\\n self.window = tk.Frame(self.root)\\n self.window.pack(side=\\\"top\\\", fill=\\\"both\\\", expand=True)\\n\\n self.widgets = {}\\n self.images = {}\\n\\n self.widgets['lblTitle'] = tk.Label(self.window, text='GUV analysis tool', font=\\\"-weight bold -size 20\\\")\\n self.widgets['lblTitle'].grid(column=0, row=0, columnspan=3)\\n\\n self.images['newImg'] = tk.PhotoImage(file=os.path.join(os.path.dirname(__file__),'icon-new.png')).subsample(2,2)\\n self.widgets['btnNew'] = tk.Button(self.window, text='New analysis', image=self.images['newImg'], command=self.start_new_analysis, compound=tk.TOP, borderwidth=0)\\n self.widgets['btnNew'].grid(column=0, row=1, padx=10)\\n\\n self.images['openImg'] = PhotoImage_cd('icon-open.png').subsample(2,2)\\n self.widgets['btnOpen'] = tk.Button(self.window, text='Open existing analysis', command=self.reopen_existing_analysis, image=self.images['openImg'], compound=tk.TOP, borderwidth=0)\\n self.widgets['btnOpen'].grid(column=1, row=1, padx=10)\\n\\n self.images['closeImg'] = PhotoImage_cd('icon-close.png').subsample(2,2)\\n self.widgets['btnClose'] = tk.Button(self.window, text='Close program', command=self.root.quit, image=self.images['closeImg'], compound=tk.TOP, borderwidth=0)\\n self.widgets['btnClose'].grid(column=2, row=1, padx=10)\",\n \"def ui_setup(self):\\n loader = QUiLoader()\\n file = QFile('./user_interface/form/main_window.ui')\\n file.open(QFile.ReadOnly)\\n self._window = loader.load(file)\\n file.close()\\n\\n status_bar = QStatusBar(self._window)\\n status_bar.showMessage(__copyright__)\\n self._window.setStatusBar(status_bar)\\n self._window.setWindowIcon(QIcon('./user_interface/media/bucketing_icon.jpeg'))\\n self._window.setWindowTitle('PySide2 Project - Basic UI Framework')\\n\\n self._option_panel = OptionPanel()\\n self._option_panel.add_button('DekBan', './user_interface/media/dekban.png')\\n self._option_panel.add_button('Charlie', './user_interface/media/charlie.jpeg')\\n self._option_panel.add_button('Simon', './user_interface/media/Simon.jpeg')\\n\\n # Add widget to main layout\\n main_layout = self._window.main_layout\\n main_layout.itemAtPosition(0, 0).setAlignment(QtCore.Qt.AlignCenter)\\n main_layout.itemAtPosition(0, 1).setAlignment(QtCore.Qt.AlignVCenter)\\n main_layout.addWidget(self._option_panel, 2, 0, 1, 1)\\n\\n # Add page widget to stack\\n self._pages['item'] = ItemWidget()\\n self._pages['text1'] = TextPage(text=PAUSE_TEXT)\\n self._pages['text2'] = TextPage(text=STOP_TEXT)\\n\\n for index, name in enumerate(self._pages):\\n print('pages {} : {} page'.format(index, name))\\n self._window.widget_stack.addWidget(self._pages[name].widget)\\n\\n self._window.widget_stack.setCurrentIndex(0)\\n\\n # Build up signal / slot\\n self._option_panel.currentItemChanged.connect(self.set_page)\",\n \"def build_ui(self):\\n\\n self.frame.columnconfigure(0, pad=20)\\n self.frame.columnconfigure(1, pad=20)\\n\\n\\n self.frame.rowconfigure(0, pad=3)\\n self.frame.rowconfigure(1, pad=3)\\n self.frame.rowconfigure(2, pad=3)\\n\\n p1_label = Label(self.frame)\\n p1_label[\\\"text\\\"] = \\\"Player 1\\\"\\n p1_label.grid(row=0, column=0)\\n\\n p2_label = Label(self.frame)\\n p2_label[\\\"text\\\"] = \\\"Player 2\\\"\\n p2_label.grid(row=0, column=1)\\n\\n self.lb1 = Listbox(self.frame)\\n for script in self.ai_list:\\n self.lb1.insert(END, script)\\n self.lb1.grid(row=1, column=0)\\n\\n self.lb1.selection_set(0)\\n self.lb1[\\\"exportselection\\\"] = 0\\n\\n self.lb2 = Listbox(self.frame)\\n for script in self.ai_list:\\n self.lb2.insert(END, script)\\n self.lb2.grid(row=1, column=1)\\n\\n self.lb2.selection_set(0)\\n self.lb2[\\\"exportselection\\\"] = 0\\n\\n start_game_button = Button(self.frame)\\n start_game_button[\\\"text\\\"] = \\\"Start Game\\\"\\n start_game_button[\\\"command\\\"] = self.start_game\\n start_game_button.grid(row=2, column=0)\\n\\n self.check_box = Checkbutton(self.frame, text=\\\"Draw UI\\\",variable=self.ui_draw)\\n self.check_box.grid(row=2,column=1)\\n\\n self.frame.pack()\",\n \"def __setup_ui_controls(self):\\n self.scene.append_to_caption('\\\\n')\\n\\n # Button to reset camera\\n btn_reset = button(\\n bind=self.__reset_camera, text=\\\"Reset Camera\\\")\\n self.__ui_controls.btn_reset = btn_reset\\n self.scene.append_to_caption('\\\\t')\\n\\n chkbox_cam = checkbox(\\n bind=self.__camera_lock_checkbox,\\n text=\\\"Camera Lock\\\", checked=self.__camera_lock)\\n self.__ui_controls.chkbox_cam = chkbox_cam\\n self.scene.append_to_caption('\\\\t')\\n\\n chkbox_rel = checkbox(\\n bind=self.__grid_relative_checkbox,\\n text=\\\"Grid Relative\\\", checked=self.__grid_relative)\\n self.__ui_controls.chkbox_rel = chkbox_rel\\n self.scene.append_to_caption('\\\\n\\\\n')\\n\\n # Button to clear the screen\\n btn_clr = button(bind=self.clear_scene, text=\\\"Clear Scene\\\")\\n self.__ui_controls.btn_clear = btn_clr\\n self.scene.append_to_caption('\\\\n\\\\n')\\n\\n # Checkbox for grid visibility\\n chkbox_grid = checkbox(\\n bind=self.__grid_visibility_checkbox, text=\\\"Grid Visibility\\\",\\n checked=self.__grid_visibility)\\n self.__ui_controls.chkbox_grid = chkbox_grid\\n self.scene.append_to_caption('\\\\t')\\n\\n # Prevent the space bar from toggling the active checkbox/button/etc\\n # (default browser behaviour)\\n self.scene.append_to_caption('''\\n <script type=\\\"text/javascript\\\">\\n $(document).keyup(function(event) {\\n if(event.which === 32) {\\n event.preventDefault();\\n }\\n });\\n </script>''')\\n # https://stackoverflow.com/questions/22280139/prevent-space-button-from-triggering-any-other-button-click-in-jquery\\n\\n # Control manual\\n controls_str = '<br><b>Controls</b><br>' \\\\\\n '<b>PAN</b><br>' \\\\\\n 'SHFT + LMB | <i>free pan</i><br>' \\\\\\n 'W , S | <i>up / down</i><br>' \\\\\\n 'A , D | <i>left / right</i><br>' \\\\\\n '<b>ROTATE</b><br>' \\\\\\n 'ARROWS KEYS | <i>rotate direction</i><br>' \\\\\\n 'Q , E | <i>roll left / right</i><br>' \\\\\\n '<b>ZOOM</b></br>' \\\\\\n 'MOUSEWHEEL | <i>zoom in / out</i><br>' \\\\\\n '<script type=\\\"text/javascript\\\">var arrow_keys_handler = function(e) {switch(e.keyCode){ case 37: case 39: case 38: case 40: case 32: e.preventDefault(); break; default: break;}};window.addEventListener(\\\"keydown\\\", arrow_keys_handler, false);</script>' # noqa\\n # Disable the arrow keys from scrolling in the browser\\n # https://stackoverflow.com/questions/8916620/disable-arrow-key-scrolling-in-users-browser\\n self.scene.append_to_caption(controls_str)\",\n \"def set_controls(self):\\n # Image control\\n image = pyxbmct.Image(addonfolder+artsfolder+'/generic.png')\\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\\n\\n\\t\\t# USB\\n self.usb_button = pyxbmct.RadioButton('')\\n self.placeControl(self.usb_button, 9, 3, rowspan=2, columnspan=4)\\n self.connect(self.usb_button, self.usb_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'usb', 2) == 1:\\n self.usb_button.setSelected(True)\\n else:\\n self.usb_button.setSelected(False)\\n usb = pyxbmct.Image(addonfolder+artsfolder+'/usb.png')\\n self.placeControl(usb, 9, 3, rowspan=2, columnspan=4)\\n\\n\\t\\t# PCI-X\\n self.pcix_button = pyxbmct.RadioButton('')\\n self.placeControl(self.pcix_button, 9, 9, rowspan=2, columnspan=4)\\n self.connect(self.pcix_button, self.pcix_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'pcix', 2) == 1:\\n self.pcix_button.setSelected(True)\\n else:\\n self.pcix_button.setSelected(False)\\n pcix = pyxbmct.Image(addonfolder+artsfolder+'/pcix.png')\\n self.placeControl(pcix, 9, 9, rowspan=2, columnspan=4)\\n\\n\\t\\t# Close button\\n self.close_button = pyxbmct.Button('Exit')\\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\\n self.connect(self.close_button, lambda: self.closepage())\",\n \"def set_controls(self):\\n # Image control\\n image = pyxbmct.Image(addonfolder+artsfolder+'/tvh.png')\\n self.placeControl(image, 0, 0, rowspan=9, columnspan=16)\\n\\n # Image control\\n image = pyxbmct.Image(addonfolder+artsfolder+'/installaddons.png')\\n self.placeControl(image, 8, 6, rowspan=4, columnspan=4)\\n\\n\\t\\t# Tvheadend button\\n self.tvh_button = pyxbmct.Button('TVHEADEND')\\n self.placeControl(self.tvh_button, 10, 11, rowspan=1, columnspan=3)\\n self.connect(self.tvh_button, lambda: self.installaddons('service.tvheadend42', 'service.tvheadend43'))\\n\\n\\t\\t# Tvheadend HTSP Client button\\n self.htsp_button = pyxbmct.Button('HTSP CLIENT')\\n self.placeControl(self.htsp_button, 10, 2, rowspan=1, columnspan=3)\\n self.connect(self.htsp_button, lambda: self.installaddon('pvr.hts'))\\n\\n\\t\\t# Start button\\n self.start_button = pyxbmct.Button('START')\\n self.placeControl(self.start_button, 12, 7, rowspan=1, columnspan=2)\\n self.connect(self.start_button, lambda: self.page('service.tvheadend42', 'service.tvheadend43', 'pvr.hts'))\\n\\n\\t\\t# Close button\\n self.close_button = pyxbmct.Button('Exit')\\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\\n self.connect(self.close_button, lambda: self.closepage())\",\n \"def set_ui(self):\\n\\n self.setLayout(self.horizon_layout)\\n self.setWindowTitle(\\\"数据采集\\\")\\n self.setWindowIcon(self.Icon)\\n self.setWindowState(Qt.WindowMaximized)\\n # self.resize(self._size_of_x, self._size_of_y)\\n\\n # //-set left\\n self.horizon_left_layout1.addWidget(self.ECG)\\n self.horizon_left_layout1.addWidget(self.ECGWin)\\n self.horizon_left_layout2.addWidget(self.Respiration)\\n self.horizon_left_layout2.addWidget(self.RespirationWin)\\n self.horizon_left_layout3.addWidget(self.PulseWave)\\n self.horizon_left_layout3.addWidget(self.PulseWaveWin)\\n # self.horizon_left_layout4.addWidget(self.SpO2)\\n # self.horizon_left_layout4.addWidget(self.SpO2Win)\\n\\n # self.vertical_left_layout.addStretch(1)\\n self.vertical_left_layout.addLayout(self.horizon_left_layout1)\\n # self.vertical_left_layout.addStretch(1)\\n self.vertical_left_layout.addLayout(self.horizon_left_layout2)\\n # self.vertical_left_layout.addStretch(1)\\n self.vertical_left_layout.addLayout(self.horizon_left_layout3)\\n # self.vertical_left_layout.addStretch(1)\\n # self.vertical_left_layout.addLayout(self.horizon_left_layout4)\\n # self.vertical_left_layout.addStretch(1)\\n\\n # //-set right\\n # self.vertical_right_layout.addStretch(1)\\n self.vertical_right_layout.addWidget(self.save)\\n self.vertical_right_layout.addWidget(self.clear)\\n self.vertical_right_layout.addWidget(self.receive)\\n self.vertical_right_layout.addStretch(1)\\n self.vertical_right_layout.addWidget(self.exit)\\n # self.vertical_right_layout.addStretch(1)\\n\\n # //-set layout\\n # self.horizon_layout.addStretch(0)\\n self.horizon_layout.addLayout(self.vertical_left_layout)\\n # self.horizon_layout.addStretch(0)\\n # self.horizon_layout.addWidget(self.dataWin)\\n self.horizon_layout.addLayout(self.vertical_right_layout)\",\n \"def _init_ui(self):\\n # Create GUI elements, set them in dict structure\\n inf_symbol = u'\\\\u221E'\\n gamma_symbol = u'\\\\u03B3'\\n unicode_squared = u'\\\\u00B9'\\n labelwidth=175\\n\\n if len(self.waterlevels) > 100:\\n raise NotImplementedError('More than 100 water levels where discovered in the hydraulic loads. The method with PHAROS is not implemented for this number of loads. Recalculate the wave conditions at given water levels, or pick a method without PHAROS.')\\n\\n self.input_elements['hydraulic loads'] = {\\n 'Hs_max': widgets.ParameterLabel(\\n label='Max. significante golfhoogte:',\\n labelwidth=labelwidth,\\n value='{:.3f}'.format(self.Hs_max),\\n unit='m'\\n ),\\n # 'Tp_max': widgets.ParameterLabel(\\n # label='Maximale piekperiode',\\n # labelwidth=150\\n # ),\\n 'factor Tm Tp': widgets.ParameterInputLine(\\n label='Factor Tm naar Tp:',\\n labelwidth=labelwidth,\\n validator=QtGui.QDoubleValidator(0.01, 99.99, 20),\\n ),\\n 'water depth for wave length': widgets.ParameterInputLine(\\n label='Waterdiepte voor golflengte:',\\n labelwidth=labelwidth,\\n unitlabel='m',\\n validator=QtGui.QDoubleValidator(0.00, np.inf, 20),\\n ),\\n }\\n\\n self.input_elements['wave directions'] = {\\n 'lowest': widgets.ParameterInputLine(\\n label='Laagste waarde [0-360]:',\\n labelwidth=labelwidth,\\n unitlabel='graden (nautisch)',\\n validator=QtGui.QDoubleValidator(0.00, 360.00, 20),\\n ),\\n 'highest': widgets.ParameterInputLine(\\n label='Hoogste waarde [0-360]:',\\n labelwidth=labelwidth,\\n unitlabel='graden (nautisch)',\\n validator=QtGui.QDoubleValidator(0.00, 360.00, 20),\\n ),\\n 'bin size': widgets.ParameterInputLine(\\n label='Klassegrootte [1-360]:',\\n labelwidth=labelwidth,\\n unitlabel='graden',\\n validator=QtGui.QDoubleValidator(1.00, 360.00, 20),\\n )\\n }\\n\\n self.input_elements['frequencies'] = {\\n 'lowest': widgets.ParameterInputLine(\\n label='Ondergrens [{:.3f} - {:.3f}]:'.format(*self.f_range),\\n labelwidth=labelwidth,\\n unitlabel='Hz',\\n validator=QtGui.QDoubleValidator(self.f_range[0] - 0.01, self.f_range[1] + 0.01, 20),\\n ),\\n 'highest': widgets.ParameterInputLine(\\n label='Bovengrens [{:.3f} - {:.3f}]:'.format(*self.f_range),\\n labelwidth=labelwidth,\\n unitlabel='Hz',\\n validator=QtGui.QDoubleValidator(self.f_range[0] - 0.01, self.f_range[1] + 0.01, 20),\\n ),\\n 'number of bins': widgets.ParameterInputLine(\\n label='Aantal klassen [1-50]:',\\n labelwidth=labelwidth,\\n validator=QtGui.QIntValidator(1, 50),\\n ),\\n 'scale': widgets.ComboboxInputLine(\\n label='Frequentie schaal:',\\n labelwidth=labelwidth,\\n items=['lineair', 'logaritmisch'],\\n )\\n }\\n\\n self.input_elements['2d wave spectrum'] = {\\n 'spread': widgets.ParameterInputLine(\\n label='Spreiding [10-70]:',\\n labelwidth=labelwidth,\\n unitlabel='graden',\\n validator=QtGui.QDoubleValidator(10.0, 70.0, 20),\\n ),\\n 'gamma': widgets.ParameterInputLine(\\n label='JONSWAP peak\\\\nenhancement factor {} [1-7]:'.format(gamma_symbol),\\n labelwidth=labelwidth,\\n unitlabel='',\\n validator=QtGui.QDoubleValidator(1.00, 7.00, 20),\\n ),\\n 'min energy': widgets.ParameterInputLine(\\n label='Signaleringswaarde energie [0-{}]:'.format(inf_symbol),\\n labelwidth=labelwidth,\\n unitlabel='m{}s/degree'.format(unicode_squared),\\n validator=QtGui.QDoubleValidator(0.00, 2.00, 20),\\n )\\n }\\n\\n self.input_elements['paths'] = {\\n 'pharos folder': widgets.ExtendedLineEdit(\\n label='Uitvoermap:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton(\\n '...',\\n clicked=self._load_pharos_folder\\n )\\n ),\\n 'schematisation folder': widgets.ExtendedLineEdit(\\n label='Schematisatiemap:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton(\\n '...',\\n clicked=self._load_schematisations_folder\\n )\\n )\\n }\\n\\n self.input_elements['water levels'] = {\\n 'checked': widgets.CheckBoxInput(\\n labels=self.waterlevels,\\n nrows=max(2, len(self.waterlevels) // 20),\\n unitlabel='m + NAP'\\n )\\n }\\n\\n delta = u'\\\\u0394'\\n self.input_elements['transformation'] = {\\n 'dx': widgets.ParameterInputLine(\\n label='{}x [RD + {}x = lokaal]:'.format(delta, delta),\\n labelwidth=labelwidth,\\n ),\\n 'dy': widgets.ParameterInputLine(\\n label='{}y [RD + {}y = lokaal]:'.format(delta, delta),\\n labelwidth=labelwidth,\\n )\\n }\\n\\n\\n # Define titles for groups\\n titles = {\\n 'hydraulic loads': 'Hydraulische belastingen',\\n 'wave directions': 'Golfrichtingen',\\n 'frequencies': 'Frequenties',\\n '2d wave spectrum': '2D golfspectrum',\\n 'paths': 'Paden',\\n 'water levels': 'Te simuleren waterstanden',\\n 'transformation': 'Transformatie voor coordinatenstelsel'\\n }\\n\\n\\n # Create base layout\\n self.setLayout(QtWidgets.QVBoxLayout())\\n # self.layout().setSpacing(10)\\n\\n for tag, title in titles.items():\\n if tag in self.input_elements:\\n group_layout = QtWidgets.QVBoxLayout()\\n for _, item in self.input_elements[tag].items():\\n group_layout.addWidget(item)\\n\\n # Add groupbox with title\\n groupbox = QtWidgets.QGroupBox(title)\\n groupbox.setLayout(group_layout)\\n self.layout().addWidget(groupbox)\\n\\n\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n self.layout().addWidget(line)\\n\\n # OK and Cancel buttons\\n\\n self.generate_button = QtWidgets.QPushButton('Genereer tabel')\\n self.generate_button.setDefault(True)\\n # self.generate_button.setEnabled(False)\\n self.generate_button.clicked.connect(self.generate)\\n\\n self.cancel_button = QtWidgets.QPushButton('Annuleren')\\n self.cancel_button.setAutoDefault(False)\\n self.cancel_button.clicked.connect(self.cancel)\\n\\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\\n button_box.addButton(self.generate_button, QtWidgets.QDialogButtonBox.ActionRole)\\n button_box.addButton(self.cancel_button, QtWidgets.QDialogButtonBox.RejectRole)\\n\\n button_box.accepted.connect(QtWidgets.QDialog.accept)\\n # button_box.rejected.connect(QtWidgets.QDialog.reject)\\n\\n self.layout().addWidget(button_box)\",\n \"def buildUI(self):\\n\\n if cmds.window(\\\"pyART_AddToCanvasWIN\\\", exists=True):\\n cmds.deleteUI(\\\"pyART_AddToCanvasWIN\\\", wnd=True)\\n\\n # create the main window\\n self.mainWin = QtWidgets.QMainWindow(self.pickerUI)\\n\\n # create the main widget\\n self.mainWidget = QtWidgets.QWidget()\\n self.mainWin.setCentralWidget(self.mainWidget)\\n\\n # create the mainLayout\\n self.layout = QtWidgets.QVBoxLayout(self.mainWidget)\\n\\n # load stylesheet\\n styleSheetFile = utils.returnNicePath(self.toolsPath, \\\"Core/Scripts/Interfaces/StyleSheets/animPicker.qss\\\")\\n f = open(styleSheetFile, \\\"r\\\")\\n self.style = f.read()\\n f.close()\\n\\n self.mainWin.setStyleSheet(self.style)\\n\\n self.mainWin.setMinimumSize(QtCore.QSize(250, 400))\\n self.mainWin.setMaximumSize(QtCore.QSize(250, 400))\\n self.mainWin.resize(250, 400)\\n\\n # set qt object name\\n self.mainWin.setObjectName(\\\"pyART_AddToCanvasWIN\\\")\\n self.mainWin.setWindowTitle(\\\"Add Module To Canvas\\\")\\n\\n # label, listWidget, button\\n label = QtWidgets.QLabel(\\\"Available Modules:\\\")\\n label.setProperty(\\\"boldFont\\\", True)\\n self.layout.addWidget(label)\\n\\n self.moduleList = QtWidgets.QListWidget()\\n self.moduleList.setMaximumSize(230, 300)\\n self.moduleList.setMinimumSize(230, 300)\\n self.layout.addWidget(self.moduleList)\\n\\n # add modules to listWidget\\n self.addModulesToList()\\n\\n # create add button\\n button = QtWidgets.QPushButton(\\\"Add Selected To Canvas\\\")\\n self.layout.addWidget(button)\\n button.setObjectName(\\\"blueButton\\\")\\n button.clicked.connect(self.addSelectedToCanvas)\\n\\n # show ui\\n self.mainWin.show()\",\n \"def InitGUI(cls):\\n SensorGUI = {}\\n for subCls,instnts in cls.__sensors__.iteritems():\\n print(\\\"Creating GUI for Sensor: '%s'\\\" %(subCls.__name__))\\n SensorGUI[subCls.__name__] = SensorFrame(sensors = instnts ,\\n title = subCls.__name__ )\\n\\n return SensorGUI\",\n \"def setup_main_menus_architecture(instances_tournament, instances_report) -> list:\\n return [{'name': \\\"tournoi actuel\\\",\\n 'unfold': [{'label': elem.label, 'state': elem.state,\\n 'function': \\\"lambda i= ['\\\" + elem.name + \\\"', self.frame_right, \\\"\\n \\\"self.list_instances_menus_tournament]: \\\"\\n \\\"RightWindow.display_right_window(i)\\\"}\\n for elem in instances_tournament]},\\n {'name': \\\"générer les rapports\\\",\\n 'unfold': [{'label': elem.label, 'state': elem.state,\\n 'function': \\\"lambda i= '\\\" +\\n elem.name + \\\"': ChooseTournamentForReport(self.frame_right, i)\\\"}\\n for elem in instances_report]}]\",\n \"def update_views():\\n # replace Supervisor main entry\\n here = os.path.abspath(os.path.dirname(__file__))\\n # set main page\\n VIEWS['index.html'] = {'template': os.path.join(here, 'ui/index.html'),\\n 'view': SupvisorsView}\\n # set address /processpage\\n VIEWS['procaddress.html'] = {'template': os.path.join(\\n here, 'ui/procaddress.html'),\\n 'view': ProcAddressView}\\n # set address/host page\\n VIEWS['hostaddress.html'] = {'template': os.path.join(\\n here, 'ui/hostaddress.html'),\\n 'view': HostAddressView}\\n # set application page\\n VIEWS['application.html'] = {'template': os.path.join(\\n here, 'ui/application.html'),\\n 'view': ApplicationView}\\n # set fake page to export images\\n VIEWS['process_cpu.png'] = {'template': os.path.join(\\n here, 'ui/empty.html'),\\n 'view': ProcessCpuImageView}\\n VIEWS['process_mem.png'] = {'template': os.path.join(\\n here, 'ui/empty.html'),\\n 'view': ProcessMemoryImageView}\\n VIEWS['address_cpu.png'] = {'template': os.path.join(\\n here, 'ui/empty.html'),\\n 'view': AddressCpuImageView}\\n VIEWS['address_mem.png'] = {'template': os.path.join(\\n here, 'ui/empty.html'),\\n 'view': AddressMemoryImageView}\\n VIEWS['address_io.png'] = {'template': os.path.join(\\n here, 'ui/empty.html'),\\n 'view': AddressNetworkImageView}\",\n \"def _buildUi(self):\\r\\n # units\\r\\n self.units_label = QtGui.QLabel('Units: ')\\r\\n self.units_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\\r\\n self.imperial_button = QtGui.QRadioButton('imperial')\\r\\n self.metric_button = QtGui.QRadioButton('metric')\\r\\n\\r\\n self.unit_buttons_group = QtGui.QButtonGroup()\\r\\n self.unit_buttons_group.addButton(self.imperial_button)\\r\\n self.unit_buttons_group.addButton(self.metric_button)\\r\\n self.unit_buttons_group.setExclusive(True)\\r\\n\\r\\n # age\\r\\n self.age_label = QtGui.QLabel('Age: ')\\r\\n self.age_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\\r\\n self.age_field = QtGui.QDoubleSpinBox()\\r\\n self.age_field.setFixedWidth(70)\\r\\n self.age_field.setRange(1, 200)\\r\\n self.age_field.setSingleStep(1)\\r\\n self.age_field.setValue(self._age)\\r\\n\\r\\n # height\\r\\n self.height_label = QtGui.QLabel('Height: ')\\r\\n self.height_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\\r\\n self.height_field = QtGui.QDoubleSpinBox()\\r\\n self.height_field.setFixedWidth(70)\\r\\n self.height_field.setRange(1, 1000)\\r\\n self.height_field.setSingleStep(0.1)\\r\\n self.height_field.setValue(self._height)\\r\\n self.height_units_label = QtGui.QLabel()\\r\\n\\r\\n # weight\\r\\n self.weight_label = QtGui.QLabel('Weight: ')\\r\\n self.weight_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\\r\\n self.weight_field = QtGui.QDoubleSpinBox()\\r\\n self.weight_field.setFixedWidth(70)\\r\\n self.weight_field.setRange(1, 2000)\\r\\n self.weight_field.setSingleStep(0.1)\\r\\n self.weight_field.setValue(self._weight)\\r\\n self.weight_units_label = QtGui.QLabel()\\r\\n\\r\\n # body fat\\r\\n self.bodyFat_label = QtGui.QLabel('Body Fat %: ')\\r\\n self.bodyFat_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\\r\\n self.bodyFat_field = QtGui.QDoubleSpinBox()\\r\\n self.bodyFat_field.setFixedWidth(70)\\r\\n self.bodyFat_field.setRange(1, 100)\\r\\n self.bodyFat_field.setSingleStep(0.1)\\r\\n self.bodyFat_field.setValue(self._body_fat)\\r\\n\\r\\n # gender\\r\\n self.gender_label = QtGui.QLabel('Gender: ')\\r\\n self.gender_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)\\r\\n self.gender_combobox = QtGui.QComboBox()\\r\\n self.gender_combobox.addItems(GENDERS)\\r\\n\\r\\n # data display\\r\\n self.calculate_button = QtGui.QPushButton('Calculate ...')\\r\\n self.calculate_button.setFixedHeight(35)\\r\\n self.feedback_field = QtGui.QTextEdit()\\r\\n\\r\\n # data entry lyout\\r\\n self.data_entry_grid = QtGui.QGridLayout()\\r\\n self.data_entry_grid.setSpacing(4)\\r\\n self.data_entry_grid.setContentsMargins(6, 6, 6, 6)\\r\\n self.data_entry_grid.addWidget(self.age_label, 0, 0, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.age_field, 0, 1, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.height_label, 1, 0, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.height_field, 1, 1, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.height_units_label, 1, 2, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.weight_label, 2, 0, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.weight_field, 2, 1, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.weight_units_label, 2, 2, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.bodyFat_label, 3, 0, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.bodyFat_field, 3, 1, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.gender_label, 4, 0, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.gender_combobox, 4, 1, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.units_label, 5, 0, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.imperial_button, 5, 1, 1, 1)\\r\\n self.data_entry_grid.addWidget(self.metric_button, 5, 2, 1, 1)\\r\\n\\r\\n self.data_entry_grid.setColumnStretch(0, 0)\\r\\n self.data_entry_grid.setColumnStretch(1, 0)\\r\\n self.data_entry_grid.setColumnStretch(2, 0)\\r\\n self.data_entry_grid.setColumnStretch(3, 1)\\r\\n\\r\\n # main layout\\r\\n self.main_layout = QtGui.QVBoxLayout()\\r\\n self.main_layout.addLayout(self.data_entry_grid)\\r\\n self.main_layout.addWidget(self.calculate_button)\\r\\n self.main_layout.addWidget(self.feedback_field)\\r\\n self.setLayout(self.main_layout)\",\n \"def __init__(self, ui_file, controller):\\n super(InputDeviceView, self).__init__()\\n self._controller = controller\\n self._controller.accepted_cb = self._accepted_cb\\n self._controller.finished_cb = self._finished_cb\\n self._controller.rejected_cb = self._rejected_cb\\n self._controller.current_gait_cb = self._current_gait_cb\\n\\n self._always_enabled_buttons = []\\n\\n # Extend the widget with all attributes and children from UI file\\n loadUi(ui_file, self)\\n\\n self.refresh_button.clicked.connect(self._update_possible_gaits)\\n\\n self._create_buttons()\\n self._update_possible_gaits()\",\n \"def initUI(self):\\n language_help = _('''<h4>Language code.</h4>\\n<p>This will be transmitted as part of the requst sent to the\\nsites. As some sites only support one language, this is also used to\\ndecide where to send the requests. Use a standard language code\\nhere. Using invalid values or codes of unsupported languages will\\nresult in no downloads. Do <em>not</em> use domain codes (E.g. use\\n<code>zh</code> rather than <code>cn</code> for Chinese.)</p>''')\\n self.setWindowTitle(_('Anki – Download audio'))\\n self.setWindowIcon(QIcon(\\\":/icons/anki.png\\\"))\\n layout = QVBoxLayout()\\n self.setLayout(layout)\\n edit_word_head = QLabel()\\n kanji_et = _('''\\\\\\n<h4>Requests to send to the download sites</h4>\\n<p>In the split edit fields, set the kanji on the left, the\\nkana on the right.</p>\\n''')\\n base_et = _('''\\\\\\n<h4>Requests to send to the download sites</h4>\\n<p>In split edit fields, set the expression (base) on the left, the\\nreading (ruby) on the right.</p>\\n''')\\n single_et = _('''\\\\\\n<h4>Requests to send to the download sites</h4>\\n''')\\n # Now decide which help text to show.\\n # First, decide if we have any split fields.\\n if any(f_data.split for f_data in self.field_data_list):\\n if self.language_code and self.language_code.startswith('ja'):\\n # Japanese\\n edit_word_head.setText(kanji_et)\\n else:\\n # Chinese should not happen at the moment\\n edit_word_head.setText(base_et)\\n else:\\n edit_word_head.setText(single_et)\\n layout.addWidget(edit_word_head)\\n self.create_data_rows(layout)\\n line = QFrame(self)\\n line.setFrameShape(QFrame.HLine)\\n line.setFrameShadow(QFrame.Sunken)\\n layout.addWidget(line)\\n lcode_head = QLabel(_('''<h4>Language code</h4>'''))\\n layout.addWidget(lcode_head)\\n lang_hlayout = QHBoxLayout()\\n lc_label = QLabel(_('Language code:'), self)\\n lang_hlayout.addWidget(lc_label)\\n lc_label.setToolTip(language_help)\\n self.language_code_lineedit = QLineEdit(self)\\n try:\\n self.language_code_lineedit.setText(self.language_code)\\n except:\\n self.language_code_lineedit.setText(default_audio_language_code)\\n lang_hlayout.addWidget(self.language_code_lineedit)\\n self.language_code_lineedit.setToolTip(language_help)\\n layout.addLayout(lang_hlayout)\\n dialog_buttons = QDialogButtonBox(self)\\n dialog_buttons.addButton(QDialogButtonBox.Cancel)\\n dialog_buttons.addButton(QDialogButtonBox.Ok)\\n dialog_buttons.accepted.connect(self.accept)\\n dialog_buttons.rejected.connect(self.reject)\\n layout.addWidget(dialog_buttons)\",\n \"def update_views():\\n # replace Supervisor main entry\\n here = path.abspath(path.dirname(__file__))\\n # set main page\\n VIEWS['index.html'] = {'template': path.join(here, 'ui/index.html'), 'view': SupvisorsView}\\n # set address /processpage\\n VIEWS['procaddress.html'] = {'template': path.join(here, 'ui/procaddress.html'), 'view': ProcAddressView}\\n # set address/host page\\n VIEWS['hostaddress.html'] = {'template': path.join(here, 'ui/hostaddress.html'), 'view': HostAddressView}\\n # set application page\\n VIEWS['application.html'] = {'template': path.join(here, 'ui/application.html'), 'view': ApplicationView}\\n # set fake page to export images\\n VIEWS['process_cpu.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': ProcessCpuImageView}\\n VIEWS['process_mem.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': ProcessMemoryImageView}\\n VIEWS['address_cpu.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': AddressCpuImageView}\\n VIEWS['address_mem.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': AddressMemoryImageView}\\n VIEWS['address_io.png'] = {'template': path.join(here, 'ui/empty.html'), 'view': AddressNetworkImageView}\",\n \"def loadUi(uifile, baseinstance=None, custom_widgets=None):\\n return _loadUi(uifile, baseinstance, custom_widgets)\",\n \"def setup_gui(self):\\n # if there are more than 1 visualizer we need to assure that there\\n # will not be tag conflicts\\n BaseRealTimeVisualizer.setup_gui_lock.acquire()\\n # look for valid tag\\n dpg.create_context()\\n\\n self.id = 0\\n while dpg.does_item_exist(f'main_window_{self.id}'):\\n self.id += 1\\n\\n with dpg.texture_registry(show=False):\\n dpg.add_dynamic_texture(\\n width=self.width,\\n height=self.height,\\n default_value=np.zeros((self.width, self.height, 3)),\\n tag=f'input_image_texture_{self.id}',\\n )\\n\\n with dpg.window(\\n tag=f'main_window_{self.id}',\\n no_title_bar=True,\\n autosize=True\\n ):\\n dpg.add_image(\\n texture_tag=f'input_image_texture_{self.id}',\\n tag=f'image_render_{self.id}',\\n pos=(_PADDING, _PADDING)\\n )\\n\\n dpg.set_global_font_scale(_FONT_SCALE)\\n\\n if self.id == 0:\\n dpg.set_primary_window(f'main_window_{self.id}', True)\\n dpg.create_viewport(\\n title=self.title,\\n width=self.width + _PADDING*2,\\n height=self.height + _PADDING*2,\\n resizable=True\\n )\\n dpg.setup_dearpygui()\\n dpg.show_viewport()\\n elif self.id == 1:\\n dpg.set_primary_window('main_window_0', False)\\n\\n BaseRealTimeVisualizer.setup_gui_lock.release()\",\n \"def buildUI(self):\\n outside = QtWidgets.QVBoxLayout(self)\\n columns = QtWidgets.QHBoxLayout(self)\\n layout = QtWidgets.QVBoxLayout(self)\\n self.details_layout = QtWidgets.QVBoxLayout(self) #column with edit panel\\n self.restriction = QtWidgets.QWidget() #restricts size of details_layout\\n self.restriction.setLayout(self.details_layout)\\n self.restriction.setFixedWidth(200)\\n columns.addLayout(layout)\\n columns.addWidget(self.restriction)\\n outside.addLayout(columns)\\n\\n #tab widget\\n self.tabwidget = tabsWindow(self) #QtWidgets.QTabWidget(tabsClosable = True, movable = True)\\n layout.addWidget(self.tabwidget)\\n #add base tab\\n self.tabwidget.newTab(name =\\\"Untitled\\\", image = \\\"\\\")\\n\\n #add second column with details\\n self.updateDetails(\\\"edit\\\")\\n\\n #edit button\\n layout_btns = QtWidgets.QHBoxLayout()\\n editBtn = QtWidgets.QPushButton(\\\"Stop Editing\\\")\\n editBtn.clicked.connect(lambda: self.editChange(editBtn))\\n layout_btns.addWidget(editBtn)\\n\\n #save button\\n saveBtn = QtWidgets.QPushButton(\\\"Save\\\")\\n saveBtn.clicked.connect(self.save)\\n layout_btns.addWidget(saveBtn)\\n\\n #load button\\n loadBtn = QtWidgets.QPushButton(\\\"Load\\\")\\n loadBtn.clicked.connect(self.load)\\n layout_btns.addWidget(loadBtn)\\n\\n #close button\\n closeBtn = QtWidgets.QPushButton('Close')\\n closeBtn.clicked.connect(self.closeEvent)\\n layout_btns.addWidget(closeBtn)\\n\\n outside.addLayout(layout_btns) #add buttons to layout\",\n \"def loadUI(self,factory={'GLOB':Glob,'BOOK':Book,'SCPT':Scpt,'CELL':Cell}):\\n FileRep.loadUI(self,factory)\",\n \"def set_controls(self):\\n # Image control\\n image = pyxbmct.Image(addonfolder+artsfolder+'/k.png')\\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\\n\\n\\t\\t# KI Plus\\n self.k1plus_button = pyxbmct.RadioButton('')\\n self.placeControl(self.k1plus_button, 8, 1, rowspan=2, columnspan=4)\\n self.connect(self.k1plus_button, self.k1plus_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'k1plus', 2) == 1:\\n self.k1plus_button.setSelected(True)\\n else:\\n self.k1plus_button.setSelected(False)\\n k1plus = pyxbmct.Image(addonfolder+artsfolder+'/k1plus.png')\\n self.placeControl(k1plus, 8, 1, rowspan=2, columnspan=4)\\n\\n\\t\\t# KI Pro\\n self.k1pro_button = pyxbmct.RadioButton('')\\n self.placeControl(self.k1pro_button, 11, 6, rowspan=2, columnspan=4)\\n self.connect(self.k1pro_button, self.k1pro_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'k1pro', 2) == 1:\\n self.k1pro_button.setSelected(True)\\n else:\\n self.k1pro_button.setSelected(False)\\n k1pro = pyxbmct.Image(addonfolder+artsfolder+'/k1pro.png')\\n self.placeControl(k1pro, 11, 6, rowspan=2, columnspan=4)\\n\\n\\t\\t# KII Pro\\n self.k2pro_button = pyxbmct.RadioButton('')\\n self.placeControl(self.k2pro_button, 8, 6, rowspan=2, columnspan=4)\\n self.connect(self.k2pro_button, self.k2pro_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'k2pro', 2) == 1:\\n self.k2pro_button.setSelected(True)\\n else:\\n self.k2pro_button.setSelected(False)\\n k2pro = pyxbmct.Image(addonfolder+artsfolder+'/k2pro.png')\\n self.placeControl(k2pro, 8, 6, rowspan=2, columnspan=4)\\n\\n\\t\\t# KIII Pro\\n self.k3pro_button = pyxbmct.RadioButton('')\\n self.placeControl(self.k3pro_button, 8, 11, rowspan=2, columnspan=4)\\n self.connect(self.k3pro_button, self.k3pro_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'k3pro', 2) == 1:\\n self.k3pro_button.setSelected(True)\\n else:\\n self.k3pro_button.setSelected(False)\\n k3pro = pyxbmct.Image(addonfolder+artsfolder+'/k3pro.png')\\n self.placeControl(k3pro, 8, 11, rowspan=2, columnspan=4)\\n\\n\\t\\t# Close button\\n self.close_button = pyxbmct.Button('Exit')\\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\\n self.connect(self.close_button, lambda: self.closepage())\",\n \"def _initUI(self, folder):\\n\\n vlayout = QtWidgets.QVBoxLayout()\\n\\n # Pharos schematisaties\\n #----------------------------------------------------------------\\n\\n schematisationsFrame = QtWidgets.QGroupBox()\\n schematisationsFrame.setTitle('Kies Pharos schematisaties')\\n\\n self.listSchematisations = QtWidgets.QListView()\\n\\n # Create an empty model for the list's data\\n schematisationModel = QtGui.QStandardItemModel(self.listSchematisations)\\n\\n schematisations = self.pharos.pharosio.getSchematisations(folder)\\n for schematisation in schematisations:\\n # create an item with a caption\\n item = QtGui.QStandardItem(schematisation)\\n # Add a checkbox to it\\n item.setCheckable(True)\\n # Set default true\\n item.setCheckState(QtCore.Qt.Checked)\\n # Add the item to the model\\n schematisationModel.appendRow(item)\\n\\n # Apply the model to the list view\\n self.listSchematisations.setModel(schematisationModel)\\n\\n ## Show the window and run the app\\n vlayout.addWidget(self.listSchematisations)\\n\\n schematisationsFrame.setLayout(vlayout)\\n\\n\\n # Water levels\\n #----------------------------------------------------------------\\n waterlevelsframe = QtWidgets.QGroupBox()\\n waterlevelsframe.setTitle('Kies waterstanden')\\n\\n vlayout = QtWidgets.QVBoxLayout()\\n self.listWaterlevels = QtWidgets.QListView()\\n # Create an empty model for the list's data\\n waterlevelsModel = QtGui.QStandardItemModel(self.listWaterlevels)\\n\\n for waterlevel in self.waterlevels:\\n # create an item with a caption\\n item = QtGui.QStandardItem(str(waterlevel.round(2)))\\n # Add a checkbox to it\\n item.setCheckable(True)\\n # Set default true\\n item.setCheckState(QtCore.Qt.Checked)\\n # Add the item to the model\\n waterlevelsModel.appendRow(item)\\n\\n # Apply the model to the list view\\n self.listWaterlevels.setModel(waterlevelsModel)\\n\\n vlayout.addWidget(self.listWaterlevels)\\n\\n waterlevelsframe.setLayout(vlayout)\\n\\n vbox = QtWidgets.QVBoxLayout()\\n vbox.addWidget(schematisationsFrame)\\n vbox.addWidget(waterlevelsframe)\\n\\n self.setLayout(vbox)\\n\\n # OK and Cancel buttons\\n\\n self.generateButton = QtWidgets.QPushButton('OK')\\n self.generateButton.setDefault(True)\\n self.generateButton.clicked.connect(self.ok)\\n\\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\\n self.cancelButton.setAutoDefault(False)\\n self.cancelButton.clicked.connect(self.cancel)\\n\\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\\n\\n button_box.accepted.connect(QtWidgets.QDialog.accept)\\n # button_box.rejected.connect(QtWidgets.QDialog.reject)\\n\\n self.layout().addWidget(button_box)\",\n \"def __init__(self):\\n self.view = GuiView(self)\\n return\",\n \"def __init__(self, base_image=None, subject=None, subjects_dir=None,\\n verbose=None):\\n # initialize QMainWindow class\\n super(SliceBrowser, self).__init__()\\n\\n self._verbose = verbose\\n # if bad/None subject, will raise an informative error when loading MRI\\n subject = os.environ.get('SUBJECT') if subject is None else subject\\n subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)\\n self._subject_dir = op.join(subjects_dir, subject)\\n self._load_image_data(base_image=base_image)\\n\\n # GUI design\\n\\n # Main plots: make one plot for each view; sagittal, coronal, axial\\n self._plt_grid = QGridLayout()\\n self._figs = list()\\n for i in range(3):\\n canvas, fig = _make_slice_plot()\\n self._plt_grid.addWidget(canvas, i // 2, i % 2)\\n self._figs.append(fig)\\n self._renderer = _get_renderer(\\n name='Slice Browser', size=(400, 400), bgcolor='w')\\n self._plt_grid.addWidget(self._renderer.plotter, 1, 1)\\n\\n self._set_ras([0., 0., 0.], update_plots=False)\\n\\n self._plot_images()\\n\\n self._configure_ui()\",\n \"def initCentralUic(self):\\n self.initFileTableWidget()\\n self.initViewerStack()\\n self.splitter.setSizes([150, 850])\",\n \"def controls_setup(self):\\n\\n self.subbie_name = element.Link(self, css_selector='th:nth-child(1) > a', alias=\\\"Admin Subbie Name Link\\\")\\n self.type = element.Caption(self, css_selector='td:nth-child(2)', alias=\\\"Subbie Type\\\")\\n self.username = element.Caption(self, css_selector='td:nth-child(3)', alias=\\\"Username\\\")\\n self.email = element.Caption(self, css_selector='td:nth-child(4)', alias=\\\"Email\\\")\\n self.active_start_date = element.Link(self, css_selector='td:nth-child(5)', alias=\\\"Active Start Date Text\\\")\\n self.active_end_date = element.Link(self, css_selector='td:nth-child(6)', alias=\\\"Active End Date Text\\\")\",\n \"def setUI(self):\\n \\n l = QtGui.QLabel(\\\"Open file:\\\")\\n browseButton = QtGui.QPushButton(\\\"Browse\\\")\\n analyzeButton = QtGui.QPushButton(\\\"Analyse\\\")\\n self.filelabel = QtGui.QLabel(\\\"\\\")\\n self.messageLabel = QtGui.QLabel(\\\"\\\")\\n \\n #camera intrasec values\\n self.fxlabel = QtGui.QLabel('focal x')\\n self.fylabel = QtGui.QLabel('focal y')\\n self.dist1label = QtGui.QLabel('K1')\\n self.dist2label = QtGui.QLabel('K2')\\n self.dist3label = QtGui.QLabel('P1')\\n self.dist4label = QtGui.QLabel('P2')\\n\\n #set layout\\n self.grid = QtGui.QGridLayout()\\n a = self.grid.addWidget\\n a(l, 0,0)\\n a(browseButton, 0,2)\\n a(self.filelabel,0,1)\\n a(self.messageLabel, 1,0,1,4)\\n a(analyzeButton, 2,0,1,4)\\n\\n a(self.fxlabel, 3,0)\\n a(self.fylabel, 3,1)\\n a(self.dist1label, 4,0)\\n a(self.dist2label, 5,0)\\n a(self.dist3label, 6,0)\\n a(self.dist4label, 7,0)\\n\\n self.setLayout(self.grid)\\n\\n\\n #connect signals to methods\\n self.connect(browseButton, QtCore.SIGNAL('clicked()'), self.onOpenFileClicked)\\n self.connect(analyzeButton, QtCore.SIGNAL('clicked()'), self.startAnalyze)\",\n \"def _setupUi(self, widget):\\n \\n widget._setup_vertical_layout()\\n widget._setup_horizontal_layout()\\n widget._setup_vertical_layout()\\n for field in self._fields:\\n if field=='channel_idx':\\n widget._exit_layout()\\n widget._setup_vertical_layout()\\n choices = None\\n if hasattr(self, field + 's'):\\n choices = self.__getattribute__(field + 's')\\n widget._setup_gui_element(field, choices)\\n widget._exit_layout()\\n widget._exit_layout()\\n self._setup_fetch_buttons(widget)\",\n \"def __init__(self, baseinstance, customWidgets=None):\\n\\n QUiLoader.__init__(self, baseinstance)\\n\\n self.baseinstance = baseinstance\\n\\n if customWidgets is None:\\n self.customWidgets = {}\\n else:\\n self.customWidgets = customWidgets\",\n \"def _load_ui(self):\\n load_ui(\\\"about_dlg.ui\\\", self)\\n\\n self.title_label = self.findChild(QLabel, \\\"title_label\\\")\\n self.title_label.setText(f\\\"Friendly Pics 2 v{__version__}\\\")\\n\\n self.runtime_env_label = self.findChild(QLabel, \\\"runtime_env_label\\\")\\n if is_mac_app_bundle():\\n self.runtime_env_label.setText(\\\"Running as MacOS app bundle\\\")\\n elif is_pyinstaller_bundle():\\n self.runtime_env_label.setText(\\\"Running as a pyinstaller binary\\\")\\n else:\\n self.runtime_env_label.setText(\\\"Running under conventional Python environment\\\")\\n\\n self.gui_settings_label = self.findChild(QLabel, \\\"gui_settings_label\\\")\\n self.gui_settings_label.setText(f\\\"<b>GUI Settings:</b> {self._settings.fileName()}\\\")\\n\\n self.gui_settings_clear_button = self.findChild(QPushButton, \\\"gui_settings_clear_button\\\")\\n self.gui_settings_clear_button.clicked.connect(self._clear_gui_settings)\\n\\n self.app_settings_label = self.findChild(QLabel, \\\"app_settings_label\\\")\\n self.app_settings_label.setText(f\\\"<b>App Settings:</b> {self._app_settings.path}\\\")\\n\\n # Center the about box on the parent window\\n parent_geom = self.parent().geometry()\\n self.move(parent_geom.center() - self.rect().center())\",\n \"def __init__(self, parent=None):\\n super(Inj, self).__init__(parent)\\n self.setupUi(self)\",\n \"def inicialUI(self):\\r\\n\\r\\n self.setGeometry(500, 500, 500, 500)\\r\\n self.setWindownTitle(\\\"Pesquisa\\\")\\r\\n self.displayWidgets()\\r\\n\\r\\n self.show()\",\n \"def setup(self):\\n self.ui_manager.purge_ui_elements()\\n y_slot = self.window.height // 12\\n\\n ui_input_box = arcade.gui.UIInputBox(\\n center_x=self.window.width // 2,\\n center_y=y_slot * 7,\\n width=250\\n )\\n ui_input_box.set_style_attrs(\\n bg_color=(66, 179, 208),\\n bg_color_hover=(112, 212, 238),\\n bg_color_focus=(255, 228, 14)\\n )\\n ui_input_box.text = self.name\\n ui_input_box.cursor_index = len(ui_input_box.text)\\n self.ui_manager.add_ui_element(ui_input_box)\\n\\n button = buttons.ExitButton(\\n 'Exit',\\n center_x=self.window.width // 2,\\n center_y=y_slot * 1,\\n width=250\\n )\\n button.set_style_attrs(\\n bg_color=(51, 139, 57),\\n bg_color_hover=(135, 21, 25),\\n bg_color_press=(122, 21, 24),\\n )\\n self.ui_manager.add_ui_element(button)\\n\\n button = buttons.AuthorButton(\\\"Author\\\",\\n center_x=self.window.width // 2,\\n center_y=y_slot * 2,\\n width=250,\\n user=ui_input_box\\n )\\n button.set_style_attrs(\\n bg_color=(51, 139, 57),\\n bg_color_hover=(88, 196, 96),\\n bg_color_press=(28, 71, 32),\\n )\\n self.ui_manager.add_ui_element(button)\\n\\n button = buttons.ResultButton(\\\"Results\\\",\\n center_x=self.window.width // 2,\\n center_y=y_slot * 3,\\n width=250,\\n user=ui_input_box,\\n level = \\\"level1\\\"\\n )\\n button.set_style_attrs(\\n bg_color=(51, 139, 57),\\n bg_color_hover=(88, 196, 96),\\n bg_color_press=(28, 71, 32),\\n )\\n self.ui_manager.add_ui_element(button)\\n\\n button = buttons.RulesButton(\\\"Rules\\\",\\n center_x=self.window.width // 2,\\n center_y=y_slot * 4,\\n width=250,\\n user=ui_input_box\\n )\\n button.set_style_attrs(\\n bg_color=(51, 139, 57),\\n bg_color_hover=(88, 196, 96),\\n bg_color_press=(28, 71, 32),\\n )\\n self.ui_manager.add_ui_element(button)\\n\\n button = buttons.LevelButton(\\\"Play level 1\\\",\\n center_x=self.window.width // 2,\\n center_y=y_slot * 6,\\n width=250,\\n user=ui_input_box,\\n level=\\\"level1\\\"\\n )\\n button.set_style_attrs(\\n bg_color=(51, 139, 57),\\n bg_color_hover=(88, 196, 96),\\n bg_color_press=(28, 71, 32),\\n )\\n self.ui_manager.add_ui_element(button)\\n\\n button = buttons.LevelButton(\\\"Play level 2\\\",\\n center_x=self.window.width // 2,\\n center_y=y_slot * 5,\\n width=250,\\n user=ui_input_box,\\n level = \\\"level2\\\"\\n )\\n button.set_style_attrs(\\n bg_color=(51, 139, 57),\\n bg_color_hover=(88, 196, 96),\\n bg_color_press=(28, 71, 32),\\n )\\n self.ui_manager.add_ui_element(button)\",\n \"def setup(self):\\n ScriptedLoadableModuleWidget.setup(self)\\n try:\\n self.reloadCollapsibleButton.collapsed = True\\n except:\\n pass\\n # Instantiate and connect widgets ...\\n #\\n \\n # Inputs volume selectors\\n DataCollButtom = ctk.ctkCollapsibleButton()\\n DataCollButtom.text = \\\"Input Volumes\\\"\\n self.layout.addWidget(DataCollButtom)\\n self.InputOutput_Layout = qt.QFormLayout(DataCollButtom)\\n self.setupAnatomicalRef()\\n self.setupLL_Native()\\n self.setupLL_Enhanced()\\n\\n # Apply Buttons\\n self.setRefreshViewsAndCheckButtonButton()\\n self.setT1Button()\\n\\n # Statistics section widgets\\n Statistics = ctk.ctkCollapsibleButton()\\n Statistics.text = \\\"Statistics\\\"\\n Statistics.collapsed = True\\n self.layout.addWidget(Statistics)\\n self.Statistics_Layout = qt.QFormLayout(Statistics)\\n self.Stats = statistics()\\n self.Stats.setupSegmentationSelector(self.Statistics_Layout,self.layout)\\n\\n # ECV section widgets\\n ECVcollButton = ctk.ctkCollapsibleButton()\\n ECVcollButton.text = \\\"ECV Mapping\\\"\\n ECVcollButton.collapsed = True\\n self.layout.addWidget(ECVcollButton)\\n self.ECVcollButton_Layout = qt.QFormLayout(ECVcollButton)\\n self.setECVScalarVolume()\\n self.setupSpinBoxControllers()\\n self.setECVButton()\\n\\n # Threshold Controllers \\n ThCollButton = ctk.ctkCollapsibleButton()\\n ThCollButton.text = \\\"Threshold controlers\\\"\\n ThCollButton.collapsed = True\\n self.layout.addWidget(ThCollButton)\\n self.Th_Layout = qt.QFormLayout(ThCollButton)\\n self.ThSlider_LLN = DoubleSlider(self.Th_Layout, self.SetThreshold)\\n self.ThSlider_LLN.SetupDoubleSliderControl(WidgetName = 'T1-Native Threshold')\\n self.ThSlider_LLE = DoubleSlider(self.Th_Layout, self.SetThreshold)\\n self.ThSlider_LLE.SetupDoubleSliderControl(WidgetName = 'T1-Enhanced Threshold')\\n self.ThSlider_ECV = DoubleSlider(self.Th_Layout, self.SetThreshold)\\n self.ThSlider_ECV.SetupDoubleSliderControl(WidgetName = 'ECV Mapping')\\n\\n self.onCheckbuttonChecked()\\n self.setupConnections()\",\n \"def set_controls(self):\\n # Image control\\n image = pyxbmct.Image(addonfolder+artsfolder+'/tvh.png')\\n self.placeControl(image, 0, 0, rowspan=8, columnspan=16)\\n\\n\\t\\t# Label information\\n image = pyxbmct.Image(addonfolder+artsfolder+'/users.png')\\n self.placeControl(image, 8, 1, rowspan=1, columnspan=14)\\n\\t\\t\\n\\t\\t# Username input\\n image = pyxbmct.Image(addonfolder+artsfolder+'/username.png')\\n self.placeControl(image, 10, 1, rowspan=1, columnspan=3)\\n self.username_input = pyxbmct.Edit('')\\n self.placeControl(self.username_input, 10, 4, rowspan=1, columnspan=4)\\n\\n\\t\\t# Password input\\n image = pyxbmct.Image(addonfolder+artsfolder+'/password.png')\\n self.placeControl(image, 11, 1, rowspan=1, columnspan=3)\\n self.password_input = pyxbmct.Edit('', isPassword=True)\\n self.placeControl(self.password_input, 11, 4, rowspan=1, columnspan=4)\\n\\n\\t\\t# Next button\\n self.next_button = pyxbmct.Button('Next')\\n self.placeControl(self.next_button, 13, 14, rowspan=1, columnspan=1)\\n # Connect close button\\n self.connect(self.next_button, lambda: self.page())\\n\\t\\t\\n\\t\\t# Close button\\n self.close_button = pyxbmct.Button('Exit')\\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\\n self.connect(self.close_button, lambda: self.closepage())\",\n \"def html_viewer(i):\\n\\n i['module_uoa']='experiment.tune.compiler.flags'\\n i['module_cfg']=copy.deepcopy(cfg)\\n i['module_work']=copy.deepcopy(work)\\n return ck.access(i)\",\n \"def populateTabs(self):\\n frameworks = self.data['frameworks']\\n for fw in frameworks:\\n frameworkElements = frameworks[fw]\\n for element in frameworkElements:\\n\\n ui = self.framework2gui[fw].get(element)\\n\\n if isinstance(ui, QComboBox):\\n ui.clear()\\n ui.setView(QListView())\\n for i, deviceName in enumerate(frameworks[fw][element]):\\n ui.addItem(deviceName)\\n if frameworks[fw]['deviceName'] == deviceName:\\n ui.setCurrentIndex(i)\\n\\n elif isinstance(ui, QLineEdit):\\n ui.setText(f'{frameworks[fw][element]}')\\n\\n elif isinstance(ui, QCheckBox):\\n ui.setChecked(frameworks[fw][element])\\n\\n elif isinstance(ui, QDoubleSpinBox):\\n ui.setValue(frameworks[fw][element])\\n return True\",\n \"def initGui(self):\\r\\n\\r\\n # Create help action \\r\\n self.helpAction = QAction( QIcon(\\\":/plugins/layercombinations/about.png\\\"), u\\\"Help\\\", self.iface.mainWindow())\\r\\n # connect the action \\r\\n self.helpAction.triggered.connect( self.showHelp )\\r\\n # Add menu item\\r\\n self.iface.addPluginToMenu(u\\\"&Layer Combinations\\\", self.helpAction)\\r\\n\\r\\n # Create the action that allows to change the widget type\\r\\n self.changeWidgetAction = QAction(\\\"Change widget type\\\", self.iface.mainWindow())\\r\\n self.changeWidgetAction.triggered.connect( self.changeWidget )\\r\\n self.iface.addPluginToMenu(u\\\"&Layer Combinations\\\", self.changeWidgetAction)\\r\\n\\r\\n # Create the action that will toggle the plugin panel\\r\\n self.action = QAction(QIcon(\\\":/plugins/layercombinations/icon.png\\\"), \\\"Show/hide the Layer Combinations widgets\\\", self.iface.mainWindow())\\r\\n self.action.triggered.connect( self.widget.toggle )\\r\\n # Add toolbar button and menu item\\r\\n self.iface.addToolBarIcon(self.action)\\r\\n self.iface.addPluginToMenu(u\\\"&Layer Combinations\\\", self.action)\\r\\n\\r\\n\\r\\n # Add the widget to the mainWindow\\r\\n self.widget.addToiFace(self.iface)\",\n \"def __init__(self, viewer: geoviewer.GeoGraphViewer) -> None:\\n super().__init__(viewer=viewer)\\n\\n # Creating individual (sub-)widgets\\n visibility_widget = RadioVisibilityWidget(viewer=self.viewer)\\n metrics_widget = MetricsWidget(viewer=self.viewer)\\n settings_widget = SettingsWidget(viewer=self.viewer)\\n\\n viewer_height = int(viewer.layout.height.replace(\\\"px\\\", \\\"\\\"))\\n metrics_widget.layout.height = \\\"{}px\\\".format(viewer_height * 0.3)\\n\\n if self.viewer.small_screen:\\n view_tab = [visibility_widget]\\n else:\\n view_tab = [visibility_widget, widget_utils.HRULE, metrics_widget]\\n\\n # Create combined widget, each key corresponds to a tab\\n combined_widget_dict = dict()\\n combined_widget_dict[\\\"View\\\"] = widgets.VBox(view_tab)\\n if self.viewer.small_screen:\\n combined_widget_dict[\\\"Metrics\\\"] = metrics_widget\\n combined_widget_dict[\\\"Settings\\\"] = settings_widget\\n combined_widget_dict[\\\"Log\\\"] = self.log_handler.out\\n\\n combined_widget = widgets.Tab()\\n combined_widget.children = list(combined_widget_dict.values())\\n for i, title in enumerate(combined_widget_dict):\\n combined_widget.set_title(i, title)\\n\\n self.children = [combined_widget]\",\n \"def set_controls(self):\\n # Image control\\n image = pyxbmct.Image(addonfolder+artsfolder+'/osc.png')\\n self.placeControl(image, 0, 0, rowspan=7, columnspan=16)\\n\\n\\t\\t# Label information\\n image = pyxbmct.Image(addonfolder+artsfolder+'/readers.png')\\n self.placeControl(image, 7, 1, rowspan=1, columnspan=14)\\n\\t\\t\\n\\t\\t# Hostname input\\n image = pyxbmct.Image(addonfolder+artsfolder+'/hostname.png')\\n self.placeControl(image, 9, 0, rowspan=1, columnspan=4)\\n self.hostname_input = pyxbmct.Edit('')\\n self.placeControl(self.hostname_input, 9, 4, rowspan=1, columnspan=5)\\n\\n\\t\\t# Port input\\n image = pyxbmct.Image(addonfolder+artsfolder+'/port.png')\\n self.placeControl(image, 12, 1, rowspan=1, columnspan=3)\\n self.port_input = pyxbmct.Edit('')\\n self.placeControl(self.port_input, 12, 4, rowspan=1, columnspan=2)\\n\\n\\t\\t# Username input\\n image = pyxbmct.Image(addonfolder+artsfolder+'/username.png')\\n self.placeControl(image, 10, 1, rowspan=1, columnspan=3)\\n self.username_input = pyxbmct.Edit('')\\n self.placeControl(self.username_input, 10, 4, rowspan=1, columnspan=4)\\n\\t\\t\\n\\t\\t# Password input\\n image = pyxbmct.Image(addonfolder+artsfolder+'/password.png')\\n self.placeControl(image, 11, 1, rowspan=1, columnspan=3)\\n self.password_input = pyxbmct.Edit('', isPassword=True)\\n self.placeControl(self.password_input, 11, 4, rowspan=1, columnspan=4)\\n\\n\\t\\t# Close button\\n self.close_button = pyxbmct.Button('Exit')\\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\\n self.connect(self.close_button, lambda: self.page(Readers))\",\n \"def create_widgets(self):\",\n \"def __init__(self, controller):\\n super().__init__(controller)\\n\\n # The hovered input when entering this View.\\n self.first_inp = \\\"s\\\"\\n\\n # Initialize selected variable.\\n self.selected = None\\n\\n # Make background graphics.\\n self.make_background_graphics()\\n\\n # Make Buttons.\\n self.make_buttons()\\n\\n # Make the information box. This explains each Button.\\n self.make_info_box()\\n\\n # Initializes popup.\\n self.make_popup()\\n\\n # Map of input to functions.\\n enter = self.graphics.ENTER_KEY\\n self.controls = {\\n # Pressing \\\"q\\\" will go back to the main menu.\\n \\\"q\\\": lambda: Action(\\\"goto main menu view\\\", []),\\n\\n # Movement keys.\\n \\\"w\\\": lambda: self.move_cursor(Direction.U),\\n \\\"a\\\": lambda: self.move_cursor(Direction.L),\\n \\\"s\\\": lambda: self.move_cursor(Direction.D),\\n \\\"d\\\": lambda: self.move_cursor(Direction.R),\\n\\n # Repeat the last valid input.\\n enter: self.repeat_last_valid_input,\\n\\n # Click the selected UIElement.\\n \\\"m\\\": self.click\\n }\",\n \"def _ui_content(self):\\n\\n # Cleat the tree\\n self.clear()\\n\\n # Set the font\\n font = QtGui.QFont()\\n font.setPointSize(11)\\n\\n # Add the id sets and set items\\n for id_set, id_dict in sorted(self.scnData.items()):\\n tree_item = QtGui.QTreeWidgetItem(self)\\n\\n tree_item.setText(0, id_set)\\n tree_item.setFont(0, font)\\n\\n icon_folder = os.path.dirname(os.path.abspath(__file__))\\n icon_path = os.path.join(icon_folder, \\\"icons\\\", \\\"IdSet.png\\\")\\n\\n tree_item.setIcon(0, QtGui.QIcon(icon_path))\\n\\n tree_item.setData(0, QtCore.Qt.UserRole, \\\"set\\\")\\n tree_item.setData(1, QtCore.Qt.UserRole, id_set)\\n\\n for id_color, id_objects in sorted(id_dict.items()):\\n if id_color != \\\"Holdout\\\":\\n self._add_id_color(id_objects,\\n id_color,\\n tree_item)\\n\\n self._add_id_color(id_dict[\\\"Holdout\\\"], \\\"Holdout\\\", tree_item)\\n\\n return\",\n \"def __init__(self, parent, config, twirlpath):\\r\\n\\t\\tself._init_ctrls(parent)\\r\\n\\r\\n\\t\\t# Merely hide frame if the close window [X] button used\\r\\n\\t\\tself.Bind(wx.EVT_CLOSE, self.OnFrameClose)\\r\\n\\r\\n\\t\\t# Load config data and make temporary copy, updates not passed\\r\\n\\t\\t# to main copy until user pressed OK so as to not cause any\\r\\n\\t\\t# intervening image downloads to be based on intermediate values\\r\\n\\t\\tself._config = config\\r\\n\\t\\tself._configtmp = ConfigOps()\\r\\n\\t\\tself._configtmp.update(config)\\r\\n\\r\\n\\t\\t# Set local config variables\\r\\n\\t\\tself._twirlpath = twirlpath\\r\\n\\t\\tself._password = \\\"\\\"\\r\\n\\r\\n\\t\\t# Set program icon\\r\\n\\t\\tself.SetIcon(icons.getTwirlIcon())\\r\\n\\r\\n\\t\\t# Generate list containing icons\\r\\n\\t\\ticonlist = wx.ImageList(16, 16)\\r\\n\\t\\ticonyellowstar = iconlist.Add(icons.getYellowStarBitmap())\\r\\n\\t\\ticonuser = iconlist.Add(icons.getUserBitmap())\\r\\n\\t\\ticonwrench = iconlist.Add(icons.getWrenchBitmap())\\r\\n\\t\\ticoninfo = iconlist.Add(icons.getInfoBitmap())\\r\\n\\r\\n\\t\\t# Assign icon list to notebook, then assign icons\\r\\n\\t\\t# to individual pages\\r\\n\\t\\tself.notebookApp.AssignImageList(iconlist)\\r\\n\\t\\tself.notebookApp.SetPageImage(0, iconyellowstar)\\r\\n\\t\\tself.notebookApp.SetPageImage(1, iconuser)\\r\\n\\t\\tself.notebookApp.SetPageImage(2, iconwrench)\\r\\n\\t\\tself.notebookApp.SetPageImage(3, iconinfo)\",\n \"def initGui(self):\\n self.sketchButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'sketch.svg'),\\n text=self.tr('Sketch on map'),\\n callback=self.sketchAction,\\n parent=self.iface.mainWindow(),\\n object_name='mSketchAction')\\n self.penButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'pen.svg'),\\n text=self.tr('Draw line on map'),\\n callback=self.penAction,\\n parent=self.iface.mainWindow(),\\n object_name='mPenAction')\\n self.canvasButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'canvas.svg'),\\n text=self.tr('Color and width canvas'),\\n callback=None,\\n parent=self.iface.mainWindow())\\n self.eraseButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'erase.svg'),\\n text=self.tr('Erase sketches'),\\n callback=self.eraseAction,\\n parent=self.iface.mainWindow(),\\n object_name='mEraseAction')\\n self.removeButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'remove.svg'),\\n text=self.tr('Remove all sketches'),\\n callback=self.removeSketchesAction,\\n parent=self.iface.mainWindow(),\\n object_name='mRemoveAllSketches')\\n self.noteButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'note.svg'),\\n text=self.tr('Add text annotations to sketches'),\\n callback=None,\\n parent=self.iface.mainWindow(),\\n object_name='mAddTextAnnotations')\\n self.convertButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'toLayer.svg'),\\n text=self.tr('Convert annotations to Memory Layer'),\\n callback=self.toMemoryLayerAction,\\n parent=self.iface.mainWindow(),\\n object_name='mConvertAnnotationsToMemoryLayer')\\n self.saveButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'inbox.svg'),\\n text=self.tr('Save sketches to file'),\\n callback=self.saveAction,\\n parent=self.iface.mainWindow(),\\n object_name='mSaveSketchesToFile')\\n self.loadButton = self.add_action(\\n path.join(self.plugin_dir, 'icons', 'outbox.svg'),\\n text=self.tr('Load sketches from file'),\\n callback=self.loadAction,\\n parent=self.iface.mainWindow(),\\n object_name='mLoadSketchesFromFile')\\n self.canvasButton.setMenu(self.canvasMenu())\\n self.noteButton.setCheckable(True)\\n self.penButton.setCheckable(True)\\n self.sketchButton.setCheckable(True)\\n self.eraseButton.setCheckable(True)\\n self.geoSketches = []\\n self.dumLayer = QgsVectorLayer(\\\"Point?crs=EPSG:4326\\\", \\\"temporary_points\\\", \\\"memory\\\")\\n self.pressed = None\\n self.previousPoint = None\\n self.previousMoved = None\\n self.gestures = 0\\n self.points = 0\\n self.currentColor = QColor(\\\"#aa0000\\\")\\n self.currentWidth = 5\\n self.annotation = sketchNoteDialog(self.iface)\\n self.annotatatedSketch = None\\n self.sketchEnabled(None)\\n self.iface.projectRead.connect(self.projectReadAction)\\n self.iface.newProjectCreated.connect(self.newProjectCreatedAction)\\n QgsProject.instance().legendLayersAdded.connect(self.notSavedProjectAction)\",\n \"def __init__(self):\\n super(QTUIProject, self).__init__()\\n self.setupUi(self)\\n self.assignWidgets()\\n self.show()\\n self.SlotsJsonName = \\\"Slots Assets Folder\\\"\\n self.BingoJsonName = \\\"Bingo Assets Folder\\\"\",\n \"def initUI(self):\\n self.logger.debug('Setting up the Measurement GUI')\\n self.setWindowTitle(self.title)\\n\\n self.show()\\n\\n self.make_combobox_scanner()\\n self.make_combobox_movements()\\n self.make_combobox_configurate()\\n self.make_combobox_basic()\",\n \"def initAppletDrawerUic(self):\\n with Tracer(traceLogger):\\n # Load the ui file (find it in our own directory)\\n localDir = os.path.split(__file__)[0]+'/'\\n # (We don't pass self here because we keep the drawer ui in a separate object.)\\n self.drawer = uic.loadUi(localDir+\\\"/dataSelectionDrawer.ui\\\")\\n\\n # Set up our handlers\\n self.drawer.addFileButton.clicked.connect(self.handleAddFileButtonClicked)\\n self.drawer.addFileButton.setIcon( QIcon(ilastikIcons.AddSel) )\\n\\n self.drawer.addMassButton.clicked.connect(self.handleMassAddButtonClicked)\\n self.drawer.addMassButton.setIcon( QIcon(ilastikIcons.AddSel) )\\n\\n self.drawer.addStackButton.clicked.connect(self.handleAddStackButtonClicked)\\n self.drawer.addStackButton.setIcon( QIcon(ilastikIcons.AddSel) )\\n\\n self.drawer.addStackFilesButton.clicked.connect(self.handleAddStackFilesButtonClicked)\\n self.drawer.addStackFilesButton.setIcon( QIcon(ilastikIcons.AddSel) )\\n\\n self.drawer.removeFileButton.setEnabled(False)\\n self.drawer.removeFileButton.clicked.connect(self.handleRemoveButtonClicked)\\n self.drawer.removeFileButton.setIcon( QIcon(ilastikIcons.RemSel) )\",\n \"def _icons(self):\",\n \"def _setup_ui(self):\\n from functools import partial\\n\\n self.setStyleSheet(\\n \\\"\\\"\\\"\\n QLabel[labelField=\\\"true\\\"] {\\n font-weight: bold;\\n }\\n \\\"\\\"\\\"\\n )\\n\\n # The main layout\\n self.main_layout = QtWidgets.QVBoxLayout(self)\\n self.main_layout.setContentsMargins(0, 0, 0, 0)\\n\\n # the form layout\\n self.form_layout = QtWidgets.QFormLayout()\\n self.form_layout.setLabelAlignment(\\n QtCore.Qt.AlignRight | QtCore.Qt.AlignTrailing | QtCore.Qt.AlignVCenter\\n )\\n\\n # store roles\\n label_role = QtWidgets.QFormLayout.LabelRole\\n field_role = QtWidgets.QFormLayout.FieldRole\\n\\n self.main_layout.addLayout(self.form_layout)\\n\\n i = -1\\n\\n # Reviewer\\n i += 1\\n reviewer_name_label = QtWidgets.QLabel(self)\\n reviewer_name_label.setText(\\\"Reviewer\\\")\\n self.form_layout.setWidget(i, label_role, reviewer_name_label)\\n\\n self.reviewer_name_widget = QtWidgets.QLabel(self)\\n self.form_layout.setWidget(i, field_role, self.reviewer_name_widget)\\n\\n # Task Name field\\n i += 1\\n task_name_label = QtWidgets.QLabel(self)\\n task_name_label.setText(\\\"Task\\\")\\n self.form_layout.setWidget(i, label_role, task_name_label)\\n\\n self.task_name_widget = QtWidgets.QLabel(self)\\n self.form_layout.setWidget(i, field_role, self.task_name_widget)\\n\\n # # Version Info field\\n # from anima.ui.widgets.version import VersionDetailsWidget\\n # self.latest_version_widget = VersionDetailsWidget(parent=self)\\n # self.main_layout.insertWidget(0, self.latest_version_widget)\\n\\n # Review Type Field\\n i += 1\\n review_type_label = QtWidgets.QLabel(self)\\n review_type_label.setText(\\\"Review Type\\\")\\n self.form_layout.setWidget(i, label_role, review_type_label)\\n\\n self.review_type_widget = ReviewTypeWidget(self)\\n self.review_type_widget.currentIndexChanged.connect(\\n partial(self.review_type_changed_callback)\\n )\\n\\n self.form_layout.setWidget(i, field_role, self.review_type_widget)\\n\\n # Timing Field\\n i += 1\\n effort_label = QtWidgets.QLabel(self)\\n effort_label.setText(\\\"Timing\\\")\\n self.form_layout.setWidget(i, label_role, effort_label)\\n\\n effort_layout = QtWidgets.QHBoxLayout()\\n self.form_layout.setLayout(i, field_role, effort_layout)\\n\\n from anima.ui.widgets.timing import ScheduleTimingWidget\\n from anima import defaults\\n\\n self.timing_widget = ScheduleTimingWidget(\\n self, timing_resolution=defaults.timing_resolution\\n )\\n self.timing_widget.setEnabled(False)\\n # set the default to 1 hour\\n self.timing_widget.set_schedule_info(timing=1, unit=\\\"h\\\")\\n effort_layout.addWidget(self.timing_widget)\\n\\n # Description Field\\n i += 1\\n description_label = QtWidgets.QLabel(self)\\n description_label.setText(\\\"Description\\\")\\n self.form_layout.setWidget(i, label_role, description_label)\\n\\n self.description_widget = QtWidgets.QTextEdit(self)\\n self.form_layout.setWidget(i, field_role, self.description_widget)\",\n \"def initUI(self):\\n # Setting the main layout as Vertical.\\n self.mainLayout = QHBoxLayout()\\n\\n # Create title.\\n self.title = QLabel(self.__name + \\\" : \\\")\\n\\n # Add description as tooltip.\\n self.title.setToolTip(self.__description)\\n\\n # Add title to main layout.\\n self.mainLayout.addWidget(self.title)\\n\\n # Create ComboBox.\\n self.dropDown = QComboBox()\\n\\n # Add datas to drop down.\\n self.dropDown.addItems(self.__datas)\\n\\n # Set default index to dropdown.\\n self.dropDown.setCurrentIndex(self.__currentValue)\\n\\n # Connect dropdown with update method.\\n self.dropDown.currentIndexChanged.connect(self.changeCurrentValue)\\n\\n # Add ComboBox to main layout.\\n self.mainLayout.addWidget(self.dropDown)\\n\\n # Add the main layout to the window.\\n self.setLayout(self.mainLayout)\",\n \"def __init__(self):\\n\\t\\tself.walltime_edit = urwid.Edit( ('editcp',\\\"walltime=\\\"), \\\"200:00:00\\\" )\\n\\t\\tself.nodes_edit = urwid.IntEdit( ('editcp', \\\"nodes=\\\"), 0 )\\n\\t\\tself.myri_ppn_edit = urwid.IntEdit( ('editcp', \\\"myri:ppn=\\\"), 4)\\n\\t\\tself.workdir_edit = urwid.Edit( (\\\"editcp\\\", \\\"WORKDIR(-d) \\\"), '~/qjob_output')\\n\\t\\tself.runtime_output_checkbox = urwid.CheckBox(\\\"See output while running\\\")\\n\\t\\tself.other_options_edit = urwid.Edit( (\\\"editcp\\\", \\\"others:\\\"), '-q cmb -j oe -S /bin/bash')\\n\\t\\tself.source_bash_profile_checkbox = urwid.CheckBox(\\\"source ~/.bash_profile\\\")\\n\\t\\tself.source_bash_profile_checkbox.set_state(True)\\n\\t\\tself.just_write_down_checkbox = urwid.CheckBox(\\\"Write jobfile. No submission.\\\")\\n\\t\\tself.jobname_prefix_edit = urwid.Edit( (\\\"editcp\\\", \\\"jobname_prefix:\\\"), '~/qjob/job')\\n\\t\\tself.jobnumber_edit = urwid.IntEdit( (\\\"editcp\\\", \\\"job number:\\\"), 0)\\n\\t\\tself.job_content_reset_button = urwid.Button(\\\"Job Content Reset\\\", self.job_content_reset)\\n\\t\\tself.exit_button = urwid.Button(\\\"Exit\\\", self.program_exit)\\n\\t\\tself.job_edit = urwid.Edit( ('editcp',\\\"\\\"), multiline=True )\\n\\t\\t\\n\\t\\tself.items = [\\n\\t\\turwid.Padding(\\n\\t\\t\\turwid.Columns(\\n\\t\\t\\t\\t[\\n\\t\\t\\t\\turwid.AttrWrap( self.walltime_edit, 'editbx', 'editfc' ),\\n\\t\\t\\t\\turwid.AttrWrap( self.nodes_edit, 'editbx', 'editfc'),\\n\\t\\t\\t\\turwid.AttrWrap( self.myri_ppn_edit, 'editbx', 'editfc'),\\n\\t\\t\\t\\t],\\n\\t\\t\\t\\t2 ), \\n\\t\\t\\t('fixed left',2), ('fixed right',2)),\\n\\t\\tblank,\\n\\t\\turwid.Padding(\\n\\t\\t\\turwid.Columns(\\n\\t\\t\\t\\t[\\n\\t\\t\\t\\turwid.AttrWrap( self.workdir_edit, 'editbx', 'editfc' ), \\n\\t\\t\\t\\turwid.AttrWrap( self.runtime_output_checkbox, 'buttn', 'buttnf'),\\n\\t\\t\\t\\t],\\n\\t\\t\\t\\t2),\\n\\t\\t\\t('fixed left',2), ('fixed right',2)),\\n\\t\\tblank,\\n\\t\\turwid.Padding(\\n\\t\\t\\turwid.AttrWrap( self.other_options_edit, 'editbx', 'editfc' ), ('fixed left',2), ('fixed right',2)),\\n\\t\\tblank,\\n\\t\\turwid.Padding(\\n\\t\\t\\turwid.GridFlow(\\n\\t\\t\\t\\t[\\n\\t\\t\\t\\turwid.AttrWrap( self.source_bash_profile_checkbox, 'buttn','buttnf'),\\n\\t\\t\\t\\turwid.AttrWrap( self.just_write_down_checkbox, 'buttn', 'buttnf'),\\n\\t\\t\\t\\turwid.AttrWrap( self.jobname_prefix_edit, 'editbx', 'editfc' ),\\n\\t\\t\\t\\turwid.AttrWrap( self.jobnumber_edit, 'editbx', 'editfc' ),\\n\\t\\t\\t\\turwid.AttrWrap(self.job_content_reset_button, 'buttn', 'buttnf'),\\n\\t\\t\\t\\turwid.AttrWrap(self.exit_button, 'buttn', 'buttnf'),\\n\\t\\t\\t\\t],\\n\\t\\t\\t\\t34, 2, 1, 'left'),\\n\\t\\t\\t('fixed left',2), ('fixed right',2)),\\n\\t\\tblank,\\n\\t\\turwid.Padding(\\n\\t\\t\\turwid.Pile(\\n\\t\\t\\t[\\n\\t\\t\\turwid.Text('One line one job. One job with >1 commands put on one line, separated by ;'),\\n\\t\\t\\turwid.AttrWrap(self.job_edit, 'editbx', 'editfc'),\\n\\t\\t\\t], 1),\\n\\t\\t\\t('fixed left',2), ('fixed right',2) )\\n\\t\\t\\t\\n\\t\\t]\\n\\t\\t\\n\\t\\tself.listbox = urwid.ListBox( self.items )\\n\\t\\t\\n\\t\\tinstruct = urwid.Text(\\\"Job submission program based on Urwid. F8 to submit, F12 to quit.\\\")\\n\\t\\theader = urwid.AttrWrap( instruct, 'header' )\\n\\t\\t\\n\\t\\tself.footer_text = urwid.Text(\\\"Mar 15th, 2008 by Yu Huang\\\")\\n\\t\\tfooter = urwid.AttrWrap(self.footer_text, 'footer')\\n\\t\\t\\n\\t\\tself.top_frame = urwid.Frame(urwid.AttrWrap(self.listbox, 'body'), header, footer)\",\n \"def __init__(self, parent):\\r\\n Frame.__init__(self, parent) \\r\\n \\r\\n self.parent = parent\\r\\n self.initUI()\",\n \"def init_ui(self):\\n self.parent.title(\\\"Roku Player Controller\\\")\\n self.style.theme_use(\\\"default\\\")\",\n \"def _create_analyses_input_page(self, notebook): # pylint: disable=R0914\\r\\n\\r\\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\\r\\n # Build-up the containers for the tab. #\\r\\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\\r\\n _hbox = gtk.HPaned()\\r\\n\\r\\n _fixed = gtk.Fixed()\\r\\n\\r\\n _frame = Widgets.make_frame(label=_(u\\\"Analysis Inputs\\\"))\\r\\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)\\r\\n _frame.add(_fixed)\\r\\n\\r\\n _hbox.pack1(_frame, True, True)\\r\\n\\r\\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\\r\\n # Place the widgets used to display analysis input information. #\\r\\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\\r\\n # Load the gtk.ComboBox() widgets.\\r\\n _results = [[u\\\"MCF\\\"], [u\\\"Kaplan-Meier\\\"], [_(u\\\"NHPP - Power Law\\\")],\\r\\n [u\\\"NHPP - Loglinear\\\"], [_(u\\\"Exponential\\\")],\\r\\n [_(u\\\"Lognormal\\\")], [_(u\\\"Normal\\\")], [u\\\"Weibull\\\"],\\r\\n [\\\"WeiBayes\\\"]]\\r\\n Widgets.load_combo(self.cmbDistribution, _results)\\r\\n _results = [[_(u\\\"Lower One-Sided\\\")], [_(u\\\"Upper One-Sided\\\")],\\r\\n [_(u\\\"Two-Sided\\\")]]\\r\\n Widgets.load_combo(self.cmbConfType, _results)\\r\\n _results = [[_(u\\\"Crow (NHPP Only)\\\")], [_(u\\\"Duane (NHPP Only)\\\")],\\r\\n [_(u\\\"Fisher Matrix\\\")], [_(u\\\"Likelihood\\\")],\\r\\n [_(u\\\"Bootstrap\\\")]]\\r\\n Widgets.load_combo(self.cmbConfMethod, _results)\\r\\n _results = [[\\\"MLE\\\"], [_(u\\\"Regression\\\")]]\\r\\n Widgets.load_combo(self.cmbFitMethod, _results)\\r\\n\\r\\n # Create the labels for the left half of the right side.\\r\\n _labels = [_(u\\\"Assembly:\\\"), _(u\\\"Description:\\\"), _(u\\\"Distribution:\\\"),\\r\\n _(\\\"Fit Method:\\\"), _(u\\\"Confidence:\\\"), _(u\\\"Confidence Type:\\\"),\\r\\n _(\\\"Confidence Method:\\\")]\\r\\n (_x_pos1, _y_pos1) = Widgets.make_labels(_labels, _fixed, 5, 5)\\r\\n _x_pos1 += 55\\r\\n\\r\\n # Create the labels for the right half of the right side.\\r\\n _labels = [_(u\\\"Start Time:\\\"), _(u\\\"End Time:\\\"), _(u\\\"Step Interval:\\\"),\\r\\n _(u\\\"Start Date:\\\"), _(u\\\"End Date:\\\")]\\r\\n (_x_pos2,\\r\\n _y_pos2) = Widgets.make_labels(_labels, _fixed, _x_pos1 + 215, 5)\\r\\n _x_pos2 += _x_pos1\\r\\n _x_pos2 += 275\\r\\n\\r\\n # Place widgets on the left side.\\r\\n _fixed.put(self.cmbAssembly, _x_pos1, _y_pos1[0])\\r\\n _fixed.put(self.txtDescription, _x_pos1, _y_pos1[1])\\r\\n _fixed.put(self.cmbDistribution, _x_pos1, _y_pos1[2])\\r\\n _fixed.put(self.cmbFitMethod, _x_pos1, _y_pos1[3])\\r\\n _fixed.put(self.txtConfidence, _x_pos1, _y_pos1[4])\\r\\n _fixed.put(self.cmbConfType, _x_pos1, _y_pos1[5])\\r\\n _fixed.put(self.cmbConfMethod, _x_pos1, _y_pos1[6])\\r\\n\\r\\n # Place widgets on the right side.\\r\\n _fixed.put(self.txtStartTime, _x_pos2, _y_pos2[0])\\r\\n _fixed.put(self.txtEndTime, _x_pos2, _y_pos2[1])\\r\\n _fixed.put(self.txtRelPoints, _x_pos2, _y_pos2[2])\\r\\n _fixed.put(self.txtStartDate, _x_pos2, _y_pos2[3])\\r\\n _fixed.put(self.btnStartDate, _x_pos2 + 105, _y_pos2[3])\\r\\n _fixed.put(self.txtEndDate, _x_pos2, _y_pos2[4])\\r\\n _fixed.put(self.btnEndDate, _x_pos2 + 105, _y_pos2[4])\\r\\n _fixed.put(self.chkGroup, _x_pos2, _y_pos2[4] + 30)\\r\\n _fixed.put(self.chkParts, _x_pos2, _y_pos2[4] + 60)\\r\\n\\r\\n _fixed.show_all()\\r\\n\\r\\n # Insert the tab.\\r\\n _label = gtk.Label()\\r\\n _label.set_markup(\\\"<span weight='bold'>\\\" +\\r\\n _(u\\\"Analysis\\\\nInputs\\\") + \\\"</span>\\\")\\r\\n _label.set_alignment(xalign=0.5, yalign=0.5)\\r\\n _label.set_justify(gtk.JUSTIFY_CENTER)\\r\\n _label.show_all()\\r\\n _label.set_tooltip_text(_(u\\\"Displays analysis inputs for the selected \\\"\\r\\n u\\\"dataset.\\\"))\\r\\n notebook.insert_page(_hbox, tab_label=_label, position=-1)\\r\\n\\r\\n return False\",\n \"def create_risk_analysis_page(self, notebook):\\r\\n\\r\\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\\r\\n # Build-up the containers for the tab. #\\r\\n # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #\\r\\n _hpaned = gtk.HPaned()\\r\\n self.pack1(_hpaned, resize=True, shrink=True)\\r\\n\\r\\n # Create the organizational risk pane.\\r\\n _fixed = gtk.Fixed()\\r\\n\\r\\n _scrollwindow = gtk.ScrolledWindow()\\r\\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\\r\\n _scrollwindow.add_with_viewport(_fixed)\\r\\n\\r\\n _frame = Widgets.make_frame(label=_(u\\\"Organization\\\"))\\r\\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\\r\\n _frame.add(_scrollwindow)\\r\\n\\r\\n _hpaned.pack1(_frame, True, True)\\r\\n\\r\\n _labels = [_(u\\\"1. There are separate design and coding \\\"\\r\\n u\\\"organizations.\\\"),\\r\\n _(u\\\"2. There is an independent software test \\\"\\r\\n u\\\"organization.\\\"),\\r\\n _(u\\\"3. There is an independent software quality \\\"\\r\\n u\\\"assurance organization.\\\"),\\r\\n _(u\\\"4. There is an independent software configuration \\\"\\r\\n u\\\"management organization.\\\"),\\r\\n _(u\\\"5. There is an independent software verification \\\"\\r\\n u\\\"and validation organization.\\\"),\\r\\n _(u\\\"6. A structured programming team will develop the \\\"\\r\\n u\\\"software.\\\"),\\r\\n _(u\\\"7. The educational level of the software team members \\\"\\r\\n u\\\"is above average.\\\"),\\r\\n _(u\\\"8. The experience level of the software team members \\\"\\r\\n u\\\"is above average.\\\")]\\r\\n (_x_pos,\\r\\n _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\\r\\n _x_pos += 125\\r\\n\\r\\n _fixed.put(self.chkDevEnvQ1, _x_pos, _y_pos[0])\\r\\n _fixed.put(self.chkDevEnvQ2, _x_pos, _y_pos[1])\\r\\n _fixed.put(self.chkDevEnvQ3, _x_pos, _y_pos[2])\\r\\n _fixed.put(self.chkDevEnvQ4, _x_pos, _y_pos[3])\\r\\n _fixed.put(self.chkDevEnvQ5, _x_pos, _y_pos[4])\\r\\n _fixed.put(self.chkDevEnvQ6, _x_pos, _y_pos[5])\\r\\n _fixed.put(self.chkDevEnvQ7, _x_pos, _y_pos[6])\\r\\n _fixed.put(self.chkDevEnvQ8, _x_pos, _y_pos[7])\\r\\n\\r\\n # Create the methods risk pane.\\r\\n _fixed = gtk.Fixed()\\r\\n\\r\\n _scrollwindow = gtk.ScrolledWindow()\\r\\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\\r\\n _scrollwindow.add_with_viewport(_fixed)\\r\\n\\r\\n _frame = Widgets.make_frame(label=_(u\\\"Methods\\\"))\\r\\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\\r\\n _frame.add(_scrollwindow)\\r\\n\\r\\n _hpaned.pack2(_frame, True, True)\\r\\n\\r\\n _labels = [_(u\\\"1. Standards are defined and will be enforced.\\\"),\\r\\n _(u\\\"2. Software will be developed using a higher order \\\"\\r\\n u\\\"language.\\\"),\\r\\n _(u\\\"3. The development process will include formal \\\"\\r\\n u\\\"reviews (PDR, CDR, etc.).\\\"),\\r\\n _(u\\\"4. The development process will include frequent \\\"\\r\\n u\\\"walkthroughs.\\\"),\\r\\n _(u\\\"5. Development will take a top-down and \\\"\\r\\n u\\\"structured approach.\\\"),\\r\\n _(u\\\"6. Unit development folders will be used.\\\"),\\r\\n _(u\\\"7. A software development library will be used.\\\"),\\r\\n _(u\\\"8. A formal change and error reporting process \\\"\\r\\n u\\\"will be used.\\\"),\\r\\n _(u\\\"9. Progress and status will routinely be \\\"\\r\\n u\\\"reported.\\\")]\\r\\n (__, _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\\r\\n\\r\\n _fixed.put(self.chkDevEnvQ9, _x_pos, _y_pos[0])\\r\\n _fixed.put(self.chkDevEnvQ10, _x_pos, _y_pos[1])\\r\\n _fixed.put(self.chkDevEnvQ11, _x_pos, _y_pos[2])\\r\\n _fixed.put(self.chkDevEnvQ12, _x_pos, _y_pos[3])\\r\\n _fixed.put(self.chkDevEnvQ13, _x_pos, _y_pos[4])\\r\\n _fixed.put(self.chkDevEnvQ14, _x_pos, _y_pos[5])\\r\\n _fixed.put(self.chkDevEnvQ15, _x_pos, _y_pos[6])\\r\\n _fixed.put(self.chkDevEnvQ16, _x_pos, _y_pos[7])\\r\\n _fixed.put(self.chkDevEnvQ17, _x_pos, _y_pos[8])\\r\\n\\r\\n # Create the documentation risk pane.\\r\\n _hpaned = gtk.HPaned()\\r\\n self.pack2(_hpaned, resize=True, shrink=True)\\r\\n\\r\\n _fixed = gtk.Fixed()\\r\\n\\r\\n _scrollwindow = gtk.ScrolledWindow()\\r\\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\\r\\n _scrollwindow.add_with_viewport(_fixed)\\r\\n\\r\\n _frame = Widgets.make_frame(label=_(u\\\"Documentation\\\"))\\r\\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\\r\\n _frame.add(_scrollwindow)\\r\\n\\r\\n _hpaned.pack1(_frame, True, True)\\r\\n\\r\\n _labels = [_(u\\\" 1. System requirements specifications will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\" 2. Software requirements specifications will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\" 3. Interface design specifications will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\" 4. Software design specification will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\" 5. Test plans, procedures, and reports will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\" 6. The software development plan will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\" 7. The software quality assurance plan will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\" 8. The software configuration management plan will \\\"\\r\\n u\\\"be documented.\\\"),\\r\\n _(u\\\" 9. A requirements traceability matrix will be \\\"\\r\\n u\\\"used.\\\"),\\r\\n _(u\\\"10. The software version description will be \\\"\\r\\n u\\\"documented.\\\"),\\r\\n _(u\\\"11. All software discrepancies will be \\\"\\r\\n u\\\"documented.\\\")]\\r\\n (__, _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\\r\\n\\r\\n _fixed.put(self.chkDevEnvQ18, _x_pos, _y_pos[0])\\r\\n _fixed.put(self.chkDevEnvQ19, _x_pos, _y_pos[1])\\r\\n _fixed.put(self.chkDevEnvQ20, _x_pos, _y_pos[2])\\r\\n _fixed.put(self.chkDevEnvQ21, _x_pos, _y_pos[3])\\r\\n _fixed.put(self.chkDevEnvQ22, _x_pos, _y_pos[4])\\r\\n _fixed.put(self.chkDevEnvQ23, _x_pos, _y_pos[5])\\r\\n _fixed.put(self.chkDevEnvQ24, _x_pos, _y_pos[6])\\r\\n _fixed.put(self.chkDevEnvQ25, _x_pos, _y_pos[7])\\r\\n _fixed.put(self.chkDevEnvQ26, _x_pos, _y_pos[8])\\r\\n _fixed.put(self.chkDevEnvQ27, _x_pos, _y_pos[9])\\r\\n _fixed.put(self.chkDevEnvQ28, _x_pos, _y_pos[10])\\r\\n\\r\\n # Create the tools and test techniques risk pane.\\r\\n _fixed = gtk.Fixed()\\r\\n\\r\\n _scrollwindow = gtk.ScrolledWindow()\\r\\n _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)\\r\\n _scrollwindow.add_with_viewport(_fixed)\\r\\n\\r\\n _frame = Widgets.make_frame(label=_(u\\\"Tools & Test Techniques\\\"))\\r\\n _frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)\\r\\n _frame.add(_scrollwindow)\\r\\n\\r\\n _hpaned.pack2(_frame, True, True)\\r\\n\\r\\n _labels = [_(u\\\" 1. The software language requirements will be \\\"\\r\\n u\\\"specified.\\\"),\\r\\n _(u\\\" 2. Formal program design language will be used.\\\"),\\r\\n _(u\\\" 3. Program design graphical techniques \\\"\\r\\n u\\\"(flowcharts, HIPO, etc.) will be used.\\\"),\\r\\n _(u\\\" 4. Simulation/emulation tools will be used.\\\"),\\r\\n _(u\\\" 5. Configuration management tools will be used.\\\"),\\r\\n _(u\\\" 6. A code auditing tool will be used.\\\"),\\r\\n _(u\\\" 7. A data flow analyzer will be used.\\\"),\\r\\n _(u\\\" 8. A programmer's workbench will be used.\\\"),\\r\\n _(u\\\" 9. Measurement tools will be used.\\\"),\\r\\n _(u\\\"10. Software code reviews will be used.\\\"),\\r\\n _(u\\\"11. Software branch testing will be used.\\\"),\\r\\n _(u\\\"12. Random testing will be used.\\\"),\\r\\n _(u\\\"13. Functional testing will be used.\\\"),\\r\\n _(u\\\"14. Error and anomaly detection testing will be \\\"\\r\\n u\\\"used.\\\"),\\r\\n _(u\\\"15. Structure analysis will be used.\\\")]\\r\\n (__, _y_pos) = Widgets.make_labels(_labels, _fixed, 5, 5, wrap=False)\\r\\n\\r\\n _fixed.put(self.chkDevEnvQ29, _x_pos, _y_pos[0])\\r\\n _fixed.put(self.chkDevEnvQ30, _x_pos, _y_pos[1])\\r\\n _fixed.put(self.chkDevEnvQ31, _x_pos, _y_pos[2])\\r\\n _fixed.put(self.chkDevEnvQ32, _x_pos, _y_pos[3])\\r\\n _fixed.put(self.chkDevEnvQ33, _x_pos, _y_pos[4])\\r\\n _fixed.put(self.chkDevEnvQ34, _x_pos, _y_pos[5])\\r\\n _fixed.put(self.chkDevEnvQ35, _x_pos, _y_pos[6])\\r\\n _fixed.put(self.chkDevEnvQ36, _x_pos, _y_pos[7])\\r\\n _fixed.put(self.chkDevEnvQ37, _x_pos, _y_pos[8])\\r\\n _fixed.put(self.chkDevEnvQ38, _x_pos, _y_pos[9])\\r\\n _fixed.put(self.chkDevEnvQ39, _x_pos, _y_pos[10])\\r\\n _fixed.put(self.chkDevEnvQ40, _x_pos, _y_pos[11])\\r\\n _fixed.put(self.chkDevEnvQ41, _x_pos, _y_pos[12])\\r\\n _fixed.put(self.chkDevEnvQ42, _x_pos, _y_pos[13])\\r\\n _fixed.put(self.chkDevEnvQ43, _x_pos, _y_pos[14])\\r\\n\\r\\n _label = gtk.Label()\\r\\n _label.set_markup(\\\"<span weight='bold'>\\\" +\\r\\n _(u\\\"Development\\\\nEnvironment\\\") +\\r\\n \\\"</span>\\\")\\r\\n _label.set_alignment(xalign=0.5, yalign=0.5)\\r\\n _label.set_justify(gtk.JUSTIFY_CENTER)\\r\\n _label.set_angle(0)\\r\\n _label.show_all()\\r\\n _label.set_tooltip_text(_(u\\\"Assesses risk due to the development \\\"\\r\\n u\\\"environment.\\\"))\\r\\n notebook.insert_page(self, tab_label=_label, position=-1)\\r\\n\\r\\n return False\",\n \"def __create_ui(self):\\n vbox = gtk.VBox()\\n\\n # Create the viewable area of the file browser\\n self.__view_port = gtk.ScrolledWindow()\\n self.__view_port.set_policy(gtk.POLICY_AUTOMATIC,\\n gtk.POLICY_AUTOMATIC)\\n # Create the tree view and add it to the viewable area\\n self.__tree_view = ProjectTreeView()\\n self.__project_explorer = ProjectExplorer(self.window, self.__tree_view)\\n self.__tree_view.connect('button_press_event',\\n self.__on_treeview_button_press_event)\\n self.__project_explorer.set_repository()\\n self.__view_port.add(self.__tree_view)\\n # Create the toolbar\\n hbox = gtk.HBox()\\n toolbar = gtk.Toolbar()\\n toolbar.set_style(gtk.TOOLBAR_ICONS)\\n toolbar.set_icon_size(gtk.ICON_SIZE_MENU)\\n back = gtk.ToolButton(gtk.STOCK_GO_UP)\\n back.connect('clicked', self.__on_back_clicked)\\n toolbar.insert(back, 0)\\n toolbar.insert(gtk.SeparatorToolItem(), 1)\\n refresh = gtk.ToolButton(gtk.STOCK_REFRESH)\\n refresh.connect('clicked', self.__on_refresh_clicked)\\n toolbar.insert(refresh, 2)\\n hbox.pack_start(toolbar, True, True, 0)\\n vbox.pack_start(hbox, False, False, 0)\\n vbox.pack_start(self.__view_port, True, True, 0)\\n\\n # Setup the create the buttons for:\\n # New File, New Folder\\n # ----------------------------------------------------------------------\\n hbox1 = gtk.VBox()\\n toolbar_actions = gtk.Toolbar()\\n toolbar_actions.set_style(gtk.TOOLBAR_ICONS)\\n toolbar_actions.set_icon_size(gtk.ICON_SIZE_MENU)\\n new_file = gtk.ToolButton(gtk.STOCK_NEW)\\n new_file.connect('clicked', self.__on_new_file_clicked_cb)\\n toolbar_actions.insert(new_file, 0)\\n new_dir = gtk.ToolButton(gtk.STOCK_OPEN) # TODO: use a custom icon\\n new_dir.connect('clicked', self.__on_new_dir_clicked_cb)\\n toolbar_actions.insert(new_dir, 1)\\n hbox1.pack_start(gtk.HSeparator(), True, True, 0)\\n hbox1.pack_start(toolbar_actions, True, True, 0)\\n vbox.pack_end(hbox1, False, False, 0)\\n # ----------------------------------------------------------------------\\n vbox.show_all()\\n # Attach the project explorer to GMate's side panel\\n self.__side_panel = self.window.get_side_panel()\\n self.__side_panel.add_tab(vbox, msg0005, gtk.STOCK_HARDDISK)\",\n \"def initUI(self):\\n\\t\\t#de button om het spel te beginnen\\n\\t\\tself.playButton = QtGui.QPushButton(\\\"Play\\\", self)\\n\\t\\tself.playButton.clicked.connect(self.playField)\\n\\t\\tself.playButton.setStyleSheet(\\\"background-color: red;border-style: outset; border-radius:5px; font: bold 18px;\\\")\\n\\t\\tself.playButton.move(210,100)\\n\\t\\tself.playButton.resize(150, 50)\\n\\t\\t\\n\\t\\t#zakje chips\\n\\t\\tself.chips = QtGui.QPixmap(\\\"chips.png\\\")\\n\\t\\tself.lbl = QtGui.QLabel(self)\\n\\t\\tself.lbl.setPixmap(self.chips)\\n\\t\\tself.lbl.move(410, 300)\\n\\t\\t\\n\\t\\t#1 zak chips is nooit genoeg voor de heavy breathing cat\\n\\t\\tself.chips2 = QtGui.QPixmap(\\\"chips.png\\\")\\n\\t\\tself.lbl2 = QtGui.QLabel(self)\\n\\t\\tself.lbl2.setPixmap(self.chips)\\n\\t\\tself.lbl2.move(30, 30)\\n\\t\\t\\n\\t\\t#pikachu in een sailor pakje, want battleships\\n\\t\\tself.pikachu = QtGui.QPixmap(\\\"pikachu.png\\\")\\n\\t\\tself.lbl3 = QtGui.QLabel(self)\\n\\t\\tself.lbl3.setPixmap(self.pikachu)\\n\\t\\tself.lbl3.move(400,0)\\n\\t\\t\\n\\t\\t#een kat kan natuurlijk niet ontbreken\\n\\t\\tself.kat = QtGui.QPixmap(\\\"hb2.jpeg\\\")\\n\\t\\tself.lblKat = QtGui.QLabel(self)\\n\\t\\tself.lblKat.setPixmap(self.kat)\\n\\t\\tself.lblKat.move(0,230)\\n\\t\\t\\n\\t\\t#ons super vette logo #swek\\n\\t\\tself.battlechipsPlaatje = QtGui.QPixmap(\\\"battleships.png\\\")\\n\\t\\tself.lblbattle = QtGui.QLabel(self)\\n\\t\\tself.lblbattle.setPixmap(self.battlechipsPlaatje)\\n\\t\\tself.lblbattle.move(180,10)\\n\\t\\t\\n\\t\\t#le window\\n\\t\\tself.setGeometry(150, 150, 600, 600)\\n\\t\\tself.setWindowTitle(\\\"Menu\\\")\\n\\t\\tself.setStyleSheet(\\\"background-color: #8e8f94\\\")\\n\\t\\tself.show()\",\n \"def controls_setup(self):\\n self.dashboard = element.Link(self, class_name='menu-dashboard', alias='Dashboard Menu')\\n # catalogue and sub-menus\\n self.catalogue = element.LinkButton(self, class_name='menu-catalogue', alias='Catalogue Menu')\\n self.products = element.Link(self, class_name='submenu-products', alias='Catalogue->Products Menu')\\n self.product_types = element.Link(self, class_name='submenu-product-types',\\n alias='Catalogue->Product Types Menu')\\n self.categories = element.Link(self, class_name='submenu-categories', alias='Catalogue->Categories Menu')\\n self.ranges = element.Link(self, class_name='submenu-ranges', alias='Catalogue->Ranges Menu')\\n self.stock_alerts = element.Link(self, class_name='submenu-low-stock-alerts',\\n alias='Catalogue->Low Stock Alerts Menu')\\n # fulfilment and sub-menus\\n self.fulfilment = element.LinkButton(self, class_name='menu-fulfilment', alias='Fulfilment Menu')\\n self.orders = element.Link(self, class_name='submenu-orders', alias='Fulfilment->Orders Menu')\\n self.statistics = element.Link(self, class_name='submenu-statistics', alias='Fulfilment->Statistics Menu')\\n self.partners = element.Link(self, class_name='submenu-partners', alias='Fulfilment->Partners Menu')\\n # customers and sub-menus\\n self.customers = element.LinkButton(self, class_name='menu-customers', alias='Customers Menu')\\n self.customers_submenu = element.Link(self, class_name='submenu-customers', alias='Customers->Customers Menu')\\n self.deleted_accounts = element.Link(self, class_name='submenu-deleted_accounts',\\n alias='Customers->Deleted Accounts Menu')\\n self.stock_alert_requests = element.Link(self, class_name='submenu-stock-alert-requests-customers',\\n alias='Customers->Stock Alert Requests Menu')\\n # offers and sub-menus\\n self.offers = element.LinkButton(self, class_name='menu-offers', alias='Offers Menu')\\n self.offers_submenu = element.Link(self, class_name='submenu-offers', alias='Offers->Offers Menu')\\n self.vouchers = element.Link(self, class_name='submenu-vouchers', alias='Offers->Vouchers Menu')\\n # content and sub-menus\\n self.content_menu = element.LinkButton(self, class_name='menu-content', alias='Content Menu')\\n self.pages = element.Link(self, class_name='menu-pages', alias='Content->Pages Menu')\\n self.announcements = element.Link(self, class_name='menu-announcements', alias='Content->Announcements Menu')\\n self.reviews = element.Link(self, class_name='menu-reviews', alias='Content->Reviews Menu')\\n\\n self.reports = element.Link(self, class_name='menu-reports', alias='Reports Menu')\\n self.store_info = element.LinkButton(self, css_selector='.dropdown.store > a', alias='Store Info Menu')\\n self.partner_store = []\",\n \"def create_sliders(self):\\n self.create_contrast_slider()\\n self.create_crop_sliders()\",\n \"def initGui(self):\\n self.network_layer_notifier = QgepLayerNotifier(\\n self.iface.mainWindow(), [\\\"vw_network_node\\\", \\\"vw_network_segment\\\"]\\n )\\n self.wastewater_networkelement_layer_notifier = QgepLayerNotifier(\\n self.iface.mainWindow(), [\\\"vw_wastewater_node\\\", \\\"vw_qgep_reach\\\"]\\n )\\n self.toolbarButtons = []\\n\\n # Create toolbar button\\n self.profileAction = QAction(\\n QIcon(os.path.join(plugin_root_path(), \\\"icons/wastewater-profile.svg\\\")),\\n self.tr(\\\"Profile\\\"),\\n self.iface.mainWindow(),\\n )\\n self.profileAction.setWhatsThis(self.tr(\\\"Reach trace\\\"))\\n self.profileAction.setEnabled(False)\\n self.profileAction.setCheckable(True)\\n self.profileAction.triggered.connect(self.profileToolClicked)\\n\\n self.downstreamAction = QAction(\\n QIcon(os.path.join(plugin_root_path(), \\\"icons/wastewater-downstream.svg\\\")),\\n self.tr(\\\"Downstream\\\"),\\n self.iface.mainWindow(),\\n )\\n self.downstreamAction.setWhatsThis(self.tr(\\\"Downstream reaches\\\"))\\n self.downstreamAction.setEnabled(False)\\n self.downstreamAction.setCheckable(True)\\n self.downstreamAction.triggered.connect(self.downstreamToolClicked)\\n\\n self.upstreamAction = QAction(\\n QIcon(os.path.join(plugin_root_path(), \\\"icons/wastewater-upstream.svg\\\")),\\n self.tr(\\\"Upstream\\\"),\\n self.iface.mainWindow(),\\n )\\n self.upstreamAction.setWhatsThis(self.tr(\\\"Upstream reaches\\\"))\\n self.upstreamAction.setEnabled(False)\\n self.upstreamAction.setCheckable(True)\\n self.upstreamAction.triggered.connect(self.upstreamToolClicked)\\n\\n self.wizardAction = QAction(\\n QIcon(os.path.join(plugin_root_path(), \\\"icons/wizard.svg\\\")),\\n \\\"Wizard\\\",\\n self.iface.mainWindow(),\\n )\\n self.wizardAction.setWhatsThis(self.tr(\\\"Create new manholes and reaches\\\"))\\n self.wizardAction.setEnabled(False)\\n self.wizardAction.setCheckable(True)\\n self.wizardAction.triggered.connect(self.wizard)\\n\\n self.connectNetworkElementsAction = QAction(\\n QIcon(\\n os.path.join(\\n plugin_root_path(), \\\"icons/link-wastewater-networkelement.svg\\\"\\n )\\n ),\\n QApplication.translate(\\\"qgepplugin\\\", \\\"Connect wastewater networkelements\\\"),\\n self.iface.mainWindow(),\\n )\\n self.connectNetworkElementsAction.setEnabled(False)\\n self.connectNetworkElementsAction.setCheckable(True)\\n self.connectNetworkElementsAction.triggered.connect(self.connectNetworkElements)\\n\\n self.refreshNetworkTopologyAction = QAction(\\n QIcon(os.path.join(plugin_root_path(), \\\"icons/refresh-network.svg\\\")),\\n \\\"Refresh network topology\\\",\\n self.iface.mainWindow(),\\n )\\n self.refreshNetworkTopologyAction.setWhatsThis(\\n self.tr(\\\"Refresh network topology\\\")\\n )\\n self.refreshNetworkTopologyAction.setEnabled(False)\\n self.refreshNetworkTopologyAction.setCheckable(False)\\n self.refreshNetworkTopologyAction.triggered.connect(\\n self.refreshNetworkTopologyActionClicked\\n )\\n\\n self.aboutAction = QAction(self.tr(\\\"About\\\"), self.iface.mainWindow())\\n self.aboutAction.triggered.connect(self.about)\\n\\n self.settingsAction = QAction(self.tr(\\\"Settings\\\"), self.iface.mainWindow())\\n self.settingsAction.triggered.connect(self.showSettings)\\n\\n self.importAction = QAction(\\n QIcon(os.path.join(plugin_root_path(), \\\"icons/interlis_import.svg\\\")),\\n self.tr(\\\"Import from interlis\\\"),\\n self.iface.mainWindow(),\\n )\\n self.importAction.setWhatsThis(self.tr(\\\"Import from interlis\\\"))\\n self.importAction.setEnabled(False)\\n self.importAction.setCheckable(False)\\n self.importAction.triggered.connect(self.actionImportClicked)\\n\\n self.exportAction = QAction(\\n QIcon(os.path.join(plugin_root_path(), \\\"icons/interlis_export.svg\\\")),\\n self.tr(\\\"Export to interlis\\\"),\\n self.iface.mainWindow(),\\n )\\n self.exportAction.setWhatsThis(self.tr(\\\"Export from interlis\\\"))\\n self.exportAction.setEnabled(False)\\n self.exportAction.setCheckable(False)\\n self.exportAction.triggered.connect(self.actionExportClicked)\\n\\n self.datamodelInitToolAction = QAction(\\n self.tr(\\\"Datamodel tool\\\"), self.iface.mainWindow()\\n )\\n self.datamodelInitToolAction.triggered.connect(self.showDatamodelInitTool)\\n\\n # Add toolbar button and menu item\\n self.toolbar = QToolBar(QApplication.translate(\\\"qgepplugin\\\", \\\"QGEP\\\"))\\n self.toolbar.addAction(self.profileAction)\\n self.toolbar.addAction(self.upstreamAction)\\n self.toolbar.addAction(self.downstreamAction)\\n self.toolbar.addAction(self.wizardAction)\\n self.toolbar.addAction(self.refreshNetworkTopologyAction)\\n self.toolbar.addAction(self.connectNetworkElementsAction)\\n\\n self.iface.addPluginToMenu(\\\"&QGEP\\\", self.profileAction)\\n self.iface.addPluginToMenu(\\\"&QGEP\\\", self.settingsAction)\\n self.iface.addPluginToMenu(\\\"&QGEP\\\", self.aboutAction)\\n\\n admin_mode = QSettings().value(\\\"/QGEP/AdminMode\\\", False)\\n # seems QGIS loads True as \\\"true\\\" on restart ?!\\n if admin_mode and admin_mode != \\\"false\\\":\\n self.toolbar.addAction(self.importAction)\\n self.toolbar.addAction(self.exportAction)\\n self.iface.addPluginToMenu(\\\"&QGEP\\\", self.datamodelInitToolAction)\\n\\n self.iface.addToolBar(self.toolbar)\\n\\n # Local array of buttons to enable / disable based on context\\n self.toolbarButtons.append(self.profileAction)\\n self.toolbarButtons.append(self.upstreamAction)\\n self.toolbarButtons.append(self.downstreamAction)\\n self.toolbarButtons.append(self.wizardAction)\\n self.toolbarButtons.append(self.refreshNetworkTopologyAction)\\n self.toolbarButtons.append(self.importAction)\\n self.toolbarButtons.append(self.exportAction)\\n\\n self.network_layer_notifier.layersAvailable.connect(self.onLayersAvailable)\\n self.network_layer_notifier.layersUnavailable.connect(self.onLayersUnavailable)\\n\\n # Init the object maintaining the network\\n self.network_analyzer = QgepGraphManager()\\n self.network_analyzer.message_emitted.connect(\\n self.iface.messageBar().pushMessage\\n )\\n # Create the map tool for profile selection\\n self.profile_tool = QgepProfileMapTool(\\n self.iface, self.profileAction, self.network_analyzer\\n )\\n self.profile_tool.profileChanged.connect(self.onProfileChanged)\\n\\n self.upstream_tree_tool = QgepTreeMapTool(\\n self.iface, self.upstreamAction, self.network_analyzer\\n )\\n self.upstream_tree_tool.setDirection(\\\"upstream\\\")\\n self.upstream_tree_tool.treeChanged.connect(self.onTreeChanged)\\n self.downstream_tree_tool = QgepTreeMapTool(\\n self.iface, self.downstreamAction, self.network_analyzer\\n )\\n self.downstream_tree_tool.setDirection(\\\"downstream\\\")\\n self.downstream_tree_tool.treeChanged.connect(self.onTreeChanged)\\n\\n self.maptool_connect_networkelements = QgepMapToolConnectNetworkElements(\\n self.iface, self.connectNetworkElementsAction\\n )\\n\\n self.wastewater_networkelement_layer_notifier.layersAvailableChanged.connect(\\n self.connectNetworkElementsAction.setEnabled\\n )\\n\\n self.processing_provider = QgepProcessingProvider()\\n QgsApplication.processingRegistry().addProvider(self.processing_provider)\\n\\n self.network_layer_notifier.layersAdded([])\",\n \"def __init__(self, contr: widgets.base_controller,\\n parent: widgets.base_widget,\\n idstr: str,\\n attrdct: dict,\\n jsel,\\n titletext: str,\\n helptext: str) -> None:\\n super().__init__(contr, parent, idstr, attrdct, jsel)\\n self.wcstatus: wcstatus.WCstatus = contr.wcstatus\\n self.addClass(\\\"w3-container\\\")\\n self.addClass('switchview-cls')\\n self.setAttribute('height', '80%')\\n self.setAttribute('width', '100%')\\n self.h1 = html.h1text(self, titletext)\\n help_attrdct = {'class': 'w3-container'}\\n self.helptext = html.spanhelptext(self, \\\"addhelptext\\\", help_attrdct, helptext)\",\n \"def test_ui_class_instantiates_ui_object(self):\\n self.assertEqual(type(self.ui), UI, \\\"Does not create a ui object\\\")\",\n \"def set_controls(self):\\n # Image control\\n image = pyxbmct.Image(addonfolder+artsfolder+'/wplay.png')\\n self.placeControl(image, 0, 0, rowspan=10, columnspan=16)\\n\\n # LNB1\\n self.wplnb1_button = pyxbmct.RadioButton('')\\n self.placeControl(self.wplnb1_button, 11, 1, rowspan=1, columnspan=4)\\n self.connect(self.wplnb1_button, self.wplnb1_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'wplnb1', 2) == 1:\\n self.wplnb1_button.setSelected(True)\\n else:\\n self.wplnb1_button.setSelected(False)\\n lnb1 = pyxbmct.Image(addonfolder+artsfolder+'/lnb1.png')\\n self.placeControl(lnb1, 11, 1, rowspan=1, columnspan=4)\\n\\n # LNB2\\n self.wplnb2_button = pyxbmct.RadioButton('')\\n self.placeControl(self.wplnb2_button, 11, 6, rowspan=1, columnspan=4)\\n self.connect(self.wplnb2_button, self.wplnb2_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'wplnb2', 2) == 1:\\n self.wplnb2_button.setSelected(True)\\n else:\\n self.wplnb2_button.setSelected(False)\\n lnb2 = pyxbmct.Image(addonfolder+artsfolder+'/lnb2.png')\\n self.placeControl(lnb2, 11, 6, rowspan=1, columnspan=4)\\n\\n # LNB1/LNB2\\n self.wplnboth_button = pyxbmct.RadioButton('')\\n self.placeControl(self.wplnboth_button, 11, 11, rowspan=1, columnspan=4)\\n self.connect(self.wplnboth_button, self.wplnboth_button_update)\\n if tools.return_data('TVHWIZARD', 'STRING', 'wplnboth', 2) == 1:\\n self.wplnboth_button.setSelected(True)\\n else:\\n self.wplnboth_button.setSelected(False)\\n both = pyxbmct.Image(addonfolder+artsfolder+'/both.png')\\n self.placeControl(both, 11, 11, rowspan=1, columnspan=4)\\n\\n # Close button\\n self.close_button = pyxbmct.Button('Exit')\\n self.placeControl(self.close_button, 13, 15, rowspan=1, columnspan=1)\\n self.connect(self.close_button, lambda: self.closepage())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62471116","0.59212595","0.58168197","0.5744645","0.57158315","0.57158315","0.5714117","0.571169","0.56999123","0.56376207","0.56022507","0.5516006","0.5484253","0.5476682","0.5469117","0.5456683","0.54334265","0.5423621","0.54227364","0.5418681","0.53914136","0.5382743","0.5380339","0.5363317","0.53433526","0.5321037","0.5314748","0.5309149","0.5301783","0.5301222","0.5274095","0.5266845","0.5265388","0.5265145","0.5260832","0.5230825","0.52302986","0.5225566","0.52162164","0.521294","0.5197892","0.5194743","0.51884174","0.51778287","0.51756","0.51733094","0.51638937","0.51605934","0.51558936","0.5152728","0.51491535","0.513711","0.5134537","0.5128903","0.51266575","0.5121226","0.5116154","0.5113925","0.51092803","0.50991875","0.5092142","0.5088355","0.5081483","0.50781846","0.50701505","0.5067499","0.50592023","0.50523645","0.5048857","0.50464755","0.50446683","0.503851","0.5038431","0.5034071","0.50334406","0.50301147","0.5028433","0.5027175","0.5026937","0.5022559","0.5014748","0.50113726","0.50109315","0.50094837","0.50090986","0.500734","0.5005593","0.50047773","0.4996714","0.4993258","0.49918607","0.49911264","0.49875236","0.4984275","0.4976307","0.49746984","0.4973966","0.49737114","0.49724427","0.49706346"],"string":"[\n \"0.62471116\",\n \"0.59212595\",\n \"0.58168197\",\n \"0.5744645\",\n \"0.57158315\",\n \"0.57158315\",\n \"0.5714117\",\n \"0.571169\",\n \"0.56999123\",\n \"0.56376207\",\n \"0.56022507\",\n \"0.5516006\",\n \"0.5484253\",\n \"0.5476682\",\n \"0.5469117\",\n \"0.5456683\",\n \"0.54334265\",\n \"0.5423621\",\n \"0.54227364\",\n \"0.5418681\",\n \"0.53914136\",\n \"0.5382743\",\n \"0.5380339\",\n \"0.5363317\",\n \"0.53433526\",\n \"0.5321037\",\n \"0.5314748\",\n \"0.5309149\",\n \"0.5301783\",\n \"0.5301222\",\n \"0.5274095\",\n \"0.5266845\",\n \"0.5265388\",\n \"0.5265145\",\n \"0.5260832\",\n \"0.5230825\",\n \"0.52302986\",\n \"0.5225566\",\n \"0.52162164\",\n \"0.521294\",\n \"0.5197892\",\n \"0.5194743\",\n \"0.51884174\",\n \"0.51778287\",\n \"0.51756\",\n \"0.51733094\",\n \"0.51638937\",\n \"0.51605934\",\n \"0.51558936\",\n \"0.5152728\",\n \"0.51491535\",\n \"0.513711\",\n \"0.5134537\",\n \"0.5128903\",\n \"0.51266575\",\n \"0.5121226\",\n \"0.5116154\",\n \"0.5113925\",\n \"0.51092803\",\n \"0.50991875\",\n \"0.5092142\",\n \"0.5088355\",\n \"0.5081483\",\n \"0.50781846\",\n \"0.50701505\",\n \"0.5067499\",\n \"0.50592023\",\n \"0.50523645\",\n \"0.5048857\",\n \"0.50464755\",\n \"0.50446683\",\n \"0.503851\",\n \"0.5038431\",\n \"0.5034071\",\n \"0.50334406\",\n \"0.50301147\",\n \"0.5028433\",\n \"0.5027175\",\n \"0.5026937\",\n \"0.5022559\",\n \"0.5014748\",\n \"0.50113726\",\n \"0.50109315\",\n \"0.50094837\",\n \"0.50090986\",\n \"0.500734\",\n \"0.5005593\",\n \"0.50047773\",\n \"0.4996714\",\n \"0.4993258\",\n \"0.49918607\",\n \"0.49911264\",\n \"0.49875236\",\n \"0.4984275\",\n \"0.4976307\",\n \"0.49746984\",\n \"0.4973966\",\n \"0.49737114\",\n \"0.49724427\",\n \"0.49706346\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5426657"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":13291,"cells":{"query":{"kind":"string","value":"This function handles the showing and hiding of UIs when the program is being run."},"document":{"kind":"string","value":"def next_pressed(self):\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Next pressed.\"\n\n #Check stage.\n if self.stage==0:\n self.ShowAllInstruments.retrieve_selected()\n self.XMLWriter.instruments = self.ShowAllInstruments.retrieve_selected()\n if len(self.XMLWriter.instruments)!=0:\n self.LinkInstruments.setInstruments(self.XMLWriter.instruments)\n #Show and hide appropriate widgets\n self.LinkInstruments.show()\n self.ShowAllInstruments.hide()\n #self.resize()\n else:\n print \"No items in the list.\"\n self.stage = self.stage + 1\n else:\n if self.stage==1:\n #Retrieve Instruments\n self.XMLWriter.links, self.XMLWriter.control, proceed = self.LinkInstruments.getLinksandControl()\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Proceed = \" + str(proceed)\n if proceed == 0:\n self.LinkInstruments.hide()\n self.SetFundamentalParameters.show()\n #self.resize()\n for i in self.XMLWriter.links:\n i.print_links()\n self.stage = self.stage + 1\n else:\n msg_box = QMessageBox()\n msg_box.setText(\"Please Enter a Control Value for all Variables.\")\n msg_box.exec_()\n else:\n if self.stage==2:\n #Hide widgets\n self.XMLWriter.fundamentals = self.SetFundamentalParameters.getState()\n self.XMLWriter.fundamentals.printFundamentals()\n \n self.stage = self.stage + 1\n #Open up file dialog\n path, _ = QFileDialog.getSaveFileName(self, \"Save\", '', \"*.xml\")\n if path != \"\":\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print \"Write XML.\"\n print path\n self.XMLWriter.path = path\n self.XMLWriter.writeElementTree()\n self.XMLWriter.writeElementTreeToFile()\n \n self.currentExperiment.create_experiment_from_elementtree(self.XMLWriter.tree)\n self.currentExperiment.make_gui()\n self.currentExperiment.tree = self.XMLWriter.tree\n\n if AMOEBA_CREATE_EXPERIMENT_DEBUG:\n print ET.tostring(self.XMLWriter.tree, encoding='utf8', method='xml')\n\n self.subWindow.hide()\n self.stage = 0"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def hide_gui():\n pass","def show_gui():\n pass","def isUIused():\n return False","def showDisplay(self, type=\"DEFAULT\"):\n gd = mamba.getDisplayer() # <- trick to ensure the root windows is created and hidden\n if type==\"DEFAULT\":\n # First if there is any display already opened it is showed\n no_display = True\n if self._displayUsr:\n self._displayUsr.show()\n no_display = False\n if self._displayVtk:\n self._displayVtk.show()\n no_display = False\n if self._displayPjt:\n self._displayPjt.show()\n no_display = False\n \n if no_display:\n # If no display is yet open we create one\n # preferentially using user defines display\n # or if not VTK\n if self._displayerUsr:\n self._displayUsr = self._displayerUsr(self.name)\n if self._displayUsr:\n self._displayUsr.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\n self._displayUsr.updateim()\n else:\n self._displayVtk = self._displayerVtk(self.name)\n if self._displayVtk:\n self._displayVtk.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\n self._displayVtk.updateim()\n \n elif type==\"USER\":\n if self._displayerUsr:\n if self._displayUsr:\n self._displayUsr.show()\n else:\n self._displayUsr = self._displayerUsr(self.name)\n if self._displayUsr:\n self._displayUsr.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\n self._displayUsr.updateim()\n \n elif type==\"PROJECTION\":\n if self._displayerPjt:\n if self._displayPjt:\n self._displayPjt.show()\n else:\n self._displayPjt = self._displayerPjt(self.name)\n if self._displayPjt:\n self._displayPjt.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\n self._displayPjt.updateim()\n \n elif type==\"VTK\":\n if self._displayerVtk:\n if self._displayVtk:\n self._displayVtk.show()\n else:\n self._displayVtk = self._displayerVtk(self.name)\n if self._displayVtk:\n self._displayVtk.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\n self._displayVtk.updateim()","def show():\n from siding.addons import ui\n ui.show()","def main(self): \n self.window.hide_all()\n self.window.isHide = True\n \n gtk.main()","def togglePulseUI():\n if isPulseUIShowing():\n hidePulseUI()\n else:\n showPulseUI()","def hide(self):\n self.root.iconify() # self.root.withdraw()","def toggle(self):\n if self.is_visible():\n self.hide()\n self._app[\"main_window\"].grab_focus()\n self._app[\"statusbar\"].update_info()\n elif self._app.get_paths() and \\\n self._app.get_focused_widget() not in [\"lib\", \"thu\"]:\n if os.path.islink(self._app.get_path()):\n self._app[\"statusbar\"].message(\n \"Manipulating symbolic links is not supported\", \"warning\")\n elif not edit_supported(self._app.get_path()):\n self._app[\"statusbar\"].message(\n \"This filetype is not supported\", \"warning\")\n else:\n self.show()\n self._pixbuf = self._app[\"image\"].get_pixbuf_original()\n self.sliders[\"bri\"].grab_focus()\n self._app[\"statusbar\"].update_info()\n else:\n if self._app[\"thumbnail\"].toggled:\n self._app[\"statusbar\"].message(\n \"Manipulate not supported in thumbnail mode\", \"warning\")\n elif self._app[\"library\"].is_focus():\n self._app[\"statusbar\"].message(\n \"Manipulate not supported in library\", \"warning\")\n else:\n self._app[\"statusbar\"].message(\"No image open to edit\",\n \"warning\")","def hideDisplay(self):\n if self._displayPjt:\n self._displayPjt.hide()\n if self._displayUsr:\n self._displayUsr.hide()\n if self._displayVtk:\n self._displayVtk.hide()","def inicialUI(self):\r\n\r\n self.setGeometry(500, 500, 500, 500)\r\n self.setWindownTitle(\"Pesquisa\")\r\n self.displayWidgets()\r\n\r\n self.show()","def DoShowHide(self):\r\n\r\n pages = self.GetPages()\r\n\r\n # show new active page first\r\n for page in pages:\r\n if page.active:\r\n page.window.Show(True)\r\n break\r\n \r\n # hide all other pages\r\n for page in pages:\r\n if not page.active:\r\n page.window.Show(False)","def set_visible(self):\n\t\tself.hide()\n\t\tself.__sys_tray_icon.setVisible(True)","def menu_screen(win):\n\tpass","def show(self, window):\r\n\r\n return","def SetAutoDetectUi(Ui):\n SPI.DeviceList[\"spi_rpi_ui\"]= Ui \n I2C.DeviceList[\"i2c_rpi_ui\"]= Ui","def showGUI(self,**kwargs):\n self.baxter.menu.select(self.modes[0])","def show():\n dialog = SkinIODialog(getMayaWindow())\n dialog.show()","def show(self):\n # This function has to be placed here (and not in the user.py script)\n self.showMaximized()\n visapp.run()","def volver_menu(self, widget, data = None):\n\t\tself.w4.hide()\n\t\tself.w41.hide()\n\t\tself.w5.hide()\n\t\tself.w51.hide()\n\t\tself.w6.hide()\n\t\tself.w7.hide()\n\t\tself.w71.hide()\n\t\tself.w8.hide()\n\t\tself.w81.hide()\n\n\t\tself.w3.show_all()","def close_UI(self):","def _onShow(self, event):\n# try:\n if len(self.frames) > 0:\n self.hidebutton.Show(True)\n else:\n self.hidebutton.Show(False)","def main():\n\tif mc.window( 'spiderWebCreatorUi_WIN', q = 1, ex = 1 ):\n\t\tmc.deleteUI( 'spiderWebCreatorUi_WIN' )\n\tPyForm=spiderWebCreatorUi()\n\tPyForm.show()","def show(self):\n # * displays the window, after using either the iconify or the withdraw methods\n self.wm_deiconify()\n # * this method can be called after the event which needs to happen before the window event\n self.wait_window()","def show_all(self):\n for UI_object in self.__UI_objects:\n UI_object.show()","def hide_main_buttons(self):\n pass","def main():\n\tif mc.window( 'SetupOccUI', q = 1, ex = 1 ):\n\t\tmc.deleteUI( 'SetupOccUI' )\n\tPyForm=SetupOccUI()\n\tPyForm.show()","def __call__(self):\n self.show()","def display_main(self):\n self.clear_terminal()\n self.main_menu()\n self.handle_selection_main()","def show(self):\n self.wid.show()","def start_ui(self):\n\t\tself.start_animation()\n\t\tself.app.exec()","def hide (self):\n \n self.top.withdraw()","def _hide_vol_bar(self):\n self.root.withdraw()","def configure_ui(self):\n self.setWindowIcon(self.MAIN_ICON)\n self.setWindowModality(Qt.ApplicationModal)","def launchUI():\n app = QtWidgets.QApplication(sys.argv)\n ui = ClientFileManager()\n ui.resize(1200, 650)\n ui.show()\n sys.exit(app.exec_())","def hide(self):\n self.root.withdraw()","def main():\r\n root = tk.Tk()\r\n root.config(bg='gray40')\r\n root.geometry('800x400')\r\n # OpenUser('Christof', lambda: print('Hallo'), 'german')\r\n inter = User_Interface(root, 'Christof')\r\n inter.UserInterface.place(x=10, y=10)\r\n\r\n root.mainloop()","def show_main_buttons(self):\n pass","def _ipython_display_(self):\n with self._sc:\n self._box._ipython_display_()","def window_info_toggle():\n window_info.hide() if window_info.showing else window_info.show()","def run(self):\n self.ui['main_window'].widgets['main'].show_all()\n gtk.main()","def XPShowWidget(inWidget):\n pass","def hide_ios(self) -> bool:\n return pulumi.get(self, \"hide_ios\")","def iniciaUI(self):\n\n self.setGeometry(100,100, 250, 250)\n self.setWindowTitle(\"Login\")\n self.displayWidgets()\n\n self.show()","def onShow(self):\n pass","def setupDeviceGui(self):\n\n dropDowns = list(self.drivers[driver]['uiDriver'] for driver in self.drivers)\n for dropDown in dropDowns:\n dropDown.clear()\n dropDown.setView(PyQt5.QtWidgets.QListView())\n dropDown.addItem('No device selected')\n\n # adding special items\n self.drivers['dome']['uiDriver'].addItem('INDI')\n self.drivers['imaging']['uiDriver'].addItem('INDI')\n self.drivers['sensorWeather']['uiDriver'].addItem('INDI')\n self.drivers['directWeather']['uiDriver'].addItem('Built-In')\n self.drivers['onlineWeather']['uiDriver'].addItem('Built-In')\n self.drivers['cover']['uiDriver'].addItem('INDI')\n self.drivers['skymeter']['uiDriver'].addItem('INDI')\n self.drivers['telescope']['uiDriver'].addItem('INDI')\n self.drivers['power']['uiDriver'].addItem('INDI')\n self.drivers['relay']['uiDriver'].addItem('Built-In')\n for app in self.app.astrometry.solverAvailable:\n self.drivers['astrometry']['uiDriver'].addItem(app)\n self.drivers['remote']['uiDriver'].addItem('Built-In')\n self.drivers['measure']['uiDriver'].addItem('Built-In')\n\n return True","def show(self):\n self.Show()","def make_gui(filename):\n\n from subprocess import check_call\n import os\n\n cmd = os.path.normpath('C:\\Anaconda\\Scripts\\pyside-uic')\n infile = filename + '.ui'\n outfile = filename + '.py'\n\n call_args = [cmd, infile, '-o', outfile]\n print call_args\n\n check_call(call_args)","def iniciaUI(self):\n\n self.setGeometry(100,100, 300, 200)\n self.setWindowTitle(\"Formulario\")\n self.displayWidgets()\n\n self.show()","def showInfoWindow():\n\treturn 0","def close_hud():\n if pm.headsUpDisplay('a1_hud', exists=True):\n for i in range(6):\n pm.headsUpDisplay('a{}_hud'.format(i + 1), remove=True)","def gui():\n\tglobal dialog\n\tif not dialog:\n\t\tdialog = helixhunter()\n\tdialog.enter()","def hide(self):\n\n self.stop_repl()\n self.visible = False\n self.withdraw() # Hide window","def hide_all(self):\n for UI_object in self.__UI_objects:\n UI_object.hide()","def _showMainWindow(self) -> None:\n if not self._main_dialog:\n self._main_dialog = self._createDialog(\"Thingiverse.qml\")\n self._main_dialog.show()\n self._service.updateSupportedFileTypes()\n self._service.search(\"ultimaker\")","def tear_down_ui():\n from .gen import icons_rc\n from .contextmenus import unregister_context_menu\n\n close_all_editors()\n unregister_context_menu()\n icons_rc.qCleanupResources()","def ocultar(self, widget, *args):\n self.show(False)\n self.ventana.hide_all()","def hide(self):\r\n if self.visible:\r\n nid = (self.hwnd, 0)\r\n Shell_NotifyIcon(NIM_DELETE, nid)\r\n self.visible = 0","def ShowMe(self, event):\n self.Show(True)","def activate_statusbar_icon_mode():\n pass","def hide_show_volume_scale(_=None):\n if volume_ctrl.winfo_viewable():\n volume_frame.place_forget()\n else:\n volume_frame.place(x=512,y=120)","def load_gui():\r\n\r\n print(\"\\nLoading graphical user interface...\\n\")\r\n SongStorageGUI().mainloop()","def show(self):\n QtGui.QGuiApplication.processEvents()","def fullscreen(self):\n self.port_edit.setVisible(False)\n self.ip_edit.setVisible(False)\n self.connect_btn.setVisible(False)\n self.setup_btn.setVisible(False)\n self.play_btn.setVisible(False)\n self.pause_btn.setVisible(False)\n self.teardown_btn.setVisible(False)\n self.fullscreen_btn.setVisible(False)\n self.video_slider.setVisible(False)\n self.rtp_port_edit.setVisible(False)\n self.rtp_label.setVisible(False)\n self.rtcp_port_edit.setVisible(False)\n self.rtcp_port_label.setVisible(False)\n self.movie_name_edit.setVisible(False)\n self.movie_name_label.setVisible(False)\n self.rate_select.setVisible(False)\n self.time_label.setVisible(False)\n self.low_level_video.setVisible(False)\n self.high_level_video.setVisible(False)\n self.video_list.setVisible(False)\n self.video_label.setGeometry(0, 0, self.screen_width, self.screen_height)\n self.showFullScreen()","def should_show():","def hide(self):\r\n\t\tself.frame.Show(False)","def prepare_UI(self):","def show_window(icon, item):\n icon.stop()\n app.after(0, app.deiconify())","def abrir_inicio_rutina(self, widget, data=None):\n\t\tself.w3.hide()\n\t\tself.w6.show_all()","def show(self):\r\n\t\tself.frame.Show(True)","def main():\n uilist = {\n 'joyride':(\"Uses a joystick for steering and outputs console text\", joyride),\n 'curses':(\"A simple curses-based output UI with very basic arrow-key steering\", cursesui),\n 'framebuffer':(\"An output intenteded for the on-board computer, with no steering\", framebuffer),\n }\n\n parser = OptionParser()\n\n uigroup = OptionGroup(parser, \"UI options\")\n uigroup.add_option('-u', '--ui', action=\"store\", type=\"choice\", dest=\"ui\", default=\"joyride\", choices=uilist.keys(),\n help=\"Interact with this type of UI [Default: joyride]\")\n uigroup.add_option('-j', '--joystick', action=\"store\", type=\"string\", dest=\"joystick_device\", default=None,\n help=\"Path to the device file of the joystick (for joyride UI) [Default: None]\")\n uigroup.add_option('-s', '--disable-sound', action=\"store_false\", dest=\"sound\", default=True,\n help=\"Disable sound [Default: False]\")\n uigroup.add_option('-i', '--disable-input', action=\"store_false\", dest=\"allow_input\", default=True,\n help=\"Disable input [Default: False]\")\n uigroup.add_option('-c', '--become-controller', action=\"store_true\", dest=\"become_controller\", default=False,\n help=\"Become exclusive controlling connection [Default: False]\")\n uigroup.add_option('-n', '--no-control', action=\"store_false\", dest=\"allow_control\", default=True,\n help=\"Ignore all UI commands from this client [Default: False]\")\n uigroup.add_option(\"--list\", action=\"store_true\", dest=\"list\", default=False,\n help=\"List the available UIs and exit\")\n parser.add_option_group(uigroup)\n\n netgroup = OptionGroup(parser, \"Network options\")\n netgroup.add_option('-a', '--host', action=\"store\", type=\"string\", dest=\"host\", default=\"localhost\",\n help=\"Host/address to connect to [Default: localhost]\")\n netgroup.add_option('-p', '--port', action=\"store\", type=\"int\", dest=\"port\", default=9999,\n help=\"Port the server is listening on [Default: 9999]\")\n parser.add_option_group(netgroup)\n\n options, args = parser.parse_args()\n\n list_and_exit = False\n if options.list:\n list_and_exit = True\n\n if not options.ui or options.ui not in uilist:\n print \"You must pick one of the available UIs with --ui\"\n\n if list_and_exit:\n print \"Available UIs:\"\n for name, info in uilist.items():\n print \"%s %s\" % (name.ljust(30), info[0])\n return 0\n\n # create the robot\n robot = Robot(options.host, options.port)\n status = robot.get_status()\n\n # handle gracefully disconnecting the robot if anything else fails\n try:\n # create the ui\n uimod = uilist[options.ui][1]\n ui = uimod.get_ui(**vars(options))\n\n # create the steerer\n steerer = steering.SteeringModel(status)\n\n if options.sound:\n player = sound.SoundPlayer(status)\n player.play(player.SOUNDS['startup'])\n else:\n player = None\n\n # create the robot client\n client = RobotClient(robot, ui, steerer, player, options.allow_control, options.become_controller)\n\n # start up all the pieces in the right order\n if player: player.start()\n try:\n ui.init()\n ui.start()\n try:\n client.run()\n finally:\n ui.stop()\n finally:\n if player:\n player.stop(player.SOUNDS['crash'])\n finally:\n if not robot.disconnected:\n robot.disconnect()","def on_device_dialog_cancel_clicked(self,widget=None):\n self.widgets['main'].hide()","def init_ui(self):\n self.parent.title(\"Roku Player Controller\")\n self.style.theme_use(\"default\")","def show_menus(self, type_):\n if type_ == self._current:\n # do nothing\n pass\n else:\n if self._current == self.TYPE_VOIGT:\n # Plot menus are visible; hide them.\n plot_menu_labels = [menu.label for menu in self._plot_menus]\n\n for menu in self.top_level_menus:\n if menu.label in plot_menu_labels:\n self.Remove(self.FindMenu(menu.label))\n elif self._current == self.TYPE_GISO:\n # Plot menus are visible; hide them.\n plot_menu_labels = [menu.label for menu in self._plot_menus]\n\n for menu in self.top_level_menus:\n if menu.label in plot_menu_labels:\n self.Remove(self.FindMenu(menu.label))\n\n # Rebuild the view menu by deleting everything from it and then \n # reappending the appropriate items.\n while self.view_menu.GetMenuItemCount():\n #self.view_menu.DeleteItem(self.view_menu.FindItemByPosition(0))\n self.view_menu.Delete(self.view_menu.FindItemByPosition(0))\n\n _append_items(self._main, self.view_menu, self._menu_data[type_])\n\n if type_ == self.TYPE_VOIGT:\n # add plot menus\n for menu in self._plot_menus[::-1]:\n self.Insert(_PLOT_MENU_INSERT_INDEX, menu, menu.label)\n # Under wxPython 2.9, the menus I add with this call to \n # Insert() don't have their label set. I think it's a bug,\n # but I can't recreate it outside of this app. Manually\n # setting the label here is a workaround.\n self.SetMenuLabel(_PLOT_MENU_INSERT_INDEX, menu.label)\n elif type_ == self.TYPE_GISO:\n # add plot menus\n for menu in self._plot_menus[::-1]:\n self.Insert(_PLOT_MENU_INSERT_INDEX, menu, menu.label)\n # Under wxPython 2.9, the menus I add with this call to \n # Insert() don't have their label set. I think it's a bug,\n # but I can't recreate it outside of this app. Manually\n # setting the label here is a workaround.\n self.SetMenuLabel(_PLOT_MENU_INSERT_INDEX, menu.label)\n\n\n self._current = type_","def show(self, caller_is_main: bool):\n pass","def minimap_show_hide(self):\n if self.minimap_flag == 0:\n self.code_minimap_frame.pack_forget()\n self.working_area.pack_forget()\n self.line_num_frame.pack(fill='y', side='left')\n self.working_area.pack(fill='both', side='left', expand=True)\n self.code_minimap_frame.pack(fill='both', side='left', pady=(22, 0))\n self.minimap_flag = 1\n self.View.entryconfigure(1, label=' Hide Code Minimap ', command=self.minimap_show_hide)\n else:\n self.code_minimap_frame.pack_forget()\n self.minimap_flag = 0\n self.View.entryconfigure(1, label='Show Minimap')","def open_gui():\n guiController.main()","def showUI(cls):\r\n win = cls(uiFile)\r\n win.create()\r\n return win","def _load_ui(self):\n load_ui(\"about_dlg.ui\", self)\n\n self.title_label = self.findChild(QLabel, \"title_label\")\n self.title_label.setText(f\"Friendly Pics 2 v{__version__}\")\n\n self.runtime_env_label = self.findChild(QLabel, \"runtime_env_label\")\n if is_mac_app_bundle():\n self.runtime_env_label.setText(\"Running as MacOS app bundle\")\n elif is_pyinstaller_bundle():\n self.runtime_env_label.setText(\"Running as a pyinstaller binary\")\n else:\n self.runtime_env_label.setText(\"Running under conventional Python environment\")\n\n self.gui_settings_label = self.findChild(QLabel, \"gui_settings_label\")\n self.gui_settings_label.setText(f\"<b>GUI Settings:</b> {self._settings.fileName()}\")\n\n self.gui_settings_clear_button = self.findChild(QPushButton, \"gui_settings_clear_button\")\n self.gui_settings_clear_button.clicked.connect(self._clear_gui_settings)\n\n self.app_settings_label = self.findChild(QLabel, \"app_settings_label\")\n self.app_settings_label.setText(f\"<b>App Settings:</b> {self._app_settings.path}\")\n\n # Center the about box on the parent window\n parent_geom = self.parent().geometry()\n self.move(parent_geom.center() - self.rect().center())","def OnFrameShow(self):\r\n\r\n\t\t# Update local copy of config\r\n\t\tself._configtmp.update(self._config)\r\n\r\n\t\t# Fix notebook background color when switching themes in XP\r\n\t\tself.notebookApp.SetBackgroundColour(\\\r\n\t\t\tself.notebookApp.GetThemeBackgroundColour())\r\n\r\n\t\t# Set flag\r\n\t\tself.toggleButtonRateFlag.SetValue(self._configtmp[\"flagimage\"])\r\n\r\n\t\t# Set ratings\r\n\t\tself._iconstars = [icons.getGrayStarBitmap(),\r\n\t\t\ticons.getYellowStarBitmap(),\r\n\t\t\ticons.getGrayOrangeStarBitmap(),\r\n\t\t\ticons.getYellowOrangeStarBitmap()]\r\n\t\tself.SetStars()\r\n\r\n\t\t# Set image info\r\n\t\tself.textCtrlImageInfo.Clear()\r\n\t\tself.textCtrlImageInfo.WriteText(self._configtmp[\"imageinfo\"])\r\n\r\n\t\t# If login still valid, change text on Sign In page\r\n\t\tif (self._configtmp[\"userhash\"] != \"00000000000000000000000000000000\"):\r\n\t\t\tself.staticTextSignedIn.SetLabel(\" You are signed in.\")\r\n\t\telse:\r\n\t\t\tself.staticTextSignedIn.SetLabel(\"You are not signed in.\")\r\n\t\tusername = self._configtmp[\"username\"]\r\n\t\tself.textCtrlLogin.Clear()\r\n\t\tself.textCtrlLogin.WriteText(username)\r\n\r\n\t\t# Set options\r\n\t\t_ratelist = [1, 2, 3, 4, 5]\r\n\t\tself.choiceOptionRatedAtLeast.SetSelection(\r\n\t\t\t_ratelist.index(self._configtmp[\"ratedatleast\"]))\r\n\t\t_percentlist = [5, 10, 20, 50, 75, 100]\r\n\t\tself.choiceOptionPercentUnrated.SetSelection(\r\n\t\t\t_percentlist.index(self._configtmp[\"percentnew\"]))\r\n\t\t_changeeverylist = [900, 1800, 3600, 7200, 14400, 28800, 86400,\r\n\t\t\t172800, 345600, 604800]\r\n\t\tself.choiceOptionChangeEvery.SetSelection(\r\n\t\t\t_changeeverylist.index(self._configtmp[\"changeevery\"]))\r\n\r\n\t\t# Update complete, show frame\r\n\t\tself.Show()\r\n\t\tself.Raise()","def show(self,window):\n self.showFunctions(window)","def hide(self):\n self._dev.hide()","def activate_statusbar_icon_close():\n pass","def on_first_registration(self):\n self.main.tabify_plugins(self.main.help, self)\n self.dockwidget.hide()","def toggle_display_mode(self):\n if self.main_window.windowState() == Qt.WindowFullScreen:\n self.main_window.showNormal()\n else:\n self.main_window.showFullScreen()\n # Keep the settings window active to prevent main window from\n # burying it\n self.settings_window.activateWindow()","def show_window(self):\n self.show()","def load_main_gui(self, gui_handle):\n elementsToModify = [\"butZoomIn\", \"butZoomOut\", \"butGoToLoc\",\n \"butChrUp\", \"butChrDown\"]\n\n for element in elementsToModify:\n xrc.XRCCTRL(gui_handle, element).SetLabel(self.__data[element])\n\n return(True)\n\n # the menus are a little different:\n elementsToModify = [\"file\", \"about\", \"help\"]\n\n menu_head = gui_handle.GetMenuBar()\n\n for element in elementsToModify:\n item = menu_head.FindItem(element)\n print item\n if item:\n menu_item = menu_head.GetMenu(item)\n menu_item.SetLabel(element)","def setupPopUp(self):\n\n for driver in self.drivers:\n if self.sender() != self.drivers[driver]['uiSetup']:\n continue\n\n # calculate geometry\n geometry = self.pos().x(), self.pos().y(), self.height(), self.width()\n # get all available frameworks\n framework = self.drivers[driver]['class'].run.keys()\n # selecting the device type\n deviceType = self.drivers[driver]['deviceType']\n\n self.popupUi = DevicePopup(geometry=geometry,\n driver=driver,\n deviceType=deviceType,\n framework=framework,\n data=self.driversData)\n # memorizing the driver we have to update\n self.popupUi.exec_()\n if self.popupUi.returnValues.get('close', 'cancel') == 'cancel':\n # when cancel nothing happens\n return False\n else:\n # when ok, we have to further work\n break\n\n # check if copy are made. if so, than restart all drivers related\n if self.popupUi.returnValues.get('copyIndi', False):\n for driver in self.drivers:\n if not self.drivers[driver]['class'].framework == 'indi':\n continue\n self.dispatch(driverName=driver)\n elif self.popupUi.returnValues.get('copyAlpaca', False):\n for driver in self.drivers:\n if not self.drivers[driver]['class'].framework == 'alpaca':\n continue\n self.dispatch(driverName=driver)\n else:\n # if we choose a driver and it's available, we select it from drop down\n if self.popupUi.returnValues.get('framework', '') == 'indi':\n index = self.findIndexValue(self.drivers[driver]['uiDropDown'], 'indi')\n self.drivers[driver]['uiDropDown'].setCurrentIndex(index)\n self.dispatch(driverName=driver)\n\n return True","def iconify(self):\n if self.active:\n self.master.withdraw()\n self.active = False","def show_menu(self):\n curses.curs_set(0)\n self.main_menu.display()","def do_hf_unhide(self, arg):\n self.show_hidden_frames = True\n self.refresh_stack()","def toggle(self):\n if not self.hidden and not self.vimiv.commandline.entry.is_visible():\n self.bar.hide()\n else:\n self.bar.show()\n self.hidden = not self.hidden\n # Resize the image if necessary\n if not self.vimiv.image.user_zoomed and self.vimiv.paths and \\\n not self.vimiv.thumbnail.toggled:\n self.vimiv.image.zoom_to(0)","def init_ui(self):\n raise NotImplementedError","def init_ui(self):\n raise NotImplementedError","def showMainWindowGUI(script=None, inputEvent=None):\n\n try:\n module = __import__(settings.mainWindowModule,\n globals(),\n locals(),\n [''])\n if settings.showMainWindow:\n module.showMainUI()\n else:\n module.hideMainUI()\n except:\n debug.printException(debug.LEVEL_SEVERE)\n\n return True","def setupDeviceGui(self):\n\n # all dropdown have disabled as capability\n dropDowns = list(self.drivers[driver]['uiDropDown'] for driver in self.drivers)\n for dropDown in dropDowns:\n dropDown.clear()\n dropDown.setView(PyQt5.QtWidgets.QListView())\n dropDown.addItem('device disabled')\n\n # adding driver items with applicable framework\n for driver in self.drivers:\n if not hasattr(self.drivers[driver]['class'], 'run'):\n continue\n for framework in self.drivers[driver]['class'].run.keys():\n self.drivers[driver]['uiDropDown'].addItem(framework)\n\n return True","def on_hide_view(self):\n self.ui_manager.unregister_handlers()","def on_hide_view(self):\n self.ui_manager.unregister_handlers()","def on_hide_view(self):\n self.ui_manager.unregister_handlers()","def early_interact():\n\n global fullscreen\n global current_movie\n\n fullscreen = True\n current_movie = None","def abrir_menu_principal(self, widget, data=None):\t\n\t\t#print(\"Bandera1\")\n\t\tself.w2.hide()\n\t\tself.w3.show_all()"],"string":"[\n \"def hide_gui():\\n pass\",\n \"def show_gui():\\n pass\",\n \"def isUIused():\\n return False\",\n \"def showDisplay(self, type=\\\"DEFAULT\\\"):\\n gd = mamba.getDisplayer() # <- trick to ensure the root windows is created and hidden\\n if type==\\\"DEFAULT\\\":\\n # First if there is any display already opened it is showed\\n no_display = True\\n if self._displayUsr:\\n self._displayUsr.show()\\n no_display = False\\n if self._displayVtk:\\n self._displayVtk.show()\\n no_display = False\\n if self._displayPjt:\\n self._displayPjt.show()\\n no_display = False\\n \\n if no_display:\\n # If no display is yet open we create one\\n # preferentially using user defines display\\n # or if not VTK\\n if self._displayerUsr:\\n self._displayUsr = self._displayerUsr(self.name)\\n if self._displayUsr:\\n self._displayUsr.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\\n self._displayUsr.updateim()\\n else:\\n self._displayVtk = self._displayerVtk(self.name)\\n if self._displayVtk:\\n self._displayVtk.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\\n self._displayVtk.updateim()\\n \\n elif type==\\\"USER\\\":\\n if self._displayerUsr:\\n if self._displayUsr:\\n self._displayUsr.show()\\n else:\\n self._displayUsr = self._displayerUsr(self.name)\\n if self._displayUsr:\\n self._displayUsr.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\\n self._displayUsr.updateim()\\n \\n elif type==\\\"PROJECTION\\\":\\n if self._displayerPjt:\\n if self._displayPjt:\\n self._displayPjt.show()\\n else:\\n self._displayPjt = self._displayerPjt(self.name)\\n if self._displayPjt:\\n self._displayPjt.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\\n self._displayPjt.updateim()\\n \\n elif type==\\\"VTK\\\":\\n if self._displayerVtk:\\n if self._displayVtk:\\n self._displayVtk.show()\\n else:\\n self._displayVtk = self._displayerVtk(self.name)\\n if self._displayVtk:\\n self._displayVtk.connect(list(map(lambda im: im.mbIm, self.seq)), self.name)\\n self._displayVtk.updateim()\",\n \"def show():\\n from siding.addons import ui\\n ui.show()\",\n \"def main(self): \\n self.window.hide_all()\\n self.window.isHide = True\\n \\n gtk.main()\",\n \"def togglePulseUI():\\n if isPulseUIShowing():\\n hidePulseUI()\\n else:\\n showPulseUI()\",\n \"def hide(self):\\n self.root.iconify() # self.root.withdraw()\",\n \"def toggle(self):\\n if self.is_visible():\\n self.hide()\\n self._app[\\\"main_window\\\"].grab_focus()\\n self._app[\\\"statusbar\\\"].update_info()\\n elif self._app.get_paths() and \\\\\\n self._app.get_focused_widget() not in [\\\"lib\\\", \\\"thu\\\"]:\\n if os.path.islink(self._app.get_path()):\\n self._app[\\\"statusbar\\\"].message(\\n \\\"Manipulating symbolic links is not supported\\\", \\\"warning\\\")\\n elif not edit_supported(self._app.get_path()):\\n self._app[\\\"statusbar\\\"].message(\\n \\\"This filetype is not supported\\\", \\\"warning\\\")\\n else:\\n self.show()\\n self._pixbuf = self._app[\\\"image\\\"].get_pixbuf_original()\\n self.sliders[\\\"bri\\\"].grab_focus()\\n self._app[\\\"statusbar\\\"].update_info()\\n else:\\n if self._app[\\\"thumbnail\\\"].toggled:\\n self._app[\\\"statusbar\\\"].message(\\n \\\"Manipulate not supported in thumbnail mode\\\", \\\"warning\\\")\\n elif self._app[\\\"library\\\"].is_focus():\\n self._app[\\\"statusbar\\\"].message(\\n \\\"Manipulate not supported in library\\\", \\\"warning\\\")\\n else:\\n self._app[\\\"statusbar\\\"].message(\\\"No image open to edit\\\",\\n \\\"warning\\\")\",\n \"def hideDisplay(self):\\n if self._displayPjt:\\n self._displayPjt.hide()\\n if self._displayUsr:\\n self._displayUsr.hide()\\n if self._displayVtk:\\n self._displayVtk.hide()\",\n \"def inicialUI(self):\\r\\n\\r\\n self.setGeometry(500, 500, 500, 500)\\r\\n self.setWindownTitle(\\\"Pesquisa\\\")\\r\\n self.displayWidgets()\\r\\n\\r\\n self.show()\",\n \"def DoShowHide(self):\\r\\n\\r\\n pages = self.GetPages()\\r\\n\\r\\n # show new active page first\\r\\n for page in pages:\\r\\n if page.active:\\r\\n page.window.Show(True)\\r\\n break\\r\\n \\r\\n # hide all other pages\\r\\n for page in pages:\\r\\n if not page.active:\\r\\n page.window.Show(False)\",\n \"def set_visible(self):\\n\\t\\tself.hide()\\n\\t\\tself.__sys_tray_icon.setVisible(True)\",\n \"def menu_screen(win):\\n\\tpass\",\n \"def show(self, window):\\r\\n\\r\\n return\",\n \"def SetAutoDetectUi(Ui):\\n SPI.DeviceList[\\\"spi_rpi_ui\\\"]= Ui \\n I2C.DeviceList[\\\"i2c_rpi_ui\\\"]= Ui\",\n \"def showGUI(self,**kwargs):\\n self.baxter.menu.select(self.modes[0])\",\n \"def show():\\n dialog = SkinIODialog(getMayaWindow())\\n dialog.show()\",\n \"def show(self):\\n # This function has to be placed here (and not in the user.py script)\\n self.showMaximized()\\n visapp.run()\",\n \"def volver_menu(self, widget, data = None):\\n\\t\\tself.w4.hide()\\n\\t\\tself.w41.hide()\\n\\t\\tself.w5.hide()\\n\\t\\tself.w51.hide()\\n\\t\\tself.w6.hide()\\n\\t\\tself.w7.hide()\\n\\t\\tself.w71.hide()\\n\\t\\tself.w8.hide()\\n\\t\\tself.w81.hide()\\n\\n\\t\\tself.w3.show_all()\",\n \"def close_UI(self):\",\n \"def _onShow(self, event):\\n# try:\\n if len(self.frames) > 0:\\n self.hidebutton.Show(True)\\n else:\\n self.hidebutton.Show(False)\",\n \"def main():\\n\\tif mc.window( 'spiderWebCreatorUi_WIN', q = 1, ex = 1 ):\\n\\t\\tmc.deleteUI( 'spiderWebCreatorUi_WIN' )\\n\\tPyForm=spiderWebCreatorUi()\\n\\tPyForm.show()\",\n \"def show(self):\\n # * displays the window, after using either the iconify or the withdraw methods\\n self.wm_deiconify()\\n # * this method can be called after the event which needs to happen before the window event\\n self.wait_window()\",\n \"def show_all(self):\\n for UI_object in self.__UI_objects:\\n UI_object.show()\",\n \"def hide_main_buttons(self):\\n pass\",\n \"def main():\\n\\tif mc.window( 'SetupOccUI', q = 1, ex = 1 ):\\n\\t\\tmc.deleteUI( 'SetupOccUI' )\\n\\tPyForm=SetupOccUI()\\n\\tPyForm.show()\",\n \"def __call__(self):\\n self.show()\",\n \"def display_main(self):\\n self.clear_terminal()\\n self.main_menu()\\n self.handle_selection_main()\",\n \"def show(self):\\n self.wid.show()\",\n \"def start_ui(self):\\n\\t\\tself.start_animation()\\n\\t\\tself.app.exec()\",\n \"def hide (self):\\n \\n self.top.withdraw()\",\n \"def _hide_vol_bar(self):\\n self.root.withdraw()\",\n \"def configure_ui(self):\\n self.setWindowIcon(self.MAIN_ICON)\\n self.setWindowModality(Qt.ApplicationModal)\",\n \"def launchUI():\\n app = QtWidgets.QApplication(sys.argv)\\n ui = ClientFileManager()\\n ui.resize(1200, 650)\\n ui.show()\\n sys.exit(app.exec_())\",\n \"def hide(self):\\n self.root.withdraw()\",\n \"def main():\\r\\n root = tk.Tk()\\r\\n root.config(bg='gray40')\\r\\n root.geometry('800x400')\\r\\n # OpenUser('Christof', lambda: print('Hallo'), 'german')\\r\\n inter = User_Interface(root, 'Christof')\\r\\n inter.UserInterface.place(x=10, y=10)\\r\\n\\r\\n root.mainloop()\",\n \"def show_main_buttons(self):\\n pass\",\n \"def _ipython_display_(self):\\n with self._sc:\\n self._box._ipython_display_()\",\n \"def window_info_toggle():\\n window_info.hide() if window_info.showing else window_info.show()\",\n \"def run(self):\\n self.ui['main_window'].widgets['main'].show_all()\\n gtk.main()\",\n \"def XPShowWidget(inWidget):\\n pass\",\n \"def hide_ios(self) -> bool:\\n return pulumi.get(self, \\\"hide_ios\\\")\",\n \"def iniciaUI(self):\\n\\n self.setGeometry(100,100, 250, 250)\\n self.setWindowTitle(\\\"Login\\\")\\n self.displayWidgets()\\n\\n self.show()\",\n \"def onShow(self):\\n pass\",\n \"def setupDeviceGui(self):\\n\\n dropDowns = list(self.drivers[driver]['uiDriver'] for driver in self.drivers)\\n for dropDown in dropDowns:\\n dropDown.clear()\\n dropDown.setView(PyQt5.QtWidgets.QListView())\\n dropDown.addItem('No device selected')\\n\\n # adding special items\\n self.drivers['dome']['uiDriver'].addItem('INDI')\\n self.drivers['imaging']['uiDriver'].addItem('INDI')\\n self.drivers['sensorWeather']['uiDriver'].addItem('INDI')\\n self.drivers['directWeather']['uiDriver'].addItem('Built-In')\\n self.drivers['onlineWeather']['uiDriver'].addItem('Built-In')\\n self.drivers['cover']['uiDriver'].addItem('INDI')\\n self.drivers['skymeter']['uiDriver'].addItem('INDI')\\n self.drivers['telescope']['uiDriver'].addItem('INDI')\\n self.drivers['power']['uiDriver'].addItem('INDI')\\n self.drivers['relay']['uiDriver'].addItem('Built-In')\\n for app in self.app.astrometry.solverAvailable:\\n self.drivers['astrometry']['uiDriver'].addItem(app)\\n self.drivers['remote']['uiDriver'].addItem('Built-In')\\n self.drivers['measure']['uiDriver'].addItem('Built-In')\\n\\n return True\",\n \"def show(self):\\n self.Show()\",\n \"def make_gui(filename):\\n\\n from subprocess import check_call\\n import os\\n\\n cmd = os.path.normpath('C:\\\\Anaconda\\\\Scripts\\\\pyside-uic')\\n infile = filename + '.ui'\\n outfile = filename + '.py'\\n\\n call_args = [cmd, infile, '-o', outfile]\\n print call_args\\n\\n check_call(call_args)\",\n \"def iniciaUI(self):\\n\\n self.setGeometry(100,100, 300, 200)\\n self.setWindowTitle(\\\"Formulario\\\")\\n self.displayWidgets()\\n\\n self.show()\",\n \"def showInfoWindow():\\n\\treturn 0\",\n \"def close_hud():\\n if pm.headsUpDisplay('a1_hud', exists=True):\\n for i in range(6):\\n pm.headsUpDisplay('a{}_hud'.format(i + 1), remove=True)\",\n \"def gui():\\n\\tglobal dialog\\n\\tif not dialog:\\n\\t\\tdialog = helixhunter()\\n\\tdialog.enter()\",\n \"def hide(self):\\n\\n self.stop_repl()\\n self.visible = False\\n self.withdraw() # Hide window\",\n \"def hide_all(self):\\n for UI_object in self.__UI_objects:\\n UI_object.hide()\",\n \"def _showMainWindow(self) -> None:\\n if not self._main_dialog:\\n self._main_dialog = self._createDialog(\\\"Thingiverse.qml\\\")\\n self._main_dialog.show()\\n self._service.updateSupportedFileTypes()\\n self._service.search(\\\"ultimaker\\\")\",\n \"def tear_down_ui():\\n from .gen import icons_rc\\n from .contextmenus import unregister_context_menu\\n\\n close_all_editors()\\n unregister_context_menu()\\n icons_rc.qCleanupResources()\",\n \"def ocultar(self, widget, *args):\\n self.show(False)\\n self.ventana.hide_all()\",\n \"def hide(self):\\r\\n if self.visible:\\r\\n nid = (self.hwnd, 0)\\r\\n Shell_NotifyIcon(NIM_DELETE, nid)\\r\\n self.visible = 0\",\n \"def ShowMe(self, event):\\n self.Show(True)\",\n \"def activate_statusbar_icon_mode():\\n pass\",\n \"def hide_show_volume_scale(_=None):\\n if volume_ctrl.winfo_viewable():\\n volume_frame.place_forget()\\n else:\\n volume_frame.place(x=512,y=120)\",\n \"def load_gui():\\r\\n\\r\\n print(\\\"\\\\nLoading graphical user interface...\\\\n\\\")\\r\\n SongStorageGUI().mainloop()\",\n \"def show(self):\\n QtGui.QGuiApplication.processEvents()\",\n \"def fullscreen(self):\\n self.port_edit.setVisible(False)\\n self.ip_edit.setVisible(False)\\n self.connect_btn.setVisible(False)\\n self.setup_btn.setVisible(False)\\n self.play_btn.setVisible(False)\\n self.pause_btn.setVisible(False)\\n self.teardown_btn.setVisible(False)\\n self.fullscreen_btn.setVisible(False)\\n self.video_slider.setVisible(False)\\n self.rtp_port_edit.setVisible(False)\\n self.rtp_label.setVisible(False)\\n self.rtcp_port_edit.setVisible(False)\\n self.rtcp_port_label.setVisible(False)\\n self.movie_name_edit.setVisible(False)\\n self.movie_name_label.setVisible(False)\\n self.rate_select.setVisible(False)\\n self.time_label.setVisible(False)\\n self.low_level_video.setVisible(False)\\n self.high_level_video.setVisible(False)\\n self.video_list.setVisible(False)\\n self.video_label.setGeometry(0, 0, self.screen_width, self.screen_height)\\n self.showFullScreen()\",\n \"def should_show():\",\n \"def hide(self):\\r\\n\\t\\tself.frame.Show(False)\",\n \"def prepare_UI(self):\",\n \"def show_window(icon, item):\\n icon.stop()\\n app.after(0, app.deiconify())\",\n \"def abrir_inicio_rutina(self, widget, data=None):\\n\\t\\tself.w3.hide()\\n\\t\\tself.w6.show_all()\",\n \"def show(self):\\r\\n\\t\\tself.frame.Show(True)\",\n \"def main():\\n uilist = {\\n 'joyride':(\\\"Uses a joystick for steering and outputs console text\\\", joyride),\\n 'curses':(\\\"A simple curses-based output UI with very basic arrow-key steering\\\", cursesui),\\n 'framebuffer':(\\\"An output intenteded for the on-board computer, with no steering\\\", framebuffer),\\n }\\n\\n parser = OptionParser()\\n\\n uigroup = OptionGroup(parser, \\\"UI options\\\")\\n uigroup.add_option('-u', '--ui', action=\\\"store\\\", type=\\\"choice\\\", dest=\\\"ui\\\", default=\\\"joyride\\\", choices=uilist.keys(),\\n help=\\\"Interact with this type of UI [Default: joyride]\\\")\\n uigroup.add_option('-j', '--joystick', action=\\\"store\\\", type=\\\"string\\\", dest=\\\"joystick_device\\\", default=None,\\n help=\\\"Path to the device file of the joystick (for joyride UI) [Default: None]\\\")\\n uigroup.add_option('-s', '--disable-sound', action=\\\"store_false\\\", dest=\\\"sound\\\", default=True,\\n help=\\\"Disable sound [Default: False]\\\")\\n uigroup.add_option('-i', '--disable-input', action=\\\"store_false\\\", dest=\\\"allow_input\\\", default=True,\\n help=\\\"Disable input [Default: False]\\\")\\n uigroup.add_option('-c', '--become-controller', action=\\\"store_true\\\", dest=\\\"become_controller\\\", default=False,\\n help=\\\"Become exclusive controlling connection [Default: False]\\\")\\n uigroup.add_option('-n', '--no-control', action=\\\"store_false\\\", dest=\\\"allow_control\\\", default=True,\\n help=\\\"Ignore all UI commands from this client [Default: False]\\\")\\n uigroup.add_option(\\\"--list\\\", action=\\\"store_true\\\", dest=\\\"list\\\", default=False,\\n help=\\\"List the available UIs and exit\\\")\\n parser.add_option_group(uigroup)\\n\\n netgroup = OptionGroup(parser, \\\"Network options\\\")\\n netgroup.add_option('-a', '--host', action=\\\"store\\\", type=\\\"string\\\", dest=\\\"host\\\", default=\\\"localhost\\\",\\n help=\\\"Host/address to connect to [Default: localhost]\\\")\\n netgroup.add_option('-p', '--port', action=\\\"store\\\", type=\\\"int\\\", dest=\\\"port\\\", default=9999,\\n help=\\\"Port the server is listening on [Default: 9999]\\\")\\n parser.add_option_group(netgroup)\\n\\n options, args = parser.parse_args()\\n\\n list_and_exit = False\\n if options.list:\\n list_and_exit = True\\n\\n if not options.ui or options.ui not in uilist:\\n print \\\"You must pick one of the available UIs with --ui\\\"\\n\\n if list_and_exit:\\n print \\\"Available UIs:\\\"\\n for name, info in uilist.items():\\n print \\\"%s %s\\\" % (name.ljust(30), info[0])\\n return 0\\n\\n # create the robot\\n robot = Robot(options.host, options.port)\\n status = robot.get_status()\\n\\n # handle gracefully disconnecting the robot if anything else fails\\n try:\\n # create the ui\\n uimod = uilist[options.ui][1]\\n ui = uimod.get_ui(**vars(options))\\n\\n # create the steerer\\n steerer = steering.SteeringModel(status)\\n\\n if options.sound:\\n player = sound.SoundPlayer(status)\\n player.play(player.SOUNDS['startup'])\\n else:\\n player = None\\n\\n # create the robot client\\n client = RobotClient(robot, ui, steerer, player, options.allow_control, options.become_controller)\\n\\n # start up all the pieces in the right order\\n if player: player.start()\\n try:\\n ui.init()\\n ui.start()\\n try:\\n client.run()\\n finally:\\n ui.stop()\\n finally:\\n if player:\\n player.stop(player.SOUNDS['crash'])\\n finally:\\n if not robot.disconnected:\\n robot.disconnect()\",\n \"def on_device_dialog_cancel_clicked(self,widget=None):\\n self.widgets['main'].hide()\",\n \"def init_ui(self):\\n self.parent.title(\\\"Roku Player Controller\\\")\\n self.style.theme_use(\\\"default\\\")\",\n \"def show_menus(self, type_):\\n if type_ == self._current:\\n # do nothing\\n pass\\n else:\\n if self._current == self.TYPE_VOIGT:\\n # Plot menus are visible; hide them.\\n plot_menu_labels = [menu.label for menu in self._plot_menus]\\n\\n for menu in self.top_level_menus:\\n if menu.label in plot_menu_labels:\\n self.Remove(self.FindMenu(menu.label))\\n elif self._current == self.TYPE_GISO:\\n # Plot menus are visible; hide them.\\n plot_menu_labels = [menu.label for menu in self._plot_menus]\\n\\n for menu in self.top_level_menus:\\n if menu.label in plot_menu_labels:\\n self.Remove(self.FindMenu(menu.label))\\n\\n # Rebuild the view menu by deleting everything from it and then \\n # reappending the appropriate items.\\n while self.view_menu.GetMenuItemCount():\\n #self.view_menu.DeleteItem(self.view_menu.FindItemByPosition(0))\\n self.view_menu.Delete(self.view_menu.FindItemByPosition(0))\\n\\n _append_items(self._main, self.view_menu, self._menu_data[type_])\\n\\n if type_ == self.TYPE_VOIGT:\\n # add plot menus\\n for menu in self._plot_menus[::-1]:\\n self.Insert(_PLOT_MENU_INSERT_INDEX, menu, menu.label)\\n # Under wxPython 2.9, the menus I add with this call to \\n # Insert() don't have their label set. I think it's a bug,\\n # but I can't recreate it outside of this app. Manually\\n # setting the label here is a workaround.\\n self.SetMenuLabel(_PLOT_MENU_INSERT_INDEX, menu.label)\\n elif type_ == self.TYPE_GISO:\\n # add plot menus\\n for menu in self._plot_menus[::-1]:\\n self.Insert(_PLOT_MENU_INSERT_INDEX, menu, menu.label)\\n # Under wxPython 2.9, the menus I add with this call to \\n # Insert() don't have their label set. I think it's a bug,\\n # but I can't recreate it outside of this app. Manually\\n # setting the label here is a workaround.\\n self.SetMenuLabel(_PLOT_MENU_INSERT_INDEX, menu.label)\\n\\n\\n self._current = type_\",\n \"def show(self, caller_is_main: bool):\\n pass\",\n \"def minimap_show_hide(self):\\n if self.minimap_flag == 0:\\n self.code_minimap_frame.pack_forget()\\n self.working_area.pack_forget()\\n self.line_num_frame.pack(fill='y', side='left')\\n self.working_area.pack(fill='both', side='left', expand=True)\\n self.code_minimap_frame.pack(fill='both', side='left', pady=(22, 0))\\n self.minimap_flag = 1\\n self.View.entryconfigure(1, label=' Hide Code Minimap ', command=self.minimap_show_hide)\\n else:\\n self.code_minimap_frame.pack_forget()\\n self.minimap_flag = 0\\n self.View.entryconfigure(1, label='Show Minimap')\",\n \"def open_gui():\\n guiController.main()\",\n \"def showUI(cls):\\r\\n win = cls(uiFile)\\r\\n win.create()\\r\\n return win\",\n \"def _load_ui(self):\\n load_ui(\\\"about_dlg.ui\\\", self)\\n\\n self.title_label = self.findChild(QLabel, \\\"title_label\\\")\\n self.title_label.setText(f\\\"Friendly Pics 2 v{__version__}\\\")\\n\\n self.runtime_env_label = self.findChild(QLabel, \\\"runtime_env_label\\\")\\n if is_mac_app_bundle():\\n self.runtime_env_label.setText(\\\"Running as MacOS app bundle\\\")\\n elif is_pyinstaller_bundle():\\n self.runtime_env_label.setText(\\\"Running as a pyinstaller binary\\\")\\n else:\\n self.runtime_env_label.setText(\\\"Running under conventional Python environment\\\")\\n\\n self.gui_settings_label = self.findChild(QLabel, \\\"gui_settings_label\\\")\\n self.gui_settings_label.setText(f\\\"<b>GUI Settings:</b> {self._settings.fileName()}\\\")\\n\\n self.gui_settings_clear_button = self.findChild(QPushButton, \\\"gui_settings_clear_button\\\")\\n self.gui_settings_clear_button.clicked.connect(self._clear_gui_settings)\\n\\n self.app_settings_label = self.findChild(QLabel, \\\"app_settings_label\\\")\\n self.app_settings_label.setText(f\\\"<b>App Settings:</b> {self._app_settings.path}\\\")\\n\\n # Center the about box on the parent window\\n parent_geom = self.parent().geometry()\\n self.move(parent_geom.center() - self.rect().center())\",\n \"def OnFrameShow(self):\\r\\n\\r\\n\\t\\t# Update local copy of config\\r\\n\\t\\tself._configtmp.update(self._config)\\r\\n\\r\\n\\t\\t# Fix notebook background color when switching themes in XP\\r\\n\\t\\tself.notebookApp.SetBackgroundColour(\\\\\\r\\n\\t\\t\\tself.notebookApp.GetThemeBackgroundColour())\\r\\n\\r\\n\\t\\t# Set flag\\r\\n\\t\\tself.toggleButtonRateFlag.SetValue(self._configtmp[\\\"flagimage\\\"])\\r\\n\\r\\n\\t\\t# Set ratings\\r\\n\\t\\tself._iconstars = [icons.getGrayStarBitmap(),\\r\\n\\t\\t\\ticons.getYellowStarBitmap(),\\r\\n\\t\\t\\ticons.getGrayOrangeStarBitmap(),\\r\\n\\t\\t\\ticons.getYellowOrangeStarBitmap()]\\r\\n\\t\\tself.SetStars()\\r\\n\\r\\n\\t\\t# Set image info\\r\\n\\t\\tself.textCtrlImageInfo.Clear()\\r\\n\\t\\tself.textCtrlImageInfo.WriteText(self._configtmp[\\\"imageinfo\\\"])\\r\\n\\r\\n\\t\\t# If login still valid, change text on Sign In page\\r\\n\\t\\tif (self._configtmp[\\\"userhash\\\"] != \\\"00000000000000000000000000000000\\\"):\\r\\n\\t\\t\\tself.staticTextSignedIn.SetLabel(\\\" You are signed in.\\\")\\r\\n\\t\\telse:\\r\\n\\t\\t\\tself.staticTextSignedIn.SetLabel(\\\"You are not signed in.\\\")\\r\\n\\t\\tusername = self._configtmp[\\\"username\\\"]\\r\\n\\t\\tself.textCtrlLogin.Clear()\\r\\n\\t\\tself.textCtrlLogin.WriteText(username)\\r\\n\\r\\n\\t\\t# Set options\\r\\n\\t\\t_ratelist = [1, 2, 3, 4, 5]\\r\\n\\t\\tself.choiceOptionRatedAtLeast.SetSelection(\\r\\n\\t\\t\\t_ratelist.index(self._configtmp[\\\"ratedatleast\\\"]))\\r\\n\\t\\t_percentlist = [5, 10, 20, 50, 75, 100]\\r\\n\\t\\tself.choiceOptionPercentUnrated.SetSelection(\\r\\n\\t\\t\\t_percentlist.index(self._configtmp[\\\"percentnew\\\"]))\\r\\n\\t\\t_changeeverylist = [900, 1800, 3600, 7200, 14400, 28800, 86400,\\r\\n\\t\\t\\t172800, 345600, 604800]\\r\\n\\t\\tself.choiceOptionChangeEvery.SetSelection(\\r\\n\\t\\t\\t_changeeverylist.index(self._configtmp[\\\"changeevery\\\"]))\\r\\n\\r\\n\\t\\t# Update complete, show frame\\r\\n\\t\\tself.Show()\\r\\n\\t\\tself.Raise()\",\n \"def show(self,window):\\n self.showFunctions(window)\",\n \"def hide(self):\\n self._dev.hide()\",\n \"def activate_statusbar_icon_close():\\n pass\",\n \"def on_first_registration(self):\\n self.main.tabify_plugins(self.main.help, self)\\n self.dockwidget.hide()\",\n \"def toggle_display_mode(self):\\n if self.main_window.windowState() == Qt.WindowFullScreen:\\n self.main_window.showNormal()\\n else:\\n self.main_window.showFullScreen()\\n # Keep the settings window active to prevent main window from\\n # burying it\\n self.settings_window.activateWindow()\",\n \"def show_window(self):\\n self.show()\",\n \"def load_main_gui(self, gui_handle):\\n elementsToModify = [\\\"butZoomIn\\\", \\\"butZoomOut\\\", \\\"butGoToLoc\\\",\\n \\\"butChrUp\\\", \\\"butChrDown\\\"]\\n\\n for element in elementsToModify:\\n xrc.XRCCTRL(gui_handle, element).SetLabel(self.__data[element])\\n\\n return(True)\\n\\n # the menus are a little different:\\n elementsToModify = [\\\"file\\\", \\\"about\\\", \\\"help\\\"]\\n\\n menu_head = gui_handle.GetMenuBar()\\n\\n for element in elementsToModify:\\n item = menu_head.FindItem(element)\\n print item\\n if item:\\n menu_item = menu_head.GetMenu(item)\\n menu_item.SetLabel(element)\",\n \"def setupPopUp(self):\\n\\n for driver in self.drivers:\\n if self.sender() != self.drivers[driver]['uiSetup']:\\n continue\\n\\n # calculate geometry\\n geometry = self.pos().x(), self.pos().y(), self.height(), self.width()\\n # get all available frameworks\\n framework = self.drivers[driver]['class'].run.keys()\\n # selecting the device type\\n deviceType = self.drivers[driver]['deviceType']\\n\\n self.popupUi = DevicePopup(geometry=geometry,\\n driver=driver,\\n deviceType=deviceType,\\n framework=framework,\\n data=self.driversData)\\n # memorizing the driver we have to update\\n self.popupUi.exec_()\\n if self.popupUi.returnValues.get('close', 'cancel') == 'cancel':\\n # when cancel nothing happens\\n return False\\n else:\\n # when ok, we have to further work\\n break\\n\\n # check if copy are made. if so, than restart all drivers related\\n if self.popupUi.returnValues.get('copyIndi', False):\\n for driver in self.drivers:\\n if not self.drivers[driver]['class'].framework == 'indi':\\n continue\\n self.dispatch(driverName=driver)\\n elif self.popupUi.returnValues.get('copyAlpaca', False):\\n for driver in self.drivers:\\n if not self.drivers[driver]['class'].framework == 'alpaca':\\n continue\\n self.dispatch(driverName=driver)\\n else:\\n # if we choose a driver and it's available, we select it from drop down\\n if self.popupUi.returnValues.get('framework', '') == 'indi':\\n index = self.findIndexValue(self.drivers[driver]['uiDropDown'], 'indi')\\n self.drivers[driver]['uiDropDown'].setCurrentIndex(index)\\n self.dispatch(driverName=driver)\\n\\n return True\",\n \"def iconify(self):\\n if self.active:\\n self.master.withdraw()\\n self.active = False\",\n \"def show_menu(self):\\n curses.curs_set(0)\\n self.main_menu.display()\",\n \"def do_hf_unhide(self, arg):\\n self.show_hidden_frames = True\\n self.refresh_stack()\",\n \"def toggle(self):\\n if not self.hidden and not self.vimiv.commandline.entry.is_visible():\\n self.bar.hide()\\n else:\\n self.bar.show()\\n self.hidden = not self.hidden\\n # Resize the image if necessary\\n if not self.vimiv.image.user_zoomed and self.vimiv.paths and \\\\\\n not self.vimiv.thumbnail.toggled:\\n self.vimiv.image.zoom_to(0)\",\n \"def init_ui(self):\\n raise NotImplementedError\",\n \"def init_ui(self):\\n raise NotImplementedError\",\n \"def showMainWindowGUI(script=None, inputEvent=None):\\n\\n try:\\n module = __import__(settings.mainWindowModule,\\n globals(),\\n locals(),\\n [''])\\n if settings.showMainWindow:\\n module.showMainUI()\\n else:\\n module.hideMainUI()\\n except:\\n debug.printException(debug.LEVEL_SEVERE)\\n\\n return True\",\n \"def setupDeviceGui(self):\\n\\n # all dropdown have disabled as capability\\n dropDowns = list(self.drivers[driver]['uiDropDown'] for driver in self.drivers)\\n for dropDown in dropDowns:\\n dropDown.clear()\\n dropDown.setView(PyQt5.QtWidgets.QListView())\\n dropDown.addItem('device disabled')\\n\\n # adding driver items with applicable framework\\n for driver in self.drivers:\\n if not hasattr(self.drivers[driver]['class'], 'run'):\\n continue\\n for framework in self.drivers[driver]['class'].run.keys():\\n self.drivers[driver]['uiDropDown'].addItem(framework)\\n\\n return True\",\n \"def on_hide_view(self):\\n self.ui_manager.unregister_handlers()\",\n \"def on_hide_view(self):\\n self.ui_manager.unregister_handlers()\",\n \"def on_hide_view(self):\\n self.ui_manager.unregister_handlers()\",\n \"def early_interact():\\n\\n global fullscreen\\n global current_movie\\n\\n fullscreen = True\\n current_movie = None\",\n \"def abrir_menu_principal(self, widget, data=None):\\t\\n\\t\\t#print(\\\"Bandera1\\\")\\n\\t\\tself.w2.hide()\\n\\t\\tself.w3.show_all()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68529445","0.6712458","0.6654804","0.65738904","0.6489169","0.6392772","0.6144045","0.6099471","0.6089309","0.59926564","0.59250045","0.5883586","0.58749723","0.5853369","0.5846495","0.5838198","0.58305126","0.5829298","0.5809941","0.58038217","0.5800064","0.5792026","0.57840323","0.577771","0.57759714","0.57655036","0.57545567","0.5748445","0.57231116","0.57131237","0.5711566","0.5704421","0.5701811","0.56979024","0.5680348","0.566082","0.5638351","0.5635953","0.563478","0.5633728","0.5623538","0.55891633","0.5586382","0.55859816","0.55798435","0.55787617","0.55784786","0.5572632","0.5570074","0.5565871","0.5555353","0.5553011","0.5548929","0.55488145","0.5542804","0.5539851","0.5530386","0.55192876","0.5511619","0.55082816","0.55010736","0.55000114","0.5499612","0.54995245","0.5495579","0.54923743","0.54698324","0.546263","0.5458298","0.5448273","0.54267424","0.5420216","0.5413423","0.5405231","0.53986937","0.53968304","0.53957826","0.5394049","0.53922474","0.5391707","0.5391111","0.53906894","0.53887045","0.5383441","0.5377235","0.5375531","0.5373162","0.5367135","0.536677","0.53603715","0.5358958","0.534876","0.5344783","0.5344783","0.5341061","0.5337878","0.53366107","0.53366107","0.53366107","0.533118","0.5329725"],"string":"[\n \"0.68529445\",\n \"0.6712458\",\n \"0.6654804\",\n \"0.65738904\",\n \"0.6489169\",\n \"0.6392772\",\n \"0.6144045\",\n \"0.6099471\",\n \"0.6089309\",\n \"0.59926564\",\n \"0.59250045\",\n \"0.5883586\",\n \"0.58749723\",\n \"0.5853369\",\n \"0.5846495\",\n \"0.5838198\",\n \"0.58305126\",\n \"0.5829298\",\n \"0.5809941\",\n \"0.58038217\",\n \"0.5800064\",\n \"0.5792026\",\n \"0.57840323\",\n \"0.577771\",\n \"0.57759714\",\n \"0.57655036\",\n \"0.57545567\",\n \"0.5748445\",\n \"0.57231116\",\n \"0.57131237\",\n \"0.5711566\",\n \"0.5704421\",\n \"0.5701811\",\n \"0.56979024\",\n \"0.5680348\",\n \"0.566082\",\n \"0.5638351\",\n \"0.5635953\",\n \"0.563478\",\n \"0.5633728\",\n \"0.5623538\",\n \"0.55891633\",\n \"0.5586382\",\n \"0.55859816\",\n \"0.55798435\",\n \"0.55787617\",\n \"0.55784786\",\n \"0.5572632\",\n \"0.5570074\",\n \"0.5565871\",\n \"0.5555353\",\n \"0.5553011\",\n \"0.5548929\",\n \"0.55488145\",\n \"0.5542804\",\n \"0.5539851\",\n \"0.5530386\",\n \"0.55192876\",\n \"0.5511619\",\n \"0.55082816\",\n \"0.55010736\",\n \"0.55000114\",\n \"0.5499612\",\n \"0.54995245\",\n \"0.5495579\",\n \"0.54923743\",\n \"0.54698324\",\n \"0.546263\",\n \"0.5458298\",\n \"0.5448273\",\n \"0.54267424\",\n \"0.5420216\",\n \"0.5413423\",\n \"0.5405231\",\n \"0.53986937\",\n \"0.53968304\",\n \"0.53957826\",\n \"0.5394049\",\n \"0.53922474\",\n \"0.5391707\",\n \"0.5391111\",\n \"0.53906894\",\n \"0.53887045\",\n \"0.5383441\",\n \"0.5377235\",\n \"0.5375531\",\n \"0.5373162\",\n \"0.5367135\",\n \"0.536677\",\n \"0.53603715\",\n \"0.5358958\",\n \"0.534876\",\n \"0.5344783\",\n \"0.5344783\",\n \"0.5341061\",\n \"0.5337878\",\n \"0.53366107\",\n \"0.53366107\",\n \"0.53366107\",\n \"0.533118\",\n \"0.5329725\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13292,"cells":{"query":{"kind":"string","value":"Test prefix. Printed every test"},"document":{"kind":"string","value":"def setUp(self):\n print(\"New test by Nikolay Melnik\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def print_tests_results(self):\n\n for test in self.test_report:\n for detail in test:\n print detail + ': ', test[detail]","def test(got, expected):\r\n if got == expected:\r\n prefix = \" OK \"\r\n else:\r\n prefix = \" X \"\r\n print(\"%s got: %s expected: %s\" % (prefix, repr(got), repr(expected)))","def test(got, expected):\n if got == expected:\n prefix = \" OK \"\n else:\n prefix = \" X \"\n print(\"%s got: %s expected: %s\" % (prefix, repr(got), repr(expected)))","def print_results(self):\n for test_cases in self._tests:\n for test_case in test_cases:\n print('{} ...ok'.format(test_case.get_name()))\n return 0","def test(self):\n # -- Test --\n\n # (1)\n\n # (2)\n\n # (3)\n\n # (4)\n # -- Test --","def print_test_comparison(test_name, expected, result):\n line = \"\\n\"\n line += \"-\" * 60 + \"\\n\"\n line += \"{}\\n\".format(test_name)\n line += \"-\" * 60 + \"\\n\"\n line += \"-\" * 26 + \"EXPECTED\" + \"-\" * 26 + \"\\n\"\n line += \"{}\\n\".format(expected)\n line += \"-\" * 28 + \"END\" + \"-\" * 29 + \"\\n\"\n line += \"-\" * 27 + \"RESULT\" + \"-\" * 27 + \"\\n\"\n line += \"{}\\n\".format(result)\n line += \"-\" * 28 + \"END\" + \"-\" * 29 + \"\\n\"\n line += \"\\n\"\n return line","def test_prefix(self):\n self.chck_triple('prefix')","def _test (self) :\n print (_T (ckw.title or \"Baz\"))\n print (_T (\"Foo\"))\n foo = _(\"Markup %d\")\n print (_T(foo) % 42)\n print (_Tn (\"Singular\", \"Plural\", 4))","def zio_test_help():\n print(\"zio-ut [TESTS]\")\n print(\"\")\n print(\"[TESTS]: list of tests to perform. It can be the name of a specific test, or the name of a module of tests\")\n print(\" In alternative, you che use the test code:\")\n print(\"Code test case\")\n print(\"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \")\n i = 0\n for t in test_list:\n print(str(i) + \" \" + t)\n i = i + 1","def generate_test_string(self, test_log: dict, step: Union[int,None] = None) -> str:\n print_str = 'Epoch {}, '.format(step) if step else ''\n for k,v in test_log.items():\n print_str = print_str + '{} : {:.4f}, '.format(k, v)\n \n return print_str[:-1]","def test_code010(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code010 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def print_testvals(self):\n print(self.use_planck)","def test_name(self):\r\n parts = []\r\n if self.test.__module__ != '__main__':\r\n parts.append(self.test.__module__)\r\n if hasattr(self.test, 'im_class'):\r\n parts.append(self.test.im_class.__name__)\r\n parts.append(self.test.__name__)\r\n return '.'.join(parts)","def tests():","def test_code006(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code006 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def test_code001(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code001 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def print_tests(pkg):\n\n # Some built-in base packages (e.g., Autotools) define callback (e.g.,\n # check) inherited by descendant packages. These checks may not result\n # in build-time testing if the package's build does not implement the\n # expected functionality (e.g., a 'check' or 'test' targets).\n #\n # So the presence of a callback in Spack does not necessarily correspond\n # to the actual presence of built-time tests for a package.\n for callbacks, phase in [\n (pkg.build_time_test_callbacks, \"Build\"),\n (pkg.install_time_test_callbacks, \"Install\"),\n ]:\n color.cprint(\"\")\n color.cprint(section_title(\"Available {0} Phase Test Methods:\".format(phase)))\n names = []\n if callbacks:\n for name in callbacks:\n if getattr(pkg, name, False):\n names.append(name)\n\n if names:\n colify(sorted(names), indent=4)\n else:\n color.cprint(\" None\")\n\n # PackageBase defines an empty install/smoke test but we want to know\n # if it has been overridden and, therefore, assumed to be implemented.\n color.cprint(\"\")\n color.cprint(section_title(\"Stand-Alone/Smoke Test Methods:\"))\n names = []\n pkg_cls = pkg if inspect.isclass(pkg) else pkg.__class__\n if has_test_method(pkg_cls):\n pkg_base = spack.package_base.PackageBase\n test_pkgs = [\n str(cls.test)\n for cls in inspect.getmro(pkg_cls)\n if issubclass(cls, pkg_base) and cls.test != pkg_base.test\n ]\n test_pkgs = list(set(test_pkgs))\n names.extend([(test.split()[1]).lower() for test in test_pkgs])\n\n # TODO Refactor START\n # Use code from package_base.py's test_process IF this functionality is\n # accepted.\n v_names = list(set([vspec.name for vspec in pkg.virtuals_provided]))\n\n # hack for compilers that are not dependencies (yet)\n # TODO: this all eventually goes away\n c_names = (\"gcc\", \"intel\", \"intel-parallel-studio\", \"pgi\")\n if pkg.name in c_names:\n v_names.extend([\"c\", \"cxx\", \"fortran\"])\n if pkg.spec.satisfies(\"llvm+clang\"):\n v_names.extend([\"c\", \"cxx\"])\n # TODO Refactor END\n\n v_specs = [spack.spec.Spec(v_name) for v_name in v_names]\n for v_spec in v_specs:\n try:\n pkg_cls = spack.repo.path.get_pkg_class(v_spec.name)\n if has_test_method(pkg_cls):\n names.append(\"{0}.test\".format(pkg_cls.name.lower()))\n except spack.repo.UnknownPackageError:\n pass\n\n if names:\n colify(sorted(names), indent=4)\n else:\n color.cprint(\" None\")","def test_03_pass_print(self):\n print('Hello World!')","def test(): \n\treturn [\"vice.yields.ccsne.import\", \n\t\t[ \n\t\t\ttest_LC18_import(), \n\t\t\ttest_CL13_import(), \n\t\t\ttest_CL04_import(), \n\t\t\ttest_WW95_import(), \n\t\t\ttest_NKT13_import(), \n\t\t\ttest_S16_import() \n\t\t] \n\t]","def test_generate_all_testing(self):\n pass","def test_print_result(capsys):\n assert \"\"\"Total 5 hands solved\nTotal 4 hands solved with hint\nTotal 4 hands failed to solve\"\"\" in hl.test_help_print_result(capsys)","def displayStdout(self, test):\n test = proto_test(test)\n if test.dotted_name in self.stdout_output:\n self.stream.write(\n \"\\n{} for {}\\n{}\".format(\n self.colors.yellow(\"Captured stdout\"),\n self.colors.bold(test.dotted_name),\n self.stdout_output[test],\n )\n )\n del self.stdout_output[test]","def __str__(self):\n return 'Observables Test Case: {0}'.format(self.title)","def runTestsWithPrefix(testFile1,testFile2,prefix,outfile):\n loader = unittest.TestLoader()\n loader.testMethodPrefix = prefix\n\n #print(\"*** run test params \" + testFile1 + \", \" + testFile2 + \", \" + outfile)\n # open the outfile as the destination of the output\n f = open(outfile, \"w\")\n\n # reload the modules \n if isfile(testFile1) and isfile(testFile2):\n try:\n imp.reload(lab01Funcs)\n imp.reload(lab01Tests)\n except Exception as inst:\n print(inst)\n return -1\n\n # add all the unit tests into the TestSuite object\n suite = loader.discover('.', pattern = testFile1) \n print(\"Cases %d\" % (suite.countTestCases()))\n suite.addTest( loader.discover('.', pattern = testFile2) )\n print(\"Cases %d\" % (suite.countTestCases()))\n\n # pass the file as the stream location for output\n unittest.TextTestRunner(stream=f,verbosity=2).run(suite)\n f.close()","def test_print_start(self):\n response = support.create_project(self, 'chicago')\n self.assertFalse(\n response.failed,\n Message('should have created project', response=response)\n )\n\n print_string = string.ascii_lowercase\n\n code = '\\n'.join([\n 'import cauldron as cd',\n 'print(\"{}\")'.format(print_string),\n 'cd.display.text(\"Hello World\")'\n ])\n\n support.add_step(self, contents=code)\n\n response = support.run_command('run -f')\n self.assertFalse(\n response.failed,\n Message('should have run step', response=response)\n )\n\n project = cauldron.project.get_internal_project()\n dom = project.steps[1].dom # type: str\n\n self.assertEqual(\n dom.count(print_string),\n 2,\n 'should have printed ascii lowercase'\n )","def print_functions(top):\n global exnum\n global callers\n for item in top:\n if 'cases' in item:\n print_functions(item['cases'])\n continue\n exnum += 1\n desc = re.sub('[^0-9a-zA-Z]+', '_', item['description'])\n print >> F, ('void test_' + item['property'] + '_' +\n desc.lower() + '(void)')\n print >> F, '{'\n if exnum == 2:\n print >> F, (' TEST_IGNORE(); '\n '// delete this line to run test')\n elif exnum > 2:\n print >> F, ' TEST_IGNORE();'\n print >> F, ' /*'\n print >> F, '----Input----'\n print >> F, json.dumps(item['input'], indent=3)\n print >> F, '---Expected---'\n print >> F, json.dumps(item['expected'], indent=3)\n print >> F, ' */'\n print >> F, '}'\n print >> F\n callers += (' RUN_TEST(test_' + item['property'] + '_' +\n desc.lower() + ');')\n callers += '\\n'\n return","def test_4():","def test_code007(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code007 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def tests(c):\n results = [test(c, i) for i, test_path in enumerate(TEST_PATHS)]\n print('\\n\\n\\n############## SUMMARY ##############')\n for i, test_path in enumerate(TEST_PATHS):\n print(i, test_path, 'PASSED' if result[i] == 0 else 'FAILED')","def test_code009(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code009 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def logTestName(self):\n logging.info('%s', self.id())","def test():\n v_print(1, \"-vvv Verbose 1 - INFO\")\n v_print(2, \"-vv Verbose 2 - WARN\")\n v_print(3, \"-v Verbose 3 - ERROR\")","def create_python_tests(fout):\n for keyword in LibraryDocBuilder().build('FusionLibrary').keywords:\n print(keyword.name)\n fout.write('Test {}\\n'.format(keyword.name))\n fout.write(' [Documentation] {}\\n'.format(keyword.name))\n fout.write(' {} '.format(keyword.name))\n for arg in keyword.args:\n if '=' in arg:\n fout.write(' {} '.format(arg.split('=')[-1]))\n else:\n if arg.startswith('&'):\n fout.write(' testk=testv ')\n else:\n fout.write(' test ')\n fout.write('\\n\\n')","def template_for_test_functions():\r\n\r\n expected = \"\"\r\n actual = \"\"\r\n print_test_results(func, expected, actual)","def test_code004(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code004 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def main():\n assert_verbose(triple(\"hello\"), \"hhheeellllllooo\")\n assert_verbose(triple(\"kevin szuchet\"), \"kkkeeevvviiinnn ssszzzuuuccchhheeettt\")\n assert_verbose(triple(\" \"), \" \")\n assert_verbose(triple(\"\"), \"\")\n print(\"--- All tests passed ---\")","def _generate_test_name(source):\n out = source.replace(' ', '_').replace(':', '').replace(',', '').lower()\n return \"test_%s\" % out","def test_title(names):","def test_basic(self):\n test_cases = (\n makeSimpleTestCase('nicki minaj'),\n makeSimpleTestCase('jay-z'),\n makeTestCase('jay z', Matcher(title=Equals('jay-z'))),\n makeSimpleTestCase('passion pit'),\n makeSimpleTestCase('red hot chili peppers'),\n makeSimpleTestCase('the temper trap'),\n makeTestCase('glitch mob', Matcher(title=Equals('the glitch mob'))),\n makeTestCase('kanye', Matcher(title=Equals('kanye west'))),\n makeSimpleTestCase('justin bieber'),\n makeTestCase('carly rae', Matcher(title=Equals('carly rae jepsen'))),\n makeSimpleTestCase('johnny cash'),\n makeTestCase('waylon', Matcher(title=Equals('waylon jennings'))),\n makeTestCase('tmbg', Matcher(title=Equals('they might be giants'))),\n makeSimpleTestCase('mgmt'),\n makeSimpleTestCase('rjd2'),\n makeTestCase('B.o.B', Matcher(title=StartsWith('B.o.B'))),\n makeSimpleTestCase('50 cent'),\n makeTestCase('50', Matcher(title=Equals('50 cent'))),\n makeTestCase('fifty cent', Matcher(title=Equals('50 cent'))),\n makeSimpleTestCase('katy perry'),\n makeSimpleTestCase('alison krauss'),\n makeSimpleTestCase('the highwaymen'),\n makeSimpleTestCase('flo rida'),\n # TODO: Will this ever work? We don't have recordings by Mozart, just recordings of music he composed.\n # Do we really want to try to support composers?\n makeSimpleTestCase('mozart')\n )\n\n self._run_tests('basic_artist', test_cases)","def prepend_type(prefix, test_list):\n br_test = 'buildrunner_tests'\n return (\n ['%s_%s' % (prefix, value) for value in test_list if value != br_test] +\n filter(br_test.__eq__, test_list)) # Add back in buildrunner_tests.","def test_print_multiple(self):\n response = support.create_project(self, 'omaha')\n self.assertFalse(\n response.failed,\n Message('should have created project', response=response)\n )\n\n code = '\\n'.join([\n 'import cauldron as cd',\n 'import string',\n 'print(string.ascii_lowercase)',\n 'cd.display.text(\"Hello World\")',\n 'print(string.ascii_uppercase)',\n 'print(string.hexdigits)'\n ])\n\n support.add_step(self, contents=code)\n\n response = support.run_command('run -f')\n self.assertFalse(\n response.failed,\n Message('should have run step', response=response)\n )\n\n project = cauldron.project.get_internal_project()\n dom = project.steps[1].dom # type: str\n\n self.assertEqual(\n dom.count(string.ascii_lowercase),\n 1,\n 'should have printed ascii lowercase'\n )\n\n self.assertEqual(\n dom.count(string.ascii_uppercase),\n 1,\n 'should have printed ascii uppercase'\n )\n\n self.assertEqual(\n dom.count(string.hexdigits),\n 1,\n 'should have printed hex digits'\n )","def test_prefix_tokens(self):\n args = [\n '--model-file',\n 'zoo:unittest/transformer_generator2/model',\n '--model',\n 'test_agents/transformer_generator_prefix',\n '--inference',\n 'beam',\n '--truncate',\n '1024',\n '--beam-size',\n '2',\n ]\n pp = ParlaiParser(True, True)\n agent = create_agent(pp.parse_args(args), True)\n obs = {'text': '1 2 3 4 ' * 256, 'episode_done': False}\n agent.observe(obs)\n act = agent.act()\n beam_texts = [x[0] for x in act['beam_texts']]\n for beam in beam_texts:\n # check that all beams start with the prefix text\n assert beam.startswith(\n PREFIX_TEXT\n ), f\"[{beam}] does not start with [{PREFIX_TEXT}]\"","def test_print_solo(self):\n response = support.create_project(self, 'minneapolis')\n self.assertFalse(\n response.failed,\n Message('should have created project', response=response)\n )\n\n print_string = string.ascii_lowercase\n\n code = '\\n'.join([\n 'values = [x ** 2 for x in range(100)]',\n 'print(\"{}\")'.format(print_string)\n ])\n\n support.add_step(self, contents=code)\n\n response = support.run_command('run -f')\n self.assertFalse(\n response.failed,\n Message('should have run step', response=response)\n )\n\n project = cauldron.project.get_internal_project()\n dom = project.steps[1].dom # type: str\n\n self.assertEqual(\n dom.count(print_string),\n 2,\n 'should have printed ascii lowercase'\n )","def main():\n num_of_tests = int(input())\n\n # iterate over test cases\n for test_case in range(1, num_of_tests + 1):\n result = handle_case()\n printable_result = handle_result(result)\n print(\"Case #{}: {}\".format(test_case, printable_result))","def __str__(self):\n return '%s; %s' % (self.id, unittest.TestCase.__str__(self))","def list(self):\n print \"\\nAvailable Test Cases\"\n print \"====================\"\n for case in self.cases:\n print case.__name__","def visitTests(tests, grepStr=''):\n\n # First flatten the list of tests.\n testsFlat = []\n toCheck = [t for t in tests]\n while toCheck:\n test = toCheck.pop()\n if isinstance(test, unittest.TestSuite):\n toCheck += [t for t in test]\n else:\n if grepStr in str(type(test)):\n testsFlat.append(test)\n testsFlat.sort()\n\n # Follow the flattened list of tests and show the module, class\n # and name, in a nice way.\n lastClass = None\n lastModule = None\n \n grepPrint = '' if grepStr is '' else red(' (grep: %s)'%grepStr)\n\n for t in testsFlat:\n moduleName, className, testName = t.id().rsplit('.', 2)\n \n # If there is a failure loading the test, show it\n if moduleName.startswith('unittest.loader.ModuleImportFailure'):\n print red(moduleName), \" test:\", t.id()\n continue\n\n if moduleName != lastModule:\n lastModule = moduleName\n print(\" - From %s.py (to run all use --allPrograms)\"\n % '/'.join(moduleName.split('.')) + grepPrint)\n\n\n if className != lastClass:\n lastClass = className\n print(\" ./xmipp test %s\" % className)","def do_test(name, digits, limit=85):\n line = '##' + '#'*len(name) + '##'\n print (line)\n print ('# ' + name + ' #')\n print (line)\n\n observed = count(digits,limit)\n expected = expected_coupons(observed)\n\n test.make_test(observed, expected, 'Test du CDC : '+name, 'r', 'Nombre d\\'occurences')","def test_backend_name_reporting_with_prefix(self):\n for volume_id in self.volume_id_list_with_prefix:\n self._test_backend_name_reporting_by_volume_id(volume_id)","def pytest_terminal_summary(self, terminalreporter, exitstatus):\n # pylint: disable=unused-argument\n terminalreporter.section(\"Test Information\")\n for test, info in self._info.items():\n for datum in info:\n terminalreporter.write(\"{}: {}\\n\".format(test, datum))","def test_code008(self, *test_code_args, **test_code_kwargs):\n print(\"This is test_code008 from TestDefinition #\", self.ID, \", test case #\", self.test_case_ID, sep='')","def test_print(chikin):\n chikin.print()","def name_python_package_tests(self) -> str:\n return f'test_{self.name}'","def generate_test_list(tdir):\n\n # Skip this if it already exists\n if os.path.exists(os.path.join(tdir.name, \"kstest-list\")):\n return\n\n kstest_log = os.path.join(tdir.name, \"kstest.log\")\n with open(kstest_log) as f:\n for line in f.readlines():\n if not line.startswith(\"Running tests: \"):\n continue\n\n tests = [os.path.basename(os.path.splitext(s)[0]) for s in line[15:].split()]\n with open(os.path.join(tdir.name, \"kstest-list\"), \"wt\") as klf:\n for t in tests:\n print(t, file=klf)\n break","def test_5():","def _RemoveAllPrefixes(test):\n test_name_start = max(test.find('.'), 0)\n if test_name_start == 0:\n return test\n\n test_suite = test[: test_name_start]\n test_name = test[test_name_start + 1 :]\n pre_position = test_name.find(_PRE_TEST_PREFIX)\n while pre_position == 0:\n test_name = test_name[len(_PRE_TEST_PREFIX):]\n pre_position = test_name.find(_PRE_TEST_PREFIX)\n base_test = '%s.%s' % (test_suite, test_name)\n return base_test","def testbed_name(self): \n return \"C-Lab\"","def test_T01():","def test_1():","def teststartprint(self):\n import Intelligence\n res = Intelligence.Intelligence.startprint(self)\n exp = (\"Welcome to the Dice Game of life. We will play using the rules of Pig. One dice.\" +\n \"\\nYour rolled numbers will add together.\" +\n \"\\nYou may also hold at anytime, which will add your numbers together and give the turn to the other player.\" +\n \"\\nThe catch is that if you roll a 1, your turn is over and your temporary points are wasted.\")\n self.assertEqual(res,exp)","def setUp(self):\n chars = string.ascii_uppercase + string.digits\n self.file_text = ''.join(random.choice(chars) for x in range(6))\n self.file_text = \"Dummy Test: %s\" % self.file_text\n self.VERBOSE = False","def check_new_test(test):\n msg = \"Test '%s' was run for the first time with the following output:\\n\"\n print(Ansi.clear_screen())\n print(Ansi.in_color(msg % test.name, Ansi.WHITE))\n\n for line in test.output.split(\"\\n\")[:-1]:\n print(\" \", line)\n\n ask_for_blessing(test)","def _print_results_header(self):\n print(\"\\033[94m\"+\"Summary\\n\"+\"-\"*32+\"\\033[0m\")\n print(\"Subroutine: {}\".format(self.mc_sample.__name__))\n print(\"Num Runs: {:2.1e}\".format(self.num_runs))\n print(\"-\"*32+'\\n')","def test_foo(person):\n print('\\n hello, ' + person + ' !')","def parse_gtest_tests(gtest_output_raw: str):\n test_list = []\n current_test_prefix = ''\n gtest_output_split = gtest_output_raw.split('\\n')\n current_index = 0\n # skip to the actual test list\n while current_index < len(gtest_output_split):\n current_string = gtest_output_split[current_index]\n test_matches = re.findall(r'^[a-zA-Z]*\\.$', current_string)\n if len(test_matches) != 0:\n break\n current_index += 1\n while current_index < len(gtest_output_split):\n current_string = gtest_output_split[current_index]\n if len(current_string) == 0:\n current_index += 1\n continue\n # get the test name\n test_match = re.findall(r'^\\s*\\S*', current_string)[0].replace(' ', '')\n if test_match[len(test_match) - 1] == '.':\n # We've found a new prefix\n current_test_prefix = test_match\n current_index += 1\n continue\n test_list.append(current_test_prefix + test_match)\n current_index += 1\n return test_list","def create_print(prefix):\n def inner(*args):\n print prefix + str(args)\n return inner","def print_summary(self):\n #outcomes = self.get_outcomes()\n #passes = 'Passes: %i' % sum(1 for outcome in outcomes if outcome == Result.PASS)\n #untested = 'Untested: %i' % sum(1 for outcome in outcomes if outcome == Result.UNTESTED)\n #errors = 'Errors: %i' % sum(1 for outcome in outcomes if outcome == Result.ERROR)\n #fails = 'Fails: %i' % sum(1 for outcome in outcomes if outcome == Result.FAIL)\n print('')\n print ('Passes: %i' % self.get_pass_count())\n print ('Fails: %i' % self.get_fail_count())\n print ('Errors: %i' % self.get_error_count())\n print ('Untested: %i' % self.get_untested_count())\n print ('Skipped: %i' % self.get_skipped_count())","def get_test_text(project_name):\r\n \r\n return \"\"\"\r\nfrom nose.tools import *\r\nimport %s\r\n\r\ndef setup():\r\n print \"SETUP!\"\r\n\r\ndef teardown():\r\n print \"TEAR DOWN!\"\r\n\r\ndef test_basic():\r\n print \"I RAN!\"\r\n \"\"\" % project_name","def describe_tests(remit, sourcelist):\n print('* run tests with \"%s\"' % remit)\n print('* tests to run: ')\n for line in pretty_list(sourcelist, 7):\n print(' ' + line)\n print('* writers to test: ')\n for line in pretty_list(spec.TEST['writer'], 7):\n print(' ' + line)\n print('* options to test: ')\n for line in pretty_list(spec.TEST['pandoc_options'], 7):\n print(' ' + line)\n print('* blacklisted: ')\n for config in spec.BLACKLIST:\n command = make_command(remit=remit,\n source='TEST',\n writer=config['writer'],\n pandoc_options=config['pandoc_options'],\n extension=config['extension'])\n print(' ' + ' '.join(command))\n print(' (' + config['comment'] + ')')","def test_3():","def __init__(self, stream, descriptions, verbosity):\n\n self.test_numbers = itertools.count(1)\n stream.write(f\"================================================\\n ==== Starting Tests ====\\n================================================\\n\")\n return super(CustomTextTestResult, self).__init__(stream, descriptions, verbosity)","def test(self):\n for doc, label in zip(self.test_docs(), self.test_labels()):\n yield doc, label","def step_print(self, prefix=\"\", suffix=\"\"):\n (progress, current_run_time, expected_time, expected_rest_time) = self.step()\n clear_output(True)\n if prefix != \"\":\n print(prefix)\n print(\"Current progress: {:3.1f} %\".format(progress) )\n print(\"#\" * int(progress*0.3))\n seconds, minutes, hours = self._calc_times(current_run_time)\n print(\"Current run time: {:02d}:{:02d}:{:02d}\".format(hours,minutes,seconds))\n seconds, minutes, hours = self._calc_times(expected_rest_time)\n print(\"Expected time to finish: {:02d}:{:02d}:{:02d}\".format(hours,minutes,seconds))\n if suffix != \"\":\n print(suffix)","def print_string(self):\n for x in self.minimal:\n print(\"min: %s\" % x)\n for x in self.also_installed:\n print(\"als: %s\" % x)\n for x in self.uninstalled:\n print(\"uni: %s\" % x)","def debug(self):\r\n for test in self:\r\n test.debug()","def test_numbers(number):\n print(\"\\nRunning test_numbers with {}\".format(number))","def print_result(testcase, passed):\n print '{:<6}{}'.format('{}:'.format(testcase), \"allowed\" if passed else \"blocked\")","def run_tests():\r\n p = Parser(b\"0About prices\\tPrices/aboutus\\tserver.example.com\\t70\\r\\n\".decode(\"ascii\"))\r\n print(p._parse_dir())","def runAllTests():\n\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\n\tnTests = ttr.testsRun + len(ttr.skipped)\n\tprint(\"Report:\")\n\tprint(\"\\t\" + str(len(ttr.failures)) + \"/\" + str(nTests) + \" failed\")\n\tprint(\"\\t\" + str(len(ttr.errors)) + \"/\" + str(nTests) + \" errors\")\n\tprint(\"\\t\" + str(len(ttr.skipped)) + \"/\" + str(nTests) + \" skipped\")","def print_prefix(self):\n if self.is_empty():\n return \"\"\n else:\n ch = str(self.root_value())\n if self.is_leaf():\n return ch\n else:\n if self.has_left():\n if self.has_right():\n return ch + \" \" + self.get_left().print_prefix() + \" \" + self.get_right().print_prefix()\n else:\n return ch + \" \" + self.get_left().print_prefix()\n else:\n return ch + \" \" + self.get_right().print_prefix()","def print_header(self):\n print(\"\\nTesting {} - {}\\n\".format(self.__schema_name, self.__schema_path))","def report(self, results):\n self.notice(\"Test Report\\n\")\n\n for count, group in enumerate(results, 1):\n results = (self._format_test(test, res) for test, res in group)\n results = (', ').join(results)\n self.notice(\"Test group %s:\\t%s\" % (count, results))\n\n self.divider()","def run_tests():\n def print_result(result, correct):\n if result == correct:\n print(\" OK!\")\n else:\n print(f\" Failed ({result} != {correct})!\")\n for n, test in enumerate(_tests, start=1):\n print(f\"Running test {n}...\")\n nums = line2ints(test[\"in\"])\n try:\n correct = test[\"part1\"]\n except KeyError:\n pass\n else:\n print(\" Testing part 1...\", end=\"\")\n result = part1(nums, steps=test.get(\"phases1\", 100))\n print_result(result, correct)\n try:\n correct = test[\"part2\"]\n except KeyError:\n pass\n else:\n print(\" Testing part 2...\", end=\"\")\n result = part2(nums, steps=test.get(\"phases2\", 100))\n print_result(result, correct)","def printout_all(self, indent_level):\n indent = \" \"*indent_level*INDENTATION_MULTIPLIER\n\n print(indent, \"Test Case ID:\", self.ID, sep='')\n print(indent, \"|-name:\", self.name, sep='')\n\n print(indent, \"|-JIRA URL:\", self.JIRA_URL, sep='')","def startTest(self, test):\n # Get our bearings\n test = proto_test(test)\n current_module = test.module\n current_class = test.class_name\n\n # Output\n if self.showAll:\n # Module...if it changed.\n if current_module != self.last_module:\n self.stream.writeln(self.colors.moduleName(current_module))\n # Class...if it changed.\n if current_class != self.last_class:\n self.stream.writeln(\n self.colors.className(\n self.stream.formatText(current_class, indent=1)\n )\n )\n if self.stream.isatty():\n # In the terminal, we will write a placeholder, and then\n # modify the first character and rewrite it in color after\n # the test has run.\n self.first_text_output = self.stream.formatLine(\n test.getDescription(self.verbose), indent=2\n )\n self.stream.write(self.colors.bold(self.first_text_output))\n self.stream.flush()\n\n # Set state for next time\n if current_module != self.last_module:\n self.last_module = current_module\n if current_class != self.last_class:\n self.last_class = current_class","def get_a_list_of_testset_names() -> str:\n message = 'The available test sets are:'\n for testset in sorted(DATASETS.keys(), reverse=True):\n message += '\\n%20s: %s' % (testset, DATASETS[testset].get('description', ''))\n return message","def print_test_file(data):\n set_get_pairs = determine_set_get_pairs(data['methods'])\n visited_pairs = []\n full_class_name = data['name']\n s = full_class_name.split('::')\n class_name = s.pop()\n with open('tests.txt', 'a') as f:\n f.write('\\n')\n f.write(\"\"\"\nconst libCellMLModule = require('libcellml.js/libcellml.common')\nlet libcellml = null\n\n\"\"\")\n f.write(f'describe(\"{class_name} tests\", () => {{\\n')\n f.write(\"\"\" beforeAll(async () => {\n libcellml = await libCellMLModule();\n });\n\"\"\")\n for key in data['methods']:\n s = key.split('::')\n function_name = s.pop()\n\n base_function_name = convert_to_base_method_name(function_name)\n if base_function_name in visited_pairs:\n continue\n is_pair = base_function_name in set_get_pairs\n if is_pair:\n visited_pairs.append(base_function_name)\n method_information = data['methods'][key]\n if len(method_information) == 1:\n print_test(f, class_name, function_name, is_pair=is_pair)\n else:\n for info in method_information:\n print_test(f, class_name, function_name, overload=True)\n f.write('})\\n')","def startTest(self, test):\n\n if self.showAll:\n progress = f'[{next(self.test_numbers)}/{self.test_case_count}] '\n self.stream.write(progress)\n\n # Also store the progress in the test itself, so that if it errors,\n # it can be written to the exception information by our overridden\n # _exec_info_to_string method:\n test.progress_index = progress\n\n return super(CustomTextTestResult, self).startTest(test)","def gen_stdout_test_msg(bibfile_data, verbose=False):\n msg_list = [bibfile.test_msg(verbose) for bibfile in bibfile_data]\n msg = \"\\n\".join(msg_list)\n return msg","def list_tests(arn=None, nextToken=None):\n pass","def list_feature_tests(self):\n\t\treturn self.test_names","def test_correct(self):\n tests = [\n 'KIF.test1',\n 'KIF.test2',\n ]\n expected = 'NAME:test1|test2'\n\n self.assertEqual(expected, test_apps.get_kif_test_filter(tests))","def test_func(verbose: bool) -> None:\n click.echo(verbose)","def test():\n\t\treturn [\"vice.multizone\",\n\t\t\t[\n\t\t\t\ttest_from_output(),\n\t\t\t\tmig_matrix_row.test(run = False),\n\t\t\t\tmig_matrix.test(run = False),\n\t\t\t\tmig_specs.test(run = False),\n\t\t\t\tzone_array.test(run = False),\n\t\t\t\t_multizone.test(run = False),\n\t\t\t\tsrc_test(run = False)\n\t\t\t]\n\t\t]","def test_wildcard(self):\n expected_out = '\\n'.join([\n \"Starting transaction\",\n \"Adding Rs. 1000 to account balance\",\n \"Transaction successful\"\n ])\n self.bank_obj.credit(1000)\n self.assertEquals(sys.stdout.getvalue().strip(), expected_out)","def test_simple(self):\n exp = ['(', '(', 'h', ',', 'p', ')', 'hp', ',', 'g', ')', 'hpg', ';']\n content = '((h,p)hp,g)hpg;'\n self._do_test(content, exp)\n content = '((h,p[test])hp,g)hpg;'\n self._do_test(content, exp)\n content = ' ( ( h , p[test] [test2]) hp, g) hpg ;'\n self._do_test(content, exp)","def testing(self):\n print('test successful')","def output_test():\n\toutput_comparison_page(TEST_EVENT_LIST, TEST_COMPARISON_PAGE_FILEPATH)","def startTest(self, test):\n\n super(ForceBalanceTestResult, self).startTest(test)\n self.logger.debug(\"\\n>>> Starting %s\\n\" % test.id())\n self.logger.info(\">>> \" + test.shortDescription())","def print_summary(self):\n #exec(\"print(storyline.{}_clause+', '+storyline.{}_clause.lower()+', '+storyline.{}_clause.lower())\".format(\"A\", \"B\", \"C\"))\n #exec(\"print(self.{}_clause+', '+self.{}_clause.lower()+', '+self.{}_clause.lower())\".format(\"A\", \"B\", \"C\"))\n lwr = \".lower()\"\n exec(\"print(\"+str(3*(\"self.{}_clause{}+',', \")).format(\"A\",\"\",\"B\",lwr,\"C\",lwr)+\"'\\b\\b')\")","def test_dummy():"],"string":"[\n \"def print_tests_results(self):\\n\\n for test in self.test_report:\\n for detail in test:\\n print detail + ': ', test[detail]\",\n \"def test(got, expected):\\r\\n if got == expected:\\r\\n prefix = \\\" OK \\\"\\r\\n else:\\r\\n prefix = \\\" X \\\"\\r\\n print(\\\"%s got: %s expected: %s\\\" % (prefix, repr(got), repr(expected)))\",\n \"def test(got, expected):\\n if got == expected:\\n prefix = \\\" OK \\\"\\n else:\\n prefix = \\\" X \\\"\\n print(\\\"%s got: %s expected: %s\\\" % (prefix, repr(got), repr(expected)))\",\n \"def print_results(self):\\n for test_cases in self._tests:\\n for test_case in test_cases:\\n print('{} ...ok'.format(test_case.get_name()))\\n return 0\",\n \"def test(self):\\n # -- Test --\\n\\n # (1)\\n\\n # (2)\\n\\n # (3)\\n\\n # (4)\\n # -- Test --\",\n \"def print_test_comparison(test_name, expected, result):\\n line = \\\"\\\\n\\\"\\n line += \\\"-\\\" * 60 + \\\"\\\\n\\\"\\n line += \\\"{}\\\\n\\\".format(test_name)\\n line += \\\"-\\\" * 60 + \\\"\\\\n\\\"\\n line += \\\"-\\\" * 26 + \\\"EXPECTED\\\" + \\\"-\\\" * 26 + \\\"\\\\n\\\"\\n line += \\\"{}\\\\n\\\".format(expected)\\n line += \\\"-\\\" * 28 + \\\"END\\\" + \\\"-\\\" * 29 + \\\"\\\\n\\\"\\n line += \\\"-\\\" * 27 + \\\"RESULT\\\" + \\\"-\\\" * 27 + \\\"\\\\n\\\"\\n line += \\\"{}\\\\n\\\".format(result)\\n line += \\\"-\\\" * 28 + \\\"END\\\" + \\\"-\\\" * 29 + \\\"\\\\n\\\"\\n line += \\\"\\\\n\\\"\\n return line\",\n \"def test_prefix(self):\\n self.chck_triple('prefix')\",\n \"def _test (self) :\\n print (_T (ckw.title or \\\"Baz\\\"))\\n print (_T (\\\"Foo\\\"))\\n foo = _(\\\"Markup %d\\\")\\n print (_T(foo) % 42)\\n print (_Tn (\\\"Singular\\\", \\\"Plural\\\", 4))\",\n \"def zio_test_help():\\n print(\\\"zio-ut [TESTS]\\\")\\n print(\\\"\\\")\\n print(\\\"[TESTS]: list of tests to perform. It can be the name of a specific test, or the name of a module of tests\\\")\\n print(\\\" In alternative, you che use the test code:\\\")\\n print(\\\"Code test case\\\")\\n print(\\\"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \\\")\\n i = 0\\n for t in test_list:\\n print(str(i) + \\\" \\\" + t)\\n i = i + 1\",\n \"def generate_test_string(self, test_log: dict, step: Union[int,None] = None) -> str:\\n print_str = 'Epoch {}, '.format(step) if step else ''\\n for k,v in test_log.items():\\n print_str = print_str + '{} : {:.4f}, '.format(k, v)\\n \\n return print_str[:-1]\",\n \"def test_code010(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code010 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def print_testvals(self):\\n print(self.use_planck)\",\n \"def test_name(self):\\r\\n parts = []\\r\\n if self.test.__module__ != '__main__':\\r\\n parts.append(self.test.__module__)\\r\\n if hasattr(self.test, 'im_class'):\\r\\n parts.append(self.test.im_class.__name__)\\r\\n parts.append(self.test.__name__)\\r\\n return '.'.join(parts)\",\n \"def tests():\",\n \"def test_code006(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code006 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def test_code001(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code001 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def print_tests(pkg):\\n\\n # Some built-in base packages (e.g., Autotools) define callback (e.g.,\\n # check) inherited by descendant packages. These checks may not result\\n # in build-time testing if the package's build does not implement the\\n # expected functionality (e.g., a 'check' or 'test' targets).\\n #\\n # So the presence of a callback in Spack does not necessarily correspond\\n # to the actual presence of built-time tests for a package.\\n for callbacks, phase in [\\n (pkg.build_time_test_callbacks, \\\"Build\\\"),\\n (pkg.install_time_test_callbacks, \\\"Install\\\"),\\n ]:\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"Available {0} Phase Test Methods:\\\".format(phase)))\\n names = []\\n if callbacks:\\n for name in callbacks:\\n if getattr(pkg, name, False):\\n names.append(name)\\n\\n if names:\\n colify(sorted(names), indent=4)\\n else:\\n color.cprint(\\\" None\\\")\\n\\n # PackageBase defines an empty install/smoke test but we want to know\\n # if it has been overridden and, therefore, assumed to be implemented.\\n color.cprint(\\\"\\\")\\n color.cprint(section_title(\\\"Stand-Alone/Smoke Test Methods:\\\"))\\n names = []\\n pkg_cls = pkg if inspect.isclass(pkg) else pkg.__class__\\n if has_test_method(pkg_cls):\\n pkg_base = spack.package_base.PackageBase\\n test_pkgs = [\\n str(cls.test)\\n for cls in inspect.getmro(pkg_cls)\\n if issubclass(cls, pkg_base) and cls.test != pkg_base.test\\n ]\\n test_pkgs = list(set(test_pkgs))\\n names.extend([(test.split()[1]).lower() for test in test_pkgs])\\n\\n # TODO Refactor START\\n # Use code from package_base.py's test_process IF this functionality is\\n # accepted.\\n v_names = list(set([vspec.name for vspec in pkg.virtuals_provided]))\\n\\n # hack for compilers that are not dependencies (yet)\\n # TODO: this all eventually goes away\\n c_names = (\\\"gcc\\\", \\\"intel\\\", \\\"intel-parallel-studio\\\", \\\"pgi\\\")\\n if pkg.name in c_names:\\n v_names.extend([\\\"c\\\", \\\"cxx\\\", \\\"fortran\\\"])\\n if pkg.spec.satisfies(\\\"llvm+clang\\\"):\\n v_names.extend([\\\"c\\\", \\\"cxx\\\"])\\n # TODO Refactor END\\n\\n v_specs = [spack.spec.Spec(v_name) for v_name in v_names]\\n for v_spec in v_specs:\\n try:\\n pkg_cls = spack.repo.path.get_pkg_class(v_spec.name)\\n if has_test_method(pkg_cls):\\n names.append(\\\"{0}.test\\\".format(pkg_cls.name.lower()))\\n except spack.repo.UnknownPackageError:\\n pass\\n\\n if names:\\n colify(sorted(names), indent=4)\\n else:\\n color.cprint(\\\" None\\\")\",\n \"def test_03_pass_print(self):\\n print('Hello World!')\",\n \"def test(): \\n\\treturn [\\\"vice.yields.ccsne.import\\\", \\n\\t\\t[ \\n\\t\\t\\ttest_LC18_import(), \\n\\t\\t\\ttest_CL13_import(), \\n\\t\\t\\ttest_CL04_import(), \\n\\t\\t\\ttest_WW95_import(), \\n\\t\\t\\ttest_NKT13_import(), \\n\\t\\t\\ttest_S16_import() \\n\\t\\t] \\n\\t]\",\n \"def test_generate_all_testing(self):\\n pass\",\n \"def test_print_result(capsys):\\n assert \\\"\\\"\\\"Total 5 hands solved\\nTotal 4 hands solved with hint\\nTotal 4 hands failed to solve\\\"\\\"\\\" in hl.test_help_print_result(capsys)\",\n \"def displayStdout(self, test):\\n test = proto_test(test)\\n if test.dotted_name in self.stdout_output:\\n self.stream.write(\\n \\\"\\\\n{} for {}\\\\n{}\\\".format(\\n self.colors.yellow(\\\"Captured stdout\\\"),\\n self.colors.bold(test.dotted_name),\\n self.stdout_output[test],\\n )\\n )\\n del self.stdout_output[test]\",\n \"def __str__(self):\\n return 'Observables Test Case: {0}'.format(self.title)\",\n \"def runTestsWithPrefix(testFile1,testFile2,prefix,outfile):\\n loader = unittest.TestLoader()\\n loader.testMethodPrefix = prefix\\n\\n #print(\\\"*** run test params \\\" + testFile1 + \\\", \\\" + testFile2 + \\\", \\\" + outfile)\\n # open the outfile as the destination of the output\\n f = open(outfile, \\\"w\\\")\\n\\n # reload the modules \\n if isfile(testFile1) and isfile(testFile2):\\n try:\\n imp.reload(lab01Funcs)\\n imp.reload(lab01Tests)\\n except Exception as inst:\\n print(inst)\\n return -1\\n\\n # add all the unit tests into the TestSuite object\\n suite = loader.discover('.', pattern = testFile1) \\n print(\\\"Cases %d\\\" % (suite.countTestCases()))\\n suite.addTest( loader.discover('.', pattern = testFile2) )\\n print(\\\"Cases %d\\\" % (suite.countTestCases()))\\n\\n # pass the file as the stream location for output\\n unittest.TextTestRunner(stream=f,verbosity=2).run(suite)\\n f.close()\",\n \"def test_print_start(self):\\n response = support.create_project(self, 'chicago')\\n self.assertFalse(\\n response.failed,\\n Message('should have created project', response=response)\\n )\\n\\n print_string = string.ascii_lowercase\\n\\n code = '\\\\n'.join([\\n 'import cauldron as cd',\\n 'print(\\\"{}\\\")'.format(print_string),\\n 'cd.display.text(\\\"Hello World\\\")'\\n ])\\n\\n support.add_step(self, contents=code)\\n\\n response = support.run_command('run -f')\\n self.assertFalse(\\n response.failed,\\n Message('should have run step', response=response)\\n )\\n\\n project = cauldron.project.get_internal_project()\\n dom = project.steps[1].dom # type: str\\n\\n self.assertEqual(\\n dom.count(print_string),\\n 2,\\n 'should have printed ascii lowercase'\\n )\",\n \"def print_functions(top):\\n global exnum\\n global callers\\n for item in top:\\n if 'cases' in item:\\n print_functions(item['cases'])\\n continue\\n exnum += 1\\n desc = re.sub('[^0-9a-zA-Z]+', '_', item['description'])\\n print >> F, ('void test_' + item['property'] + '_' +\\n desc.lower() + '(void)')\\n print >> F, '{'\\n if exnum == 2:\\n print >> F, (' TEST_IGNORE(); '\\n '// delete this line to run test')\\n elif exnum > 2:\\n print >> F, ' TEST_IGNORE();'\\n print >> F, ' /*'\\n print >> F, '----Input----'\\n print >> F, json.dumps(item['input'], indent=3)\\n print >> F, '---Expected---'\\n print >> F, json.dumps(item['expected'], indent=3)\\n print >> F, ' */'\\n print >> F, '}'\\n print >> F\\n callers += (' RUN_TEST(test_' + item['property'] + '_' +\\n desc.lower() + ');')\\n callers += '\\\\n'\\n return\",\n \"def test_4():\",\n \"def test_code007(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code007 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def tests(c):\\n results = [test(c, i) for i, test_path in enumerate(TEST_PATHS)]\\n print('\\\\n\\\\n\\\\n############## SUMMARY ##############')\\n for i, test_path in enumerate(TEST_PATHS):\\n print(i, test_path, 'PASSED' if result[i] == 0 else 'FAILED')\",\n \"def test_code009(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code009 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def logTestName(self):\\n logging.info('%s', self.id())\",\n \"def test():\\n v_print(1, \\\"-vvv Verbose 1 - INFO\\\")\\n v_print(2, \\\"-vv Verbose 2 - WARN\\\")\\n v_print(3, \\\"-v Verbose 3 - ERROR\\\")\",\n \"def create_python_tests(fout):\\n for keyword in LibraryDocBuilder().build('FusionLibrary').keywords:\\n print(keyword.name)\\n fout.write('Test {}\\\\n'.format(keyword.name))\\n fout.write(' [Documentation] {}\\\\n'.format(keyword.name))\\n fout.write(' {} '.format(keyword.name))\\n for arg in keyword.args:\\n if '=' in arg:\\n fout.write(' {} '.format(arg.split('=')[-1]))\\n else:\\n if arg.startswith('&'):\\n fout.write(' testk=testv ')\\n else:\\n fout.write(' test ')\\n fout.write('\\\\n\\\\n')\",\n \"def template_for_test_functions():\\r\\n\\r\\n expected = \\\"\\\"\\r\\n actual = \\\"\\\"\\r\\n print_test_results(func, expected, actual)\",\n \"def test_code004(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code004 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def main():\\n assert_verbose(triple(\\\"hello\\\"), \\\"hhheeellllllooo\\\")\\n assert_verbose(triple(\\\"kevin szuchet\\\"), \\\"kkkeeevvviiinnn ssszzzuuuccchhheeettt\\\")\\n assert_verbose(triple(\\\" \\\"), \\\" \\\")\\n assert_verbose(triple(\\\"\\\"), \\\"\\\")\\n print(\\\"--- All tests passed ---\\\")\",\n \"def _generate_test_name(source):\\n out = source.replace(' ', '_').replace(':', '').replace(',', '').lower()\\n return \\\"test_%s\\\" % out\",\n \"def test_title(names):\",\n \"def test_basic(self):\\n test_cases = (\\n makeSimpleTestCase('nicki minaj'),\\n makeSimpleTestCase('jay-z'),\\n makeTestCase('jay z', Matcher(title=Equals('jay-z'))),\\n makeSimpleTestCase('passion pit'),\\n makeSimpleTestCase('red hot chili peppers'),\\n makeSimpleTestCase('the temper trap'),\\n makeTestCase('glitch mob', Matcher(title=Equals('the glitch mob'))),\\n makeTestCase('kanye', Matcher(title=Equals('kanye west'))),\\n makeSimpleTestCase('justin bieber'),\\n makeTestCase('carly rae', Matcher(title=Equals('carly rae jepsen'))),\\n makeSimpleTestCase('johnny cash'),\\n makeTestCase('waylon', Matcher(title=Equals('waylon jennings'))),\\n makeTestCase('tmbg', Matcher(title=Equals('they might be giants'))),\\n makeSimpleTestCase('mgmt'),\\n makeSimpleTestCase('rjd2'),\\n makeTestCase('B.o.B', Matcher(title=StartsWith('B.o.B'))),\\n makeSimpleTestCase('50 cent'),\\n makeTestCase('50', Matcher(title=Equals('50 cent'))),\\n makeTestCase('fifty cent', Matcher(title=Equals('50 cent'))),\\n makeSimpleTestCase('katy perry'),\\n makeSimpleTestCase('alison krauss'),\\n makeSimpleTestCase('the highwaymen'),\\n makeSimpleTestCase('flo rida'),\\n # TODO: Will this ever work? We don't have recordings by Mozart, just recordings of music he composed.\\n # Do we really want to try to support composers?\\n makeSimpleTestCase('mozart')\\n )\\n\\n self._run_tests('basic_artist', test_cases)\",\n \"def prepend_type(prefix, test_list):\\n br_test = 'buildrunner_tests'\\n return (\\n ['%s_%s' % (prefix, value) for value in test_list if value != br_test] +\\n filter(br_test.__eq__, test_list)) # Add back in buildrunner_tests.\",\n \"def test_print_multiple(self):\\n response = support.create_project(self, 'omaha')\\n self.assertFalse(\\n response.failed,\\n Message('should have created project', response=response)\\n )\\n\\n code = '\\\\n'.join([\\n 'import cauldron as cd',\\n 'import string',\\n 'print(string.ascii_lowercase)',\\n 'cd.display.text(\\\"Hello World\\\")',\\n 'print(string.ascii_uppercase)',\\n 'print(string.hexdigits)'\\n ])\\n\\n support.add_step(self, contents=code)\\n\\n response = support.run_command('run -f')\\n self.assertFalse(\\n response.failed,\\n Message('should have run step', response=response)\\n )\\n\\n project = cauldron.project.get_internal_project()\\n dom = project.steps[1].dom # type: str\\n\\n self.assertEqual(\\n dom.count(string.ascii_lowercase),\\n 1,\\n 'should have printed ascii lowercase'\\n )\\n\\n self.assertEqual(\\n dom.count(string.ascii_uppercase),\\n 1,\\n 'should have printed ascii uppercase'\\n )\\n\\n self.assertEqual(\\n dom.count(string.hexdigits),\\n 1,\\n 'should have printed hex digits'\\n )\",\n \"def test_prefix_tokens(self):\\n args = [\\n '--model-file',\\n 'zoo:unittest/transformer_generator2/model',\\n '--model',\\n 'test_agents/transformer_generator_prefix',\\n '--inference',\\n 'beam',\\n '--truncate',\\n '1024',\\n '--beam-size',\\n '2',\\n ]\\n pp = ParlaiParser(True, True)\\n agent = create_agent(pp.parse_args(args), True)\\n obs = {'text': '1 2 3 4 ' * 256, 'episode_done': False}\\n agent.observe(obs)\\n act = agent.act()\\n beam_texts = [x[0] for x in act['beam_texts']]\\n for beam in beam_texts:\\n # check that all beams start with the prefix text\\n assert beam.startswith(\\n PREFIX_TEXT\\n ), f\\\"[{beam}] does not start with [{PREFIX_TEXT}]\\\"\",\n \"def test_print_solo(self):\\n response = support.create_project(self, 'minneapolis')\\n self.assertFalse(\\n response.failed,\\n Message('should have created project', response=response)\\n )\\n\\n print_string = string.ascii_lowercase\\n\\n code = '\\\\n'.join([\\n 'values = [x ** 2 for x in range(100)]',\\n 'print(\\\"{}\\\")'.format(print_string)\\n ])\\n\\n support.add_step(self, contents=code)\\n\\n response = support.run_command('run -f')\\n self.assertFalse(\\n response.failed,\\n Message('should have run step', response=response)\\n )\\n\\n project = cauldron.project.get_internal_project()\\n dom = project.steps[1].dom # type: str\\n\\n self.assertEqual(\\n dom.count(print_string),\\n 2,\\n 'should have printed ascii lowercase'\\n )\",\n \"def main():\\n num_of_tests = int(input())\\n\\n # iterate over test cases\\n for test_case in range(1, num_of_tests + 1):\\n result = handle_case()\\n printable_result = handle_result(result)\\n print(\\\"Case #{}: {}\\\".format(test_case, printable_result))\",\n \"def __str__(self):\\n return '%s; %s' % (self.id, unittest.TestCase.__str__(self))\",\n \"def list(self):\\n print \\\"\\\\nAvailable Test Cases\\\"\\n print \\\"====================\\\"\\n for case in self.cases:\\n print case.__name__\",\n \"def visitTests(tests, grepStr=''):\\n\\n # First flatten the list of tests.\\n testsFlat = []\\n toCheck = [t for t in tests]\\n while toCheck:\\n test = toCheck.pop()\\n if isinstance(test, unittest.TestSuite):\\n toCheck += [t for t in test]\\n else:\\n if grepStr in str(type(test)):\\n testsFlat.append(test)\\n testsFlat.sort()\\n\\n # Follow the flattened list of tests and show the module, class\\n # and name, in a nice way.\\n lastClass = None\\n lastModule = None\\n \\n grepPrint = '' if grepStr is '' else red(' (grep: %s)'%grepStr)\\n\\n for t in testsFlat:\\n moduleName, className, testName = t.id().rsplit('.', 2)\\n \\n # If there is a failure loading the test, show it\\n if moduleName.startswith('unittest.loader.ModuleImportFailure'):\\n print red(moduleName), \\\" test:\\\", t.id()\\n continue\\n\\n if moduleName != lastModule:\\n lastModule = moduleName\\n print(\\\" - From %s.py (to run all use --allPrograms)\\\"\\n % '/'.join(moduleName.split('.')) + grepPrint)\\n\\n\\n if className != lastClass:\\n lastClass = className\\n print(\\\" ./xmipp test %s\\\" % className)\",\n \"def do_test(name, digits, limit=85):\\n line = '##' + '#'*len(name) + '##'\\n print (line)\\n print ('# ' + name + ' #')\\n print (line)\\n\\n observed = count(digits,limit)\\n expected = expected_coupons(observed)\\n\\n test.make_test(observed, expected, 'Test du CDC : '+name, 'r', 'Nombre d\\\\'occurences')\",\n \"def test_backend_name_reporting_with_prefix(self):\\n for volume_id in self.volume_id_list_with_prefix:\\n self._test_backend_name_reporting_by_volume_id(volume_id)\",\n \"def pytest_terminal_summary(self, terminalreporter, exitstatus):\\n # pylint: disable=unused-argument\\n terminalreporter.section(\\\"Test Information\\\")\\n for test, info in self._info.items():\\n for datum in info:\\n terminalreporter.write(\\\"{}: {}\\\\n\\\".format(test, datum))\",\n \"def test_code008(self, *test_code_args, **test_code_kwargs):\\n print(\\\"This is test_code008 from TestDefinition #\\\", self.ID, \\\", test case #\\\", self.test_case_ID, sep='')\",\n \"def test_print(chikin):\\n chikin.print()\",\n \"def name_python_package_tests(self) -> str:\\n return f'test_{self.name}'\",\n \"def generate_test_list(tdir):\\n\\n # Skip this if it already exists\\n if os.path.exists(os.path.join(tdir.name, \\\"kstest-list\\\")):\\n return\\n\\n kstest_log = os.path.join(tdir.name, \\\"kstest.log\\\")\\n with open(kstest_log) as f:\\n for line in f.readlines():\\n if not line.startswith(\\\"Running tests: \\\"):\\n continue\\n\\n tests = [os.path.basename(os.path.splitext(s)[0]) for s in line[15:].split()]\\n with open(os.path.join(tdir.name, \\\"kstest-list\\\"), \\\"wt\\\") as klf:\\n for t in tests:\\n print(t, file=klf)\\n break\",\n \"def test_5():\",\n \"def _RemoveAllPrefixes(test):\\n test_name_start = max(test.find('.'), 0)\\n if test_name_start == 0:\\n return test\\n\\n test_suite = test[: test_name_start]\\n test_name = test[test_name_start + 1 :]\\n pre_position = test_name.find(_PRE_TEST_PREFIX)\\n while pre_position == 0:\\n test_name = test_name[len(_PRE_TEST_PREFIX):]\\n pre_position = test_name.find(_PRE_TEST_PREFIX)\\n base_test = '%s.%s' % (test_suite, test_name)\\n return base_test\",\n \"def testbed_name(self): \\n return \\\"C-Lab\\\"\",\n \"def test_T01():\",\n \"def test_1():\",\n \"def teststartprint(self):\\n import Intelligence\\n res = Intelligence.Intelligence.startprint(self)\\n exp = (\\\"Welcome to the Dice Game of life. We will play using the rules of Pig. One dice.\\\" +\\n \\\"\\\\nYour rolled numbers will add together.\\\" +\\n \\\"\\\\nYou may also hold at anytime, which will add your numbers together and give the turn to the other player.\\\" +\\n \\\"\\\\nThe catch is that if you roll a 1, your turn is over and your temporary points are wasted.\\\")\\n self.assertEqual(res,exp)\",\n \"def setUp(self):\\n chars = string.ascii_uppercase + string.digits\\n self.file_text = ''.join(random.choice(chars) for x in range(6))\\n self.file_text = \\\"Dummy Test: %s\\\" % self.file_text\\n self.VERBOSE = False\",\n \"def check_new_test(test):\\n msg = \\\"Test '%s' was run for the first time with the following output:\\\\n\\\"\\n print(Ansi.clear_screen())\\n print(Ansi.in_color(msg % test.name, Ansi.WHITE))\\n\\n for line in test.output.split(\\\"\\\\n\\\")[:-1]:\\n print(\\\" \\\", line)\\n\\n ask_for_blessing(test)\",\n \"def _print_results_header(self):\\n print(\\\"\\\\033[94m\\\"+\\\"Summary\\\\n\\\"+\\\"-\\\"*32+\\\"\\\\033[0m\\\")\\n print(\\\"Subroutine: {}\\\".format(self.mc_sample.__name__))\\n print(\\\"Num Runs: {:2.1e}\\\".format(self.num_runs))\\n print(\\\"-\\\"*32+'\\\\n')\",\n \"def test_foo(person):\\n print('\\\\n hello, ' + person + ' !')\",\n \"def parse_gtest_tests(gtest_output_raw: str):\\n test_list = []\\n current_test_prefix = ''\\n gtest_output_split = gtest_output_raw.split('\\\\n')\\n current_index = 0\\n # skip to the actual test list\\n while current_index < len(gtest_output_split):\\n current_string = gtest_output_split[current_index]\\n test_matches = re.findall(r'^[a-zA-Z]*\\\\.$', current_string)\\n if len(test_matches) != 0:\\n break\\n current_index += 1\\n while current_index < len(gtest_output_split):\\n current_string = gtest_output_split[current_index]\\n if len(current_string) == 0:\\n current_index += 1\\n continue\\n # get the test name\\n test_match = re.findall(r'^\\\\s*\\\\S*', current_string)[0].replace(' ', '')\\n if test_match[len(test_match) - 1] == '.':\\n # We've found a new prefix\\n current_test_prefix = test_match\\n current_index += 1\\n continue\\n test_list.append(current_test_prefix + test_match)\\n current_index += 1\\n return test_list\",\n \"def create_print(prefix):\\n def inner(*args):\\n print prefix + str(args)\\n return inner\",\n \"def print_summary(self):\\n #outcomes = self.get_outcomes()\\n #passes = 'Passes: %i' % sum(1 for outcome in outcomes if outcome == Result.PASS)\\n #untested = 'Untested: %i' % sum(1 for outcome in outcomes if outcome == Result.UNTESTED)\\n #errors = 'Errors: %i' % sum(1 for outcome in outcomes if outcome == Result.ERROR)\\n #fails = 'Fails: %i' % sum(1 for outcome in outcomes if outcome == Result.FAIL)\\n print('')\\n print ('Passes: %i' % self.get_pass_count())\\n print ('Fails: %i' % self.get_fail_count())\\n print ('Errors: %i' % self.get_error_count())\\n print ('Untested: %i' % self.get_untested_count())\\n print ('Skipped: %i' % self.get_skipped_count())\",\n \"def get_test_text(project_name):\\r\\n \\r\\n return \\\"\\\"\\\"\\r\\nfrom nose.tools import *\\r\\nimport %s\\r\\n\\r\\ndef setup():\\r\\n print \\\"SETUP!\\\"\\r\\n\\r\\ndef teardown():\\r\\n print \\\"TEAR DOWN!\\\"\\r\\n\\r\\ndef test_basic():\\r\\n print \\\"I RAN!\\\"\\r\\n \\\"\\\"\\\" % project_name\",\n \"def describe_tests(remit, sourcelist):\\n print('* run tests with \\\"%s\\\"' % remit)\\n print('* tests to run: ')\\n for line in pretty_list(sourcelist, 7):\\n print(' ' + line)\\n print('* writers to test: ')\\n for line in pretty_list(spec.TEST['writer'], 7):\\n print(' ' + line)\\n print('* options to test: ')\\n for line in pretty_list(spec.TEST['pandoc_options'], 7):\\n print(' ' + line)\\n print('* blacklisted: ')\\n for config in spec.BLACKLIST:\\n command = make_command(remit=remit,\\n source='TEST',\\n writer=config['writer'],\\n pandoc_options=config['pandoc_options'],\\n extension=config['extension'])\\n print(' ' + ' '.join(command))\\n print(' (' + config['comment'] + ')')\",\n \"def test_3():\",\n \"def __init__(self, stream, descriptions, verbosity):\\n\\n self.test_numbers = itertools.count(1)\\n stream.write(f\\\"================================================\\\\n ==== Starting Tests ====\\\\n================================================\\\\n\\\")\\n return super(CustomTextTestResult, self).__init__(stream, descriptions, verbosity)\",\n \"def test(self):\\n for doc, label in zip(self.test_docs(), self.test_labels()):\\n yield doc, label\",\n \"def step_print(self, prefix=\\\"\\\", suffix=\\\"\\\"):\\n (progress, current_run_time, expected_time, expected_rest_time) = self.step()\\n clear_output(True)\\n if prefix != \\\"\\\":\\n print(prefix)\\n print(\\\"Current progress: {:3.1f} %\\\".format(progress) )\\n print(\\\"#\\\" * int(progress*0.3))\\n seconds, minutes, hours = self._calc_times(current_run_time)\\n print(\\\"Current run time: {:02d}:{:02d}:{:02d}\\\".format(hours,minutes,seconds))\\n seconds, minutes, hours = self._calc_times(expected_rest_time)\\n print(\\\"Expected time to finish: {:02d}:{:02d}:{:02d}\\\".format(hours,minutes,seconds))\\n if suffix != \\\"\\\":\\n print(suffix)\",\n \"def print_string(self):\\n for x in self.minimal:\\n print(\\\"min: %s\\\" % x)\\n for x in self.also_installed:\\n print(\\\"als: %s\\\" % x)\\n for x in self.uninstalled:\\n print(\\\"uni: %s\\\" % x)\",\n \"def debug(self):\\r\\n for test in self:\\r\\n test.debug()\",\n \"def test_numbers(number):\\n print(\\\"\\\\nRunning test_numbers with {}\\\".format(number))\",\n \"def print_result(testcase, passed):\\n print '{:<6}{}'.format('{}:'.format(testcase), \\\"allowed\\\" if passed else \\\"blocked\\\")\",\n \"def run_tests():\\r\\n p = Parser(b\\\"0About prices\\\\tPrices/aboutus\\\\tserver.example.com\\\\t70\\\\r\\\\n\\\".decode(\\\"ascii\\\"))\\r\\n print(p._parse_dir())\",\n \"def runAllTests():\\n\\tttr = unittest.TextTestRunner(verbosity=3).run(suite())\\n\\tnTests = ttr.testsRun + len(ttr.skipped)\\n\\tprint(\\\"Report:\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.failures)) + \\\"/\\\" + str(nTests) + \\\" failed\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.errors)) + \\\"/\\\" + str(nTests) + \\\" errors\\\")\\n\\tprint(\\\"\\\\t\\\" + str(len(ttr.skipped)) + \\\"/\\\" + str(nTests) + \\\" skipped\\\")\",\n \"def print_prefix(self):\\n if self.is_empty():\\n return \\\"\\\"\\n else:\\n ch = str(self.root_value())\\n if self.is_leaf():\\n return ch\\n else:\\n if self.has_left():\\n if self.has_right():\\n return ch + \\\" \\\" + self.get_left().print_prefix() + \\\" \\\" + self.get_right().print_prefix()\\n else:\\n return ch + \\\" \\\" + self.get_left().print_prefix()\\n else:\\n return ch + \\\" \\\" + self.get_right().print_prefix()\",\n \"def print_header(self):\\n print(\\\"\\\\nTesting {} - {}\\\\n\\\".format(self.__schema_name, self.__schema_path))\",\n \"def report(self, results):\\n self.notice(\\\"Test Report\\\\n\\\")\\n\\n for count, group in enumerate(results, 1):\\n results = (self._format_test(test, res) for test, res in group)\\n results = (', ').join(results)\\n self.notice(\\\"Test group %s:\\\\t%s\\\" % (count, results))\\n\\n self.divider()\",\n \"def run_tests():\\n def print_result(result, correct):\\n if result == correct:\\n print(\\\" OK!\\\")\\n else:\\n print(f\\\" Failed ({result} != {correct})!\\\")\\n for n, test in enumerate(_tests, start=1):\\n print(f\\\"Running test {n}...\\\")\\n nums = line2ints(test[\\\"in\\\"])\\n try:\\n correct = test[\\\"part1\\\"]\\n except KeyError:\\n pass\\n else:\\n print(\\\" Testing part 1...\\\", end=\\\"\\\")\\n result = part1(nums, steps=test.get(\\\"phases1\\\", 100))\\n print_result(result, correct)\\n try:\\n correct = test[\\\"part2\\\"]\\n except KeyError:\\n pass\\n else:\\n print(\\\" Testing part 2...\\\", end=\\\"\\\")\\n result = part2(nums, steps=test.get(\\\"phases2\\\", 100))\\n print_result(result, correct)\",\n \"def printout_all(self, indent_level):\\n indent = \\\" \\\"*indent_level*INDENTATION_MULTIPLIER\\n\\n print(indent, \\\"Test Case ID:\\\", self.ID, sep='')\\n print(indent, \\\"|-name:\\\", self.name, sep='')\\n\\n print(indent, \\\"|-JIRA URL:\\\", self.JIRA_URL, sep='')\",\n \"def startTest(self, test):\\n # Get our bearings\\n test = proto_test(test)\\n current_module = test.module\\n current_class = test.class_name\\n\\n # Output\\n if self.showAll:\\n # Module...if it changed.\\n if current_module != self.last_module:\\n self.stream.writeln(self.colors.moduleName(current_module))\\n # Class...if it changed.\\n if current_class != self.last_class:\\n self.stream.writeln(\\n self.colors.className(\\n self.stream.formatText(current_class, indent=1)\\n )\\n )\\n if self.stream.isatty():\\n # In the terminal, we will write a placeholder, and then\\n # modify the first character and rewrite it in color after\\n # the test has run.\\n self.first_text_output = self.stream.formatLine(\\n test.getDescription(self.verbose), indent=2\\n )\\n self.stream.write(self.colors.bold(self.first_text_output))\\n self.stream.flush()\\n\\n # Set state for next time\\n if current_module != self.last_module:\\n self.last_module = current_module\\n if current_class != self.last_class:\\n self.last_class = current_class\",\n \"def get_a_list_of_testset_names() -> str:\\n message = 'The available test sets are:'\\n for testset in sorted(DATASETS.keys(), reverse=True):\\n message += '\\\\n%20s: %s' % (testset, DATASETS[testset].get('description', ''))\\n return message\",\n \"def print_test_file(data):\\n set_get_pairs = determine_set_get_pairs(data['methods'])\\n visited_pairs = []\\n full_class_name = data['name']\\n s = full_class_name.split('::')\\n class_name = s.pop()\\n with open('tests.txt', 'a') as f:\\n f.write('\\\\n')\\n f.write(\\\"\\\"\\\"\\nconst libCellMLModule = require('libcellml.js/libcellml.common')\\nlet libcellml = null\\n\\n\\\"\\\"\\\")\\n f.write(f'describe(\\\"{class_name} tests\\\", () => {{\\\\n')\\n f.write(\\\"\\\"\\\" beforeAll(async () => {\\n libcellml = await libCellMLModule();\\n });\\n\\\"\\\"\\\")\\n for key in data['methods']:\\n s = key.split('::')\\n function_name = s.pop()\\n\\n base_function_name = convert_to_base_method_name(function_name)\\n if base_function_name in visited_pairs:\\n continue\\n is_pair = base_function_name in set_get_pairs\\n if is_pair:\\n visited_pairs.append(base_function_name)\\n method_information = data['methods'][key]\\n if len(method_information) == 1:\\n print_test(f, class_name, function_name, is_pair=is_pair)\\n else:\\n for info in method_information:\\n print_test(f, class_name, function_name, overload=True)\\n f.write('})\\\\n')\",\n \"def startTest(self, test):\\n\\n if self.showAll:\\n progress = f'[{next(self.test_numbers)}/{self.test_case_count}] '\\n self.stream.write(progress)\\n\\n # Also store the progress in the test itself, so that if it errors,\\n # it can be written to the exception information by our overridden\\n # _exec_info_to_string method:\\n test.progress_index = progress\\n\\n return super(CustomTextTestResult, self).startTest(test)\",\n \"def gen_stdout_test_msg(bibfile_data, verbose=False):\\n msg_list = [bibfile.test_msg(verbose) for bibfile in bibfile_data]\\n msg = \\\"\\\\n\\\".join(msg_list)\\n return msg\",\n \"def list_tests(arn=None, nextToken=None):\\n pass\",\n \"def list_feature_tests(self):\\n\\t\\treturn self.test_names\",\n \"def test_correct(self):\\n tests = [\\n 'KIF.test1',\\n 'KIF.test2',\\n ]\\n expected = 'NAME:test1|test2'\\n\\n self.assertEqual(expected, test_apps.get_kif_test_filter(tests))\",\n \"def test_func(verbose: bool) -> None:\\n click.echo(verbose)\",\n \"def test():\\n\\t\\treturn [\\\"vice.multizone\\\",\\n\\t\\t\\t[\\n\\t\\t\\t\\ttest_from_output(),\\n\\t\\t\\t\\tmig_matrix_row.test(run = False),\\n\\t\\t\\t\\tmig_matrix.test(run = False),\\n\\t\\t\\t\\tmig_specs.test(run = False),\\n\\t\\t\\t\\tzone_array.test(run = False),\\n\\t\\t\\t\\t_multizone.test(run = False),\\n\\t\\t\\t\\tsrc_test(run = False)\\n\\t\\t\\t]\\n\\t\\t]\",\n \"def test_wildcard(self):\\n expected_out = '\\\\n'.join([\\n \\\"Starting transaction\\\",\\n \\\"Adding Rs. 1000 to account balance\\\",\\n \\\"Transaction successful\\\"\\n ])\\n self.bank_obj.credit(1000)\\n self.assertEquals(sys.stdout.getvalue().strip(), expected_out)\",\n \"def test_simple(self):\\n exp = ['(', '(', 'h', ',', 'p', ')', 'hp', ',', 'g', ')', 'hpg', ';']\\n content = '((h,p)hp,g)hpg;'\\n self._do_test(content, exp)\\n content = '((h,p[test])hp,g)hpg;'\\n self._do_test(content, exp)\\n content = ' ( ( h , p[test] [test2]) hp, g) hpg ;'\\n self._do_test(content, exp)\",\n \"def testing(self):\\n print('test successful')\",\n \"def output_test():\\n\\toutput_comparison_page(TEST_EVENT_LIST, TEST_COMPARISON_PAGE_FILEPATH)\",\n \"def startTest(self, test):\\n\\n super(ForceBalanceTestResult, self).startTest(test)\\n self.logger.debug(\\\"\\\\n>>> Starting %s\\\\n\\\" % test.id())\\n self.logger.info(\\\">>> \\\" + test.shortDescription())\",\n \"def print_summary(self):\\n #exec(\\\"print(storyline.{}_clause+', '+storyline.{}_clause.lower()+', '+storyline.{}_clause.lower())\\\".format(\\\"A\\\", \\\"B\\\", \\\"C\\\"))\\n #exec(\\\"print(self.{}_clause+', '+self.{}_clause.lower()+', '+self.{}_clause.lower())\\\".format(\\\"A\\\", \\\"B\\\", \\\"C\\\"))\\n lwr = \\\".lower()\\\"\\n exec(\\\"print(\\\"+str(3*(\\\"self.{}_clause{}+',', \\\")).format(\\\"A\\\",\\\"\\\",\\\"B\\\",lwr,\\\"C\\\",lwr)+\\\"'\\\\b\\\\b')\\\")\",\n \"def test_dummy():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.668197","0.6677865","0.6658674","0.65337527","0.63311327","0.62027156","0.61702615","0.6143053","0.6114684","0.61015594","0.60133135","0.6003737","0.5984142","0.59417367","0.5937343","0.59372973","0.592105","0.59095734","0.59049034","0.58890426","0.58832073","0.58807653","0.5833785","0.5828341","0.5824818","0.5822344","0.58188415","0.5797855","0.57757765","0.5774259","0.5766675","0.57610697","0.5760259","0.5758911","0.5755515","0.5750444","0.5741939","0.57340705","0.57181704","0.5717025","0.57022905","0.57008886","0.5687417","0.56817937","0.56703657","0.56556857","0.56545055","0.5651804","0.5643056","0.5642792","0.5632637","0.5632546","0.5632469","0.5631641","0.562262","0.56176215","0.5608011","0.560204","0.55769014","0.55745906","0.557246","0.55631495","0.55548114","0.5551821","0.5548479","0.55471545","0.5543731","0.55421466","0.55370533","0.5525599","0.5521688","0.55158716","0.55130017","0.5508289","0.55068564","0.5505382","0.54994315","0.5494144","0.5493336","0.5485112","0.54754865","0.54752177","0.5459909","0.5456693","0.545604","0.54480326","0.544141","0.5440259","0.5439228","0.54381204","0.54372126","0.54360694","0.54350644","0.54251254","0.54210657","0.54180104","0.5414944","0.5409919","0.5402677","0.5402365","0.539972"],"string":"[\n \"0.668197\",\n \"0.6677865\",\n \"0.6658674\",\n \"0.65337527\",\n \"0.63311327\",\n \"0.62027156\",\n \"0.61702615\",\n \"0.6143053\",\n \"0.6114684\",\n \"0.61015594\",\n \"0.60133135\",\n \"0.6003737\",\n \"0.5984142\",\n \"0.59417367\",\n \"0.5937343\",\n \"0.59372973\",\n \"0.592105\",\n \"0.59095734\",\n \"0.59049034\",\n \"0.58890426\",\n \"0.58832073\",\n \"0.58807653\",\n \"0.5833785\",\n \"0.5828341\",\n \"0.5824818\",\n \"0.5822344\",\n \"0.58188415\",\n \"0.5797855\",\n \"0.57757765\",\n \"0.5774259\",\n \"0.5766675\",\n \"0.57610697\",\n \"0.5760259\",\n \"0.5758911\",\n \"0.5755515\",\n \"0.5750444\",\n \"0.5741939\",\n \"0.57340705\",\n \"0.57181704\",\n \"0.5717025\",\n \"0.57022905\",\n \"0.57008886\",\n \"0.5687417\",\n \"0.56817937\",\n \"0.56703657\",\n \"0.56556857\",\n \"0.56545055\",\n \"0.5651804\",\n \"0.5643056\",\n \"0.5642792\",\n \"0.5632637\",\n \"0.5632546\",\n \"0.5632469\",\n \"0.5631641\",\n \"0.562262\",\n \"0.56176215\",\n \"0.5608011\",\n \"0.560204\",\n \"0.55769014\",\n \"0.55745906\",\n \"0.557246\",\n \"0.55631495\",\n \"0.55548114\",\n \"0.5551821\",\n \"0.5548479\",\n \"0.55471545\",\n \"0.5543731\",\n \"0.55421466\",\n \"0.55370533\",\n \"0.5525599\",\n \"0.5521688\",\n \"0.55158716\",\n \"0.55130017\",\n \"0.5508289\",\n \"0.55068564\",\n \"0.5505382\",\n \"0.54994315\",\n \"0.5494144\",\n \"0.5493336\",\n \"0.5485112\",\n \"0.54754865\",\n \"0.54752177\",\n \"0.5459909\",\n \"0.5456693\",\n \"0.545604\",\n \"0.54480326\",\n \"0.544141\",\n \"0.5440259\",\n \"0.5439228\",\n \"0.54381204\",\n \"0.54372126\",\n \"0.54360694\",\n \"0.54350644\",\n \"0.54251254\",\n \"0.54210657\",\n \"0.54180104\",\n \"0.5414944\",\n \"0.5409919\",\n \"0.5402677\",\n \"0.5402365\",\n \"0.539972\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13293,"cells":{"query":{"kind":"string","value":"Testing Tuna is not null"},"document":{"kind":"string","value":"def test_Tuna(self):\n tuna = Tuna(\"1\", \"2\", \"3\", \"4\")\n self.assertIsNotNone(tuna)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def testIsNullTrueAgain(self):\n val = is_null('') \n self.assertTrue(val)","def test_non_thesis(non_thesis):\n assert non_thesis is None","def nulltest():","def testIsNullTrue(self):\n val = is_null(\"\") \n self.assertTrue(val)","def is_null(space, w_obj):\n return space.wrap(w_obj.tp == space.tp_null)","def has_value(var) :\n return var != None","def test_get_none(self):\n self.assertTrue(self.tester.get('Not_a_Sample') is None)","def test_get_none(self):\n self.assertTrue(self.tester.get('Not_a_Sample') is None)","def _test_empty(t):\n return t.is_empty()","def is_not_none(e):\n return e is not None","def is_null(value: Any) -> bool:\n return not value","def not_none(value):\n return not value is None","def compare_with_none():\n value = {};\n if value is not None:\n print(\"value is not none\")\n else:\n print(\"value is none\")","def is_none(obj):\n return obj is None","def is_null(self):\n return self.value is None","def _val_is_null(self, val):\r\n return val is None","def is_null(self) -> bool:\n return self.allele1 == -1 and self.allele2 == -1","def testIsNullFalseAgain(self):\n val = is_null(5) \n self.assertFalse(val)","def test_get_none(self):\n self.assertTrue(self.tester.get('Not_a_Category') is None)","def test_get_none(self):\n self.assertTrue(self.tester.get('Not_a_Category') is None)","def test_valid_null(self):\n f = lws.valid_null\n assert f(None, '') is True\n assert f('asdasdasd', '') is True","def testIsNullFalse(self):\n val = is_null(\"False\") \n self.assertFalse(val)","def is_null(val):\n return (val is None)","def test_null_has_no_value(self):\n\n class Node:\n my_metric = Metric(Int64)\n\n node = Node()\n node.my_metric = None\n my_metric = get_metric_object(node, 'my_metric')\n tahu_metric = my_metric.tahu_metric(node)\n self.assertFalse(tahu_metric.HasField('long_value'))","def test_is_null(self):\n\n class Node:\n my_metric = Metric(Int64)\n\n node = Node()\n node.my_metric = None\n my_metric = get_metric_object(node, 'my_metric')\n tahu_metric = my_metric.tahu_metric(node)\n self.assertTrue(tahu_metric.is_null)","def exist(x):\n return x is not None","def assert_is_not_none(self, obj):\n if obj is None:\n raise AssertionError('unexpectedly None')","def isnull(obj):\n return _isnull(obj)","def isnull(inputobject):\n return isinstance(inputobject, matrix) and inputobject.y == 0","def is_driver_null(data):\n return data == DRIVER_NULL","def is_null(var):\r\n if var is None or not var: return True\r\n if any(isinstance(var, s) for s in [str, list, tuple, set]) and len(var) == 0: return True\r\n if isinstance(var, str) and var == '': return True\r\n if any( isinstance(var, s) for s in [int, float, complex, bool] ) and int(var) == 0: return True\r\n return False","def is_empty(self):","def is_empty(self):","def assert_is_none(self, obj):\n if obj is not None:\n raise AssertionError('%s is not None' % (str(obj),))","def filter_is_not_null(self, queryobject):\n raise NotImplementedError()","def check_foobar(self):\n return self.foobar < 10 if self.foobar is not None else NA","def notnull(obj):\n res = isnull(obj)\n if is_scalar(res):\n return not res\n return ~res","def filter_is_null(self, queryobject):\n raise NotImplementedError()","def valid(rv:Optional[int])->bool:\n # return False # stub\n # template from optional\n if rv is None:\n return False\n else:\n return True\n \n \n\n\n start_testing()","def is_tableau_empty(self):\n return all(self.tableau[i] is None for i in range(28))","def isEmpty(self):\n return self.first is None","def isNullFraudProof(tx):\n txIn = tx.txIn[0]\n if txIn.blockHeight != wire.NullBlockHeight:\n return False\n elif txIn.blockIndex != wire.NullBlockIndex:\n return False\n\n return True","def test_check_explainer_1(self):\n explainer = None\n assert check_explainer(explainer) == None","def is_null(self):\n return self._internal_handle() == 0","def is_null(self):\n return self._internal_handle() == 0","def is_null(self):\n return self._internal_handle() == 0","def is_null(self):\n return self._internal_handle() == 0","def is_null(self):\n return self._internal_handle() == 0","def is_null(self):\n return self.length2 < pygonal.EPSILON2","def isna(self):\n return super().isna()","def assert_is_not_none(self, expr, msg=None):\r\n assert expr is not None","def non_empty(val):\n return val is not None and val != \"\"","def not_empty(verifield, required):\n if not required: return True\n return not not verifield and verifield is not None","def test_query_no_def_none(self):\n self.assertEqual(\n query_yes_no(question=\"Is anyone wiser than Socrates?\", default=None), False\n )","def _check_notnull(self):\n candnull = self.df_test_resampled[self.candidate_col_name].isnull().all()\n refnull = self.df_test_resampled[self.reference_col_name].isnull().all()\n if candnull or refnull:\n return 1, 'No data for selected time frame'\n else:\n return 0, 'No error occurred'","def null_check(cur,code,table,passvalue):\n cur.execute(code)\n result = cur.fetchall()[0][0]\n if result == passvalue:\n print(f\"Data Quality check passed. {table} doesn't have any null values.\")\n else:\n print(f\"Data quality check failed. {table} has null values.\")","def test_null_as_null_indicator(self):\n self.custom_null_indicator_template('null')","def test_scalar_none() -> None:\n mock_session = UnifiedAlchemyMagicMock()\n data = mock_session.query(Model).scalar()\n assert data is None","def test_query_1(self):\n with app.test_request_context():\n agency_none = db.session.query(\n Agency).filter_by(name=\"not here\").first()\n self.assertTrue(agency_none is None)","def test_none(self):\n arr = np.empty(0)\n out = ternary(arr)\n self.assertTrue(hasattr(out, \"tax\"))\n self.assertEqual(\n type(out.tax), pyternary.ternary_axes_subplot.TernaryAxesSubplot\n )","def empty(self, value):\r\n return value is None","def empty(self, value):\r\n return value is None","def empty(self, value):\r\n return value is None","def empty(self, value):\r\n return value is None","def empty(self, value):\r\n return value is None","def is_empty(self, value, context):\n return (value is None)","def notna(self):\n return super().notna()","def assert_is_none(self, expr, msg=None):\r\n assert expr is None","def null() -> SetupVal:\n return NullVal()","def _is_null_value(self, value):\n if value is None:\n return True\n\n if IS_PY3:\n # Python 3.X\n if isinstance(value, str) and len(value) == 0:\n return True\n else:\n # Python 2.X\n if isinstance(value, basestring) and len(value) == 0: # NOQA: F821\n return True\n\n # TODO: This should probably be removed when solved in core Solr level?\n return False","def test_table_false_positives(self):\n pass","def testNoneValue(self):\n objectID = uuid4()\n user = createUser(u'username', u'password', u'User',\n u'user@example.com')\n namespace = createNamespace(user, u'name')\n tag = createTag(user, namespace, u'tag')\n self.store.add(TagValue(user.id, tag.id, objectID, None))","def test_expected_none(transformer, event):\n\n nodes = transformer.transform(event)\n\n assert nodes is None","def is_empty(self) -> bool:","def is_nullable(self) -> bool: # pragma: no cover\n pass","def EXIT_ON_NONE(var):\n\n try:\n if not var.any():\n pass\n except:\n if var == None:\n sys.exit(1)","def test_untyped(self):\n conn = self.connect()\n c = conn.cursor()\n c.execute(\"select null,''\")\n self.assertEqual((None, \"\"), c.fetchone())\n c.execute(\"select '',null\")\n self.assertEqual((\"\", None), c.fetchone())","def isNull(self):\n return self.__column is None","def isnone(cls, lhs, rhs):\n if rhs:\n return lhs is None\n else:\n return lhs is not None","def is_none_or_empty(obj):\n # type: (any) -> bool\n return obj is None or len(obj) == 0","def test_data_model_is_not_none_by_default():\n # Given\n context = DataContext()\n\n # Then\n assert context.photo_model is not None","def not_none(item, alt=None):\r\n\r\n return item if item is not None else alt","def assert_type_or_none(obj, classes):\n if obj is not None:\n assert_type(obj, classes)","def notNone(a):\n return a.count(None) != len(a)","def test_stochatreat_output_no_null_treats(treatments_dict):\n treatments_df = treatments_dict[\"treatments\"]\n assert treatments_df[\"treat\"].isnull().sum() == 0, \"There are null assignments\"","def test_empty_tree_contains(empty_t):\n empty_t.contains(1) == \"An empty tree has no values.\"","def test_none(self):\n self.assertEqual(b\"\", self.successResultOf(to_xml(None)))","def test_blank(self):\n self.assertEqual(1, 1)","def is_neutral(self, P):\n\t\treturn P.x is None","def nonull(val):\n return val if not pd.isnull(val) else None","def test_OBJT_pass(self):\n for O in self.mod.objts.itervalues():\n self.assertTrue(O.isset)","def test_get_with_None_value(self):\n self.assertEqual(self.config.get('none_types','some_value'),None)\n self.assertEqual(self.config.get('none_types','some_value','something'),'something')","def is_not_empty(obj):\n # type: (any) -> bool\n return obj is not None and len(obj) > 0","def test_build__set_none_values(self, valid_service: fixture) -> None:\n service: Service = valid_service\n\n assert (\n service.service_id is None\n and service.fare_price is None\n and service.max_schedule_time is None\n and service.shibboleth_affiliation is None\n and service.token_transit_fare_id is None\n )","def invariant(self):\n\t\treturn ((self.tenant != \"\") and (self.loginUser != \"\"))","def prove(self, query, context):\n return self.askOne(query, context) != None","def check_data_exist(data):\n if data is not None:\n if data.text is not None:\n return True\n return False","def test_id_type_none(self):\n obj = Base(None)\n self.assertTrue(obj.id is 1)","def _is_no_result(obj: Any) -> bool:\n return obj is NO_RESULT","def test_field_none_nullable(self):\n node_dict = {\n 'host_name': 'abc'\n }\n try:\n Node(**node_dict)\n except Exception as e:\n self.assertEqual(type(e), ValueError)"],"string":"[\n \"def testIsNullTrueAgain(self):\\n val = is_null('') \\n self.assertTrue(val)\",\n \"def test_non_thesis(non_thesis):\\n assert non_thesis is None\",\n \"def nulltest():\",\n \"def testIsNullTrue(self):\\n val = is_null(\\\"\\\") \\n self.assertTrue(val)\",\n \"def is_null(space, w_obj):\\n return space.wrap(w_obj.tp == space.tp_null)\",\n \"def has_value(var) :\\n return var != None\",\n \"def test_get_none(self):\\n self.assertTrue(self.tester.get('Not_a_Sample') is None)\",\n \"def test_get_none(self):\\n self.assertTrue(self.tester.get('Not_a_Sample') is None)\",\n \"def _test_empty(t):\\n return t.is_empty()\",\n \"def is_not_none(e):\\n return e is not None\",\n \"def is_null(value: Any) -> bool:\\n return not value\",\n \"def not_none(value):\\n return not value is None\",\n \"def compare_with_none():\\n value = {};\\n if value is not None:\\n print(\\\"value is not none\\\")\\n else:\\n print(\\\"value is none\\\")\",\n \"def is_none(obj):\\n return obj is None\",\n \"def is_null(self):\\n return self.value is None\",\n \"def _val_is_null(self, val):\\r\\n return val is None\",\n \"def is_null(self) -> bool:\\n return self.allele1 == -1 and self.allele2 == -1\",\n \"def testIsNullFalseAgain(self):\\n val = is_null(5) \\n self.assertFalse(val)\",\n \"def test_get_none(self):\\n self.assertTrue(self.tester.get('Not_a_Category') is None)\",\n \"def test_get_none(self):\\n self.assertTrue(self.tester.get('Not_a_Category') is None)\",\n \"def test_valid_null(self):\\n f = lws.valid_null\\n assert f(None, '') is True\\n assert f('asdasdasd', '') is True\",\n \"def testIsNullFalse(self):\\n val = is_null(\\\"False\\\") \\n self.assertFalse(val)\",\n \"def is_null(val):\\n return (val is None)\",\n \"def test_null_has_no_value(self):\\n\\n class Node:\\n my_metric = Metric(Int64)\\n\\n node = Node()\\n node.my_metric = None\\n my_metric = get_metric_object(node, 'my_metric')\\n tahu_metric = my_metric.tahu_metric(node)\\n self.assertFalse(tahu_metric.HasField('long_value'))\",\n \"def test_is_null(self):\\n\\n class Node:\\n my_metric = Metric(Int64)\\n\\n node = Node()\\n node.my_metric = None\\n my_metric = get_metric_object(node, 'my_metric')\\n tahu_metric = my_metric.tahu_metric(node)\\n self.assertTrue(tahu_metric.is_null)\",\n \"def exist(x):\\n return x is not None\",\n \"def assert_is_not_none(self, obj):\\n if obj is None:\\n raise AssertionError('unexpectedly None')\",\n \"def isnull(obj):\\n return _isnull(obj)\",\n \"def isnull(inputobject):\\n return isinstance(inputobject, matrix) and inputobject.y == 0\",\n \"def is_driver_null(data):\\n return data == DRIVER_NULL\",\n \"def is_null(var):\\r\\n if var is None or not var: return True\\r\\n if any(isinstance(var, s) for s in [str, list, tuple, set]) and len(var) == 0: return True\\r\\n if isinstance(var, str) and var == '': return True\\r\\n if any( isinstance(var, s) for s in [int, float, complex, bool] ) and int(var) == 0: return True\\r\\n return False\",\n \"def is_empty(self):\",\n \"def is_empty(self):\",\n \"def assert_is_none(self, obj):\\n if obj is not None:\\n raise AssertionError('%s is not None' % (str(obj),))\",\n \"def filter_is_not_null(self, queryobject):\\n raise NotImplementedError()\",\n \"def check_foobar(self):\\n return self.foobar < 10 if self.foobar is not None else NA\",\n \"def notnull(obj):\\n res = isnull(obj)\\n if is_scalar(res):\\n return not res\\n return ~res\",\n \"def filter_is_null(self, queryobject):\\n raise NotImplementedError()\",\n \"def valid(rv:Optional[int])->bool:\\n # return False # stub\\n # template from optional\\n if rv is None:\\n return False\\n else:\\n return True\\n \\n \\n\\n\\n start_testing()\",\n \"def is_tableau_empty(self):\\n return all(self.tableau[i] is None for i in range(28))\",\n \"def isEmpty(self):\\n return self.first is None\",\n \"def isNullFraudProof(tx):\\n txIn = tx.txIn[0]\\n if txIn.blockHeight != wire.NullBlockHeight:\\n return False\\n elif txIn.blockIndex != wire.NullBlockIndex:\\n return False\\n\\n return True\",\n \"def test_check_explainer_1(self):\\n explainer = None\\n assert check_explainer(explainer) == None\",\n \"def is_null(self):\\n return self._internal_handle() == 0\",\n \"def is_null(self):\\n return self._internal_handle() == 0\",\n \"def is_null(self):\\n return self._internal_handle() == 0\",\n \"def is_null(self):\\n return self._internal_handle() == 0\",\n \"def is_null(self):\\n return self._internal_handle() == 0\",\n \"def is_null(self):\\n return self.length2 < pygonal.EPSILON2\",\n \"def isna(self):\\n return super().isna()\",\n \"def assert_is_not_none(self, expr, msg=None):\\r\\n assert expr is not None\",\n \"def non_empty(val):\\n return val is not None and val != \\\"\\\"\",\n \"def not_empty(verifield, required):\\n if not required: return True\\n return not not verifield and verifield is not None\",\n \"def test_query_no_def_none(self):\\n self.assertEqual(\\n query_yes_no(question=\\\"Is anyone wiser than Socrates?\\\", default=None), False\\n )\",\n \"def _check_notnull(self):\\n candnull = self.df_test_resampled[self.candidate_col_name].isnull().all()\\n refnull = self.df_test_resampled[self.reference_col_name].isnull().all()\\n if candnull or refnull:\\n return 1, 'No data for selected time frame'\\n else:\\n return 0, 'No error occurred'\",\n \"def null_check(cur,code,table,passvalue):\\n cur.execute(code)\\n result = cur.fetchall()[0][0]\\n if result == passvalue:\\n print(f\\\"Data Quality check passed. {table} doesn't have any null values.\\\")\\n else:\\n print(f\\\"Data quality check failed. {table} has null values.\\\")\",\n \"def test_null_as_null_indicator(self):\\n self.custom_null_indicator_template('null')\",\n \"def test_scalar_none() -> None:\\n mock_session = UnifiedAlchemyMagicMock()\\n data = mock_session.query(Model).scalar()\\n assert data is None\",\n \"def test_query_1(self):\\n with app.test_request_context():\\n agency_none = db.session.query(\\n Agency).filter_by(name=\\\"not here\\\").first()\\n self.assertTrue(agency_none is None)\",\n \"def test_none(self):\\n arr = np.empty(0)\\n out = ternary(arr)\\n self.assertTrue(hasattr(out, \\\"tax\\\"))\\n self.assertEqual(\\n type(out.tax), pyternary.ternary_axes_subplot.TernaryAxesSubplot\\n )\",\n \"def empty(self, value):\\r\\n return value is None\",\n \"def empty(self, value):\\r\\n return value is None\",\n \"def empty(self, value):\\r\\n return value is None\",\n \"def empty(self, value):\\r\\n return value is None\",\n \"def empty(self, value):\\r\\n return value is None\",\n \"def is_empty(self, value, context):\\n return (value is None)\",\n \"def notna(self):\\n return super().notna()\",\n \"def assert_is_none(self, expr, msg=None):\\r\\n assert expr is None\",\n \"def null() -> SetupVal:\\n return NullVal()\",\n \"def _is_null_value(self, value):\\n if value is None:\\n return True\\n\\n if IS_PY3:\\n # Python 3.X\\n if isinstance(value, str) and len(value) == 0:\\n return True\\n else:\\n # Python 2.X\\n if isinstance(value, basestring) and len(value) == 0: # NOQA: F821\\n return True\\n\\n # TODO: This should probably be removed when solved in core Solr level?\\n return False\",\n \"def test_table_false_positives(self):\\n pass\",\n \"def testNoneValue(self):\\n objectID = uuid4()\\n user = createUser(u'username', u'password', u'User',\\n u'user@example.com')\\n namespace = createNamespace(user, u'name')\\n tag = createTag(user, namespace, u'tag')\\n self.store.add(TagValue(user.id, tag.id, objectID, None))\",\n \"def test_expected_none(transformer, event):\\n\\n nodes = transformer.transform(event)\\n\\n assert nodes is None\",\n \"def is_empty(self) -> bool:\",\n \"def is_nullable(self) -> bool: # pragma: no cover\\n pass\",\n \"def EXIT_ON_NONE(var):\\n\\n try:\\n if not var.any():\\n pass\\n except:\\n if var == None:\\n sys.exit(1)\",\n \"def test_untyped(self):\\n conn = self.connect()\\n c = conn.cursor()\\n c.execute(\\\"select null,''\\\")\\n self.assertEqual((None, \\\"\\\"), c.fetchone())\\n c.execute(\\\"select '',null\\\")\\n self.assertEqual((\\\"\\\", None), c.fetchone())\",\n \"def isNull(self):\\n return self.__column is None\",\n \"def isnone(cls, lhs, rhs):\\n if rhs:\\n return lhs is None\\n else:\\n return lhs is not None\",\n \"def is_none_or_empty(obj):\\n # type: (any) -> bool\\n return obj is None or len(obj) == 0\",\n \"def test_data_model_is_not_none_by_default():\\n # Given\\n context = DataContext()\\n\\n # Then\\n assert context.photo_model is not None\",\n \"def not_none(item, alt=None):\\r\\n\\r\\n return item if item is not None else alt\",\n \"def assert_type_or_none(obj, classes):\\n if obj is not None:\\n assert_type(obj, classes)\",\n \"def notNone(a):\\n return a.count(None) != len(a)\",\n \"def test_stochatreat_output_no_null_treats(treatments_dict):\\n treatments_df = treatments_dict[\\\"treatments\\\"]\\n assert treatments_df[\\\"treat\\\"].isnull().sum() == 0, \\\"There are null assignments\\\"\",\n \"def test_empty_tree_contains(empty_t):\\n empty_t.contains(1) == \\\"An empty tree has no values.\\\"\",\n \"def test_none(self):\\n self.assertEqual(b\\\"\\\", self.successResultOf(to_xml(None)))\",\n \"def test_blank(self):\\n self.assertEqual(1, 1)\",\n \"def is_neutral(self, P):\\n\\t\\treturn P.x is None\",\n \"def nonull(val):\\n return val if not pd.isnull(val) else None\",\n \"def test_OBJT_pass(self):\\n for O in self.mod.objts.itervalues():\\n self.assertTrue(O.isset)\",\n \"def test_get_with_None_value(self):\\n self.assertEqual(self.config.get('none_types','some_value'),None)\\n self.assertEqual(self.config.get('none_types','some_value','something'),'something')\",\n \"def is_not_empty(obj):\\n # type: (any) -> bool\\n return obj is not None and len(obj) > 0\",\n \"def test_build__set_none_values(self, valid_service: fixture) -> None:\\n service: Service = valid_service\\n\\n assert (\\n service.service_id is None\\n and service.fare_price is None\\n and service.max_schedule_time is None\\n and service.shibboleth_affiliation is None\\n and service.token_transit_fare_id is None\\n )\",\n \"def invariant(self):\\n\\t\\treturn ((self.tenant != \\\"\\\") and (self.loginUser != \\\"\\\"))\",\n \"def prove(self, query, context):\\n return self.askOne(query, context) != None\",\n \"def check_data_exist(data):\\n if data is not None:\\n if data.text is not None:\\n return True\\n return False\",\n \"def test_id_type_none(self):\\n obj = Base(None)\\n self.assertTrue(obj.id is 1)\",\n \"def _is_no_result(obj: Any) -> bool:\\n return obj is NO_RESULT\",\n \"def test_field_none_nullable(self):\\n node_dict = {\\n 'host_name': 'abc'\\n }\\n try:\\n Node(**node_dict)\\n except Exception as e:\\n self.assertEqual(type(e), ValueError)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66639656","0.6589096","0.6544759","0.6537418","0.65249217","0.6464309","0.6438317","0.6438317","0.6416694","0.6395729","0.6372581","0.6337188","0.63306767","0.6319348","0.6262661","0.62500733","0.61865604","0.6135527","0.6083987","0.6083987","0.6083662","0.60798484","0.6076057","0.60601246","0.6056041","0.595791","0.59244365","0.59136534","0.58893275","0.5858065","0.5848205","0.5837625","0.5837625","0.5826554","0.5812832","0.5810929","0.5808641","0.5803258","0.578684","0.5776864","0.5772064","0.57676685","0.57639307","0.57582927","0.57582927","0.57582927","0.57582927","0.57582927","0.5731932","0.5731805","0.57106185","0.57069767","0.5696092","0.56574464","0.5656085","0.56528735","0.56469715","0.5644857","0.5634626","0.563411","0.5633799","0.5633799","0.5633799","0.5633799","0.5633799","0.56328386","0.5629721","0.5622296","0.56087726","0.56013644","0.56000125","0.5596939","0.55776405","0.5563467","0.5563247","0.55579054","0.555301","0.55526567","0.5539871","0.5538208","0.55323786","0.5517519","0.5516723","0.5515638","0.5501904","0.5498725","0.5477533","0.54762954","0.54715765","0.5470695","0.545563","0.5446401","0.544559","0.5443455","0.54411304","0.54379845","0.5437396","0.54277724","0.54256564","0.5422875"],"string":"[\n \"0.66639656\",\n \"0.6589096\",\n \"0.6544759\",\n \"0.6537418\",\n \"0.65249217\",\n \"0.6464309\",\n \"0.6438317\",\n \"0.6438317\",\n \"0.6416694\",\n \"0.6395729\",\n \"0.6372581\",\n \"0.6337188\",\n \"0.63306767\",\n \"0.6319348\",\n \"0.6262661\",\n \"0.62500733\",\n \"0.61865604\",\n \"0.6135527\",\n \"0.6083987\",\n \"0.6083987\",\n \"0.6083662\",\n \"0.60798484\",\n \"0.6076057\",\n \"0.60601246\",\n \"0.6056041\",\n \"0.595791\",\n \"0.59244365\",\n \"0.59136534\",\n \"0.58893275\",\n \"0.5858065\",\n \"0.5848205\",\n \"0.5837625\",\n \"0.5837625\",\n \"0.5826554\",\n \"0.5812832\",\n \"0.5810929\",\n \"0.5808641\",\n \"0.5803258\",\n \"0.578684\",\n \"0.5776864\",\n \"0.5772064\",\n \"0.57676685\",\n \"0.57639307\",\n \"0.57582927\",\n \"0.57582927\",\n \"0.57582927\",\n \"0.57582927\",\n \"0.57582927\",\n \"0.5731932\",\n \"0.5731805\",\n \"0.57106185\",\n \"0.57069767\",\n \"0.5696092\",\n \"0.56574464\",\n \"0.5656085\",\n \"0.56528735\",\n \"0.56469715\",\n \"0.5644857\",\n \"0.5634626\",\n \"0.563411\",\n \"0.5633799\",\n \"0.5633799\",\n \"0.5633799\",\n \"0.5633799\",\n \"0.5633799\",\n \"0.56328386\",\n \"0.5629721\",\n \"0.5622296\",\n \"0.56087726\",\n \"0.56013644\",\n \"0.56000125\",\n \"0.5596939\",\n \"0.55776405\",\n \"0.5563467\",\n \"0.5563247\",\n \"0.55579054\",\n \"0.555301\",\n \"0.55526567\",\n \"0.5539871\",\n \"0.5538208\",\n \"0.55323786\",\n \"0.5517519\",\n \"0.5516723\",\n \"0.5515638\",\n \"0.5501904\",\n \"0.5498725\",\n \"0.5477533\",\n \"0.54762954\",\n \"0.54715765\",\n \"0.5470695\",\n \"0.545563\",\n \"0.5446401\",\n \"0.544559\",\n \"0.5443455\",\n \"0.54411304\",\n \"0.54379845\",\n \"0.5437396\",\n \"0.54277724\",\n \"0.54256564\",\n \"0.5422875\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6774843"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":13294,"cells":{"query":{"kind":"string","value":"Testing Tuna's setTunasFeatures method works"},"document":{"kind":"string","value":"def test_setTunaFeatures(self):\n tuna = Tuna()\n array = [\"1\", \"2\", \"3\", \"4\"]\n tuna.setTunaFeatures(array)\n self.assertEqual(tuna.getTunaFeatures(), array)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_getTunaFeatures(self):\n tuna = Tuna(\"1\", \"2\", \"3\", \"4\")\n array = [\"1\", \"2\", \"3\", \"4\"]\n self.assertEqual(tuna.getTunaFeatures(), array)","def _initialize_with_tune_context(self, context: \"TuneContext\") -> None:\n raise NotImplementedError","def prepare_features(self, wavs, stage):\n wavs, lens = wavs\n if stage == sb.Stage.TRAIN:\n if hasattr(self.modules, \"env_corrupt\"):\n wavs_noise = self.modules.env_corrupt(wavs, lens)\n wavs = torch.cat([wavs, wavs_noise], dim=0)\n lens = torch.cat([lens, lens])\n\n if hasattr(self.hparams, \"augmentation\"):\n wavs = self.hparams.augmentation(wavs, lens)\n\n # Choose what features we want to use\n # todo: support multiple features and feature concat\n target_feats = self.hparams.embedding_features\n\n FEATURE_EXTRACTOR = {\n # 'cqt': self.modules.cqt,\n # 'fbanks': self.modules.fbanks\n 'fastaudiogauss': self.modules.fastaudiogauss\n # 'ifr': self.modules.ifr\n # 'mag': self.modules.mag\n # 'mfcc': self.modules.mfcc\n # 'leaf': self.modules.leaf\n # 'tdfbanks': self.modules.tdfbanks\n # 'pcen': self.modules.pcen\n # 'sincnet': self.modules.sincnet\n # 'trainable_fbanks': self.modules.trainable_fbanks\n }\n\n if len(target_feats) == 1:\n # wavs = wavs.unsqueeze(1).cuda()\n feats = FEATURE_EXTRACTOR[target_feats[0]](wavs)\n # feats = torch.unsqueeze(feats, 1)\n # feats = torch.transpose(feats, 1,2)\n if target_feats[0]=='cqt':\n log_spec = 10.0 * torch.log10(torch.clamp(feats, min=1e-30))\n log_spec -= 10.0\n feats=log_spec\n feats = torch.transpose(feats, 1,2)\n else:\n feats = []\n for target in target_feats:\n temp = FEATURE_EXTRACTOR[target](wavs)\n if target=='cqt':\n temp = torch.transpose(temp, 1,2)\n feats.append(temp)\n f =feats[0]\n for i in range(1, len(feats)):\n f = torch.cat((f, feats[i]), dim=2)\n feats = f\n feats = self.modules.mean_var_norm(feats, lens)\n return feats, lens","def _initialize_with_tune_context(self, context: \"TuneContext\") -> None:\n _ffi_api.MutatorInitializeWithTuneContext( # type: ignore # pylint: disable=no-member\n self, context\n )","def test(self, test):\r\n self.ml_data.set_target(test[0])\r\n self.ml_data.set_features(test[1])\r\n if self.ml_data.target_type.all() == np.float64 or self.ml_data.target_type.all() == np.int64:\r\n self.model_qua.open()\r\n else:\r\n self.model_quali.open()","def features(self, features):\n\n self._features = features","def test_svm():\n backend = BasicAer.get_backend('statevector_simulator')\n random_seed = r.randint(1, 10598)\n\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\n\n # iris\n pres = \"Test pour le data set Iris (facile, classique)\"\n test_from_func(pres, 15, 10, 3, True, Iris, quantum_instance)\n\n # breast cancer\n pres = \"Test pour le data set Breast Cancer (facile, classique)\"\n test_from_func(pres, 15, 10, 3, True, Breast_cancer, quantum_instance)\n\n # digits (it's long so be careful)\n #pres = \"Test pour le data set Digits (difficile, classique)\"\n #test_from_func(pres, 10, 10, 10, True, Digits, quantum_instance)\n\n # wine\n pres = \"Test pour le data set Wine (moyen, classique)\"\n test_from_func(pres, 15, 10, 5, True, Wine, quantum_instance)\n\n # gaussian\n pres = \"Test pour des données gaussiennes (moyen, classique)\"\n for _ in range(1):\n print(\"\\n\")\n print(\"New iteration\")\n test_from_func(pres, 25, 10, 2, True, Gaussian, quantum_instance)\n print(\"\\n\")\n\n # small adn strings\n pres = \"Test pour des séquences ADN courtes (difficile, classique)\"\n test_from_func(pres, 10, 15, 14, True, Sequence, quantum_instance)","def set_features(self, features):\n self.features_ = list(features)","def nonlearning():\n\taT.featureAndTrain(['../../AudioData/chunked_data_sorted/pos', '../../AudioData/chunked_data_sorted/neg'], \n\t\t\t\t\t\t1.0, 1.0, aT.shortTermWindow, aT.shortTermStep, \n \"svm\", \"emotion_classifier\", True)","def set_features(self, features: list):\n self._features = features","def test_intent_classifier_update_training_samples(self):\n pass","def set_features(self, features: np.ndarray):\n self.features = features","async def async_set_features(self, features):\n self._features = features","def testSetup(self):\n \n train = QuizBowlData(None, \"\", self.vectorizer)\n train.vectorize(kTOY_TRAIN) \n model, optimizer = setup(train, 1.0)\n\n self.assertEqual(list(model.weight.size()), [2, 2])\n self.assertEqual(list(model.bias.size()), [2])","def setup(self, num_qubit, fusion_enable, use_cu1):","def test_regressors_hypertune(setup):\n # Load the data\n train_features, test_features, train_target, test_target = setup\n # Call the function that we would like to test\n tuned, tune_time = regressors.hyperTune(RandomForestRegressor(), train_features, train_target,\n grid=grid.rf_paramgrid(), folds=2, iters=1, jobs=1)\n # Assert if tuned is a dictionary\n assert type(tuned) == dict\n # Assert if tune_time is a float\n assert type(tune_time) == float","def __init__(self, features=None):\n self.features = features","def test_text_classifier_update_training_samples(self):\n pass","def findFeatures(self):\n\t\tpass","def get_feature_set_SA(tweet):\n features= {}\n return features","def test_all_features(self):\n to_create = ['looktest1', 'looktest2', 'looktest3']\n for f in to_create:\n Feature(f).activate()\n\n all_features = Feature.all_features()\n self.assertEqual(len(all_features), len(to_create))\n for f in to_create:\n self.assertTrue(f in all_features)","def feat():\n pass","def train(self, features, labels):\n pass","def load_features(self, features):\n pass\n # self.features = features","def test(self):\n self.training = False","def test__extract_features(self):\n text_sample = \"I really really love this movie\"\n feature_sample = ['really','love','good']\n feature_score_type = \"presence\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':1,'love':1,'good':0})\n feature_score_type = \"term_frequency\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':2,'love':1,'good':0})","def __init__(self, num_features):\n super(TLU, self).__init__()\n self.num_features = num_features\n self.tau = nn.parameter.Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)\n self.reset_parameters()","def get_feature_set_PB(tweet):\n features= {\n 'text_length': np.log(len(tweet.text))\n } #ADD ADDITIONAL FEATURES\n if tweet.nrof_sademoticons>0:\n features['sademoticons'] = tweet.nrof_sademoticons\n if tweet.nrof_happyemoticons>0:\n features['happyemoticons'] = tweet.nrof_happyemoticons\n \n return features","def main():\n \n # The following 5 command lines can be outcommented if the features are already created.\n # There is no need to process the data every single time.\n # Fine tuning the learning algorythm is much faster without that extra step.\n \n # by reading the train dataset the feature index is created.\n # First calling of the processdata function\n # Data limited to 300000\n featureIndexes = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000)\n print \"featureIndex generated!\"\n print len(featureIndexes)\n\n # Trainfeature is created using the indexfeatures...\n # Second calling of the processdata function\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000) # Original itemsLimit=300000\n\n # Building the test dataset... just like the training...\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\"avito_test.tsv\"), featureIndexes)\n\n # Dumping data into file...\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\"train_data.pkl\"))\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\"SeparatedByCategory.pkl\"))\n\n\n # loading data pack...\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\"train_data.pkl\"))\n\n #logging.info(\"Feature preparation done, fitting model...\")\n\n # Stochastic gradient model","def setup_svm_classifier(training_data, y_training, testing_data, features, method=\"count\", ngrams=(1,1)):\n # generate x and y training data\n\n if method == \"count\":\n vec, x_training, x_testing = define_features_vectorizer(features, training_data, testing_data,ngramrange=ngrams)\n elif method == \"tfidf\":\n vec, x_training, x_testing = define_features_tfidf(features, training_data, testing_data,ngramrange=ngrams)\n else:\n print(\"Method has to be either count or tfidf\")\n return 1\n\n # train classifier\n\n model = SVMClassifier_scratch()\n model.fit(x_training, y_training)\n\n return model, vec, x_testing","def test_svm_quantique():\n backend = BasicAer.get_backend('statevector_simulator')\n random_seed = 10598\n\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\n pres = \"Test pour des données générées par ordinateur quantique (facile, quantique)\"\n print(pres)\n _, samp_train, samp_test, labels = ad_hoc_data(15, 10, 2, 0.3, True)\n sample_m, sample_p = stock_get(20, 0.3)\n\n labels_me = [-1, 1]\n samp_train_me = {-1: np.array(sample_m[:15]), 1: np.array(sample_p[:15])}\n samp_test_me = {-1: np.array(sample_m[15:]), 1: np.array(sample_p[15:])}\n print(samp_train)\n print(samp_train_me)\n print(samp_test)\n print(samp_test_me)\n classical_kernel_estimation(samp_train, samp_test, labels)\n classical_kernel_estimation(samp_train_me, samp_test_me, labels_me)\n\n # Generate the feature map\n feature_map = FirstOrderExpansion(feature_dimension=2, depth=2)\n\n # Run the Quantum Kernel Estimator and classify the test data\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\n test_dataset=samp_test)\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\n test_dataset=samp_test_me)\n\n result = qsvm.run(quantum_instance)\n result_me = qsvm_me.run(quantum_instance)\n print(\"Success of the FirstOrder feature map kernel:\")\n print(result['testing_accuracy'])\n print(result_me['testing_accuracy'])\n\n # Generate the feature map\n feature_map = SecondOrderExpansion(feature_dimension=2, depth=2)\n\n # Run the Quantum Kernel Estimator and classify the test data\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\n test_dataset=samp_test)\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\n test_dataset=samp_test_me)\n\n result = qsvm.run(quantum_instance)\n result_me = qsvm_me.run(quantum_instance)\n print(\"Success of the SecondOrder feature map kernel:\")\n print(result['testing_accuracy'])\n print(result_me['testing_accuracy'])\n\n # Last implementation using the custom circuit generator\n print(\"Success for my implementation (second order):\")\n my_impl(samp_train, samp_test, labels)\n my_impl(samp_train_me, samp_test_me, labels_me)\n\n feature_map = CustomExpansion(num_qubits=2, constructor_function=custom_constr, feature_param=[1])\n\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\n test_dataset=samp_test)\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\n test_dataset=samp_test_me)\n\n result = qsvm.run(quantum_instance)\n result_me = qsvm_me.run(quantum_instance)\n print(\"Success of the Custom feature map kernel:\")\n print(result['testing_accuracy'])\n print(result_me['testing_accuracy'])","def test_training(self):\n\t\tpass","def setup_to_finetune(model):\r\n # for layer in model.layers[:NB_IV3_LAYERS_TO_FREEZE]:\r\n # layer.trainable = False\r\n for layer in model.layers[:]:\r\n layer.trainable = True\r\n model.compile(optimizer=Adam(lr=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])","def __init__(self, tfiles, featurizer):\n\t\t### [ Featurize the classifier ] ###\n\t\t# random.shuffle(tfiles)\n\t\tself.featurizer = featurizer\n\t\tself.tfiles = tfiles\n\n\t\t# Now build a model based on these vectors\n\t\tnum_files = len(tfiles)\n\t\tnum_training_files = int(PERCENT_TRAINING * num_files)\n\t\tnum_test_files = num_files - num_training_files\n\n\t\tself.train_files = self.tfiles[:num_training_files]\n\t\tself.test_files = self.tfiles[num_training_files:]\n\n\t\tself.all_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.tfiles]\n\t\tall_data_vectors = [d[0] for d in self.all_data]\n\t\tprint([v.shape for v in all_data_vectors])\n\t\tself.all_features = np.vstack(d[0] for d in self.all_data)\n\t\tself.all_labels = np.hstack(d[1] for d in self.all_data)\n\n\t\tself.train_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.train_files]\n\t\tself.train_features = np.vstack([d[0] for d in self.train_data])\n\t\tself.train_labels = np.hstack([d[1] for d in self.train_data])\n\n\t\tself.test_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.test_files]\n\t\tself.test_features = np.vstack([d[0] for d in self.test_data])\n\t\tself.test_labels = np.hstack(d[1] for d in self.test_data)\n\n\t\tself.trained_clf = []\n\t\tfor cl in used_classifiers:\n\t\t\tself.trained_clf += [cl(self.train_features, self.train_labels)]","def tunings(self, tunings):\n self.Kp, self.Ki, self.Kd = tunings","def test_Tuna(self):\n tuna = Tuna(\"1\", \"2\", \"3\", \"4\")\n self.assertIsNotNone(tuna)","def __trainLocal__(self, featureVals, targetVals):\n pass","def test_update_hyperflex_feature_limit_internal(self):\n pass","def fit(self, features, target, **kwargs):\n self.features = features\n self.target = target\n super(tpot_class, self).fit(features, target, **kwargs)","def __init__(self, **kwargs):\n FeatureDefinition.__init__(self)\n\n nbTypes = self._getTypeNumber(kwargs)\n \n print(\"BETTER FEATURES\")\n \n \n block_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\n (\"xywh\", Pipeline([\n ('selector', NodeTransformerXYWH_v2()),\n #v1 ('xywh', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('xywh', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n , (\"neighbors\", Pipeline([\n ('selector', NodeTransformerNeighbors()),\n #v1 ('neighbors', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('neighbors', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n , (\"1hot\", Pipeline([\n ('1hot', Node1HotFeatures()) #does the 1-hot encoding directly\n ])\n )\n ])\n grid_line_transformer = GridLine_NodeTransformer_v2()\n \n self._node_transformer = TransformerListByType([block_transformer, grid_line_transformer]) \n \n edge_BB_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\n (\"1hot\", Pipeline([\n ('1hot', Edge1HotFeatures(PageNumberSimpleSequenciality()))\n ])\n )\n , (\"boolean\", Pipeline([\n ('boolean', EdgeBooleanFeatures_v2())\n ])\n )\n , (\"numerical\", Pipeline([\n ('selector', EdgeNumericalSelector()),\n #v1 ('numerical', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('numerical', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n ] )\n edge_BL_transformer = DU_ABPTableRG.Block2GridLine_EdgeTransformer()\n edge_LL_transformer = DU_ABPTableRG.GridLine2GridLine_EdgeTransformer()\n self._edge_transformer = TransformerListByType([edge_BB_transformer,\n edge_BL_transformer,\n edge_BL_transformer, # useless but required\n edge_LL_transformer \n ])\n \n self.tfidfNodeTextVectorizer = None #tdifNodeTextVectorizer","def test_machine_learning():","def setup_features():\n\n core_features = {\"web\": [\"content_directory\", \"controllers\", \"templates\"]}\n\n imported_features = []\n for feature_type, feature_list in core_features.items():\n features_list_names = \", \".join(feature_list)\n print(\n \"** Setting up {0} features {1}\".format(\n info(feature_type), info(features_list_names)\n )\n )\n for feature_name in feature_list:\n script_dir = dirname(abspath(__file__))\n module_fname = join(\n script_dir, \"features\", feature_type, feature_name + \".py\"\n )\n\n feature_dict = {}\n with open(module_fname) as source_file:\n exec(compile(source_file.read(), module_fname, \"exec\"), feature_dict)\n try:\n feature = feature_dict[\"Feature\"]()\n except KeyError:\n print_error(\n \"Feature module '%s' does not provide a Feature class!\"\n % feature_name\n )\n sys.exit(1)\n try:\n feature.setup()\n except: # NOQA: E722\n print_error(\"Failed setting up feature '%s' !\" % feature_name)\n raise\n imported_features.append(feature)\n\n for feature in imported_features:\n if hasattr(feature, \"activate\"):\n feature.activate()","def get_feature_set_SB(tweet):\n #pos-tag frequencies\n# print \"Tagged words in tweet: \", tweet.tagged_words\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# if tag=='PRtinf':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJS':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJ':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='NP':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='DET':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='P':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n# print \"Tag frequencies: \", pos_tag_freq\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n# print \"Additional frequencies: \", additional_freq\n# raw_input(\"Continue?\")\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n# print \"All features: \", features\n# raw_input(\"Continue?\")\n return features","def trainMVA(config, samples, cuts):\n\n # cutbased set to true during runtime if running of a cutbased analysis has already been detected\n # i.e. originally cutbased = (len(mva)==0) from bookAnalysisJobs and is set to true if any analysis job is added to the provided cuts\n runtime = config.getFolder(\"runtime+\")\n cutbased = runtime.getTagBoolDefault(\"cutbased\", False)\n\n mvascriptnames = config.getTagVString(\"MVA\")\n mvaOK = False\n if len(mvascriptnames)>0:\n for mvaconfig in mvascriptnames:\n mvascriptname = ROOT.TString()\n QFramework.TQStringUtils.readUpTo(mvaconfig,mvascriptname,\"(\")\n QFramework.TQStringUtils.removeLeadingText(mvaconfig,\"(\")\n QFramework.TQStringUtils.removeTrailingText(mvaconfig,\")\")\n path = QFramework.TQFolder.concatPaths(\"MVA\",mvascriptname).Data() + \".py\"\n if (mvaconfig):\n QFramework.INFO(\"now running analysis '{:s}' with options '{:s}'\".format(mvascriptname,mvaconfig))\n else:\n QFramework.INFO(\"now running analysis '{:s}'\".format(mvascriptname))\n allOK = True\n\n try:\n myMVA = imp.load_source(\"myMVA\",path)\n except IOError:\n QFramework.CRITICAL(\"unable to open file '{:s}' - please double-check!\".format(path))\n allOK = False\n\n if allOK:\n try:\n QFramework.TQUtils.ensureDirectory(\"weights\")\n tqmva = QFramework.TQMVA(samples)\n tqmva.setBaseCut(cuts)\n tqmva.setName(mvascriptname)\n tqmva.setTitle(mvascriptname)\n tqmva.setAliases(aliases)\n tqmva.importTags(mvaconfig,False)\n timer = ROOT.TStopwatch()\n if not dummy:\n retval = myMVA.runMVA(tqmva)\n else:\n retval = True\n QFramework.WARN(\"dummy run, skipping execution of MVA analysis '{:s}'\".format(tqmva.GetName()))\n timer.Stop()\n if retval:\n QFramework.INFO(\"analysis '{:s}' complete after {:.2f}s, output written to '{:s}'!\".format(mvascriptname,timer.RealTime(),tqmva.getTagStringDefault(\"outputFileName\",\"<unknown file>\")))\n mvaOK = True\n else:\n QFramework.WARN(\"analysis '{:s}' returned '{:s}' - please double-check!\".format(mvascript,str(retval)))\n except Exception as ex:\n template = \"An exception of type '{0}' occured: {1!s}\"\n message = template.format(type(ex).__name__, \",\".join(map(str,ex.args)))\n QFramework.ERROR(message)\n allOK = False\n\n elif not cutbased:\n appname = QFramework.TQLibrary.getApplicationName().Data()\n QFramework.ERROR(\"no analysis script given, please use 'MVA: myAnalysis' under the [{:s}] section to import and execute some python script 'MVA/myAnalysis.py'. it should contain a function 'runMVA(...)' that will receive a readily prepared sample folder at your disposal\".format(appname))\n\n # store in runtime folder whether or not at least 1 MVA finished successfully\n runtime = config.getFolder(\"runtime+\")\n runtime.setTagString(\"mvaOK\", mvaOK)\n\n return","def train(self, tdict):\n pass","def test():\n listpost,listclass = bayes.loaddataset()\n myvocablist = bayes.createlist(listpost)\n tmatrix = list()\n for doc in listpost:\n\t vec = bayes.word2vec(myvocablist,doc)\n\t tmatrix.append(vec)\n p0,p1,pa = bayes.train(tmatrix,listclass)\n testdoc1 = ['love','my','dalmation']\n testvec1 = bayes.word2vec(myvocablist,testdoc1)\n print testdoc1,'classify as :',bayes.classify(testvec1,p0,p1,pa)\n testdoc2 = ['stupid','love']\n testvec2 = bayes.word2vec(myvocablist,testdoc2)\n print testdoc2,'classify as :',bayes.classify(testvec2,p0,p1,pa)","def run():\n # all data and labels\n # tracemalloc.start()\n # start = time.time()\n data, labels = Startdata.getdata() # texts\n data2, labels2 = Startdata.getdata2() # emails\n # Startdata.bagofwords(data2, labels2)\n data, labels = Startdata.combinedata(data, data2, labels, labels2)\n # split into training and testing. 1/3 test, 2/3 train\n traind, trainl, testd, testl = Startdata.splitdata(data, labels)\n\n # labels\n trainlabels = Startdata.labelfix(trainl)\n testlabels = Startdata.labelfix(testl)\n\n # selective features\n #\n # extract features for use. in the shape of NxD\n # N is number of samples, D is number of features\n # current, peak = tracemalloc.get_traced_memory()\n trainfeat = Startdata.featurextract(traind, trainl)\n testfeat = Startdata.featurextract(testd, testl)\n # theta is the weights in a D+1 X 1 array\n theta = Spamfilter.train(trainfeat, trainlabels)\n #\n # trying bag of words\n #\n\n # Startdata.featurextract(data, labels)\n # error rate was 1.69% for trainingdata\n # 2.21% for testing data\n # bag, tfeat = Startdata.bagofwords(traind)\n # theta = Spamfilter.train(tfeat, trainlabels)\n # testfeat = Startdata.features(testd, bag)\n\n test(theta, testfeat, testlabels)\n # tracemalloc.stop()\n # done = time.time()\n # print(f\"Current memory usage is {current / 10**6} MB; Peak was {peak / 10**6} MB\")\n # print(\"time to complete\", done - start)\n # NTR 12/1/2020 current best featextraction at 25 iterations is about\n # 0.7-1% error for\n # trainingdata and testing data\n # NTR 12/2/2020 bag of words at 25 iterations\n # 1.69% training error, 2.21% testing error\n # NTR 12/2/2020 bag of words, 25 iter, removal of some features\n # NTR 12/3/2020 featextraction 20 iterations, new features, emails inc\n # 0.59% error on training. 0.63% testing error","def test_ann_features():\n CQT(file_struct, FeatureTypes.ann_beatsync, sr=11025).features","def test_intent_classifier_add_training_samples(self):\n pass","def test_features_property():\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\n atom.run(\"LR\")\n assert [i == j for i, j in zip(atom.lr.features, atom.features)]","def get_feature_set_PA(tweet):\n features= {}\n return features","def setWalabotSettings():\n wlbt.SetProfile(wlbt.PROF_SENSOR)\n wlbt.SetArenaR(R_MIN, R_MAX, R_RES)\n wlbt.SetArenaTheta(THETA_MIN, THETA_MAX, THETA_RES)\n wlbt.SetArenaPhi(PHI_MIN, PHI_MAX, PHI_RES)\n #wlbt.SetThreshold(THRESHOLD)\n wlbt.SetDynamicImageFilter(wlbt.FILTER_TYPE_DERIVATIVE) #Also test with FILTER_TYPE_NONE\n print('- Walabot Configured.')","def train_naive(): # add arguments as needed\n pass","def test_create_hyperflex_feature_limit_internal(self):\n pass","def train(self):\n\t\traise NotImplementedError","def get_feature_set_PC(tweet, sentimentvalues):\n features= {\n 'text_length': np.log(len(tweet.text))\n } #ADD ADDITIONAL FEATURES\n if tweet.nrof_sademoticons>0:\n features['sademoticons'] = tweet.nrof_sademoticons\n if tweet.nrof_happyemoticons>0:\n features['happyemoticons'] = tweet.nrof_happyemoticons\n \n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n features[tag] = features.get(tag, 0) + 1\n if tag in ADJECTIVES:\n features['adjectives'] = features.get(tag, 0) + 1\n elif tag in ADVERBS: \n features['adverbs'] = features.get(tag, 0) + 1\n elif tag in PRONOUNS:\n features['pronoun'] = 1\n except KeyError:\n continue\n for key in features.keys():\n features[key] = features[key]*1.0\n \n #Add lexical features\n # total polarity score, number of positive words, number of negative words\n pos_score = 0\n neg_score = 0\n nrof_pos_words = 0\n nrof_neg_words = 0\n for word in sentimentvalues.keys():\n if sentimentvalues[word][0]>0:\n nrof_pos_words = nrof_pos_words + 1\n pos_score = pos_score + sentimentvalues[word][0]\n if sentimentvalues[word][1]>0:\n nrof_neg_words = nrof_neg_words + 1\n neg_score = neg_score + sentimentvalues[word][1]\n\n if neg_score>0:\n features['neg_score'] = neg_score+1.0\n if pos_score>0:\n features['pos_score'] = pos_score+1.0\n if nrof_pos_words>0:\n features['positive_words'] = nrof_pos_words*1.0\n if nrof_neg_words>0:\n features['negative_words'] = nrof_neg_words*1.0\n \n return features","def features(self, state, action, next_state):\n raise NotImplementedError","def __init__(\n self,\n feature_config: Union[tf.tpu.experimental.embedding.FeatureConfig,\n Iterable], # pylint:disable=g-bare-generic\n optimizer: Optional[Union[tf.tpu.experimental.embedding.SGD,\n tf.tpu.experimental.embedding.Adagrad,\n tf.tpu.experimental.embedding.Adam,\n tf.tpu.experimental.embedding.FTRL]],\n pipeline_execution_with_tensor_core: bool = False,\n batch_size: Optional[int] = None,\n embedding_feature: Optional[\n tf.tpu.experimental.HardwareFeature.EmbeddingFeature] = None):\n super().__init__()\n self._feature_config, self._table_config_map = (\n _clone_and_prepare_features(feature_config))\n self._optimizer = _normalize_and_prepare_optimizer(optimizer)\n\n self._strategy = tf.distribute.get_strategy()\n self._using_tpu = _is_tpu_strategy(self._strategy)\n\n self._embedding_feature = None\n if self._using_tpu:\n self._embedding_feature = self._strategy.extended.tpu_hardware_feature.embedding_feature\n # Override the embedding feature setting if passed.\n if embedding_feature is not None:\n if embedding_feature == _EMBEDDING_UNSUPPORTED:\n self._embedding_feature = _EMBEDDING_UNSUPPORTED\n if (embedding_feature != _EMBEDDING_UNSUPPORTED and\n self._embedding_feature != embedding_feature):\n raise ValueError(\n \"TPU only supports {} and {}, but got {} which is not supported.\"\n .format(_EMBEDDING_UNSUPPORTED, self._embedding_feature,\n embedding_feature))\n\n # Create TPU embedding mid level APIs according to the embedding feature\n # setting.\n self._tpu_embedding = self._create_tpu_embedding_mid_level_api(\n self._using_tpu, self._embedding_feature,\n pipeline_execution_with_tensor_core)\n\n self.batch_size = batch_size\n\n self._tpu_call_id = 0","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def test_feature_shape():\n\n N = 1024\n n_sample = 100\n\n def get_gemm_feature(target):\n k = tvm.reduce_axis((0, N), 'k')\n A = tvm.placeholder((N, N), name='A')\n B = tvm.placeholder((N, N), name='B')\n C = tvm.compute(A.shape, lambda y, x: tvm.sum(A[y, k] * B[k, x], axis=k),\n name='C')\n\n s = tvm.create_schedule(C.op)\n\n y, x = s[C].op.axis\n axes = list(s[C].tile(y, x, 8, 8)) + [k]\n perm = np.random.permutation(5)\n axes = [axes[x] for x in perm]\n s[C].reorder(*axes)\n\n if \"gpu\" in target.keys:\n pick = []\n # filter out reduction axis\n for i in range(len(perm)):\n if perm[i] != 4:\n pick.append(axes[i])\n s[C].bind(pick[0], tvm.thread_axis(\"blockIdx.x\"))\n s[C].bind(pick[1], tvm.thread_axis(\"vthread\"))\n s[C].bind(pick[2], tvm.thread_axis(\"threadIdx.y\"))\n\n with target:\n feas = feature.get_itervar_feature(s, [A, B, C])\n feas = feature.flatten_itervar_feature(feas)\n return feas\n\n targets = [\n tvm.target.cuda(),\n tvm.target.mali(),\n tvm.target.arm_cpu(),\n ]\n\n for target in targets:\n dim = len(get_gemm_feature(target))\n for i in range(n_sample):\n assert dim == len(get_gemm_feature(target)), \"dimensions of feature do not match\" \\\n \" for different configurations\"","def feature(self):\n Feature(run=default_frame, flags=TE)\n Feature(run=load(\"window_functions.tests.rows_frame\", \"feature\"), flags=TE)\n Feature(run=load(\"window_functions.tests.range_frame\", \"feature\"), flags=TE)\n Feature(run=load(\"window_functions.tests.range_overflow\", \"feature\"), flags=TE)\n Feature(run=load(\"window_functions.tests.range_datetime\", \"feature\"), flags=TE)\n Feature(run=load(\"window_functions.tests.range_errors\", \"feature\"), flags=TE)","def test_update_hyperflex_feature_limit_external(self):\n pass","def test_text_classifier_update_testing_samples(self):\n pass","def __init__(self, eta, mu, n_feature):\r\n self.eta = 0.09\r\n self.weight = [0.0] * n_feature\r\n self.temp = [0.0] * n_feature\r\n self.mu = 0.0\r\n self.size= n_feature","def trainModel( self, featureTrain, classTrain):","def test_setup(self, test_data: list=None):\n print(\"[dataset]: using test setup ...\")\n self.vocabulary = [\"empty\"]\n self.eval_dataset = ABSADataset(data_path=self.dev_path, mode=self.in_mode, task=self.task,\n tokenizer=self.tokenizer, vocab=\"bert\", test=True)\n return","def train(self, trainingData, trainingLabels, validationData, validationLabels): \n \n # might be useful in your code later...\n # this is a list of all features in the training set.\n self.features = list(set([ f for datum in trainingData for f in datum.keys() ]));\n \n if (self.automaticTuning):\n kgrid = [0.001, 0.01, 0.05, 0.1, 0.5, 1, 5, 10, 20, 50]\n else:\n kgrid = [self.k]\n \n self.trainAndTune(trainingData, trainingLabels, validationData, validationLabels, kgrid)","def supported_features(self):\n return SUPPORT_LGSMARTTV","def test_predictor():","def __init__(self, traindat, trainlabs, k=5):\r\n self.features = traindat.columns\r\n self.traindat = traindat.values\r\n self.trainlabs = trainlabs.values\r\n self.k = k","def train():\n pass","def test_all_features_with_data(self):\n feature1 = Feature('looktest1')\n feature1.set_percentage(5)\n\n feature2 = Feature('looktest2')\n feature2.activate()\n feature2.add_to_whitelist(3)\n\n feature3 = Feature('looktest3')\n feature3.activate()\n feature3.add_to_blacklist(4)\n feature3.add_to_blacklist(5)\n\n feature4 = Feature('looktest4')\n feature4.activate()\n feature4.add_to_whitelist(3)\n feature4.add_to_whitelist(5)\n feature4.add_to_blacklist(4)\n\n all_features = Feature.all_features(include_data=True)\n self.assertEqual(len(all_features), 4)\n\n for key in ['looktest1', 'looktest2', 'looktest3', 'looktest4']:\n self.assertTrue(key in all_features)\n if not key == 'looktest1':\n self.assertEqual(all_features[key]['percentage'], 100)\n\n self.assertEqual(all_features['looktest1']['percentage'], 5)\n self.assertFalse('whitelist' in all_features['looktest1'])\n self.assertFalse('blacklist' in all_features['looktest1'])\n\n self.assertTrue('whitelist' in all_features['looktest2'])\n self.assertEqual(all_features['looktest2']['whitelist'], [3])\n self.assertFalse('blacklist' in all_features['looktest2'])\n\n self.assertFalse('whitelist' in all_features['looktest3'])\n self.assertTrue('blacklist' in all_features['looktest3'])\n self.assertEqual(all_features['looktest3']['blacklist'], [4, 5])\n\n self.assertTrue('whitelist' in all_features['looktest4'])\n self.assertEqual(all_features['looktest4']['whitelist'], [3, 5])\n self.assertTrue('blacklist' in all_features['looktest4'])\n self.assertEqual(all_features['looktest4']['blacklist'], [4])","def feature_eng2(housing_tr, housing):\n logging.info(\"Adding features.....\")\n housing_tr[\"rooms_per_household\"] = (\n housing_tr[\"total_rooms\"] / housing_tr[\"households\"]\n )\n housing_tr[\"bedrooms_per_room\"] = (\n housing_tr[\"total_bedrooms\"] / housing_tr[\"total_rooms\"]\n )\n housing_tr[\"population_per_household\"] = (\n housing_tr[\"population\"] / housing_tr[\"households\"]\n )\n housing_cat = housing[[\"ocean_proximity\"]]\n housing_prepared = housing_tr.join(\n pd.get_dummies(housing_cat, drop_first=True)\n )\n return housing_prepared","def test_create_hyperflex_feature_limit_external(self):\n pass","def __call__(self, sample):\n if self.mode == VectorizeMode.TRAIN or self.mode == VectorizeMode.EVAL:\n assert type(sample) == TrainInput, 'In train/eval mode, vectorizer input must be of type TrainInput'\n\n if self.mode == VectorizeMode.GENERATE:\n assert type(\n sample) == GenerationInput, 'In generation mode, vectorizer input must be of type GenerationInput'\n\n context = dict()\n context['COALICION'] = ' [COALICION] ' + sample.COALICION if sample.COALICION != \"\" else \"\"\n context['PARTIDO'] = ' [PARTIDO] ' + sample.PARTIDO if sample.PARTIDO != \"\" else \"\"\n context['SENTIMIENTO'] = ' [SENTIMIENTO] ' + sample.SENTIMIENTO if sample.SENTIMIENTO != \"\" else \"\"\n context['ENTIDADES'] = ' [ENTIDADES] ' + sample.ENTIDADES if sample.ENTIDADES != \"\" else \"\"\n context['HASHTAGS'] = ' [HASHTAGS] ' + sample.HASHTAGS if sample.HASHTAGS != \"\" else \"\"\n context['FRASES'] = ' [FRASES] ' + sample.FRASES if sample.FRASES != \"\" else \"\"\n context['PARTIDO'] = ' [PARTIDO] ' + sample.PARTIDO if sample.PARTIDO != \"\" else \"\"\n context['TWEET'] = ' [TWEET] ' \n\n\n # Encode the context\n\n for key, value in context.items():\n context[key] = self.tokenizer.encode(value)\n\n # In generate mode, obviously, the true P2 doest not exist\n TWEET = sample.TWEET if self.mode != VectorizeMode.GENERATE else \"\"\n\n # Compute the number of tokens we saved for TWEET in the input block\n if self.mode == VectorizeMode.GENERATE:\n nb_tokens_for_TWEET = 200 + 50\n else:\n nb_tokens_for_TWEET = len(self.tokenizer.encode(TWEET)) + 2 # +1 for [TWEET] and +1 for <|endoftext|>\n\n if self.mode == VectorizeMode.TRAIN:\n input_ids, type_ids, labels = self.vectorize(context, TWEET, nb_tokens_for_TWEET)\n return input_ids, type_ids, labels\n\n if self.mode == VectorizeMode.GENERATE:\n input_ids, type_ids = self.vectorize(context, TWEET, nb_tokens_for_TWEET)\n return input_ids, type_ids\n\n if self.mode == VectorizeMode.EVAL:\n input_ids, type_ids = self.vectorize(context, TWEET, nb_tokens_for_TWEET)\n return input_ids, sample, nb_tokens_for_TWEET","def test_init_custom_parameters():\n\n tpot_obj = TPOTClassifier(population_size=500, generations=1000,\n mutation_rate=0.05, crossover_rate=0.9,\n scoring='accuracy', num_cv_folds=10,\n verbosity=1, random_state=42,\n disable_update_check=True)\n\n assert tpot_obj.population_size == 500\n assert tpot_obj.generations == 1000\n assert tpot_obj.mutation_rate == 0.05\n assert tpot_obj.crossover_rate == 0.9\n assert tpot_obj.scoring_function == 'accuracy'\n assert tpot_obj.num_cv_folds == 10\n assert tpot_obj.max_time_mins is None\n assert tpot_obj.verbosity == 1\n assert tpot_obj._optimized_pipeline is None\n assert tpot_obj._fitted_pipeline is None\n assert not (tpot_obj._pset is None)\n assert not (tpot_obj._toolbox is None)","def feature():\n pass","def train(self, features, labels):\n self.train_features = features\n self.train_labels = labels\n #raise NotImplementedError","def setup_to_finetune(model):\n\n for layer in model.layers[:NB_VGG_LAYERS_TO_FREEZE]:\n layer.trainable = False\n for layer in model.layers[NB_VGG_LAYERS_TO_FREEZE:]:\n layer.trainable = True\n\n # opt = Adam(lr=0.0001)\n model.compile(optimizer=SGD(lr=0.0001, momentum=0.9),\n loss='categorical_crossentropy',\n metrics=['categorical_accuracy', f1_score])","def test_set_params():\n\n tpot_obj = TPOTClassifier()\n assert tpot_obj.set_params() is tpot_obj","def finalizeFeatures(self):\n pass","def test_features(iris):\n assert iris.num_features == 4\n assert iris.feature_names == [\n \"sepal length (cm)\",\n \"sepal width (cm)\",\n \"petal length (cm)\",\n \"petal width (cm)\",\n ]","def train(self)->None:","def __init__(self, *args, **kwargs):\n if len(args) > len(self.features):\n raise PydmrsTypeError(\"{} takes {} arguments, but {} were given\".format(type(self).__name__,\n len(self.features),\n len(args)))\n for i, value in enumerate(args):\n setattr(self, self.features[i], value)\n for feature, value in kwargs.items():\n setattr(self, feature, value)\n for feature in self.features:\n if not hasattr(self, feature):\n setattr(self, feature, None)","def test_text_classifier_set_params(self):\n pass","def test_stage_0():\n\tra_1 = readImage(TRAIN_RAW_IMAGE_1)\n\tre_1 = readImage(TRAIN_RESULT_IMAGE_1)\n\n\tra_2 = readImage(TRAIN_RAW_IMAGE_2)\n\tre_2 = readImage(TRAIN_RESULT_IMAGE_2)\n\n\t# Uncomment below if more examples are required.\n\t# ra_3 = readImage(TRAIN_RAW_IMAGE_3)\n\t# re_3 = readImage(TRAIN_RESULT_IMAGE_3)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_1 += (\n\t# \tlaplace_operator(TRAIN_RAW_IMAGE_1),\\\n\t# \t# k_means(TRAIN_RAW_IMAGE_1)[0],\\\n\t# \t)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_2 += (\n\t# \tlaplace_operator(TRAIN_RAW_IMAGE_2),\\\n\t# \t# k_means(TRAIN_RAW_IMAGE_2)[0],\\\n\t# \t)\n\n\t# The prediction model is obtained and trained.\n\tengine = get_model((ra_1, ra_2,), (re_1, re_2,), model_type=SVM, percentage=0.1)\n\n\ttest_percentage = float(1) # how many tests\n\n\tra_1 = readImage(TEST_RAW_IMAGE_1)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_1 += (\n\t# \tlaplace_operator(TEST_RAW_IMAGE_1),\\\n\t# \t# k_means(TEST_RAW_IMAGE_1)[0],\\\n\t# \t)\n\n\tre_1 = readImage(TEST_RESULT_IMAGE_1)\n\n\t# ra_2 = readImage(TEST_RAW_IMAGE_2)\n\t# re_2 = readImage(TEST_RESULT_IMAGE_2)\n\n\tinput_vec = []\n\t# The features are extracted.\n\tinput_vec += buildFeatureArray_2(ra_1[0], ra_1[1], ra_1[2],\\\n\t\tRADIUS_ARRAY,\\\n\t\tadditional_feats=([] if len(ra_1) == 3 else ra_1[3:]))\n\n\tex_no = int(test_percentage * len(input_vec)) # actual number of the test sample\n\n\toutput_vec = []\n\toutput_vec += matrixToArray(re_1[0], lambda el: 1 if el == 255 else 0)\n\n\tprint('Will start predicting...')\n\n\tpredicted_vec = engine.predict(input_vec[:ex_no])\n\n\tcounter = float(0)\n\tfor y, p in zip(output_vec[:ex_no], predicted_vec[:ex_no]):\n\t\tif y == p: counter += 1\n\n\tprint('Accuracy: ' + str(counter/ex_no))\n\n\tpredicted_mat = arrayToMatrix( predicted_vec, len(re_1[0]), len(re_1[0][0]),\\\n\t\tlambda el: 255 if el == 1 else 0)\n\n\t# The predicted segmentation is saved.\n\tsave_rgb_img(\\\n\t np.array(predicted_mat).transpose(),\\\n\t np.array(predicted_mat).transpose(),\\\n\t np.array(predicted_mat).transpose(),\\\n\t 'pred.bmp',\\\n\t)","def test_synth_tr():\n test_path = tempfile.mkdtemp()\n x_train, metadata = synth_tr(test_path)\n try:\n assert x_train.shape == (250, 3)\n except:\n shutil.rmtree(test_path)\n raise()","def _update_feature_vec(fvec, word, tag_ngram):","def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \n rep_to_plot = 0\n ttbrs = [0.5, 1,1.5]\n idx = syn_idx[str(rep_to_plot)]\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\n x_3d = syn_fm(\"3d\")[str(rep_to_plot)][:]\n x_2d = syn_fm(\"2d\")[str(rep_to_plot)][:]\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\n\n for i, ttbr in enumerate(ttbrs):\n print('Using tbrr={}'.format(ttbr))\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\n labels_cat = {}\n for key, l in labels.items():\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\n \n best_params_montaez['n_snps']= x_3d.shape[1]\n \n l_0b=labels_cat[str(rep_to_plot)]\n\n model = create_montaez_dense_model(best_params_montaez)\n y_integers = np.argmax(l_0b[idx.train], axis=1)\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\n d_class_weights = dict(enumerate(class_weights))\n\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\n\n model = iutils.keras.graph.model_wo_softmax(model)\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\n weights = analyzer.analyze(x_3d).sum(0)\n\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\n\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\n \n pvalues_filled_deep = np.ones(n_total_snps)\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\n\n # Plot RPVT\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\n if i==0:\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\n\n # Plot svm weights \n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\n pvalues_filled_combi = np.ones(len(complete_pvalues))\n pvalues_filled_combi[idx_now] = pvalues\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\n if i==0:\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot COMBI\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\n if i==0:\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\n if i==2:\n axes[i][2].set_xlabel('SNP position', fontsize=18)\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot LRP relevance scores\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\n #axes[i][1].legend()\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\n if i==0:\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot DeepCOMBI\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\n if i==0:\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\n\t\t\t\n ## Plot distribution of postprocessed vectors\n #axes[i][2].plot(postprocessed_weights)\n #axes[i][2].set_title('Postprocessed relevance')\n\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')","def train(self, features, labels, seed=None):\n raise NotImplementedError('Not implemented')","def run(args: Namespace, trial: optuna.trial._trial.Trial = None) -> Dict:\n # 1. Set seed\n utils.set_seed(seed=args.seed)\n\n # 2. Set device\n device = utils.set_device(cuda=args.cuda)\n\n # 3. Load data\n projects_fp = Path(config.DATA_DIR, \"projects.json\")\n tags_fp = Path(config.DATA_DIR, \"tags.json\")\n projects = utils.load_dict(filepath=projects_fp)\n tags_dict = utils.list_to_dict(utils.load_dict(filepath=tags_fp), key=\"tag\")\n df = pd.DataFrame(projects)\n if args.shuffle:\n df = df.sample(frac=1).reset_index(drop=True)\n df = df[: args.num_samples] # None = all samples\n\n # 4. Clean data\n df, tags_above_frequency = data.clean(\n df=df,\n include=list(tags_dict.keys()),\n exclude=config.EXCLUDE,\n min_tag_freq=args.min_tag_freq,\n )\n\n # 5. Preprocess data\n df.text = df.text.apply(data.preprocess, lower=args.lower, stem=args.stem)\n\n # 6. Encode labels\n labels = df.tags\n label_encoder = data.MultiLabelLabelEncoder()\n label_encoder.fit(labels)\n y = label_encoder.encode(labels)\n\n # Class weights\n all_tags = list(itertools.chain.from_iterable(labels.values))\n counts = np.bincount([label_encoder.class_to_index[class_] for class_ in all_tags])\n class_weights = {i: 1.0 / count for i, count in enumerate(counts)}\n\n # 7. Split data\n utils.set_seed(seed=args.seed) # needed for skmultilearn\n X = df.text.to_numpy()\n X_train, X_, y_train, y_ = data.iterative_train_test_split(X=X, y=y, train_size=args.train_size)\n X_val, X_test, y_val, y_test = data.iterative_train_test_split(X=X_, y=y_, train_size=0.5)\n test_df = pd.DataFrame({\"text\": X_test, \"tags\": label_encoder.decode(y_test)})\n\n # 8. Tokenize inputs\n tokenizer = data.Tokenizer(char_level=args.char_level)\n tokenizer.fit_on_texts(texts=X_train)\n X_train = np.array(tokenizer.texts_to_sequences(X_train), dtype=object)\n X_val = np.array(tokenizer.texts_to_sequences(X_val), dtype=object)\n X_test = np.array(tokenizer.texts_to_sequences(X_test), dtype=object)\n\n # 9. Create dataloaders\n train_dataset = data.CNNTextDataset(X=X_train, y=y_train, max_filter_size=args.max_filter_size)\n val_dataset = data.CNNTextDataset(X=X_val, y=y_val, max_filter_size=args.max_filter_size)\n test_dataset = data.CNNTextDataset(X=X_test, y=y_test, max_filter_size=args.max_filter_size)\n train_dataloader = train_dataset.create_dataloader(batch_size=args.batch_size)\n val_dataloader = val_dataset.create_dataloader(batch_size=args.batch_size)\n test_dataloader = test_dataset.create_dataloader(batch_size=args.batch_size)\n\n # 10. Initialize model\n model = models.initialize_model(\n args=args,\n vocab_size=len(tokenizer),\n num_classes=len(label_encoder),\n device=device,\n )\n\n # 11. Train model\n logger.info(f\"Arguments: {json.dumps(args.__dict__, indent=2, cls=NumpyEncoder)}\")\n args, model, loss = train.train(\n args=args,\n train_dataloader=train_dataloader,\n val_dataloader=val_dataloader,\n model=model,\n device=device,\n class_weights=class_weights,\n trial=trial,\n )\n\n # 12. Evaluate model\n artifacts = {\n \"args\": args,\n \"label_encoder\": label_encoder,\n \"tokenizer\": tokenizer,\n \"model\": model,\n \"loss\": loss,\n }\n device = torch.device(\"cpu\")\n performance = eval.evaluate(\n artifacts=artifacts,\n dataloader=test_dataloader,\n df=test_df,\n device=device,\n )\n artifacts[\"performance\"] = performance\n\n return artifacts","def create_tuning_functions(self):\r\n\t\tmotion_tuning = np.zeros((par['num_motion_tuned'], par['num_receptive_fields'], par['num_motion_dirs']), dtype=np.float32)\r\n\t\tfix_tuning = np.zeros((par['num_fix_tuned'], par['num_receptive_fields']), dtype=np.float32)\r\n\t\trule_tuning = np.zeros((par['num_rule_tuned'], par['num_rules']), dtype=np.float32)\r\n\r\n\t\t# generate list of prefered directions\r\n\t\t# dividing neurons by 2 since two equal groups representing two modalities\r\n\t\tpref_dirs = np.arange(0,360,360/(par['num_motion_tuned']//par['num_receptive_fields'])).astype(np.float32)\r\n\r\n\t\t# generate list of possible stimulus directions\r\n\t\tstim_dirs = np.arange(0,360,360/par['num_motion_dirs']).astype(np.float32)\r\n\r\n\t\tfor n in range(par['num_motion_tuned']//par['num_receptive_fields']):\r\n\t\t\tfor i in range(len(stim_dirs)):\r\n\t\t\t\tfor r in range(par['num_receptive_fields']):\r\n\t\t\t\t\td = np.cos((stim_dirs[i] - pref_dirs[n])/180*np.pi)\r\n\t\t\t\t\tn_ind = n+r*par['num_motion_tuned']//par['num_receptive_fields']\r\n\t\t\t\t\tmotion_tuning[n_ind,r,i] = par['tuning_height']*np.exp(par['kappa']*d)/np.exp(par['kappa'])\r\n\r\n\t\tfor n in range(par['num_fix_tuned']):\r\n\t\t\tfor i in range(par['num_receptive_fields']):\r\n\t\t\t\tif n%par['num_receptive_fields'] == i:\r\n\t\t\t\t\tfix_tuning[n,i] = par['tuning_height']\r\n\r\n\t\tneurons_per_rule = par['num_rule_tuned']//par['num_rules']\r\n\t\tfor n in range(par['num_rule_tuned']):\r\n\t\t\tfor i in range(par['num_rules']):\r\n\t\t\t\tif n in range(i*neurons_per_rule, (i+1)*neurons_per_rule):\r\n\t\t\t\t\trule_tuning[n,i] = par['tuning_height']\r\n\r\n\r\n\t\treturn motion_tuning, fix_tuning, rule_tuning","def trainTMVAMethods(self):\n # Open the file\n DataFile = ROOT.TFile(self.FileName)\n \n if DataFile.IsZombie() == True:\n print(\"Error opening data file {}. Is it a ROOT file?\".format(self.FileName))\n return False\n \n if DataFile.IsOpen() == False:\n print(\"Error opening data file\")\n return False\n\n # Get the data tree\n DataTree = DataFile.Get(\"Quality\")\n if DataTree == 0:\n print(\"Error reading data tree from root file\")\n return False\n\n\n # Limit the number of events:\n if DataTree.GetEntries() > self.MaxEvents:\n print(\"Reducing source tree size from \" + str(DataTree.GetEntries()) + \" to \" + str(self.MaxEvents) + \" (i.e. the maximum set)\")\n NewTree = DataTree.CloneTree(0);\n NewTree.SetDirectory(0);\n\n for i in range(0, self.MaxEvents):\n DataTree.GetEntry(i)\n NewTree.Fill()\n\n DataTree = NewTree;\n\n\n # Initialize TMVA\n ROOT.TMVA.Tools.Instance()\n\n FullPrefix = self.OutputPrefix\n ResultsFile = ROOT.TFile(FullPrefix + \".root\", \"RECREATE\")\n\n Factory = ROOT.TMVA.Factory(\"TMVAClassification\", ResultsFile, \"!V:!Silent:Color:DrawProgressBar:Transformations=I;D;P;G,D:AnalysisType=Classification\")\n\n DataLoader = ROOT.TMVA.DataLoader(self.OutputPrefix)\n\n IgnoredBranches = [ 'SimulationID', 'SequenceLength']\n Branches = DataTree.GetListOfBranches()\n\n for Name in IgnoredBranches:\n DataLoader.AddSpectator(Name, \"F\")\n\n for B in list(Branches):\n if not B.GetName() in IgnoredBranches:\n if not B.GetName().startswith(\"Evaluation\"):\n DataLoader.AddVariable(B.GetName(), \"F\")\n\n SignalCut = ROOT.TCut(\"EvaluationIsCompletelyAbsorbed >= 0.5\")\n BackgroundCut = ROOT.TCut(\"EvaluationIsCompletelyAbsorbed < 0.5\")\n DataLoader.SetInputTrees(DataTree, SignalCut, BackgroundCut)\n\n DataLoader.PrepareTrainingAndTestTree(SignalCut, BackgroundCut, \"nTrain_Signal=0:nTrain_Background=0:SplitMode=Random:NormMode=NumEvents:!V\")\n\n MethodList = []\n\n # Neural Networks\n if 'MLP' in self.Algorithms:\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kMLP, \"MLP\", \"H:!V:NeuronType=tanh:VarTransform=N:NCycles=100:HiddenLayers=N+10,N-5:TestRate=5:TrainingMethod=BFGS:!UseRegulator\")\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kMLP, \"MLP\", \"H:!V:NeuronType=tanh:VarTransform=N:NCycles=100:HiddenLayers=N+10,N-5:TestRate=5:!UseRegulator\")\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kMLP, \"MLP\", \"H:!V:NeuronType=tanh:VarTransform=N:NCycles=100:HiddenLayers=N+10,N-5:TestRate=6:TrainingMethod=BFGS:Sampling=0.3:SamplingEpoch=0.8:ConvergenceImprove=1e-6:ConvergenceTests=15:!UseRegulator\")\n MethodList.append(\"MLP\")\n\n\n # PDEFoamBoost\n if 'PDEFoamBoost' in self.Algorithms:\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kPDEFoam, \"PDEFoamBoost\", \"!H:!V:Boost_Num=100:Boost_Transform=linear:SigBgSeparate=F:MaxDepth=4:UseYesNoCell=T:DTLogic=MisClassificationError:FillFoamWithOrigWeights=F:TailCut=0:nActiveCells=2000:nBin=50:Nmin=200:Kernel=None:Compress=T\")\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kPDEFoam, \"PDEFoamBoost\", \"!H:!V:Boost_Num=30:Boost_Transform=linear:SigBgSeparate=F:MaxDepth=4:UseYesNoCell=T:DTLogic=MisClassificationError:FillFoamWithOrigWeights=F:TailCut=0:nActiveCells=500:nBin=20:Nmin=400:Kernel=None:Compress=T\")\n MethodList.append(\"PDEFoamBoost\")\n\n\n # PDERSPCA\n if 'PDERSPCA' in self.Algorithms:\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kPDERS, \"PDERSPCA\", \"!H:!V:VolumeRangeMode=Adaptive:KernelEstimator=Gauss:GaussSigma=0.3:NEventsMin=400:NEventsMax=600:VarTransform=PCA\")\n MethodList.append(\"PDERSPCA\")\n\n\n # Random Forest Boosted Decision Trees\n if 'BDT' in self.Algorithms:\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \"BDT\", \"!H:!V:NTrees=1000:MinNodeSize=1%:MaxDepth=3:BoostType=AdaBoost:AdaBoostBeta=0.4:SeparationType=CrossEntropy:nCuts=100:PruneMethod=NoPruning\")\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \"BDT\", \"!H:!V:NTrees=850:nEventsMin=150:MaxDepth=3:BoostType=AdaBoost:AdaBoostBeta=0.5:SeparationType=GiniIndex:nCuts=20:PruneMethod=NoPruning\")\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \"BDT\", \"!H:!V:NTrees=1000:nEventsMin=1000:MaxDepth=4:BoostType=AdaBoost:AdaBoostBeta=0.5:SeparationType=GiniIndex:nCuts=20:PruneMethod=NoPruning\")\n \n options = \"!H:!V:NTrees={}:MinNodeSize={}%:MaxDepth={}:BoostType=AdaBoost:AdaBoostBeta={}:SeparationType=CrossEntropy:nCuts=100:PruneMethod=NoPruning\".format(self.BDT_NTrees, self.BDT_MinNodeSize, self.BDT_MaxDepth, self.BDT_AdaBoostBeta)\n \n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \"BDT\", ROOT.TString(options))\n MethodList.append(\"BDT\")\n\n\n # State Vector Machine\n if 'SVM' in self.Algorithms:\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kSVM, \"SVM\", \"Gamma=0.25:Tol=0.001:VarTransform=Norm\");\n MethodList.append(\"SVM\")\n\n\n # DNN\n if 'DNN_CPU' in self.Algorithms:\n Layout = \"Layout=TANH|N,TANH|N/2,LINEAR\"\n\n Training0 = \"LearningRate=1e-1,Momentum=0.9,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.5+0.5+0.5,Multithreading=True\"\n Training1 = \"LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\"\n Training2 = \"LearningRate=1e-3,Momentum=0.0,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\"\n TrainingStrategy = \"TrainingStrategy=\" + Training0 + \"|\" + Training1 + \"|\" + Training2\n\n Options = \"!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:\" + Layout + \":\" + TrainingStrategy\n\n Options += \":Architecture=CPU\"\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kDNN, \"DNN_CPU\", Options)\n MethodList.append(\"DNN_CPU\")\n\n\n # DNN\n if 'DNN_GPU' in self.Algorithms:\n Layout = \"Layout=TANH|N,TANH|N/2,LINEAR\"\n\n Training0 = \"LearningRate=1e-1,Momentum=0.9,Repetitions=1,ConvergenceSteps=100,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.5+0.5+0.5,Multithreading=True\"\n Training1 = \"LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=100,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\"\n Training2 = \"LearningRate=1e-3,Momentum=0.0,Repetitions=1,ConvergenceSteps=100,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\"\n TrainingStrategy = \"TrainingStrategy=\" + Training0 + \"|\" + Training1 + \"|\" + Training2\n\n Options = \"!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:\" + Layout + \":\" + TrainingStrategy\n\n Options += \":Architecture=GPU\"\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kDNN, \"DNN_GPU\", Options)\n MethodList.append(\"DNN_GPU\")\n\n\n # DL\n if 'DL_CPU' in self.Algorithms:\n Setup = \"!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM\"\n Layout = \"Layout=TANH|N,TANH|N/2,LINEAR\"\n TrainingStrategy = \"TrainingStrategy=Optimizer=ADAM,LearningRate=0.001,TestRepetitions=1,MaxEpochs=100000,ConvergenceSteps=500,BatchSize=100,DropConfig=0.0\"\n Architecture = \"Architecture=CPU\" \n \n Options = Setup + \":\" + Layout + \":\" + TrainingStrategy + \":\" + Architecture\n\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kDL, \"DL_CPU\", Options)\n MethodList.append(\"DL_CPU\")\n\n\n # Finally test, train & evaluate all methods\n print(\"Started training\")\n Factory.TrainAllMethods()\n Factory.TestAllMethods()\n Factory.EvaluateAllMethods()\n\n print(\"\\nTake a look at the results in root with:\\nTMVA::TMVAGui(\\\"Results.root\\\");\\nEspecially plot 4a\")\n\n print(Factory.GetMethod(ROOT.TString(self.OutputPrefix), ROOT.TString(\"BDT\")).GetROCIntegral())\n\n self.ResultsTMVA.clear()\n for method in MethodList:\n print(\"{}: {}\".format(method, Factory.GetMethod(ROOT.TString(self.OutputPrefix), ROOT.TString(\"BDT\")).GetROCIntegral()))\n self.ResultsTMVA[method] = Factory.GetMethod(ROOT.TString(self.OutputPrefix), ROOT.TString(\"BDT\")).GetROCIntegral()\n \n return True","def trainAndTune(self, trainingData, trainingLabels, validationData, validationLabels, Cgrid):\n \"*** YOUR CODE HERE ***\"\n\n #if predicted label is not equal to actual label\n num_errors = 0 \n \n #weights will be changed when checking if labels are equal to each other\n \n\n \n #traversing across the Cgrid to train each set across each value of c in Cgrid \n for c in Cgrid:\n updatedWeights = self.weights.copy()\n for iteration in range(self.max_iterations):\n \n print(\"Starting iteration \", iteration, \"..\")\n if iteration > 0:\n num_errors = 0\n\n for i in range(len(trainingData)):\n trainingUnit = trainingData[i].copy() #trainingUnit is one instance of training data at i\n #predLabel = self.classify(trainingUnit) #classifies data in order list of predicted label values\n #predictedLabel = predLabel[0] #extract predicted label where max is at first index\n realLabel = trainingLabels[i] #extract real label from training label in order to compare\n\n\n\n predY = 0\n predictedLabel = -1;\n for label in self.legalLabels:\n predLabel = trainingUnit * updatedWeights[label]\n if predictedLabel < predLabel or predictedLabel == -1:\n predictedLabel = predLabel\n predY = label\n\n tau = 0 \n \n #if predicted label is not equal to real label\n if predY != realLabel: \n feature = trainingUnit.copy() #extract feature of current training unit\n num_errors += 1 \n #t = ((wpred - wactual)*feature + 1.0)/(2 * feature * feature) = num/div \n num = updatedWeights[predY] - updatedWeights[realLabel]\n num = num * feature\n num += 1.0 \n \n\n div = (feature*feature)\n \n div += 2.0\n t = num/div\n \n tau = min(c,t)\n \n \n \n #for j in range(feature):\n for j in range(len(trainingData[i])):\n feature[j] = feature[j] * tau\n updatedWeights[realLabel] = updatedWeights[realLabel] + feature #wactual = wactual + tau*feature\n updatedWeights[predY] = updatedWeights[predY] - feature #wpred = wpred + tau*feature\n \n\n print(\"finished updating weights\")\n\n #determine guesses by classifying validation data\n guesses = self.classify(validationData)\n correct = 0\n bestAccuracy = None #no best accuracy rate yet\n\n #traverse over guesses, determine how many \n #answers were correct \n for i in range(len(guesses)):\n if guesses[i] == validationLabels[i]: #guess matches validation label\n correct += 1\n\n accuracy = correct / len(guesses) #determine percentage\n if(accuracy > bestAccuracy):\n bestAccuracy = accuracy\n\n self.weights = updatedWeights","def test_text_classifier_add_training_samples(self):\n pass","def test_text_classifier_add_testing_samples(self):\n pass"],"string":"[\n \"def test_getTunaFeatures(self):\\n tuna = Tuna(\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\")\\n array = [\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\"]\\n self.assertEqual(tuna.getTunaFeatures(), array)\",\n \"def _initialize_with_tune_context(self, context: \\\"TuneContext\\\") -> None:\\n raise NotImplementedError\",\n \"def prepare_features(self, wavs, stage):\\n wavs, lens = wavs\\n if stage == sb.Stage.TRAIN:\\n if hasattr(self.modules, \\\"env_corrupt\\\"):\\n wavs_noise = self.modules.env_corrupt(wavs, lens)\\n wavs = torch.cat([wavs, wavs_noise], dim=0)\\n lens = torch.cat([lens, lens])\\n\\n if hasattr(self.hparams, \\\"augmentation\\\"):\\n wavs = self.hparams.augmentation(wavs, lens)\\n\\n # Choose what features we want to use\\n # todo: support multiple features and feature concat\\n target_feats = self.hparams.embedding_features\\n\\n FEATURE_EXTRACTOR = {\\n # 'cqt': self.modules.cqt,\\n # 'fbanks': self.modules.fbanks\\n 'fastaudiogauss': self.modules.fastaudiogauss\\n # 'ifr': self.modules.ifr\\n # 'mag': self.modules.mag\\n # 'mfcc': self.modules.mfcc\\n # 'leaf': self.modules.leaf\\n # 'tdfbanks': self.modules.tdfbanks\\n # 'pcen': self.modules.pcen\\n # 'sincnet': self.modules.sincnet\\n # 'trainable_fbanks': self.modules.trainable_fbanks\\n }\\n\\n if len(target_feats) == 1:\\n # wavs = wavs.unsqueeze(1).cuda()\\n feats = FEATURE_EXTRACTOR[target_feats[0]](wavs)\\n # feats = torch.unsqueeze(feats, 1)\\n # feats = torch.transpose(feats, 1,2)\\n if target_feats[0]=='cqt':\\n log_spec = 10.0 * torch.log10(torch.clamp(feats, min=1e-30))\\n log_spec -= 10.0\\n feats=log_spec\\n feats = torch.transpose(feats, 1,2)\\n else:\\n feats = []\\n for target in target_feats:\\n temp = FEATURE_EXTRACTOR[target](wavs)\\n if target=='cqt':\\n temp = torch.transpose(temp, 1,2)\\n feats.append(temp)\\n f =feats[0]\\n for i in range(1, len(feats)):\\n f = torch.cat((f, feats[i]), dim=2)\\n feats = f\\n feats = self.modules.mean_var_norm(feats, lens)\\n return feats, lens\",\n \"def _initialize_with_tune_context(self, context: \\\"TuneContext\\\") -> None:\\n _ffi_api.MutatorInitializeWithTuneContext( # type: ignore # pylint: disable=no-member\\n self, context\\n )\",\n \"def test(self, test):\\r\\n self.ml_data.set_target(test[0])\\r\\n self.ml_data.set_features(test[1])\\r\\n if self.ml_data.target_type.all() == np.float64 or self.ml_data.target_type.all() == np.int64:\\r\\n self.model_qua.open()\\r\\n else:\\r\\n self.model_quali.open()\",\n \"def features(self, features):\\n\\n self._features = features\",\n \"def test_svm():\\n backend = BasicAer.get_backend('statevector_simulator')\\n random_seed = r.randint(1, 10598)\\n\\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\\n\\n # iris\\n pres = \\\"Test pour le data set Iris (facile, classique)\\\"\\n test_from_func(pres, 15, 10, 3, True, Iris, quantum_instance)\\n\\n # breast cancer\\n pres = \\\"Test pour le data set Breast Cancer (facile, classique)\\\"\\n test_from_func(pres, 15, 10, 3, True, Breast_cancer, quantum_instance)\\n\\n # digits (it's long so be careful)\\n #pres = \\\"Test pour le data set Digits (difficile, classique)\\\"\\n #test_from_func(pres, 10, 10, 10, True, Digits, quantum_instance)\\n\\n # wine\\n pres = \\\"Test pour le data set Wine (moyen, classique)\\\"\\n test_from_func(pres, 15, 10, 5, True, Wine, quantum_instance)\\n\\n # gaussian\\n pres = \\\"Test pour des données gaussiennes (moyen, classique)\\\"\\n for _ in range(1):\\n print(\\\"\\\\n\\\")\\n print(\\\"New iteration\\\")\\n test_from_func(pres, 25, 10, 2, True, Gaussian, quantum_instance)\\n print(\\\"\\\\n\\\")\\n\\n # small adn strings\\n pres = \\\"Test pour des séquences ADN courtes (difficile, classique)\\\"\\n test_from_func(pres, 10, 15, 14, True, Sequence, quantum_instance)\",\n \"def set_features(self, features):\\n self.features_ = list(features)\",\n \"def nonlearning():\\n\\taT.featureAndTrain(['../../AudioData/chunked_data_sorted/pos', '../../AudioData/chunked_data_sorted/neg'], \\n\\t\\t\\t\\t\\t\\t1.0, 1.0, aT.shortTermWindow, aT.shortTermStep, \\n \\\"svm\\\", \\\"emotion_classifier\\\", True)\",\n \"def set_features(self, features: list):\\n self._features = features\",\n \"def test_intent_classifier_update_training_samples(self):\\n pass\",\n \"def set_features(self, features: np.ndarray):\\n self.features = features\",\n \"async def async_set_features(self, features):\\n self._features = features\",\n \"def testSetup(self):\\n \\n train = QuizBowlData(None, \\\"\\\", self.vectorizer)\\n train.vectorize(kTOY_TRAIN) \\n model, optimizer = setup(train, 1.0)\\n\\n self.assertEqual(list(model.weight.size()), [2, 2])\\n self.assertEqual(list(model.bias.size()), [2])\",\n \"def setup(self, num_qubit, fusion_enable, use_cu1):\",\n \"def test_regressors_hypertune(setup):\\n # Load the data\\n train_features, test_features, train_target, test_target = setup\\n # Call the function that we would like to test\\n tuned, tune_time = regressors.hyperTune(RandomForestRegressor(), train_features, train_target,\\n grid=grid.rf_paramgrid(), folds=2, iters=1, jobs=1)\\n # Assert if tuned is a dictionary\\n assert type(tuned) == dict\\n # Assert if tune_time is a float\\n assert type(tune_time) == float\",\n \"def __init__(self, features=None):\\n self.features = features\",\n \"def test_text_classifier_update_training_samples(self):\\n pass\",\n \"def findFeatures(self):\\n\\t\\tpass\",\n \"def get_feature_set_SA(tweet):\\n features= {}\\n return features\",\n \"def test_all_features(self):\\n to_create = ['looktest1', 'looktest2', 'looktest3']\\n for f in to_create:\\n Feature(f).activate()\\n\\n all_features = Feature.all_features()\\n self.assertEqual(len(all_features), len(to_create))\\n for f in to_create:\\n self.assertTrue(f in all_features)\",\n \"def feat():\\n pass\",\n \"def train(self, features, labels):\\n pass\",\n \"def load_features(self, features):\\n pass\\n # self.features = features\",\n \"def test(self):\\n self.training = False\",\n \"def test__extract_features(self):\\n text_sample = \\\"I really really love this movie\\\"\\n feature_sample = ['really','love','good']\\n feature_score_type = \\\"presence\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':1,'love':1,'good':0})\\n feature_score_type = \\\"term_frequency\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':2,'love':1,'good':0})\",\n \"def __init__(self, num_features):\\n super(TLU, self).__init__()\\n self.num_features = num_features\\n self.tau = nn.parameter.Parameter(torch.Tensor(1, num_features, 1, 1), requires_grad=True)\\n self.reset_parameters()\",\n \"def get_feature_set_PB(tweet):\\n features= {\\n 'text_length': np.log(len(tweet.text))\\n } #ADD ADDITIONAL FEATURES\\n if tweet.nrof_sademoticons>0:\\n features['sademoticons'] = tweet.nrof_sademoticons\\n if tweet.nrof_happyemoticons>0:\\n features['happyemoticons'] = tweet.nrof_happyemoticons\\n \\n return features\",\n \"def main():\\n \\n # The following 5 command lines can be outcommented if the features are already created.\\n # There is no need to process the data every single time.\\n # Fine tuning the learning algorythm is much faster without that extra step.\\n \\n # by reading the train dataset the feature index is created.\\n # First calling of the processdata function\\n # Data limited to 300000\\n featureIndexes = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000)\\n print \\\"featureIndex generated!\\\"\\n print len(featureIndexes)\\n\\n # Trainfeature is created using the indexfeatures...\\n # Second calling of the processdata function\\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000) # Original itemsLimit=300000\\n\\n # Building the test dataset... just like the training...\\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\\\"avito_test.tsv\\\"), featureIndexes)\\n\\n # Dumping data into file...\\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\\\"SeparatedByCategory.pkl\\\"))\\n\\n\\n # loading data pack...\\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n\\n #logging.info(\\\"Feature preparation done, fitting model...\\\")\\n\\n # Stochastic gradient model\",\n \"def setup_svm_classifier(training_data, y_training, testing_data, features, method=\\\"count\\\", ngrams=(1,1)):\\n # generate x and y training data\\n\\n if method == \\\"count\\\":\\n vec, x_training, x_testing = define_features_vectorizer(features, training_data, testing_data,ngramrange=ngrams)\\n elif method == \\\"tfidf\\\":\\n vec, x_training, x_testing = define_features_tfidf(features, training_data, testing_data,ngramrange=ngrams)\\n else:\\n print(\\\"Method has to be either count or tfidf\\\")\\n return 1\\n\\n # train classifier\\n\\n model = SVMClassifier_scratch()\\n model.fit(x_training, y_training)\\n\\n return model, vec, x_testing\",\n \"def test_svm_quantique():\\n backend = BasicAer.get_backend('statevector_simulator')\\n random_seed = 10598\\n\\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\\n pres = \\\"Test pour des données générées par ordinateur quantique (facile, quantique)\\\"\\n print(pres)\\n _, samp_train, samp_test, labels = ad_hoc_data(15, 10, 2, 0.3, True)\\n sample_m, sample_p = stock_get(20, 0.3)\\n\\n labels_me = [-1, 1]\\n samp_train_me = {-1: np.array(sample_m[:15]), 1: np.array(sample_p[:15])}\\n samp_test_me = {-1: np.array(sample_m[15:]), 1: np.array(sample_p[15:])}\\n print(samp_train)\\n print(samp_train_me)\\n print(samp_test)\\n print(samp_test_me)\\n classical_kernel_estimation(samp_train, samp_test, labels)\\n classical_kernel_estimation(samp_train_me, samp_test_me, labels_me)\\n\\n # Generate the feature map\\n feature_map = FirstOrderExpansion(feature_dimension=2, depth=2)\\n\\n # Run the Quantum Kernel Estimator and classify the test data\\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\\n test_dataset=samp_test)\\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\\n test_dataset=samp_test_me)\\n\\n result = qsvm.run(quantum_instance)\\n result_me = qsvm_me.run(quantum_instance)\\n print(\\\"Success of the FirstOrder feature map kernel:\\\")\\n print(result['testing_accuracy'])\\n print(result_me['testing_accuracy'])\\n\\n # Generate the feature map\\n feature_map = SecondOrderExpansion(feature_dimension=2, depth=2)\\n\\n # Run the Quantum Kernel Estimator and classify the test data\\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\\n test_dataset=samp_test)\\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\\n test_dataset=samp_test_me)\\n\\n result = qsvm.run(quantum_instance)\\n result_me = qsvm_me.run(quantum_instance)\\n print(\\\"Success of the SecondOrder feature map kernel:\\\")\\n print(result['testing_accuracy'])\\n print(result_me['testing_accuracy'])\\n\\n # Last implementation using the custom circuit generator\\n print(\\\"Success for my implementation (second order):\\\")\\n my_impl(samp_train, samp_test, labels)\\n my_impl(samp_train_me, samp_test_me, labels_me)\\n\\n feature_map = CustomExpansion(num_qubits=2, constructor_function=custom_constr, feature_param=[1])\\n\\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\\n test_dataset=samp_test)\\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\\n test_dataset=samp_test_me)\\n\\n result = qsvm.run(quantum_instance)\\n result_me = qsvm_me.run(quantum_instance)\\n print(\\\"Success of the Custom feature map kernel:\\\")\\n print(result['testing_accuracy'])\\n print(result_me['testing_accuracy'])\",\n \"def test_training(self):\\n\\t\\tpass\",\n \"def setup_to_finetune(model):\\r\\n # for layer in model.layers[:NB_IV3_LAYERS_TO_FREEZE]:\\r\\n # layer.trainable = False\\r\\n for layer in model.layers[:]:\\r\\n layer.trainable = True\\r\\n model.compile(optimizer=Adam(lr=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])\",\n \"def __init__(self, tfiles, featurizer):\\n\\t\\t### [ Featurize the classifier ] ###\\n\\t\\t# random.shuffle(tfiles)\\n\\t\\tself.featurizer = featurizer\\n\\t\\tself.tfiles = tfiles\\n\\n\\t\\t# Now build a model based on these vectors\\n\\t\\tnum_files = len(tfiles)\\n\\t\\tnum_training_files = int(PERCENT_TRAINING * num_files)\\n\\t\\tnum_test_files = num_files - num_training_files\\n\\n\\t\\tself.train_files = self.tfiles[:num_training_files]\\n\\t\\tself.test_files = self.tfiles[num_training_files:]\\n\\n\\t\\tself.all_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.tfiles]\\n\\t\\tall_data_vectors = [d[0] for d in self.all_data]\\n\\t\\tprint([v.shape for v in all_data_vectors])\\n\\t\\tself.all_features = np.vstack(d[0] for d in self.all_data)\\n\\t\\tself.all_labels = np.hstack(d[1] for d in self.all_data)\\n\\n\\t\\tself.train_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.train_files]\\n\\t\\tself.train_features = np.vstack([d[0] for d in self.train_data])\\n\\t\\tself.train_labels = np.hstack([d[1] for d in self.train_data])\\n\\n\\t\\tself.test_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.test_files]\\n\\t\\tself.test_features = np.vstack([d[0] for d in self.test_data])\\n\\t\\tself.test_labels = np.hstack(d[1] for d in self.test_data)\\n\\n\\t\\tself.trained_clf = []\\n\\t\\tfor cl in used_classifiers:\\n\\t\\t\\tself.trained_clf += [cl(self.train_features, self.train_labels)]\",\n \"def tunings(self, tunings):\\n self.Kp, self.Ki, self.Kd = tunings\",\n \"def test_Tuna(self):\\n tuna = Tuna(\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\")\\n self.assertIsNotNone(tuna)\",\n \"def __trainLocal__(self, featureVals, targetVals):\\n pass\",\n \"def test_update_hyperflex_feature_limit_internal(self):\\n pass\",\n \"def fit(self, features, target, **kwargs):\\n self.features = features\\n self.target = target\\n super(tpot_class, self).fit(features, target, **kwargs)\",\n \"def __init__(self, **kwargs):\\n FeatureDefinition.__init__(self)\\n\\n nbTypes = self._getTypeNumber(kwargs)\\n \\n print(\\\"BETTER FEATURES\\\")\\n \\n \\n block_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\\n (\\\"xywh\\\", Pipeline([\\n ('selector', NodeTransformerXYWH_v2()),\\n #v1 ('xywh', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('xywh', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n , (\\\"neighbors\\\", Pipeline([\\n ('selector', NodeTransformerNeighbors()),\\n #v1 ('neighbors', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('neighbors', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n , (\\\"1hot\\\", Pipeline([\\n ('1hot', Node1HotFeatures()) #does the 1-hot encoding directly\\n ])\\n )\\n ])\\n grid_line_transformer = GridLine_NodeTransformer_v2()\\n \\n self._node_transformer = TransformerListByType([block_transformer, grid_line_transformer]) \\n \\n edge_BB_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\\n (\\\"1hot\\\", Pipeline([\\n ('1hot', Edge1HotFeatures(PageNumberSimpleSequenciality()))\\n ])\\n )\\n , (\\\"boolean\\\", Pipeline([\\n ('boolean', EdgeBooleanFeatures_v2())\\n ])\\n )\\n , (\\\"numerical\\\", Pipeline([\\n ('selector', EdgeNumericalSelector()),\\n #v1 ('numerical', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('numerical', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n ] )\\n edge_BL_transformer = DU_ABPTableRG.Block2GridLine_EdgeTransformer()\\n edge_LL_transformer = DU_ABPTableRG.GridLine2GridLine_EdgeTransformer()\\n self._edge_transformer = TransformerListByType([edge_BB_transformer,\\n edge_BL_transformer,\\n edge_BL_transformer, # useless but required\\n edge_LL_transformer \\n ])\\n \\n self.tfidfNodeTextVectorizer = None #tdifNodeTextVectorizer\",\n \"def test_machine_learning():\",\n \"def setup_features():\\n\\n core_features = {\\\"web\\\": [\\\"content_directory\\\", \\\"controllers\\\", \\\"templates\\\"]}\\n\\n imported_features = []\\n for feature_type, feature_list in core_features.items():\\n features_list_names = \\\", \\\".join(feature_list)\\n print(\\n \\\"** Setting up {0} features {1}\\\".format(\\n info(feature_type), info(features_list_names)\\n )\\n )\\n for feature_name in feature_list:\\n script_dir = dirname(abspath(__file__))\\n module_fname = join(\\n script_dir, \\\"features\\\", feature_type, feature_name + \\\".py\\\"\\n )\\n\\n feature_dict = {}\\n with open(module_fname) as source_file:\\n exec(compile(source_file.read(), module_fname, \\\"exec\\\"), feature_dict)\\n try:\\n feature = feature_dict[\\\"Feature\\\"]()\\n except KeyError:\\n print_error(\\n \\\"Feature module '%s' does not provide a Feature class!\\\"\\n % feature_name\\n )\\n sys.exit(1)\\n try:\\n feature.setup()\\n except: # NOQA: E722\\n print_error(\\\"Failed setting up feature '%s' !\\\" % feature_name)\\n raise\\n imported_features.append(feature)\\n\\n for feature in imported_features:\\n if hasattr(feature, \\\"activate\\\"):\\n feature.activate()\",\n \"def get_feature_set_SB(tweet):\\n #pos-tag frequencies\\n# print \\\"Tagged words in tweet: \\\", tweet.tagged_words\\n pos_tag_freq = {}\\n additional_freq = {}\\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# if tag=='PRtinf':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJS':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJ':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='NP':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='DET':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='P':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n additional_freq['pronoun'] = 1\\n except KeyError:\\n continue\\n# print \\\"Tag frequencies: \\\", pos_tag_freq\\n for key in pos_tag_freq.keys():\\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \\n #Number of exclamation marks, number of emoticons,\\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\\n if emoticons>0:\\n additional_freq['emoticons'] = emoticons*1.0\\n if tweet.nrof_exclamations>0:\\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\\n \\n# print \\\"Additional frequencies: \\\", additional_freq\\n# raw_input(\\\"Continue?\\\")\\n \\n #Concatenate the dicts\\n features= dict(pos_tag_freq.items() + additional_freq.items())\\n# print \\\"All features: \\\", features\\n# raw_input(\\\"Continue?\\\")\\n return features\",\n \"def trainMVA(config, samples, cuts):\\n\\n # cutbased set to true during runtime if running of a cutbased analysis has already been detected\\n # i.e. originally cutbased = (len(mva)==0) from bookAnalysisJobs and is set to true if any analysis job is added to the provided cuts\\n runtime = config.getFolder(\\\"runtime+\\\")\\n cutbased = runtime.getTagBoolDefault(\\\"cutbased\\\", False)\\n\\n mvascriptnames = config.getTagVString(\\\"MVA\\\")\\n mvaOK = False\\n if len(mvascriptnames)>0:\\n for mvaconfig in mvascriptnames:\\n mvascriptname = ROOT.TString()\\n QFramework.TQStringUtils.readUpTo(mvaconfig,mvascriptname,\\\"(\\\")\\n QFramework.TQStringUtils.removeLeadingText(mvaconfig,\\\"(\\\")\\n QFramework.TQStringUtils.removeTrailingText(mvaconfig,\\\")\\\")\\n path = QFramework.TQFolder.concatPaths(\\\"MVA\\\",mvascriptname).Data() + \\\".py\\\"\\n if (mvaconfig):\\n QFramework.INFO(\\\"now running analysis '{:s}' with options '{:s}'\\\".format(mvascriptname,mvaconfig))\\n else:\\n QFramework.INFO(\\\"now running analysis '{:s}'\\\".format(mvascriptname))\\n allOK = True\\n\\n try:\\n myMVA = imp.load_source(\\\"myMVA\\\",path)\\n except IOError:\\n QFramework.CRITICAL(\\\"unable to open file '{:s}' - please double-check!\\\".format(path))\\n allOK = False\\n\\n if allOK:\\n try:\\n QFramework.TQUtils.ensureDirectory(\\\"weights\\\")\\n tqmva = QFramework.TQMVA(samples)\\n tqmva.setBaseCut(cuts)\\n tqmva.setName(mvascriptname)\\n tqmva.setTitle(mvascriptname)\\n tqmva.setAliases(aliases)\\n tqmva.importTags(mvaconfig,False)\\n timer = ROOT.TStopwatch()\\n if not dummy:\\n retval = myMVA.runMVA(tqmva)\\n else:\\n retval = True\\n QFramework.WARN(\\\"dummy run, skipping execution of MVA analysis '{:s}'\\\".format(tqmva.GetName()))\\n timer.Stop()\\n if retval:\\n QFramework.INFO(\\\"analysis '{:s}' complete after {:.2f}s, output written to '{:s}'!\\\".format(mvascriptname,timer.RealTime(),tqmva.getTagStringDefault(\\\"outputFileName\\\",\\\"<unknown file>\\\")))\\n mvaOK = True\\n else:\\n QFramework.WARN(\\\"analysis '{:s}' returned '{:s}' - please double-check!\\\".format(mvascript,str(retval)))\\n except Exception as ex:\\n template = \\\"An exception of type '{0}' occured: {1!s}\\\"\\n message = template.format(type(ex).__name__, \\\",\\\".join(map(str,ex.args)))\\n QFramework.ERROR(message)\\n allOK = False\\n\\n elif not cutbased:\\n appname = QFramework.TQLibrary.getApplicationName().Data()\\n QFramework.ERROR(\\\"no analysis script given, please use 'MVA: myAnalysis' under the [{:s}] section to import and execute some python script 'MVA/myAnalysis.py'. it should contain a function 'runMVA(...)' that will receive a readily prepared sample folder at your disposal\\\".format(appname))\\n\\n # store in runtime folder whether or not at least 1 MVA finished successfully\\n runtime = config.getFolder(\\\"runtime+\\\")\\n runtime.setTagString(\\\"mvaOK\\\", mvaOK)\\n\\n return\",\n \"def train(self, tdict):\\n pass\",\n \"def test():\\n listpost,listclass = bayes.loaddataset()\\n myvocablist = bayes.createlist(listpost)\\n tmatrix = list()\\n for doc in listpost:\\n\\t vec = bayes.word2vec(myvocablist,doc)\\n\\t tmatrix.append(vec)\\n p0,p1,pa = bayes.train(tmatrix,listclass)\\n testdoc1 = ['love','my','dalmation']\\n testvec1 = bayes.word2vec(myvocablist,testdoc1)\\n print testdoc1,'classify as :',bayes.classify(testvec1,p0,p1,pa)\\n testdoc2 = ['stupid','love']\\n testvec2 = bayes.word2vec(myvocablist,testdoc2)\\n print testdoc2,'classify as :',bayes.classify(testvec2,p0,p1,pa)\",\n \"def run():\\n # all data and labels\\n # tracemalloc.start()\\n # start = time.time()\\n data, labels = Startdata.getdata() # texts\\n data2, labels2 = Startdata.getdata2() # emails\\n # Startdata.bagofwords(data2, labels2)\\n data, labels = Startdata.combinedata(data, data2, labels, labels2)\\n # split into training and testing. 1/3 test, 2/3 train\\n traind, trainl, testd, testl = Startdata.splitdata(data, labels)\\n\\n # labels\\n trainlabels = Startdata.labelfix(trainl)\\n testlabels = Startdata.labelfix(testl)\\n\\n # selective features\\n #\\n # extract features for use. in the shape of NxD\\n # N is number of samples, D is number of features\\n # current, peak = tracemalloc.get_traced_memory()\\n trainfeat = Startdata.featurextract(traind, trainl)\\n testfeat = Startdata.featurextract(testd, testl)\\n # theta is the weights in a D+1 X 1 array\\n theta = Spamfilter.train(trainfeat, trainlabels)\\n #\\n # trying bag of words\\n #\\n\\n # Startdata.featurextract(data, labels)\\n # error rate was 1.69% for trainingdata\\n # 2.21% for testing data\\n # bag, tfeat = Startdata.bagofwords(traind)\\n # theta = Spamfilter.train(tfeat, trainlabels)\\n # testfeat = Startdata.features(testd, bag)\\n\\n test(theta, testfeat, testlabels)\\n # tracemalloc.stop()\\n # done = time.time()\\n # print(f\\\"Current memory usage is {current / 10**6} MB; Peak was {peak / 10**6} MB\\\")\\n # print(\\\"time to complete\\\", done - start)\\n # NTR 12/1/2020 current best featextraction at 25 iterations is about\\n # 0.7-1% error for\\n # trainingdata and testing data\\n # NTR 12/2/2020 bag of words at 25 iterations\\n # 1.69% training error, 2.21% testing error\\n # NTR 12/2/2020 bag of words, 25 iter, removal of some features\\n # NTR 12/3/2020 featextraction 20 iterations, new features, emails inc\\n # 0.59% error on training. 0.63% testing error\",\n \"def test_ann_features():\\n CQT(file_struct, FeatureTypes.ann_beatsync, sr=11025).features\",\n \"def test_intent_classifier_add_training_samples(self):\\n pass\",\n \"def test_features_property():\\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\\n atom.run(\\\"LR\\\")\\n assert [i == j for i, j in zip(atom.lr.features, atom.features)]\",\n \"def get_feature_set_PA(tweet):\\n features= {}\\n return features\",\n \"def setWalabotSettings():\\n wlbt.SetProfile(wlbt.PROF_SENSOR)\\n wlbt.SetArenaR(R_MIN, R_MAX, R_RES)\\n wlbt.SetArenaTheta(THETA_MIN, THETA_MAX, THETA_RES)\\n wlbt.SetArenaPhi(PHI_MIN, PHI_MAX, PHI_RES)\\n #wlbt.SetThreshold(THRESHOLD)\\n wlbt.SetDynamicImageFilter(wlbt.FILTER_TYPE_DERIVATIVE) #Also test with FILTER_TYPE_NONE\\n print('- Walabot Configured.')\",\n \"def train_naive(): # add arguments as needed\\n pass\",\n \"def test_create_hyperflex_feature_limit_internal(self):\\n pass\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def get_feature_set_PC(tweet, sentimentvalues):\\n features= {\\n 'text_length': np.log(len(tweet.text))\\n } #ADD ADDITIONAL FEATURES\\n if tweet.nrof_sademoticons>0:\\n features['sademoticons'] = tweet.nrof_sademoticons\\n if tweet.nrof_happyemoticons>0:\\n features['happyemoticons'] = tweet.nrof_happyemoticons\\n \\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n features[tag] = features.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n features['adjectives'] = features.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n features['adverbs'] = features.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n features['pronoun'] = 1\\n except KeyError:\\n continue\\n for key in features.keys():\\n features[key] = features[key]*1.0\\n \\n #Add lexical features\\n # total polarity score, number of positive words, number of negative words\\n pos_score = 0\\n neg_score = 0\\n nrof_pos_words = 0\\n nrof_neg_words = 0\\n for word in sentimentvalues.keys():\\n if sentimentvalues[word][0]>0:\\n nrof_pos_words = nrof_pos_words + 1\\n pos_score = pos_score + sentimentvalues[word][0]\\n if sentimentvalues[word][1]>0:\\n nrof_neg_words = nrof_neg_words + 1\\n neg_score = neg_score + sentimentvalues[word][1]\\n\\n if neg_score>0:\\n features['neg_score'] = neg_score+1.0\\n if pos_score>0:\\n features['pos_score'] = pos_score+1.0\\n if nrof_pos_words>0:\\n features['positive_words'] = nrof_pos_words*1.0\\n if nrof_neg_words>0:\\n features['negative_words'] = nrof_neg_words*1.0\\n \\n return features\",\n \"def features(self, state, action, next_state):\\n raise NotImplementedError\",\n \"def __init__(\\n self,\\n feature_config: Union[tf.tpu.experimental.embedding.FeatureConfig,\\n Iterable], # pylint:disable=g-bare-generic\\n optimizer: Optional[Union[tf.tpu.experimental.embedding.SGD,\\n tf.tpu.experimental.embedding.Adagrad,\\n tf.tpu.experimental.embedding.Adam,\\n tf.tpu.experimental.embedding.FTRL]],\\n pipeline_execution_with_tensor_core: bool = False,\\n batch_size: Optional[int] = None,\\n embedding_feature: Optional[\\n tf.tpu.experimental.HardwareFeature.EmbeddingFeature] = None):\\n super().__init__()\\n self._feature_config, self._table_config_map = (\\n _clone_and_prepare_features(feature_config))\\n self._optimizer = _normalize_and_prepare_optimizer(optimizer)\\n\\n self._strategy = tf.distribute.get_strategy()\\n self._using_tpu = _is_tpu_strategy(self._strategy)\\n\\n self._embedding_feature = None\\n if self._using_tpu:\\n self._embedding_feature = self._strategy.extended.tpu_hardware_feature.embedding_feature\\n # Override the embedding feature setting if passed.\\n if embedding_feature is not None:\\n if embedding_feature == _EMBEDDING_UNSUPPORTED:\\n self._embedding_feature = _EMBEDDING_UNSUPPORTED\\n if (embedding_feature != _EMBEDDING_UNSUPPORTED and\\n self._embedding_feature != embedding_feature):\\n raise ValueError(\\n \\\"TPU only supports {} and {}, but got {} which is not supported.\\\"\\n .format(_EMBEDDING_UNSUPPORTED, self._embedding_feature,\\n embedding_feature))\\n\\n # Create TPU embedding mid level APIs according to the embedding feature\\n # setting.\\n self._tpu_embedding = self._create_tpu_embedding_mid_level_api(\\n self._using_tpu, self._embedding_feature,\\n pipeline_execution_with_tensor_core)\\n\\n self.batch_size = batch_size\\n\\n self._tpu_call_id = 0\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def test_feature_shape():\\n\\n N = 1024\\n n_sample = 100\\n\\n def get_gemm_feature(target):\\n k = tvm.reduce_axis((0, N), 'k')\\n A = tvm.placeholder((N, N), name='A')\\n B = tvm.placeholder((N, N), name='B')\\n C = tvm.compute(A.shape, lambda y, x: tvm.sum(A[y, k] * B[k, x], axis=k),\\n name='C')\\n\\n s = tvm.create_schedule(C.op)\\n\\n y, x = s[C].op.axis\\n axes = list(s[C].tile(y, x, 8, 8)) + [k]\\n perm = np.random.permutation(5)\\n axes = [axes[x] for x in perm]\\n s[C].reorder(*axes)\\n\\n if \\\"gpu\\\" in target.keys:\\n pick = []\\n # filter out reduction axis\\n for i in range(len(perm)):\\n if perm[i] != 4:\\n pick.append(axes[i])\\n s[C].bind(pick[0], tvm.thread_axis(\\\"blockIdx.x\\\"))\\n s[C].bind(pick[1], tvm.thread_axis(\\\"vthread\\\"))\\n s[C].bind(pick[2], tvm.thread_axis(\\\"threadIdx.y\\\"))\\n\\n with target:\\n feas = feature.get_itervar_feature(s, [A, B, C])\\n feas = feature.flatten_itervar_feature(feas)\\n return feas\\n\\n targets = [\\n tvm.target.cuda(),\\n tvm.target.mali(),\\n tvm.target.arm_cpu(),\\n ]\\n\\n for target in targets:\\n dim = len(get_gemm_feature(target))\\n for i in range(n_sample):\\n assert dim == len(get_gemm_feature(target)), \\\"dimensions of feature do not match\\\" \\\\\\n \\\" for different configurations\\\"\",\n \"def feature(self):\\n Feature(run=default_frame, flags=TE)\\n Feature(run=load(\\\"window_functions.tests.rows_frame\\\", \\\"feature\\\"), flags=TE)\\n Feature(run=load(\\\"window_functions.tests.range_frame\\\", \\\"feature\\\"), flags=TE)\\n Feature(run=load(\\\"window_functions.tests.range_overflow\\\", \\\"feature\\\"), flags=TE)\\n Feature(run=load(\\\"window_functions.tests.range_datetime\\\", \\\"feature\\\"), flags=TE)\\n Feature(run=load(\\\"window_functions.tests.range_errors\\\", \\\"feature\\\"), flags=TE)\",\n \"def test_update_hyperflex_feature_limit_external(self):\\n pass\",\n \"def test_text_classifier_update_testing_samples(self):\\n pass\",\n \"def __init__(self, eta, mu, n_feature):\\r\\n self.eta = 0.09\\r\\n self.weight = [0.0] * n_feature\\r\\n self.temp = [0.0] * n_feature\\r\\n self.mu = 0.0\\r\\n self.size= n_feature\",\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def test_setup(self, test_data: list=None):\\n print(\\\"[dataset]: using test setup ...\\\")\\n self.vocabulary = [\\\"empty\\\"]\\n self.eval_dataset = ABSADataset(data_path=self.dev_path, mode=self.in_mode, task=self.task,\\n tokenizer=self.tokenizer, vocab=\\\"bert\\\", test=True)\\n return\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels): \\n \\n # might be useful in your code later...\\n # this is a list of all features in the training set.\\n self.features = list(set([ f for datum in trainingData for f in datum.keys() ]));\\n \\n if (self.automaticTuning):\\n kgrid = [0.001, 0.01, 0.05, 0.1, 0.5, 1, 5, 10, 20, 50]\\n else:\\n kgrid = [self.k]\\n \\n self.trainAndTune(trainingData, trainingLabels, validationData, validationLabels, kgrid)\",\n \"def supported_features(self):\\n return SUPPORT_LGSMARTTV\",\n \"def test_predictor():\",\n \"def __init__(self, traindat, trainlabs, k=5):\\r\\n self.features = traindat.columns\\r\\n self.traindat = traindat.values\\r\\n self.trainlabs = trainlabs.values\\r\\n self.k = k\",\n \"def train():\\n pass\",\n \"def test_all_features_with_data(self):\\n feature1 = Feature('looktest1')\\n feature1.set_percentage(5)\\n\\n feature2 = Feature('looktest2')\\n feature2.activate()\\n feature2.add_to_whitelist(3)\\n\\n feature3 = Feature('looktest3')\\n feature3.activate()\\n feature3.add_to_blacklist(4)\\n feature3.add_to_blacklist(5)\\n\\n feature4 = Feature('looktest4')\\n feature4.activate()\\n feature4.add_to_whitelist(3)\\n feature4.add_to_whitelist(5)\\n feature4.add_to_blacklist(4)\\n\\n all_features = Feature.all_features(include_data=True)\\n self.assertEqual(len(all_features), 4)\\n\\n for key in ['looktest1', 'looktest2', 'looktest3', 'looktest4']:\\n self.assertTrue(key in all_features)\\n if not key == 'looktest1':\\n self.assertEqual(all_features[key]['percentage'], 100)\\n\\n self.assertEqual(all_features['looktest1']['percentage'], 5)\\n self.assertFalse('whitelist' in all_features['looktest1'])\\n self.assertFalse('blacklist' in all_features['looktest1'])\\n\\n self.assertTrue('whitelist' in all_features['looktest2'])\\n self.assertEqual(all_features['looktest2']['whitelist'], [3])\\n self.assertFalse('blacklist' in all_features['looktest2'])\\n\\n self.assertFalse('whitelist' in all_features['looktest3'])\\n self.assertTrue('blacklist' in all_features['looktest3'])\\n self.assertEqual(all_features['looktest3']['blacklist'], [4, 5])\\n\\n self.assertTrue('whitelist' in all_features['looktest4'])\\n self.assertEqual(all_features['looktest4']['whitelist'], [3, 5])\\n self.assertTrue('blacklist' in all_features['looktest4'])\\n self.assertEqual(all_features['looktest4']['blacklist'], [4])\",\n \"def feature_eng2(housing_tr, housing):\\n logging.info(\\\"Adding features.....\\\")\\n housing_tr[\\\"rooms_per_household\\\"] = (\\n housing_tr[\\\"total_rooms\\\"] / housing_tr[\\\"households\\\"]\\n )\\n housing_tr[\\\"bedrooms_per_room\\\"] = (\\n housing_tr[\\\"total_bedrooms\\\"] / housing_tr[\\\"total_rooms\\\"]\\n )\\n housing_tr[\\\"population_per_household\\\"] = (\\n housing_tr[\\\"population\\\"] / housing_tr[\\\"households\\\"]\\n )\\n housing_cat = housing[[\\\"ocean_proximity\\\"]]\\n housing_prepared = housing_tr.join(\\n pd.get_dummies(housing_cat, drop_first=True)\\n )\\n return housing_prepared\",\n \"def test_create_hyperflex_feature_limit_external(self):\\n pass\",\n \"def __call__(self, sample):\\n if self.mode == VectorizeMode.TRAIN or self.mode == VectorizeMode.EVAL:\\n assert type(sample) == TrainInput, 'In train/eval mode, vectorizer input must be of type TrainInput'\\n\\n if self.mode == VectorizeMode.GENERATE:\\n assert type(\\n sample) == GenerationInput, 'In generation mode, vectorizer input must be of type GenerationInput'\\n\\n context = dict()\\n context['COALICION'] = ' [COALICION] ' + sample.COALICION if sample.COALICION != \\\"\\\" else \\\"\\\"\\n context['PARTIDO'] = ' [PARTIDO] ' + sample.PARTIDO if sample.PARTIDO != \\\"\\\" else \\\"\\\"\\n context['SENTIMIENTO'] = ' [SENTIMIENTO] ' + sample.SENTIMIENTO if sample.SENTIMIENTO != \\\"\\\" else \\\"\\\"\\n context['ENTIDADES'] = ' [ENTIDADES] ' + sample.ENTIDADES if sample.ENTIDADES != \\\"\\\" else \\\"\\\"\\n context['HASHTAGS'] = ' [HASHTAGS] ' + sample.HASHTAGS if sample.HASHTAGS != \\\"\\\" else \\\"\\\"\\n context['FRASES'] = ' [FRASES] ' + sample.FRASES if sample.FRASES != \\\"\\\" else \\\"\\\"\\n context['PARTIDO'] = ' [PARTIDO] ' + sample.PARTIDO if sample.PARTIDO != \\\"\\\" else \\\"\\\"\\n context['TWEET'] = ' [TWEET] ' \\n\\n\\n # Encode the context\\n\\n for key, value in context.items():\\n context[key] = self.tokenizer.encode(value)\\n\\n # In generate mode, obviously, the true P2 doest not exist\\n TWEET = sample.TWEET if self.mode != VectorizeMode.GENERATE else \\\"\\\"\\n\\n # Compute the number of tokens we saved for TWEET in the input block\\n if self.mode == VectorizeMode.GENERATE:\\n nb_tokens_for_TWEET = 200 + 50\\n else:\\n nb_tokens_for_TWEET = len(self.tokenizer.encode(TWEET)) + 2 # +1 for [TWEET] and +1 for <|endoftext|>\\n\\n if self.mode == VectorizeMode.TRAIN:\\n input_ids, type_ids, labels = self.vectorize(context, TWEET, nb_tokens_for_TWEET)\\n return input_ids, type_ids, labels\\n\\n if self.mode == VectorizeMode.GENERATE:\\n input_ids, type_ids = self.vectorize(context, TWEET, nb_tokens_for_TWEET)\\n return input_ids, type_ids\\n\\n if self.mode == VectorizeMode.EVAL:\\n input_ids, type_ids = self.vectorize(context, TWEET, nb_tokens_for_TWEET)\\n return input_ids, sample, nb_tokens_for_TWEET\",\n \"def test_init_custom_parameters():\\n\\n tpot_obj = TPOTClassifier(population_size=500, generations=1000,\\n mutation_rate=0.05, crossover_rate=0.9,\\n scoring='accuracy', num_cv_folds=10,\\n verbosity=1, random_state=42,\\n disable_update_check=True)\\n\\n assert tpot_obj.population_size == 500\\n assert tpot_obj.generations == 1000\\n assert tpot_obj.mutation_rate == 0.05\\n assert tpot_obj.crossover_rate == 0.9\\n assert tpot_obj.scoring_function == 'accuracy'\\n assert tpot_obj.num_cv_folds == 10\\n assert tpot_obj.max_time_mins is None\\n assert tpot_obj.verbosity == 1\\n assert tpot_obj._optimized_pipeline is None\\n assert tpot_obj._fitted_pipeline is None\\n assert not (tpot_obj._pset is None)\\n assert not (tpot_obj._toolbox is None)\",\n \"def feature():\\n pass\",\n \"def train(self, features, labels):\\n self.train_features = features\\n self.train_labels = labels\\n #raise NotImplementedError\",\n \"def setup_to_finetune(model):\\n\\n for layer in model.layers[:NB_VGG_LAYERS_TO_FREEZE]:\\n layer.trainable = False\\n for layer in model.layers[NB_VGG_LAYERS_TO_FREEZE:]:\\n layer.trainable = True\\n\\n # opt = Adam(lr=0.0001)\\n model.compile(optimizer=SGD(lr=0.0001, momentum=0.9),\\n loss='categorical_crossentropy',\\n metrics=['categorical_accuracy', f1_score])\",\n \"def test_set_params():\\n\\n tpot_obj = TPOTClassifier()\\n assert tpot_obj.set_params() is tpot_obj\",\n \"def finalizeFeatures(self):\\n pass\",\n \"def test_features(iris):\\n assert iris.num_features == 4\\n assert iris.feature_names == [\\n \\\"sepal length (cm)\\\",\\n \\\"sepal width (cm)\\\",\\n \\\"petal length (cm)\\\",\\n \\\"petal width (cm)\\\",\\n ]\",\n \"def train(self)->None:\",\n \"def __init__(self, *args, **kwargs):\\n if len(args) > len(self.features):\\n raise PydmrsTypeError(\\\"{} takes {} arguments, but {} were given\\\".format(type(self).__name__,\\n len(self.features),\\n len(args)))\\n for i, value in enumerate(args):\\n setattr(self, self.features[i], value)\\n for feature, value in kwargs.items():\\n setattr(self, feature, value)\\n for feature in self.features:\\n if not hasattr(self, feature):\\n setattr(self, feature, None)\",\n \"def test_text_classifier_set_params(self):\\n pass\",\n \"def test_stage_0():\\n\\tra_1 = readImage(TRAIN_RAW_IMAGE_1)\\n\\tre_1 = readImage(TRAIN_RESULT_IMAGE_1)\\n\\n\\tra_2 = readImage(TRAIN_RAW_IMAGE_2)\\n\\tre_2 = readImage(TRAIN_RESULT_IMAGE_2)\\n\\n\\t# Uncomment below if more examples are required.\\n\\t# ra_3 = readImage(TRAIN_RAW_IMAGE_3)\\n\\t# re_3 = readImage(TRAIN_RESULT_IMAGE_3)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_1 += (\\n\\t# \\tlaplace_operator(TRAIN_RAW_IMAGE_1),\\\\\\n\\t# \\t# k_means(TRAIN_RAW_IMAGE_1)[0],\\\\\\n\\t# \\t)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_2 += (\\n\\t# \\tlaplace_operator(TRAIN_RAW_IMAGE_2),\\\\\\n\\t# \\t# k_means(TRAIN_RAW_IMAGE_2)[0],\\\\\\n\\t# \\t)\\n\\n\\t# The prediction model is obtained and trained.\\n\\tengine = get_model((ra_1, ra_2,), (re_1, re_2,), model_type=SVM, percentage=0.1)\\n\\n\\ttest_percentage = float(1) # how many tests\\n\\n\\tra_1 = readImage(TEST_RAW_IMAGE_1)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_1 += (\\n\\t# \\tlaplace_operator(TEST_RAW_IMAGE_1),\\\\\\n\\t# \\t# k_means(TEST_RAW_IMAGE_1)[0],\\\\\\n\\t# \\t)\\n\\n\\tre_1 = readImage(TEST_RESULT_IMAGE_1)\\n\\n\\t# ra_2 = readImage(TEST_RAW_IMAGE_2)\\n\\t# re_2 = readImage(TEST_RESULT_IMAGE_2)\\n\\n\\tinput_vec = []\\n\\t# The features are extracted.\\n\\tinput_vec += buildFeatureArray_2(ra_1[0], ra_1[1], ra_1[2],\\\\\\n\\t\\tRADIUS_ARRAY,\\\\\\n\\t\\tadditional_feats=([] if len(ra_1) == 3 else ra_1[3:]))\\n\\n\\tex_no = int(test_percentage * len(input_vec)) # actual number of the test sample\\n\\n\\toutput_vec = []\\n\\toutput_vec += matrixToArray(re_1[0], lambda el: 1 if el == 255 else 0)\\n\\n\\tprint('Will start predicting...')\\n\\n\\tpredicted_vec = engine.predict(input_vec[:ex_no])\\n\\n\\tcounter = float(0)\\n\\tfor y, p in zip(output_vec[:ex_no], predicted_vec[:ex_no]):\\n\\t\\tif y == p: counter += 1\\n\\n\\tprint('Accuracy: ' + str(counter/ex_no))\\n\\n\\tpredicted_mat = arrayToMatrix( predicted_vec, len(re_1[0]), len(re_1[0][0]),\\\\\\n\\t\\tlambda el: 255 if el == 1 else 0)\\n\\n\\t# The predicted segmentation is saved.\\n\\tsave_rgb_img(\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t 'pred.bmp',\\\\\\n\\t)\",\n \"def test_synth_tr():\\n test_path = tempfile.mkdtemp()\\n x_train, metadata = synth_tr(test_path)\\n try:\\n assert x_train.shape == (250, 3)\\n except:\\n shutil.rmtree(test_path)\\n raise()\",\n \"def _update_feature_vec(fvec, word, tag_ngram):\",\n \"def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \\n rep_to_plot = 0\\n ttbrs = [0.5, 1,1.5]\\n idx = syn_idx[str(rep_to_plot)]\\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\\n x_3d = syn_fm(\\\"3d\\\")[str(rep_to_plot)][:]\\n x_2d = syn_fm(\\\"2d\\\")[str(rep_to_plot)][:]\\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\\n\\n for i, ttbr in enumerate(ttbrs):\\n print('Using tbrr={}'.format(ttbr))\\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\\n labels_cat = {}\\n for key, l in labels.items():\\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\\n \\n best_params_montaez['n_snps']= x_3d.shape[1]\\n \\n l_0b=labels_cat[str(rep_to_plot)]\\n\\n model = create_montaez_dense_model(best_params_montaez)\\n y_integers = np.argmax(l_0b[idx.train], axis=1)\\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\\n d_class_weights = dict(enumerate(class_weights))\\n\\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\\n\\n model = iutils.keras.graph.model_wo_softmax(model)\\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\\n weights = analyzer.analyze(x_3d).sum(0)\\n\\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\\n\\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\\n \\n pvalues_filled_deep = np.ones(n_total_snps)\\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\\n\\n # Plot RPVT\\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\\n if i==0:\\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\\n\\n # Plot svm weights \\n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\\n pvalues_filled_combi = np.ones(len(complete_pvalues))\\n pvalues_filled_combi[idx_now] = pvalues\\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\\n if i==0:\\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot COMBI\\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\\n if i==0:\\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\\n if i==2:\\n axes[i][2].set_xlabel('SNP position', fontsize=18)\\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot LRP relevance scores\\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\\n #axes[i][1].legend()\\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\\n if i==0:\\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot DeepCOMBI\\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\\n if i==0:\\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n ## Plot distribution of postprocessed vectors\\n #axes[i][2].plot(postprocessed_weights)\\n #axes[i][2].set_title('Postprocessed relevance')\\n\\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')\",\n \"def train(self, features, labels, seed=None):\\n raise NotImplementedError('Not implemented')\",\n \"def run(args: Namespace, trial: optuna.trial._trial.Trial = None) -> Dict:\\n # 1. Set seed\\n utils.set_seed(seed=args.seed)\\n\\n # 2. Set device\\n device = utils.set_device(cuda=args.cuda)\\n\\n # 3. Load data\\n projects_fp = Path(config.DATA_DIR, \\\"projects.json\\\")\\n tags_fp = Path(config.DATA_DIR, \\\"tags.json\\\")\\n projects = utils.load_dict(filepath=projects_fp)\\n tags_dict = utils.list_to_dict(utils.load_dict(filepath=tags_fp), key=\\\"tag\\\")\\n df = pd.DataFrame(projects)\\n if args.shuffle:\\n df = df.sample(frac=1).reset_index(drop=True)\\n df = df[: args.num_samples] # None = all samples\\n\\n # 4. Clean data\\n df, tags_above_frequency = data.clean(\\n df=df,\\n include=list(tags_dict.keys()),\\n exclude=config.EXCLUDE,\\n min_tag_freq=args.min_tag_freq,\\n )\\n\\n # 5. Preprocess data\\n df.text = df.text.apply(data.preprocess, lower=args.lower, stem=args.stem)\\n\\n # 6. Encode labels\\n labels = df.tags\\n label_encoder = data.MultiLabelLabelEncoder()\\n label_encoder.fit(labels)\\n y = label_encoder.encode(labels)\\n\\n # Class weights\\n all_tags = list(itertools.chain.from_iterable(labels.values))\\n counts = np.bincount([label_encoder.class_to_index[class_] for class_ in all_tags])\\n class_weights = {i: 1.0 / count for i, count in enumerate(counts)}\\n\\n # 7. Split data\\n utils.set_seed(seed=args.seed) # needed for skmultilearn\\n X = df.text.to_numpy()\\n X_train, X_, y_train, y_ = data.iterative_train_test_split(X=X, y=y, train_size=args.train_size)\\n X_val, X_test, y_val, y_test = data.iterative_train_test_split(X=X_, y=y_, train_size=0.5)\\n test_df = pd.DataFrame({\\\"text\\\": X_test, \\\"tags\\\": label_encoder.decode(y_test)})\\n\\n # 8. Tokenize inputs\\n tokenizer = data.Tokenizer(char_level=args.char_level)\\n tokenizer.fit_on_texts(texts=X_train)\\n X_train = np.array(tokenizer.texts_to_sequences(X_train), dtype=object)\\n X_val = np.array(tokenizer.texts_to_sequences(X_val), dtype=object)\\n X_test = np.array(tokenizer.texts_to_sequences(X_test), dtype=object)\\n\\n # 9. Create dataloaders\\n train_dataset = data.CNNTextDataset(X=X_train, y=y_train, max_filter_size=args.max_filter_size)\\n val_dataset = data.CNNTextDataset(X=X_val, y=y_val, max_filter_size=args.max_filter_size)\\n test_dataset = data.CNNTextDataset(X=X_test, y=y_test, max_filter_size=args.max_filter_size)\\n train_dataloader = train_dataset.create_dataloader(batch_size=args.batch_size)\\n val_dataloader = val_dataset.create_dataloader(batch_size=args.batch_size)\\n test_dataloader = test_dataset.create_dataloader(batch_size=args.batch_size)\\n\\n # 10. Initialize model\\n model = models.initialize_model(\\n args=args,\\n vocab_size=len(tokenizer),\\n num_classes=len(label_encoder),\\n device=device,\\n )\\n\\n # 11. Train model\\n logger.info(f\\\"Arguments: {json.dumps(args.__dict__, indent=2, cls=NumpyEncoder)}\\\")\\n args, model, loss = train.train(\\n args=args,\\n train_dataloader=train_dataloader,\\n val_dataloader=val_dataloader,\\n model=model,\\n device=device,\\n class_weights=class_weights,\\n trial=trial,\\n )\\n\\n # 12. Evaluate model\\n artifacts = {\\n \\\"args\\\": args,\\n \\\"label_encoder\\\": label_encoder,\\n \\\"tokenizer\\\": tokenizer,\\n \\\"model\\\": model,\\n \\\"loss\\\": loss,\\n }\\n device = torch.device(\\\"cpu\\\")\\n performance = eval.evaluate(\\n artifacts=artifacts,\\n dataloader=test_dataloader,\\n df=test_df,\\n device=device,\\n )\\n artifacts[\\\"performance\\\"] = performance\\n\\n return artifacts\",\n \"def create_tuning_functions(self):\\r\\n\\t\\tmotion_tuning = np.zeros((par['num_motion_tuned'], par['num_receptive_fields'], par['num_motion_dirs']), dtype=np.float32)\\r\\n\\t\\tfix_tuning = np.zeros((par['num_fix_tuned'], par['num_receptive_fields']), dtype=np.float32)\\r\\n\\t\\trule_tuning = np.zeros((par['num_rule_tuned'], par['num_rules']), dtype=np.float32)\\r\\n\\r\\n\\t\\t# generate list of prefered directions\\r\\n\\t\\t# dividing neurons by 2 since two equal groups representing two modalities\\r\\n\\t\\tpref_dirs = np.arange(0,360,360/(par['num_motion_tuned']//par['num_receptive_fields'])).astype(np.float32)\\r\\n\\r\\n\\t\\t# generate list of possible stimulus directions\\r\\n\\t\\tstim_dirs = np.arange(0,360,360/par['num_motion_dirs']).astype(np.float32)\\r\\n\\r\\n\\t\\tfor n in range(par['num_motion_tuned']//par['num_receptive_fields']):\\r\\n\\t\\t\\tfor i in range(len(stim_dirs)):\\r\\n\\t\\t\\t\\tfor r in range(par['num_receptive_fields']):\\r\\n\\t\\t\\t\\t\\td = np.cos((stim_dirs[i] - pref_dirs[n])/180*np.pi)\\r\\n\\t\\t\\t\\t\\tn_ind = n+r*par['num_motion_tuned']//par['num_receptive_fields']\\r\\n\\t\\t\\t\\t\\tmotion_tuning[n_ind,r,i] = par['tuning_height']*np.exp(par['kappa']*d)/np.exp(par['kappa'])\\r\\n\\r\\n\\t\\tfor n in range(par['num_fix_tuned']):\\r\\n\\t\\t\\tfor i in range(par['num_receptive_fields']):\\r\\n\\t\\t\\t\\tif n%par['num_receptive_fields'] == i:\\r\\n\\t\\t\\t\\t\\tfix_tuning[n,i] = par['tuning_height']\\r\\n\\r\\n\\t\\tneurons_per_rule = par['num_rule_tuned']//par['num_rules']\\r\\n\\t\\tfor n in range(par['num_rule_tuned']):\\r\\n\\t\\t\\tfor i in range(par['num_rules']):\\r\\n\\t\\t\\t\\tif n in range(i*neurons_per_rule, (i+1)*neurons_per_rule):\\r\\n\\t\\t\\t\\t\\trule_tuning[n,i] = par['tuning_height']\\r\\n\\r\\n\\r\\n\\t\\treturn motion_tuning, fix_tuning, rule_tuning\",\n \"def trainTMVAMethods(self):\\n # Open the file\\n DataFile = ROOT.TFile(self.FileName)\\n \\n if DataFile.IsZombie() == True:\\n print(\\\"Error opening data file {}. Is it a ROOT file?\\\".format(self.FileName))\\n return False\\n \\n if DataFile.IsOpen() == False:\\n print(\\\"Error opening data file\\\")\\n return False\\n\\n # Get the data tree\\n DataTree = DataFile.Get(\\\"Quality\\\")\\n if DataTree == 0:\\n print(\\\"Error reading data tree from root file\\\")\\n return False\\n\\n\\n # Limit the number of events:\\n if DataTree.GetEntries() > self.MaxEvents:\\n print(\\\"Reducing source tree size from \\\" + str(DataTree.GetEntries()) + \\\" to \\\" + str(self.MaxEvents) + \\\" (i.e. the maximum set)\\\")\\n NewTree = DataTree.CloneTree(0);\\n NewTree.SetDirectory(0);\\n\\n for i in range(0, self.MaxEvents):\\n DataTree.GetEntry(i)\\n NewTree.Fill()\\n\\n DataTree = NewTree;\\n\\n\\n # Initialize TMVA\\n ROOT.TMVA.Tools.Instance()\\n\\n FullPrefix = self.OutputPrefix\\n ResultsFile = ROOT.TFile(FullPrefix + \\\".root\\\", \\\"RECREATE\\\")\\n\\n Factory = ROOT.TMVA.Factory(\\\"TMVAClassification\\\", ResultsFile, \\\"!V:!Silent:Color:DrawProgressBar:Transformations=I;D;P;G,D:AnalysisType=Classification\\\")\\n\\n DataLoader = ROOT.TMVA.DataLoader(self.OutputPrefix)\\n\\n IgnoredBranches = [ 'SimulationID', 'SequenceLength']\\n Branches = DataTree.GetListOfBranches()\\n\\n for Name in IgnoredBranches:\\n DataLoader.AddSpectator(Name, \\\"F\\\")\\n\\n for B in list(Branches):\\n if not B.GetName() in IgnoredBranches:\\n if not B.GetName().startswith(\\\"Evaluation\\\"):\\n DataLoader.AddVariable(B.GetName(), \\\"F\\\")\\n\\n SignalCut = ROOT.TCut(\\\"EvaluationIsCompletelyAbsorbed >= 0.5\\\")\\n BackgroundCut = ROOT.TCut(\\\"EvaluationIsCompletelyAbsorbed < 0.5\\\")\\n DataLoader.SetInputTrees(DataTree, SignalCut, BackgroundCut)\\n\\n DataLoader.PrepareTrainingAndTestTree(SignalCut, BackgroundCut, \\\"nTrain_Signal=0:nTrain_Background=0:SplitMode=Random:NormMode=NumEvents:!V\\\")\\n\\n MethodList = []\\n\\n # Neural Networks\\n if 'MLP' in self.Algorithms:\\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kMLP, \\\"MLP\\\", \\\"H:!V:NeuronType=tanh:VarTransform=N:NCycles=100:HiddenLayers=N+10,N-5:TestRate=5:TrainingMethod=BFGS:!UseRegulator\\\")\\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kMLP, \\\"MLP\\\", \\\"H:!V:NeuronType=tanh:VarTransform=N:NCycles=100:HiddenLayers=N+10,N-5:TestRate=5:!UseRegulator\\\")\\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kMLP, \\\"MLP\\\", \\\"H:!V:NeuronType=tanh:VarTransform=N:NCycles=100:HiddenLayers=N+10,N-5:TestRate=6:TrainingMethod=BFGS:Sampling=0.3:SamplingEpoch=0.8:ConvergenceImprove=1e-6:ConvergenceTests=15:!UseRegulator\\\")\\n MethodList.append(\\\"MLP\\\")\\n\\n\\n # PDEFoamBoost\\n if 'PDEFoamBoost' in self.Algorithms:\\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kPDEFoam, \\\"PDEFoamBoost\\\", \\\"!H:!V:Boost_Num=100:Boost_Transform=linear:SigBgSeparate=F:MaxDepth=4:UseYesNoCell=T:DTLogic=MisClassificationError:FillFoamWithOrigWeights=F:TailCut=0:nActiveCells=2000:nBin=50:Nmin=200:Kernel=None:Compress=T\\\")\\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kPDEFoam, \\\"PDEFoamBoost\\\", \\\"!H:!V:Boost_Num=30:Boost_Transform=linear:SigBgSeparate=F:MaxDepth=4:UseYesNoCell=T:DTLogic=MisClassificationError:FillFoamWithOrigWeights=F:TailCut=0:nActiveCells=500:nBin=20:Nmin=400:Kernel=None:Compress=T\\\")\\n MethodList.append(\\\"PDEFoamBoost\\\")\\n\\n\\n # PDERSPCA\\n if 'PDERSPCA' in self.Algorithms:\\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kPDERS, \\\"PDERSPCA\\\", \\\"!H:!V:VolumeRangeMode=Adaptive:KernelEstimator=Gauss:GaussSigma=0.3:NEventsMin=400:NEventsMax=600:VarTransform=PCA\\\")\\n MethodList.append(\\\"PDERSPCA\\\")\\n\\n\\n # Random Forest Boosted Decision Trees\\n if 'BDT' in self.Algorithms:\\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \\\"BDT\\\", \\\"!H:!V:NTrees=1000:MinNodeSize=1%:MaxDepth=3:BoostType=AdaBoost:AdaBoostBeta=0.4:SeparationType=CrossEntropy:nCuts=100:PruneMethod=NoPruning\\\")\\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \\\"BDT\\\", \\\"!H:!V:NTrees=850:nEventsMin=150:MaxDepth=3:BoostType=AdaBoost:AdaBoostBeta=0.5:SeparationType=GiniIndex:nCuts=20:PruneMethod=NoPruning\\\")\\n #method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \\\"BDT\\\", \\\"!H:!V:NTrees=1000:nEventsMin=1000:MaxDepth=4:BoostType=AdaBoost:AdaBoostBeta=0.5:SeparationType=GiniIndex:nCuts=20:PruneMethod=NoPruning\\\")\\n \\n options = \\\"!H:!V:NTrees={}:MinNodeSize={}%:MaxDepth={}:BoostType=AdaBoost:AdaBoostBeta={}:SeparationType=CrossEntropy:nCuts=100:PruneMethod=NoPruning\\\".format(self.BDT_NTrees, self.BDT_MinNodeSize, self.BDT_MaxDepth, self.BDT_AdaBoostBeta)\\n \\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kBDT, \\\"BDT\\\", ROOT.TString(options))\\n MethodList.append(\\\"BDT\\\")\\n\\n\\n # State Vector Machine\\n if 'SVM' in self.Algorithms:\\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kSVM, \\\"SVM\\\", \\\"Gamma=0.25:Tol=0.001:VarTransform=Norm\\\");\\n MethodList.append(\\\"SVM\\\")\\n\\n\\n # DNN\\n if 'DNN_CPU' in self.Algorithms:\\n Layout = \\\"Layout=TANH|N,TANH|N/2,LINEAR\\\"\\n\\n Training0 = \\\"LearningRate=1e-1,Momentum=0.9,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.5+0.5+0.5,Multithreading=True\\\"\\n Training1 = \\\"LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\\\"\\n Training2 = \\\"LearningRate=1e-3,Momentum=0.0,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\\\"\\n TrainingStrategy = \\\"TrainingStrategy=\\\" + Training0 + \\\"|\\\" + Training1 + \\\"|\\\" + Training2\\n\\n Options = \\\"!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:\\\" + Layout + \\\":\\\" + TrainingStrategy\\n\\n Options += \\\":Architecture=CPU\\\"\\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kDNN, \\\"DNN_CPU\\\", Options)\\n MethodList.append(\\\"DNN_CPU\\\")\\n\\n\\n # DNN\\n if 'DNN_GPU' in self.Algorithms:\\n Layout = \\\"Layout=TANH|N,TANH|N/2,LINEAR\\\"\\n\\n Training0 = \\\"LearningRate=1e-1,Momentum=0.9,Repetitions=1,ConvergenceSteps=100,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.5+0.5+0.5,Multithreading=True\\\"\\n Training1 = \\\"LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=100,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\\\"\\n Training2 = \\\"LearningRate=1e-3,Momentum=0.0,Repetitions=1,ConvergenceSteps=100,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0,Multithreading=True\\\"\\n TrainingStrategy = \\\"TrainingStrategy=\\\" + Training0 + \\\"|\\\" + Training1 + \\\"|\\\" + Training2\\n\\n Options = \\\"!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:\\\" + Layout + \\\":\\\" + TrainingStrategy\\n\\n Options += \\\":Architecture=GPU\\\"\\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kDNN, \\\"DNN_GPU\\\", Options)\\n MethodList.append(\\\"DNN_GPU\\\")\\n\\n\\n # DL\\n if 'DL_CPU' in self.Algorithms:\\n Setup = \\\"!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM\\\"\\n Layout = \\\"Layout=TANH|N,TANH|N/2,LINEAR\\\"\\n TrainingStrategy = \\\"TrainingStrategy=Optimizer=ADAM,LearningRate=0.001,TestRepetitions=1,MaxEpochs=100000,ConvergenceSteps=500,BatchSize=100,DropConfig=0.0\\\"\\n Architecture = \\\"Architecture=CPU\\\" \\n \\n Options = Setup + \\\":\\\" + Layout + \\\":\\\" + TrainingStrategy + \\\":\\\" + Architecture\\n\\n method = Factory.BookMethod(DataLoader, ROOT.TMVA.Types.kDL, \\\"DL_CPU\\\", Options)\\n MethodList.append(\\\"DL_CPU\\\")\\n\\n\\n # Finally test, train & evaluate all methods\\n print(\\\"Started training\\\")\\n Factory.TrainAllMethods()\\n Factory.TestAllMethods()\\n Factory.EvaluateAllMethods()\\n\\n print(\\\"\\\\nTake a look at the results in root with:\\\\nTMVA::TMVAGui(\\\\\\\"Results.root\\\\\\\");\\\\nEspecially plot 4a\\\")\\n\\n print(Factory.GetMethod(ROOT.TString(self.OutputPrefix), ROOT.TString(\\\"BDT\\\")).GetROCIntegral())\\n\\n self.ResultsTMVA.clear()\\n for method in MethodList:\\n print(\\\"{}: {}\\\".format(method, Factory.GetMethod(ROOT.TString(self.OutputPrefix), ROOT.TString(\\\"BDT\\\")).GetROCIntegral()))\\n self.ResultsTMVA[method] = Factory.GetMethod(ROOT.TString(self.OutputPrefix), ROOT.TString(\\\"BDT\\\")).GetROCIntegral()\\n \\n return True\",\n \"def trainAndTune(self, trainingData, trainingLabels, validationData, validationLabels, Cgrid):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n #if predicted label is not equal to actual label\\n num_errors = 0 \\n \\n #weights will be changed when checking if labels are equal to each other\\n \\n\\n \\n #traversing across the Cgrid to train each set across each value of c in Cgrid \\n for c in Cgrid:\\n updatedWeights = self.weights.copy()\\n for iteration in range(self.max_iterations):\\n \\n print(\\\"Starting iteration \\\", iteration, \\\"..\\\")\\n if iteration > 0:\\n num_errors = 0\\n\\n for i in range(len(trainingData)):\\n trainingUnit = trainingData[i].copy() #trainingUnit is one instance of training data at i\\n #predLabel = self.classify(trainingUnit) #classifies data in order list of predicted label values\\n #predictedLabel = predLabel[0] #extract predicted label where max is at first index\\n realLabel = trainingLabels[i] #extract real label from training label in order to compare\\n\\n\\n\\n predY = 0\\n predictedLabel = -1;\\n for label in self.legalLabels:\\n predLabel = trainingUnit * updatedWeights[label]\\n if predictedLabel < predLabel or predictedLabel == -1:\\n predictedLabel = predLabel\\n predY = label\\n\\n tau = 0 \\n \\n #if predicted label is not equal to real label\\n if predY != realLabel: \\n feature = trainingUnit.copy() #extract feature of current training unit\\n num_errors += 1 \\n #t = ((wpred - wactual)*feature + 1.0)/(2 * feature * feature) = num/div \\n num = updatedWeights[predY] - updatedWeights[realLabel]\\n num = num * feature\\n num += 1.0 \\n \\n\\n div = (feature*feature)\\n \\n div += 2.0\\n t = num/div\\n \\n tau = min(c,t)\\n \\n \\n \\n #for j in range(feature):\\n for j in range(len(trainingData[i])):\\n feature[j] = feature[j] * tau\\n updatedWeights[realLabel] = updatedWeights[realLabel] + feature #wactual = wactual + tau*feature\\n updatedWeights[predY] = updatedWeights[predY] - feature #wpred = wpred + tau*feature\\n \\n\\n print(\\\"finished updating weights\\\")\\n\\n #determine guesses by classifying validation data\\n guesses = self.classify(validationData)\\n correct = 0\\n bestAccuracy = None #no best accuracy rate yet\\n\\n #traverse over guesses, determine how many \\n #answers were correct \\n for i in range(len(guesses)):\\n if guesses[i] == validationLabels[i]: #guess matches validation label\\n correct += 1\\n\\n accuracy = correct / len(guesses) #determine percentage\\n if(accuracy > bestAccuracy):\\n bestAccuracy = accuracy\\n\\n self.weights = updatedWeights\",\n \"def test_text_classifier_add_training_samples(self):\\n pass\",\n \"def test_text_classifier_add_testing_samples(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6467389","0.6120855","0.5748472","0.5742488","0.5711489","0.56948525","0.56849676","0.5643649","0.5622461","0.5612863","0.5570076","0.5564452","0.5562412","0.5538345","0.5495508","0.5485487","0.54830647","0.5479651","0.5453535","0.54154104","0.5412377","0.53939295","0.5386679","0.5345854","0.53347707","0.532772","0.5326312","0.53261715","0.5326102","0.53220785","0.5320744","0.5308877","0.5294039","0.5291938","0.52858734","0.5282289","0.5277348","0.5268088","0.5261705","0.5260999","0.5257028","0.5255003","0.5241729","0.52403516","0.5238032","0.5213563","0.52033806","0.52028155","0.5202362","0.51963186","0.51877654","0.51856965","0.5179829","0.51765895","0.51762646","0.5173211","0.5168594","0.5128347","0.5128225","0.5128225","0.5128225","0.5128225","0.5128225","0.51250595","0.51234376","0.51226085","0.51218617","0.5119591","0.51175076","0.511718","0.5112965","0.510977","0.51077116","0.51007277","0.50919724","0.509071","0.50813186","0.50692344","0.5067561","0.5065577","0.50627035","0.5059913","0.5045554","0.5022484","0.5021665","0.5019106","0.50164294","0.5016025","0.5012325","0.5008911","0.5007205","0.5006356","0.50059515","0.5002676","0.5002236","0.50005144","0.49991444","0.49945095","0.4991239","0.49871483"],"string":"[\n \"0.6467389\",\n \"0.6120855\",\n \"0.5748472\",\n \"0.5742488\",\n \"0.5711489\",\n \"0.56948525\",\n \"0.56849676\",\n \"0.5643649\",\n \"0.5622461\",\n \"0.5612863\",\n \"0.5570076\",\n \"0.5564452\",\n \"0.5562412\",\n \"0.5538345\",\n \"0.5495508\",\n \"0.5485487\",\n \"0.54830647\",\n \"0.5479651\",\n \"0.5453535\",\n \"0.54154104\",\n \"0.5412377\",\n \"0.53939295\",\n \"0.5386679\",\n \"0.5345854\",\n \"0.53347707\",\n \"0.532772\",\n \"0.5326312\",\n \"0.53261715\",\n \"0.5326102\",\n \"0.53220785\",\n \"0.5320744\",\n \"0.5308877\",\n \"0.5294039\",\n \"0.5291938\",\n \"0.52858734\",\n \"0.5282289\",\n \"0.5277348\",\n \"0.5268088\",\n \"0.5261705\",\n \"0.5260999\",\n \"0.5257028\",\n \"0.5255003\",\n \"0.5241729\",\n \"0.52403516\",\n \"0.5238032\",\n \"0.5213563\",\n \"0.52033806\",\n \"0.52028155\",\n \"0.5202362\",\n \"0.51963186\",\n \"0.51877654\",\n \"0.51856965\",\n \"0.5179829\",\n \"0.51765895\",\n \"0.51762646\",\n \"0.5173211\",\n \"0.5168594\",\n \"0.5128347\",\n \"0.5128225\",\n \"0.5128225\",\n \"0.5128225\",\n \"0.5128225\",\n \"0.5128225\",\n \"0.51250595\",\n \"0.51234376\",\n \"0.51226085\",\n \"0.51218617\",\n \"0.5119591\",\n \"0.51175076\",\n \"0.511718\",\n \"0.5112965\",\n \"0.510977\",\n \"0.51077116\",\n \"0.51007277\",\n \"0.50919724\",\n \"0.509071\",\n \"0.50813186\",\n \"0.50692344\",\n \"0.5067561\",\n \"0.5065577\",\n \"0.50627035\",\n \"0.5059913\",\n \"0.5045554\",\n \"0.5022484\",\n \"0.5021665\",\n \"0.5019106\",\n \"0.50164294\",\n \"0.5016025\",\n \"0.5012325\",\n \"0.5008911\",\n \"0.5007205\",\n \"0.5006356\",\n \"0.50059515\",\n \"0.5002676\",\n \"0.5002236\",\n \"0.50005144\",\n \"0.49991444\",\n \"0.49945095\",\n \"0.4991239\",\n \"0.49871483\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75750804"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":13295,"cells":{"query":{"kind":"string","value":"Testing Tuna's getTunasFeatures method works"},"document":{"kind":"string","value":"def test_getTunaFeatures(self):\n tuna = Tuna(\"1\", \"2\", \"3\", \"4\")\n array = [\"1\", \"2\", \"3\", \"4\"]\n self.assertEqual(tuna.getTunaFeatures(), array)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_setTunaFeatures(self):\n tuna = Tuna()\n array = [\"1\", \"2\", \"3\", \"4\"]\n tuna.setTunaFeatures(array)\n self.assertEqual(tuna.getTunaFeatures(), array)","def findFeatures(self):\n\t\tpass","def test__extract_features(self):\n text_sample = \"I really really love this movie\"\n feature_sample = ['really','love','good']\n feature_score_type = \"presence\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':1,'love':1,'good':0})\n feature_score_type = \"term_frequency\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':2,'love':1,'good':0})","def test_svm():\n backend = BasicAer.get_backend('statevector_simulator')\n random_seed = r.randint(1, 10598)\n\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\n\n # iris\n pres = \"Test pour le data set Iris (facile, classique)\"\n test_from_func(pres, 15, 10, 3, True, Iris, quantum_instance)\n\n # breast cancer\n pres = \"Test pour le data set Breast Cancer (facile, classique)\"\n test_from_func(pres, 15, 10, 3, True, Breast_cancer, quantum_instance)\n\n # digits (it's long so be careful)\n #pres = \"Test pour le data set Digits (difficile, classique)\"\n #test_from_func(pres, 10, 10, 10, True, Digits, quantum_instance)\n\n # wine\n pres = \"Test pour le data set Wine (moyen, classique)\"\n test_from_func(pres, 15, 10, 5, True, Wine, quantum_instance)\n\n # gaussian\n pres = \"Test pour des données gaussiennes (moyen, classique)\"\n for _ in range(1):\n print(\"\\n\")\n print(\"New iteration\")\n test_from_func(pres, 25, 10, 2, True, Gaussian, quantum_instance)\n print(\"\\n\")\n\n # small adn strings\n pres = \"Test pour des séquences ADN courtes (difficile, classique)\"\n test_from_func(pres, 10, 15, 14, True, Sequence, quantum_instance)","def get_feature_set_SB(tweet):\n #pos-tag frequencies\n# print \"Tagged words in tweet: \", tweet.tagged_words\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# if tag=='PRtinf':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJS':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='ADJ':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='NP':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='DET':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n# elif tag=='P':\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n# print \"Tag frequencies: \", pos_tag_freq\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n# print \"Additional frequencies: \", additional_freq\n# raw_input(\"Continue?\")\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n# print \"All features: \", features\n# raw_input(\"Continue?\")\n return features","def test_all_features(self):\n to_create = ['looktest1', 'looktest2', 'looktest3']\n for f in to_create:\n Feature(f).activate()\n\n all_features = Feature.all_features()\n self.assertEqual(len(all_features), len(to_create))\n for f in to_create:\n self.assertTrue(f in all_features)","def feat():\n pass","def get_feature_set_SA(tweet):\n features= {}\n return features","def get_feature_set_PB(tweet):\n features= {\n 'text_length': np.log(len(tweet.text))\n } #ADD ADDITIONAL FEATURES\n if tweet.nrof_sademoticons>0:\n features['sademoticons'] = tweet.nrof_sademoticons\n if tweet.nrof_happyemoticons>0:\n features['happyemoticons'] = tweet.nrof_happyemoticons\n \n return features","def test_intent_classifier_get_training_samples(self):\n pass","def test_ann_features():\n CQT(file_struct, FeatureTypes.ann_beatsync, sr=11025).features","def getFeatures(self, state, action):\n util.raiseNotDefined()","def get_feature_set_PA(tweet):\n features= {}\n return features","def test_text_classifier_get_testing_samples(self):\n pass","def supported_features(self):\n return SUPPORT_LGSMARTTV","def nonlearning():\n\taT.featureAndTrain(['../../AudioData/chunked_data_sorted/pos', '../../AudioData/chunked_data_sorted/neg'], \n\t\t\t\t\t\t1.0, 1.0, aT.shortTermWindow, aT.shortTermStep, \n \"svm\", \"emotion_classifier\", True)","def test_intent_classifier_get_testing_samples(self):\n pass","def test_Tuna(self):\n tuna = Tuna(\"1\", \"2\", \"3\", \"4\")\n self.assertIsNotNone(tuna)","def get_features(self):\n return []","def test_get_vocabulary(self):\n\n for m in self.models:\n vocab = m.vocabulary\n self.assertTrue(isinstance(vocab, turicreate.SArray))\n self.assertEqual(len(vocab), 25)","def test_predictor():","def base_sample(self, tns_dir):\n lib = CDLL('./libsample.so') \n input_dir = tns_dir.encode()\n lib.getBaseFeatures.argtypes = [c_char_p]\n lib.getBaseFeatures.restype = c_float_p\n baseFeatures = lib.getBaseFeatures(input_dir)\n return baseFeatures","def other_features_(tweet, cleaned_tweet):\n #print(\"WARNING>>>>>>>>>>>>>>>>> VADERSENTIMENT DISABLED\")\n sentiment = nlp.sentiment_analyzer.polarity_scores(tweet)\n\n words = cleaned_tweet #Get text only\n\n syllables = textstat.syllable_count(words) #count syllables in words\n num_chars = sum(len(w) for w in words) #num chars in words\n num_chars_total = len(tweet)\n num_terms = len(tweet.split())\n num_words = len(words.split())\n avg_syl = round(float((syllables+0.001))/float(num_words+0.001),4)\n num_unique_terms = len(set(words.split()))\n ###Modified FK grade, where avg words per sentence is just num words/1\n FKRA = round(float(0.39 * float(num_words)/1.0) + float(11.8 * avg_syl) - 15.59,1)\n ##Modified FRE score, where sentence fixed to 1\n FRE = round(206.835 - 1.015*(float(num_words)/1.0) - (84.6*float(avg_syl)),2)\n\n\n twitter_objs = count_twitter_objs(tweet) #Count #, @, and http://\n features = [FKRA, FRE, syllables, num_chars, num_chars_total, num_terms, num_words,\n num_unique_terms, sentiment['compound'],\n twitter_objs[2], twitter_objs[1],]\n #features = pandas.DataFrame(features)\n return features","def test_all_features_with_data(self):\n feature1 = Feature('looktest1')\n feature1.set_percentage(5)\n\n feature2 = Feature('looktest2')\n feature2.activate()\n feature2.add_to_whitelist(3)\n\n feature3 = Feature('looktest3')\n feature3.activate()\n feature3.add_to_blacklist(4)\n feature3.add_to_blacklist(5)\n\n feature4 = Feature('looktest4')\n feature4.activate()\n feature4.add_to_whitelist(3)\n feature4.add_to_whitelist(5)\n feature4.add_to_blacklist(4)\n\n all_features = Feature.all_features(include_data=True)\n self.assertEqual(len(all_features), 4)\n\n for key in ['looktest1', 'looktest2', 'looktest3', 'looktest4']:\n self.assertTrue(key in all_features)\n if not key == 'looktest1':\n self.assertEqual(all_features[key]['percentage'], 100)\n\n self.assertEqual(all_features['looktest1']['percentage'], 5)\n self.assertFalse('whitelist' in all_features['looktest1'])\n self.assertFalse('blacklist' in all_features['looktest1'])\n\n self.assertTrue('whitelist' in all_features['looktest2'])\n self.assertEqual(all_features['looktest2']['whitelist'], [3])\n self.assertFalse('blacklist' in all_features['looktest2'])\n\n self.assertFalse('whitelist' in all_features['looktest3'])\n self.assertTrue('blacklist' in all_features['looktest3'])\n self.assertEqual(all_features['looktest3']['blacklist'], [4, 5])\n\n self.assertTrue('whitelist' in all_features['looktest4'])\n self.assertEqual(all_features['looktest4']['whitelist'], [3, 5])\n self.assertTrue('blacklist' in all_features['looktest4'])\n self.assertEqual(all_features['looktest4']['blacklist'], [4])","def test_text_classifier_get_training_samples(self):\n pass","def getFeatures(self, state, action):\n util.raiseNotDefined()","def getFeatures(self, state, action):\n util.raiseNotDefined()","def getFeatures(self, state, action):\n util.raiseNotDefined()","def feature():\n pass","def test_intent_classifier_tsne_get(self):\n pass","def prepare_features(self, wavs, stage):\n wavs, lens = wavs\n if stage == sb.Stage.TRAIN:\n if hasattr(self.modules, \"env_corrupt\"):\n wavs_noise = self.modules.env_corrupt(wavs, lens)\n wavs = torch.cat([wavs, wavs_noise], dim=0)\n lens = torch.cat([lens, lens])\n\n if hasattr(self.hparams, \"augmentation\"):\n wavs = self.hparams.augmentation(wavs, lens)\n\n # Choose what features we want to use\n # todo: support multiple features and feature concat\n target_feats = self.hparams.embedding_features\n\n FEATURE_EXTRACTOR = {\n # 'cqt': self.modules.cqt,\n # 'fbanks': self.modules.fbanks\n 'fastaudiogauss': self.modules.fastaudiogauss\n # 'ifr': self.modules.ifr\n # 'mag': self.modules.mag\n # 'mfcc': self.modules.mfcc\n # 'leaf': self.modules.leaf\n # 'tdfbanks': self.modules.tdfbanks\n # 'pcen': self.modules.pcen\n # 'sincnet': self.modules.sincnet\n # 'trainable_fbanks': self.modules.trainable_fbanks\n }\n\n if len(target_feats) == 1:\n # wavs = wavs.unsqueeze(1).cuda()\n feats = FEATURE_EXTRACTOR[target_feats[0]](wavs)\n # feats = torch.unsqueeze(feats, 1)\n # feats = torch.transpose(feats, 1,2)\n if target_feats[0]=='cqt':\n log_spec = 10.0 * torch.log10(torch.clamp(feats, min=1e-30))\n log_spec -= 10.0\n feats=log_spec\n feats = torch.transpose(feats, 1,2)\n else:\n feats = []\n for target in target_feats:\n temp = FEATURE_EXTRACTOR[target](wavs)\n if target=='cqt':\n temp = torch.transpose(temp, 1,2)\n feats.append(temp)\n f =feats[0]\n for i in range(1, len(feats)):\n f = torch.cat((f, feats[i]), dim=2)\n feats = f\n feats = self.modules.mean_var_norm(feats, lens)\n return feats, lens","def get_feature_set_PC(tweet, sentimentvalues):\n features= {\n 'text_length': np.log(len(tweet.text))\n } #ADD ADDITIONAL FEATURES\n if tweet.nrof_sademoticons>0:\n features['sademoticons'] = tweet.nrof_sademoticons\n if tweet.nrof_happyemoticons>0:\n features['happyemoticons'] = tweet.nrof_happyemoticons\n \n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n features[tag] = features.get(tag, 0) + 1\n if tag in ADJECTIVES:\n features['adjectives'] = features.get(tag, 0) + 1\n elif tag in ADVERBS: \n features['adverbs'] = features.get(tag, 0) + 1\n elif tag in PRONOUNS:\n features['pronoun'] = 1\n except KeyError:\n continue\n for key in features.keys():\n features[key] = features[key]*1.0\n \n #Add lexical features\n # total polarity score, number of positive words, number of negative words\n pos_score = 0\n neg_score = 0\n nrof_pos_words = 0\n nrof_neg_words = 0\n for word in sentimentvalues.keys():\n if sentimentvalues[word][0]>0:\n nrof_pos_words = nrof_pos_words + 1\n pos_score = pos_score + sentimentvalues[word][0]\n if sentimentvalues[word][1]>0:\n nrof_neg_words = nrof_neg_words + 1\n neg_score = neg_score + sentimentvalues[word][1]\n\n if neg_score>0:\n features['neg_score'] = neg_score+1.0\n if pos_score>0:\n features['pos_score'] = pos_score+1.0\n if nrof_pos_words>0:\n features['positive_words'] = nrof_pos_words*1.0\n if nrof_neg_words>0:\n features['negative_words'] = nrof_neg_words*1.0\n \n return features","def training(string):\n print(\"Training...\")\n vec = create_vector(string)\n print(\"Selecting features...\")\n feature_list = select_features(vec)\n print(\"Done!\")\n return feature_list","def _initialize_with_tune_context(self, context: \"TuneContext\") -> None:\n raise NotImplementedError","def test_features_property():\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\n atom.run(\"LR\")\n assert [i == j for i, j in zip(atom.lr.features, atom.features)]","def test():\n listpost,listclass = bayes.loaddataset()\n myvocablist = bayes.createlist(listpost)\n tmatrix = list()\n for doc in listpost:\n\t vec = bayes.word2vec(myvocablist,doc)\n\t tmatrix.append(vec)\n p0,p1,pa = bayes.train(tmatrix,listclass)\n testdoc1 = ['love','my','dalmation']\n testvec1 = bayes.word2vec(myvocablist,testdoc1)\n print testdoc1,'classify as :',bayes.classify(testvec1,p0,p1,pa)\n testdoc2 = ['stupid','love']\n testvec2 = bayes.word2vec(myvocablist,testdoc2)\n print testdoc2,'classify as :',bayes.classify(testvec2,p0,p1,pa)","def sent_features(tweet):\n twitter_objs = count_twitter_objs(tweet)\n tweet=clean_tweet(tweet) \n sentiment = sentiment_analyzer.polarity_scores(tweet)\n #Get text only\n words = preprocess(tweet) \n syllables = textstat.syllable_count(words)\n num_chars = sum(len(w) for w in words)\n num_chars_total = len(tweet)\n num_terms = len(tweet.split())\n num_words = len(words.split())\n avg_syl = round(float((syllables+0.001))/float(num_words+0.001),4)\n num_unique_terms = len(set(words.split()))\n \n ###Modified FK grade, where avg words per sentence is just num words/1\n FKRA = round(float(0.39 * float(num_words)/1.0) + float(11.8 * avg_syl) - 15.59,1)\n ##Modified FRE score, where sentence fixed to 1\n FRE = round(206.835 - 1.015*(float(num_words)/1.0) - (84.6*float(avg_syl)),2)\n \n \\\n retweet = 0\n if \"rt\" in words:\n retweet = 1\n features = [FKRA, FRE,syllables, avg_syl, num_chars, num_chars_total, num_terms, num_words,\n num_unique_terms, sentiment['neg'], sentiment['pos'], sentiment['neu'], sentiment['compound'],\n twitter_objs[2], twitter_objs[1],\n twitter_objs[0], retweet]\n return features","def parse_features(self, skip=...):\n ...","def parse_features(self, skip=...):\n ...","def list_feature_tests(self):\n\t\treturn self.test_names","def get_all_features(self) :\n raise NotImplementedError","def make_returnn_audio_features_func():\n return _extract","def test_machine_learning():","def test_training(self):\n\t\tpass","def get_song_features(tid):\n\n # dictionary of features to return\n spotify_track_data = SpotifyData[tid]\n\n features = {}\n features['name'] = spotify_track_data.name\n features['artists'] = spotify_track_data.artists\n features['popularity'] = spotify_track_data.popularity\n features['album'] = spotify_track_data.album_name\n features['danceability'] = spotify_track_data.danceability\n features['energy'] = spotify_track_data.energy\n features['key'] = spotify_track_data.key\n features['loudness'] = spotify_track_data.loudness\n features['mode'] = spotify_track_data.mode\n features['speechiness'] = spotify_track_data.speechiness\n features['acousticness'] = spotify_track_data.acousticness\n features['instrumentalness'] = spotify_track_data.instrumentalness\n features['liveness'] = spotify_track_data.liveness\n features['valence'] = spotify_track_data.valence\n features['tempo'] = spotify_track_data.tempo\n features['duration_ms'] = spotify_track_data.duration_ms\n features['time_signature'] = spotify_track_data.time_signature\n\n return features","def run():\n # all data and labels\n # tracemalloc.start()\n # start = time.time()\n data, labels = Startdata.getdata() # texts\n data2, labels2 = Startdata.getdata2() # emails\n # Startdata.bagofwords(data2, labels2)\n data, labels = Startdata.combinedata(data, data2, labels, labels2)\n # split into training and testing. 1/3 test, 2/3 train\n traind, trainl, testd, testl = Startdata.splitdata(data, labels)\n\n # labels\n trainlabels = Startdata.labelfix(trainl)\n testlabels = Startdata.labelfix(testl)\n\n # selective features\n #\n # extract features for use. in the shape of NxD\n # N is number of samples, D is number of features\n # current, peak = tracemalloc.get_traced_memory()\n trainfeat = Startdata.featurextract(traind, trainl)\n testfeat = Startdata.featurextract(testd, testl)\n # theta is the weights in a D+1 X 1 array\n theta = Spamfilter.train(trainfeat, trainlabels)\n #\n # trying bag of words\n #\n\n # Startdata.featurextract(data, labels)\n # error rate was 1.69% for trainingdata\n # 2.21% for testing data\n # bag, tfeat = Startdata.bagofwords(traind)\n # theta = Spamfilter.train(tfeat, trainlabels)\n # testfeat = Startdata.features(testd, bag)\n\n test(theta, testfeat, testlabels)\n # tracemalloc.stop()\n # done = time.time()\n # print(f\"Current memory usage is {current / 10**6} MB; Peak was {peak / 10**6} MB\")\n # print(\"time to complete\", done - start)\n # NTR 12/1/2020 current best featextraction at 25 iterations is about\n # 0.7-1% error for\n # trainingdata and testing data\n # NTR 12/2/2020 bag of words at 25 iterations\n # 1.69% training error, 2.21% testing error\n # NTR 12/2/2020 bag of words, 25 iter, removal of some features\n # NTR 12/3/2020 featextraction 20 iterations, new features, emails inc\n # 0.59% error on training. 0.63% testing error","def get_oth_features(tweets, cleaned_tweets,out_folder):\n feats=[]\n count=0\n # skipgram = get_skipgram(cleaned_tweets, out_folder, 2,2)\n # for line in skipgram:\n # print(line)\n # hashtags = get_hashtags_in_tweets(tweets, out_folder)\n # mispellings = get_misspellings(tweets, cleaned_tweets, out_folder)\n # specialpunc = get_specialpunct(tweets, cleaned_tweets,out_folder)\n # specialchars = get_specialchars(tweets, cleaned_tweets,out_folder)\n # capitalization = get_capitalization(tweets,cleaned_tweets,out_folder)\n for t, tc in zip(tweets, cleaned_tweets):\n feats.append(other_features_(t, tc))\n count+=1\n # if count%100==0:\n # print(\"\\t {}\".format(count))\n other_features_names = [\"FKRA\", \"FRE\",\"num_syllables\", \"num_chars\", \"num_chars_total\",\n \"num_terms\", \"num_words\", \"num_unique_words\", \"vader compound\",\n \"num_hashtags\", \"num_mentions\"]\n feature_matrix=np.array(feats)\n pickle.dump(other_features_names,\n open(out_folder+\"/\"+TWEET_TD_OTHER_FEATURES_VOCAB+\".pk\", \"wb\" ))\n\n return feature_matrix, other_features_names","def extract_features(self):\n self.extract_features_static()\n self.extract_features_dynamic()","def test_intent_classifier_add_training_samples(self):\n pass","def features(self, state, action, next_state):\n raise NotImplementedError","def get_chase_stats_features(tweets, cleaned_tweets,out_folder):\n feats=[]\n count=0\n #hashtags = get_hashtags_in_tweets(tweets, out_folder)\n #mispellings = get_misspellings(tweets, cleaned_tweets, out_folder)\n specialpunc = get_specialpunct(tweets, cleaned_tweets,out_folder)\n specialchars = get_specialchars(tweets, cleaned_tweets,out_folder)\n capitalization = get_capitalization(tweets,cleaned_tweets,out_folder)\n for t, tc in zip(tweets, cleaned_tweets):\n feats.append(other_features_(t, tc))\n count+=1\n # if count%100==0:\n # print(\"\\t {}\".format(count))\n feat_names = [\"SPECIALPUNC\",\"SPECIALCHAR\", \"CAPT\"]\n pickle.dump(feat_names,\n open(out_folder+\"/\"+TWEET_TD_OTHER_FEATURES_VOCAB+\".pk\", \"wb\" ))\n feature_matrix=np.column_stack((specialpunc, specialchars,\n capitalization))\n\n\n return feature_matrix, feat_names","def test_regressors_hypertune(setup):\n # Load the data\n train_features, test_features, train_target, test_target = setup\n # Call the function that we would like to test\n tuned, tune_time = regressors.hyperTune(RandomForestRegressor(), train_features, train_target,\n grid=grid.rf_paramgrid(), folds=2, iters=1, jobs=1)\n # Assert if tuned is a dictionary\n assert type(tuned) == dict\n # Assert if tune_time is a float\n assert type(tune_time) == float","def test_get_voice_datasets(self):\n pass","def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\r\n input_string_x1=input_string_x1.decode(\"utf-8\")\r\n input_string_x2 = input_string_x2.decode(\"utf-8\")\r\n #1. get blue score vector\r\n feature_list=[]\r\n #get blue score with n-gram\r\n for i in range(n_gram):\r\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\r\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\r\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\r\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\r\n feature_list.append(blue_score_i_1)\r\n feature_list.append(blue_score_i_2)\r\n\r\n #2. get length of questions, difference of length\r\n length1=float(len(input_string_x1))\r\n length2=float(len(input_string_x2))\r\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\r\n feature_list.append(length_diff)\r\n\r\n #3. how many words are same, how many words are unique\r\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\r\n feature_list.extend(sentence_diff_overlap_features_list)\r\n\r\n #4. question 1,2 start with how/why/when\r\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\r\n #print(\"how_why_feature_list:\",how_why_feature_list)\r\n #feature_list.extend(how_why_feature_list)\r\n\r\n #5.edit distance\r\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\r\n feature_list.append(edit_distance)\r\n\r\n #6.cos distance from sentence embedding\r\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\r\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\r\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\r\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\r\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\r\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\r\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\r\n feature_list.extend(distance_list_fasttext)\r\n feature_list.extend(distance_list_word2vec)\r\n #feature_list.extend(list(sentence_diffence))\r\n #feature_list.extend(list(sentence_multiply))\r\n return feature_list","def getFeatures(self, state, action, thisAgent):\n util.raiseNotDefined()","def test_intent_classifier_update_training_samples(self):\n pass","def _get_features(task, features, model, similarity_strategy=None):\n X = []\n langs = analysis_utils.get_langs_for_task(task)\n for feature in features:\n if feature != \"size\":\n # this is a nested array\n X_feature = analysis_utils.load_lang2vec_vectors(task=task, features=feature)\n if X_feature is None:\n #continue\n return None\n if similarity_strategy != \"-\":\n # We start with similarities to english\n X_feature = [[sim] for sim in analysis_utils.compute_similarities_of_lang_vecs(X_feature, strategy=similarity_strategy)]\n elif feature == \"size\" and model == \"xlmr\":\n # this is an array, we put it in a list\n X_feature = [[size] for size in analysis_utils.xlmr_input_corpus_sizes(langs)]\n elif feature == \"size\" and model == \"mbert\":\n X_feature = [[size] for size in analysis_utils.mbert_input_corpus_sizes(langs)]\n else:\n raise ValueError()\n # we now have a feature vector for a single feature or feature set\n if len(X) == 0:\n X = np.array(X_feature)\n else:\n X = np.concatenate((X,np.array(X_feature)), axis=1)\n if len(X) == 0:\n return None\n return np.array(X, dtype=float)","def test_features(iris):\n assert iris.num_features == 4\n assert iris.feature_names == [\n \"sepal length (cm)\",\n \"sepal width (cm)\",\n \"petal length (cm)\",\n \"petal width (cm)\",\n ]","def __init__(self, features=None):\n self.features = features","def getFeatures2(url, label):\r\n result = []\r\n url = str(url)\r\n \r\n #add the url to feature set\r\n result.append(url)\r\n \r\n #parse the URL and extract the domain information\r\n path = urlparse(url)\r\n ext = tldextract.extract(url)\r\n \r\n #counting number of dots in subdomain \r\n result.append(countdots(ext.subdomain))\r\n \r\n #checking hyphen in domain \r\n result.append(CountSoftHyphen(path.netloc))\r\n \r\n #length of URL \r\n result.append(length(url))\r\n \r\n #checking @ in the url \r\n result.append(CountAt(path.netloc))\r\n \r\n #checking presence of double slash \r\n result.append(CountDSlash(path.path))\r\n \r\n #Count number of subdir \r\n result.append(countSubDir(path.path))\r\n \r\n #number of sub domain \r\n result.append(countSubDomain(ext.subdomain))\r\n \r\n #length of domain name \r\n path2 = urlparse(url_format(url))\r\n result.append(len(path2.netloc)) \r\n \r\n #count number of queries \r\n result.append(len(path.query))\r\n \r\n #Adding domain information\r\n \r\n #if IP address is being used as a URL \r\n result.append(containsip(ext.domain))\r\n \r\n #presence of Suspicious_TLD\r\n result.append(1 if ext.suffix in Suspicious_TLD else 0)\r\n \r\n #append default for create_age(months)country\r\n result.append(-1)\r\n \r\n #append default for expiry_age(months)\r\n result.append(-1)\r\n \r\n #append default for update_age(days)\r\n result.append(-1)\r\n \r\n #append default for country\r\n result.append('None')\r\n \r\n #append extension\r\n path = urlparse(url)\r\n \r\n if get_ext(path.path) == '':\r\n result.append('None')\r\n else:\r\n result.append(get_ext(path.path))\r\n \r\n #append label\r\n result.append(str(label))\r\n \r\n return result","def test_category_and_its_feature(self):\n class RunnerBlah(Runner):\n def __init__(self, renv):\n super(RunnerBlah, self).__init__(renv)\n self.register_feature_class('bravo', Feature)\n self.register_feature_class('charlie', Feature)\n self.register_feature_category_class(\n 'alpha', features=['bravo', 'charlie'], mono=True)\n\n renv = create_runtime(RunnerBlah)\n renv.create_runner('runner')\n\n ctrl = renv.feature_ctrl\n\n total_order, _ = ctrl.get_activation_order(['alpha', 'bravo'])\n self.assertEqual(['bravo'], total_order)","def getTrainAndTestFeatures(feature_select, trainingFile):\n cleaner = TweetCleaner()\n\n #reading pre-labeled input and splitting into lines\n posSentences = []\n negSentences = []\n\n with open(trainingFile, 'r') as f:\n for line in f.readlines():\n if line.startswith('1'):\n posSentences.append(cleaner.clean(line[2:]))\n elif line.startswith('0'):\n negSentences.append(cleaner.clean(line[2:]))\n\n posFeatures = get_features(posSentences, 'pos', feature_select)\n negFeatures = get_features(negSentences, 'neg', feature_select)\n\n #selects 3/4 of the features to be used for training and 1/4 to be used for testing\n posCutoff = int(math.floor(len(posFeatures)*3/4))\n negCutoff = int(math.floor(len(negFeatures)*3/4))\n trainFeatures = posFeatures[:posCutoff] + negFeatures[:negCutoff]\n testFeatures = posFeatures[posCutoff:] + negFeatures[negCutoff:]\n return trainFeatures, testFeatures","def test_intent_classifier_vaporise(self):\n pass","def test_svm_quantique():\n backend = BasicAer.get_backend('statevector_simulator')\n random_seed = 10598\n\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\n pres = \"Test pour des données générées par ordinateur quantique (facile, quantique)\"\n print(pres)\n _, samp_train, samp_test, labels = ad_hoc_data(15, 10, 2, 0.3, True)\n sample_m, sample_p = stock_get(20, 0.3)\n\n labels_me = [-1, 1]\n samp_train_me = {-1: np.array(sample_m[:15]), 1: np.array(sample_p[:15])}\n samp_test_me = {-1: np.array(sample_m[15:]), 1: np.array(sample_p[15:])}\n print(samp_train)\n print(samp_train_me)\n print(samp_test)\n print(samp_test_me)\n classical_kernel_estimation(samp_train, samp_test, labels)\n classical_kernel_estimation(samp_train_me, samp_test_me, labels_me)\n\n # Generate the feature map\n feature_map = FirstOrderExpansion(feature_dimension=2, depth=2)\n\n # Run the Quantum Kernel Estimator and classify the test data\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\n test_dataset=samp_test)\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\n test_dataset=samp_test_me)\n\n result = qsvm.run(quantum_instance)\n result_me = qsvm_me.run(quantum_instance)\n print(\"Success of the FirstOrder feature map kernel:\")\n print(result['testing_accuracy'])\n print(result_me['testing_accuracy'])\n\n # Generate the feature map\n feature_map = SecondOrderExpansion(feature_dimension=2, depth=2)\n\n # Run the Quantum Kernel Estimator and classify the test data\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\n test_dataset=samp_test)\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\n test_dataset=samp_test_me)\n\n result = qsvm.run(quantum_instance)\n result_me = qsvm_me.run(quantum_instance)\n print(\"Success of the SecondOrder feature map kernel:\")\n print(result['testing_accuracy'])\n print(result_me['testing_accuracy'])\n\n # Last implementation using the custom circuit generator\n print(\"Success for my implementation (second order):\")\n my_impl(samp_train, samp_test, labels)\n my_impl(samp_train_me, samp_test_me, labels_me)\n\n feature_map = CustomExpansion(num_qubits=2, constructor_function=custom_constr, feature_param=[1])\n\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\n test_dataset=samp_test)\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\n test_dataset=samp_test_me)\n\n result = qsvm.run(quantum_instance)\n result_me = qsvm_me.run(quantum_instance)\n print(\"Success of the Custom feature map kernel:\")\n print(result['testing_accuracy'])\n print(result_me['testing_accuracy'])","def get_feature_set_SC2(tweet, sentimentvalues):\n pos_tag_freq = {}\n additional_freq = {}\n for phrase in tweet.tagged_words:\n for word in phrase:\n try:\n tag = word['pos']\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\n if tag in ADJECTIVES:\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\n elif tag in ADVERBS: \n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\n elif tag in PRONOUNS:\n additional_freq['pronoun'] = 1\n except KeyError:\n continue\n for key in pos_tag_freq.keys():\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \n #Number of exclamation marks, number of emoticons,\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\n if emoticons>0:\n additional_freq['emoticons'] = emoticons*1.0\n if tweet.nrof_exclamations>0:\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\n \n #Add lexicon values\n #total subjectivity score from word polarities, total objectivity score, number of subjective words, number of objective words, e\n sub_score = sentimentvalues[0]+sentimentvalues[1]\n obj_score = sentimentvalues[2]\n if sub_score>0:\n additional_freq[\"sub_score\"] = sub_score+1.0\n if obj_score>0:\n additional_freq[\"obj_score\"] = obj_score+1.0\n \n #Concatenate the dicts\n features= dict(pos_tag_freq.items() + additional_freq.items())\n \n return features","def songfeature_get(): # noqa: E501\n query = 'SELECT * FROM SongFeatures'\n results = query_to_dict(query)\n features_list = []\n for r in results:\n features_list.append(\n Songfeature(acousticness= r['Acousticness'],\n danceability= r['Danceability'],\n duration_ms= r['Duration_ms'],\n energy= r['Energy'],\n instrumentalness= r['Instrumentalness'],\n musicalkey= r['MusicalKey'],\n liveness= r['Liveness'],\n loudness= r['Loudness'],\n mode= r['Mode'],\n speechiness= r['Speechiness'],\n tempo= r['Tempo'],\n timesignature= r['Time_signature'],\n valence= r['Valence'],\n songid= r['SongID']))\n return features_list","def test_intent_classifier_add_testing_samples(self):\n pass","def test_active_inference_SPM_1b(self):","def main():\n \n # The following 5 command lines can be outcommented if the features are already created.\n # There is no need to process the data every single time.\n # Fine tuning the learning algorythm is much faster without that extra step.\n \n # by reading the train dataset the feature index is created.\n # First calling of the processdata function\n # Data limited to 300000\n featureIndexes = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000)\n print \"featureIndex generated!\"\n print len(featureIndexes)\n\n # Trainfeature is created using the indexfeatures...\n # Second calling of the processdata function\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\"avito_train.tsv\"), itemsLimit=600000) # Original itemsLimit=300000\n\n # Building the test dataset... just like the training...\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\"avito_test.tsv\"), featureIndexes)\n\n # Dumping data into file...\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\"train_data.pkl\"))\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\"SeparatedByCategory.pkl\"))\n\n\n # loading data pack...\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\"train_data.pkl\"))\n\n #logging.info(\"Feature preparation done, fitting model...\")\n\n # Stochastic gradient model","def extractFeatures(self, data, tf=False):\n tfidf_training_matrix, tfidf_terms = self.useTfidfVectorizer(data)\n \n if tf:\n tf_vectorizer = CountVectorizer(max_df=0.5, min_df=2, max_features=10000,\n stop_words='english')\n \n tf_training_matrix = tf_vectorizer.fit_transform(data)\n tf_terms = tf_vectorizer.get_feature_names()\n \n return tfidf_training_matrix, tfidf_terms, tf_training_matrix, tf_terms\n \n else:\n return tfidf_training_matrix, tfidf_terms","def test_text_classifier_tsne_get(self):\n pass","def test_api_predictors_get(self):\n pass","def run_feature_extraction_tests():\n test_feature_extraction()\n test_distributed_feature_extraction()\n test_multimodel_feature_extraction()\n test_distributed_multimodel_feature_extraction()","def get_ngram_features(train_data, test_data):\n print(\"getting ngram features\")\n ngram_vectorizer = CountVectorizer(ngram_range = (1, 2))\n ngram_vectorizer = ngram_vectorizer.fit(train_data)\n return ngram_vectorizer.transform(train_data), ngram_vectorizer.transform(test_data)","def test_text_classifier_add_testing_samples(self):\n pass","def test_get_hyperflex_feature_limit_internal_list(self):\n pass","def get_features_test(tweets):\n feats = get_feature_array(tweets)\n tfidf = vectorizer.transform(tweets).toarray()\n M = np.concatenate([tfidf,feats],axis=1)\n return M","def test_create_hyperflex_feature_limit_external(self):\n pass","def test_stage_0():\n\tra_1 = readImage(TRAIN_RAW_IMAGE_1)\n\tre_1 = readImage(TRAIN_RESULT_IMAGE_1)\n\n\tra_2 = readImage(TRAIN_RAW_IMAGE_2)\n\tre_2 = readImage(TRAIN_RESULT_IMAGE_2)\n\n\t# Uncomment below if more examples are required.\n\t# ra_3 = readImage(TRAIN_RAW_IMAGE_3)\n\t# re_3 = readImage(TRAIN_RESULT_IMAGE_3)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_1 += (\n\t# \tlaplace_operator(TRAIN_RAW_IMAGE_1),\\\n\t# \t# k_means(TRAIN_RAW_IMAGE_1)[0],\\\n\t# \t)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_2 += (\n\t# \tlaplace_operator(TRAIN_RAW_IMAGE_2),\\\n\t# \t# k_means(TRAIN_RAW_IMAGE_2)[0],\\\n\t# \t)\n\n\t# The prediction model is obtained and trained.\n\tengine = get_model((ra_1, ra_2,), (re_1, re_2,), model_type=SVM, percentage=0.1)\n\n\ttest_percentage = float(1) # how many tests\n\n\tra_1 = readImage(TEST_RAW_IMAGE_1)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_1 += (\n\t# \tlaplace_operator(TEST_RAW_IMAGE_1),\\\n\t# \t# k_means(TEST_RAW_IMAGE_1)[0],\\\n\t# \t)\n\n\tre_1 = readImage(TEST_RESULT_IMAGE_1)\n\n\t# ra_2 = readImage(TEST_RAW_IMAGE_2)\n\t# re_2 = readImage(TEST_RESULT_IMAGE_2)\n\n\tinput_vec = []\n\t# The features are extracted.\n\tinput_vec += buildFeatureArray_2(ra_1[0], ra_1[1], ra_1[2],\\\n\t\tRADIUS_ARRAY,\\\n\t\tadditional_feats=([] if len(ra_1) == 3 else ra_1[3:]))\n\n\tex_no = int(test_percentage * len(input_vec)) # actual number of the test sample\n\n\toutput_vec = []\n\toutput_vec += matrixToArray(re_1[0], lambda el: 1 if el == 255 else 0)\n\n\tprint('Will start predicting...')\n\n\tpredicted_vec = engine.predict(input_vec[:ex_no])\n\n\tcounter = float(0)\n\tfor y, p in zip(output_vec[:ex_no], predicted_vec[:ex_no]):\n\t\tif y == p: counter += 1\n\n\tprint('Accuracy: ' + str(counter/ex_no))\n\n\tpredicted_mat = arrayToMatrix( predicted_vec, len(re_1[0]), len(re_1[0][0]),\\\n\t\tlambda el: 255 if el == 1 else 0)\n\n\t# The predicted segmentation is saved.\n\tsave_rgb_img(\\\n\t np.array(predicted_mat).transpose(),\\\n\t np.array(predicted_mat).transpose(),\\\n\t np.array(predicted_mat).transpose(),\\\n\t 'pred.bmp',\\\n\t)","def setup_svm_classifier(training_data, y_training, testing_data, features, method=\"count\", ngrams=(1,1)):\n # generate x and y training data\n\n if method == \"count\":\n vec, x_training, x_testing = define_features_vectorizer(features, training_data, testing_data,ngramrange=ngrams)\n elif method == \"tfidf\":\n vec, x_training, x_testing = define_features_tfidf(features, training_data, testing_data,ngramrange=ngrams)\n else:\n print(\"Method has to be either count or tfidf\")\n return 1\n\n # train classifier\n\n model = SVMClassifier_scratch()\n model.fit(x_training, y_training)\n\n return model, vec, x_testing","def test_create_hyperflex_feature_limit_internal(self):\n pass","def track_features(tracks, authorizer, verbose=False):\n spotify_endpoint = 'https://api.spotify.com/v1/audio-features'\n headers = {\"Accept\":\"application/json\", \"Content-Type\":\"application/json\", \"Authorization\": \"Bearer {bearer}\".format(bearer=authorizer.bearer)}\n\n remainder = len(tracks)\n offset = 0\n stride = 100\n features = []\n while remainder > 0:\n params = {'ids': ','.join(tracks[offset:offset + stride])} # spotify can only process 100 tracks at a time\n\n response = requests.get(spotify_endpoint, params=params, headers=headers)\n\n if response.status_code == 200:\n features += response.json()['audio_features']\n offset += stride\n remainder -= stride\n elif response.status_code == 429:\n limit = int(response.headers['Retry-After'])\n print('Hit rate limit, waiting for {} seconds to continue'.format(limit))\n time.sleep(limit)\n elif response.status_code == 401:\n print('Access token expired, refreshing...')\n authorizer.refresh()\n headers = {\"Accept\":\"application/json\", \"Content-Type\":\"application/json\", \"Authorization\": \"Bearer {bearer}\".format(bearer=authorizer.bearer)}\n else:\n print('Error %d' % response.status_code)\n if verbose:\n print(json.loads(response.text))\n return None\n\n return zip(tracks, features)","def extractFeatures(self, datum):\n abstract","def test_gtf(self):\n #TODO write bed tests","def test_get_hyperflex_feature_limit_internal_by_moid(self):\n pass","def __init__(self, tfiles, featurizer):\n\t\t### [ Featurize the classifier ] ###\n\t\t# random.shuffle(tfiles)\n\t\tself.featurizer = featurizer\n\t\tself.tfiles = tfiles\n\n\t\t# Now build a model based on these vectors\n\t\tnum_files = len(tfiles)\n\t\tnum_training_files = int(PERCENT_TRAINING * num_files)\n\t\tnum_test_files = num_files - num_training_files\n\n\t\tself.train_files = self.tfiles[:num_training_files]\n\t\tself.test_files = self.tfiles[num_training_files:]\n\n\t\tself.all_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.tfiles]\n\t\tall_data_vectors = [d[0] for d in self.all_data]\n\t\tprint([v.shape for v in all_data_vectors])\n\t\tself.all_features = np.vstack(d[0] for d in self.all_data)\n\t\tself.all_labels = np.hstack(d[1] for d in self.all_data)\n\n\t\tself.train_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.train_files]\n\t\tself.train_features = np.vstack([d[0] for d in self.train_data])\n\t\tself.train_labels = np.hstack([d[1] for d in self.train_data])\n\n\t\tself.test_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.test_files]\n\t\tself.test_features = np.vstack([d[0] for d in self.test_data])\n\t\tself.test_labels = np.hstack(d[1] for d in self.test_data)\n\n\t\tself.trained_clf = []\n\t\tfor cl in used_classifiers:\n\t\t\tself.trained_clf += [cl(self.train_features, self.train_labels)]","def get_feature_vector(user_id: str, session: str) -> DataFrame:\n\n #Find the time windows during which the reader is doing the desired task\n activity_data = read_file(user_id, session, 'Activity.csv')\n task_number = mode(activity_data['TaskID'])\n task_name = task_names[(task_number - 1) % len(task_names)]\n tap_windows = get_tap_events(user_id, session)\n data = get_user_session_data(user_id, session)\n add_magnitude_columns(data)\n add_columns_for_taps(data, tap_windows)\n mark_tap_start_and_end(data, delta_in_ms = 200)\n\n column_names = get_feature_names()\n\n #A feature vector for each tap, to be filled in subsequently:\n featureVectors = pd.DataFrame(columns = column_names)\n\n for tap_file in tap_file_names:\n tap_feature = tap_file_to_feature_name[tap_file]\n print(tap_feature)\n window_start_indices = data[data[tap_feature] == 4].index\n window_end_indices = data[data[tap_feature] == 5].index\n if len(window_start_indices) == 0:\n continue\n \n for i in range(len(window_start_indices)):\n start, end = window_start_indices[i], window_end_indices[i]\n window_of_interest = data[start : end + 1]\n features = feature_list(user_id, session, tap_feature, task_name, window_of_interest)\n if features != None:\n featureVectors.loc[featureVectors.shape[0]] = features\n \n return featureVectors","def specialFeatures(self):\r\n return self._specialFeatures","def test_synth_tr():\n test_path = tempfile.mkdtemp()\n x_train, metadata = synth_tr(test_path)\n try:\n assert x_train.shape == (250, 3)\n except:\n shutil.rmtree(test_path)\n raise()","def test_text_classifier_update_training_samples(self):\n pass","def testSetup(self):\n \n train = QuizBowlData(None, \"\", self.vectorizer)\n train.vectorize(kTOY_TRAIN) \n model, optimizer = setup(train, 1.0)\n\n self.assertEqual(list(model.weight.size()), [2, 2])\n self.assertEqual(list(model.bias.size()), [2])","def detect(self, features):\n pass # TODO","def processFeature(prevWord, word, vector):\n \n # We add feature whether it exists or not\n unigram, exists = vector.getUnigram(prevWord)\n if not exists:\n vector.addUnigram(prevWord)\n \n \n bigram, exists = vector.getBigram(prevWord, word)\n if not exists:\n vector.addBigram(prevWord, word)","def feature_extract(self, CT_pairs):\n instances = []\n for pair in CT_pairs:\n config = pair[0]\n label = pair[1]\n data = []\n featureset = {}\n \n # for nltk NaiveBayes feature selection stuff when doing MaxEnt decoding parser commit this\n# featureset[\"topOfBuffer\"] = self.token_dict[config.beta.top()]\n# featureset[\"topOfStack\"] = self.token_dict[config.sigma.top()]\n# featureset[\"bufferStackPair\"] = (self.token_dict[config.sigma.top()], self.token_dict[config.beta.top()])\n# featureset[\"topOfBuffer\"] = self.POS_dict[config.beta.top()]\n# featureset[\"topOfStack\"] = self.POS_dict[config.sigma.top()]\n# featureset[\"bufferStackPair\"] = tuple((self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]))\n \n # add the (StackTopPOS,BufferTopPOS,bufferchildren_POS) feature\n #value_set = tuple([self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]] + [self.POS_dict[child] for child in self.getBufferChildren(config.beta.top())])\n #featureset[\"bufferStackbufferChildrenPair\"] = value_set\n \n # for MaxEnt decoding stuff\n # token variants\n data.append((\"topOfBuffer\",self.token_dict[config.beta.top()]))\n data.append((\"topOfStack\",self.token_dict[config.sigma.top()]))\n data.append((\"bufferStackPair\",self.token_dict[config.sigma.top()],self.token_dict[config.beta.top()]))\n #POS variants\n data.append((\"topOfBuffer\",self.POS_dict[config.beta.top()]))\n data.append((\"topOfStack\",self.POS_dict[config.sigma.top()]))\n data.append((\"bufferStackPair\",self.POS_dict[config.sigma.top()],self.POS_dict[config.beta.top()]))\n ins = Instance(label=label, data=data)\n #ins = Instance(label=label, data=featureset)\n instances.append(ins)\n \n return instances","def train(self):\n\t\traise NotImplementedError","def features(self, words, tags, config):\n buffer = config['buffer']\n stack = config['stack']\n pred_tree = config['pred_tree']\n\n feat = []\n\n # Single word features\n b1_w = words[buffer[0]] if buffer else \"<empty>\"\n b1_t = tags[buffer[0]] if buffer else \"<empty>\"\n b1_wt = b1_w + \" \" + b1_t\n\n b2_w = words[buffer[1]] if len(buffer) > 1 else \"<empty>\"\n b2_t = tags[buffer[1]] if len(buffer) > 1 else \"<empty>\"\n b2_wt = b2_w + \" \" + b2_t\n\n b3_w = words[buffer[2]] if len(buffer) > 2 else \"<empty>\"\n b3_t = tags[buffer[2]] if len(buffer) > 2 else \"<empty>\"\n b3_wt = b3_w + \" \" + b3_t\n\n s1_w = words[stack[-1]] if stack else \"<empty>\"\n s1_t = tags[stack[-1]] if stack else \"<empty>\"\n s1_wt = s1_w + \" \" + s1_t\n\n s2_w = words[stack[-2]] if len(stack) > 1 else \"<empty>\"\n s2_t = tags[stack[-2]] if len(stack) > 1 else \"<empty>\"\n s2_wt = s2_w + \" \" + s2_t\n\n '''\n for i in pred_tree:\n if stack and pred_tree[stack[-1]] == i:\n feat.append(\"tag\" + str(i) + str(tags[i]))\n '''\n\n # Triple word features\n\n def is_parent(parent, child):\n if child == 0:\n return False\n if parent == child:\n return True\n return is_parent(parent, pred_tree[child])\n\n # Child that is the most on the left\n def lc1(parent):\n for i in range(0, len(words)):\n if is_parent(parent, i):\n return i\n return -1\n \n # Child that is the most on the right\n def rc1(parent):\n for i in range(0, len(words), -1):\n if is_parent(parent, i):\n return i\n return -1\n\n lc1_s1 = lc1(stack[-1]) if stack else -1\n rc1_s1 = rc1(stack[-1]) if stack else -1\n lc1_s2 = lc1(stack[-2]) if len(stack) > 1 else -1\n rc1_s2 = rc1(stack[-2]) if len(stack) > 1 else -1\n\n s2_t_s1_t_b1_t = s2_t + \" \" + s1_t + \" \" + b1_t\n if lc1_s1 >= 0:\n s2_t_s1_t_lc1_s1_t = s2_t + \" \" + s1_t + \" \" + tags[lc1_s1]\n else:\n s2_t_s1_t_lc1_s1_t = \"<empty>\"\n if rc1_s1 >= 0:\n s2_t_s1_t_rc1_s1_t = s2_t + \" \" + s1_t + \" \" + tags[rc1_s1]\n else:\n s2_t_s1_t_rc1_s1_t = \"<empty>\"\n if lc1_s2 >= 0:\n s2_t_s1_t_lc1_s2_t = s2_t + \" \" + s1_t + \" \" + tags[rc1_s2]\n else:\n s2_t_s1_t_lc1_s2_t = \"<empty>\"\n if rc1_s2 >= 0:\n s2_t_s1_t_rc1_s2_t = s2_t + \" \" + s1_t + \" \" + tags[rc1_s2]\n else:\n s2_t_s1_t_rc1_s2_t = \"<empty>\"\n if lc1_s2 >= 0:\n s2_t_s1_w_rc1_s2_t = s2_t + \" \" + s1_w + \" \" + tags[rc1_s2]\n else:\n s2_t_s1_w_rc1_s2_t = \"<empty>\"\n if lc1_s1 >= 0:\n s2_t_s1_w_lc1_s1_t = s2_t + \" \" + s1_w + \" \" + tags[lc1_s1]\n else:\n s2_t_s1_w_lc1_s1_t = \"<empty>\"\n\n feat.append(\"b1_w:\" + b1_w)\n feat.append(\"b1_t:\" + b1_t)\n feat.append(\"b1_wt:\" + b1_wt)\n\n feat.append(\"b2_w:\" + b2_w)\n feat.append(\"b2_t:\" + b2_t)\n feat.append(\"b2_wt:\" + b2_wt)\n\n feat.append(\"b3_w:\" + b3_w)\n feat.append(\"b3_t:\" + b3_t)\n feat.append(\"b3_wt:\" + b3_wt)\n\n feat.append(\"s1_w:\" + s1_w)\n feat.append(\"s1_t:\" + s1_t)\n feat.append(\"s1_wt:\" + s1_wt)\n\n feat.append(\"s2_w:\" + s2_w)\n feat.append(\"s2_t:\" + s2_t)\n feat.append(\"s2_wt:\" + s2_wt)\n\n feat.append(\"s1_wt_s2_wt:\" + s1_wt + \" \" + s2_wt)\n feat.append(\"s1_wt_s2_w:\" + s1_wt + \" \" + s2_w)\n feat.append(\"s1_wt_s2_t:\" + s1_wt + \" \" + s2_t)\n feat.append(\"s1_w_s2_wt:\" + s1_w + \" \" + s2_wt)\n feat.append(\"s1_t_s2_wt:\" + s1_t + \" \" + s2_wt)\n feat.append(\"s1_w_s2_w:\" + s1_w + \" \" + s2_w)\n feat.append(\"s1_t_s2_t:\" + s1_t + \" \" + s2_t)\n feat.append(\"s1_t_b1_t:\" + s1_t + \" \" + b1_t)\n\n feat.append(\"s2_t_s1_t_b1_t:\" + s2_t_s1_t_b1_t)\n feat.append(\"s2_t_s1_t_lc1_s1_t:\" + s2_t_s1_t_lc1_s1_t)\n feat.append(\"s2_t_s1_t_rc1_s1_t:\" + s2_t_s1_t_rc1_s1_t)\n feat.append(\"s2_t_s1_t_lc1_s2_t:\" + s2_t_s1_t_lc1_s2_t)\n feat.append(\"s2_t_s1_t_rc1_s2_t:\" + s2_t_s1_t_rc1_s2_t)\n feat.append(\"s2_t_s1_w_rc1_s2_t:\" + s2_t_s1_w_rc1_s2_t)\n feat.append(\"s2_t_s1_w_lc1_s1_t:\" + s2_t_s1_w_lc1_s1_t)\n\n\n return feat","def load_features(self, features):\n pass\n # self.features = features","def get_features(file, song_index=0):\n\n chroma = get_chroma(file, song_index)\n timbre = get_timbre(file, song_index)\n max_loudness = get_max_loudness(file, song_index)\n\n # normalize to get ~ 0-1\n timbre = (timbre + 1000) / 1200\n max_loudness = (max_loudness + 70) / 70\n max_loudness = max_loudness.reshape(-1, 1)\n features = np.hstack([timbre, chroma, max_loudness])\n return features","def test_available_features():\n features = (\n \"Feature Name : Capa1\\r\\n State : Enabled\\r\\n\"\n \"Feature Name : Capa2\\r\\n State : Disabled\\r\\n\"\n )\n\n mock = MagicMock(return_value=features)\n with patch.dict(dism.__salt__, {\"cmd.run\": mock}):\n out = dism.available_features()\n mock.assert_called_once_with(\n [dism.bin_dism, \"/English\", \"/Online\", \"/Get-Features\"]\n )\n assert out == [\"Capa2\"]","def computeTemplateFeatures(self, templates, mode=''):\n pass"],"string":"[\n \"def test_setTunaFeatures(self):\\n tuna = Tuna()\\n array = [\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\"]\\n tuna.setTunaFeatures(array)\\n self.assertEqual(tuna.getTunaFeatures(), array)\",\n \"def findFeatures(self):\\n\\t\\tpass\",\n \"def test__extract_features(self):\\n text_sample = \\\"I really really love this movie\\\"\\n feature_sample = ['really','love','good']\\n feature_score_type = \\\"presence\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':1,'love':1,'good':0})\\n feature_score_type = \\\"term_frequency\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':2,'love':1,'good':0})\",\n \"def test_svm():\\n backend = BasicAer.get_backend('statevector_simulator')\\n random_seed = r.randint(1, 10598)\\n\\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\\n\\n # iris\\n pres = \\\"Test pour le data set Iris (facile, classique)\\\"\\n test_from_func(pres, 15, 10, 3, True, Iris, quantum_instance)\\n\\n # breast cancer\\n pres = \\\"Test pour le data set Breast Cancer (facile, classique)\\\"\\n test_from_func(pres, 15, 10, 3, True, Breast_cancer, quantum_instance)\\n\\n # digits (it's long so be careful)\\n #pres = \\\"Test pour le data set Digits (difficile, classique)\\\"\\n #test_from_func(pres, 10, 10, 10, True, Digits, quantum_instance)\\n\\n # wine\\n pres = \\\"Test pour le data set Wine (moyen, classique)\\\"\\n test_from_func(pres, 15, 10, 5, True, Wine, quantum_instance)\\n\\n # gaussian\\n pres = \\\"Test pour des données gaussiennes (moyen, classique)\\\"\\n for _ in range(1):\\n print(\\\"\\\\n\\\")\\n print(\\\"New iteration\\\")\\n test_from_func(pres, 25, 10, 2, True, Gaussian, quantum_instance)\\n print(\\\"\\\\n\\\")\\n\\n # small adn strings\\n pres = \\\"Test pour des séquences ADN courtes (difficile, classique)\\\"\\n test_from_func(pres, 10, 15, 14, True, Sequence, quantum_instance)\",\n \"def get_feature_set_SB(tweet):\\n #pos-tag frequencies\\n# print \\\"Tagged words in tweet: \\\", tweet.tagged_words\\n pos_tag_freq = {}\\n additional_freq = {}\\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# if tag=='PRtinf':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJS':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='ADJ':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='NP':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='DET':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n# elif tag=='P':\\n# pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n additional_freq['pronoun'] = 1\\n except KeyError:\\n continue\\n# print \\\"Tag frequencies: \\\", pos_tag_freq\\n for key in pos_tag_freq.keys():\\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \\n #Number of exclamation marks, number of emoticons,\\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\\n if emoticons>0:\\n additional_freq['emoticons'] = emoticons*1.0\\n if tweet.nrof_exclamations>0:\\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\\n \\n# print \\\"Additional frequencies: \\\", additional_freq\\n# raw_input(\\\"Continue?\\\")\\n \\n #Concatenate the dicts\\n features= dict(pos_tag_freq.items() + additional_freq.items())\\n# print \\\"All features: \\\", features\\n# raw_input(\\\"Continue?\\\")\\n return features\",\n \"def test_all_features(self):\\n to_create = ['looktest1', 'looktest2', 'looktest3']\\n for f in to_create:\\n Feature(f).activate()\\n\\n all_features = Feature.all_features()\\n self.assertEqual(len(all_features), len(to_create))\\n for f in to_create:\\n self.assertTrue(f in all_features)\",\n \"def feat():\\n pass\",\n \"def get_feature_set_SA(tweet):\\n features= {}\\n return features\",\n \"def get_feature_set_PB(tweet):\\n features= {\\n 'text_length': np.log(len(tweet.text))\\n } #ADD ADDITIONAL FEATURES\\n if tweet.nrof_sademoticons>0:\\n features['sademoticons'] = tweet.nrof_sademoticons\\n if tweet.nrof_happyemoticons>0:\\n features['happyemoticons'] = tweet.nrof_happyemoticons\\n \\n return features\",\n \"def test_intent_classifier_get_training_samples(self):\\n pass\",\n \"def test_ann_features():\\n CQT(file_struct, FeatureTypes.ann_beatsync, sr=11025).features\",\n \"def getFeatures(self, state, action):\\n util.raiseNotDefined()\",\n \"def get_feature_set_PA(tweet):\\n features= {}\\n return features\",\n \"def test_text_classifier_get_testing_samples(self):\\n pass\",\n \"def supported_features(self):\\n return SUPPORT_LGSMARTTV\",\n \"def nonlearning():\\n\\taT.featureAndTrain(['../../AudioData/chunked_data_sorted/pos', '../../AudioData/chunked_data_sorted/neg'], \\n\\t\\t\\t\\t\\t\\t1.0, 1.0, aT.shortTermWindow, aT.shortTermStep, \\n \\\"svm\\\", \\\"emotion_classifier\\\", True)\",\n \"def test_intent_classifier_get_testing_samples(self):\\n pass\",\n \"def test_Tuna(self):\\n tuna = Tuna(\\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\")\\n self.assertIsNotNone(tuna)\",\n \"def get_features(self):\\n return []\",\n \"def test_get_vocabulary(self):\\n\\n for m in self.models:\\n vocab = m.vocabulary\\n self.assertTrue(isinstance(vocab, turicreate.SArray))\\n self.assertEqual(len(vocab), 25)\",\n \"def test_predictor():\",\n \"def base_sample(self, tns_dir):\\n lib = CDLL('./libsample.so') \\n input_dir = tns_dir.encode()\\n lib.getBaseFeatures.argtypes = [c_char_p]\\n lib.getBaseFeatures.restype = c_float_p\\n baseFeatures = lib.getBaseFeatures(input_dir)\\n return baseFeatures\",\n \"def other_features_(tweet, cleaned_tweet):\\n #print(\\\"WARNING>>>>>>>>>>>>>>>>> VADERSENTIMENT DISABLED\\\")\\n sentiment = nlp.sentiment_analyzer.polarity_scores(tweet)\\n\\n words = cleaned_tweet #Get text only\\n\\n syllables = textstat.syllable_count(words) #count syllables in words\\n num_chars = sum(len(w) for w in words) #num chars in words\\n num_chars_total = len(tweet)\\n num_terms = len(tweet.split())\\n num_words = len(words.split())\\n avg_syl = round(float((syllables+0.001))/float(num_words+0.001),4)\\n num_unique_terms = len(set(words.split()))\\n ###Modified FK grade, where avg words per sentence is just num words/1\\n FKRA = round(float(0.39 * float(num_words)/1.0) + float(11.8 * avg_syl) - 15.59,1)\\n ##Modified FRE score, where sentence fixed to 1\\n FRE = round(206.835 - 1.015*(float(num_words)/1.0) - (84.6*float(avg_syl)),2)\\n\\n\\n twitter_objs = count_twitter_objs(tweet) #Count #, @, and http://\\n features = [FKRA, FRE, syllables, num_chars, num_chars_total, num_terms, num_words,\\n num_unique_terms, sentiment['compound'],\\n twitter_objs[2], twitter_objs[1],]\\n #features = pandas.DataFrame(features)\\n return features\",\n \"def test_all_features_with_data(self):\\n feature1 = Feature('looktest1')\\n feature1.set_percentage(5)\\n\\n feature2 = Feature('looktest2')\\n feature2.activate()\\n feature2.add_to_whitelist(3)\\n\\n feature3 = Feature('looktest3')\\n feature3.activate()\\n feature3.add_to_blacklist(4)\\n feature3.add_to_blacklist(5)\\n\\n feature4 = Feature('looktest4')\\n feature4.activate()\\n feature4.add_to_whitelist(3)\\n feature4.add_to_whitelist(5)\\n feature4.add_to_blacklist(4)\\n\\n all_features = Feature.all_features(include_data=True)\\n self.assertEqual(len(all_features), 4)\\n\\n for key in ['looktest1', 'looktest2', 'looktest3', 'looktest4']:\\n self.assertTrue(key in all_features)\\n if not key == 'looktest1':\\n self.assertEqual(all_features[key]['percentage'], 100)\\n\\n self.assertEqual(all_features['looktest1']['percentage'], 5)\\n self.assertFalse('whitelist' in all_features['looktest1'])\\n self.assertFalse('blacklist' in all_features['looktest1'])\\n\\n self.assertTrue('whitelist' in all_features['looktest2'])\\n self.assertEqual(all_features['looktest2']['whitelist'], [3])\\n self.assertFalse('blacklist' in all_features['looktest2'])\\n\\n self.assertFalse('whitelist' in all_features['looktest3'])\\n self.assertTrue('blacklist' in all_features['looktest3'])\\n self.assertEqual(all_features['looktest3']['blacklist'], [4, 5])\\n\\n self.assertTrue('whitelist' in all_features['looktest4'])\\n self.assertEqual(all_features['looktest4']['whitelist'], [3, 5])\\n self.assertTrue('blacklist' in all_features['looktest4'])\\n self.assertEqual(all_features['looktest4']['blacklist'], [4])\",\n \"def test_text_classifier_get_training_samples(self):\\n pass\",\n \"def getFeatures(self, state, action):\\n util.raiseNotDefined()\",\n \"def getFeatures(self, state, action):\\n util.raiseNotDefined()\",\n \"def getFeatures(self, state, action):\\n util.raiseNotDefined()\",\n \"def feature():\\n pass\",\n \"def test_intent_classifier_tsne_get(self):\\n pass\",\n \"def prepare_features(self, wavs, stage):\\n wavs, lens = wavs\\n if stage == sb.Stage.TRAIN:\\n if hasattr(self.modules, \\\"env_corrupt\\\"):\\n wavs_noise = self.modules.env_corrupt(wavs, lens)\\n wavs = torch.cat([wavs, wavs_noise], dim=0)\\n lens = torch.cat([lens, lens])\\n\\n if hasattr(self.hparams, \\\"augmentation\\\"):\\n wavs = self.hparams.augmentation(wavs, lens)\\n\\n # Choose what features we want to use\\n # todo: support multiple features and feature concat\\n target_feats = self.hparams.embedding_features\\n\\n FEATURE_EXTRACTOR = {\\n # 'cqt': self.modules.cqt,\\n # 'fbanks': self.modules.fbanks\\n 'fastaudiogauss': self.modules.fastaudiogauss\\n # 'ifr': self.modules.ifr\\n # 'mag': self.modules.mag\\n # 'mfcc': self.modules.mfcc\\n # 'leaf': self.modules.leaf\\n # 'tdfbanks': self.modules.tdfbanks\\n # 'pcen': self.modules.pcen\\n # 'sincnet': self.modules.sincnet\\n # 'trainable_fbanks': self.modules.trainable_fbanks\\n }\\n\\n if len(target_feats) == 1:\\n # wavs = wavs.unsqueeze(1).cuda()\\n feats = FEATURE_EXTRACTOR[target_feats[0]](wavs)\\n # feats = torch.unsqueeze(feats, 1)\\n # feats = torch.transpose(feats, 1,2)\\n if target_feats[0]=='cqt':\\n log_spec = 10.0 * torch.log10(torch.clamp(feats, min=1e-30))\\n log_spec -= 10.0\\n feats=log_spec\\n feats = torch.transpose(feats, 1,2)\\n else:\\n feats = []\\n for target in target_feats:\\n temp = FEATURE_EXTRACTOR[target](wavs)\\n if target=='cqt':\\n temp = torch.transpose(temp, 1,2)\\n feats.append(temp)\\n f =feats[0]\\n for i in range(1, len(feats)):\\n f = torch.cat((f, feats[i]), dim=2)\\n feats = f\\n feats = self.modules.mean_var_norm(feats, lens)\\n return feats, lens\",\n \"def get_feature_set_PC(tweet, sentimentvalues):\\n features= {\\n 'text_length': np.log(len(tweet.text))\\n } #ADD ADDITIONAL FEATURES\\n if tweet.nrof_sademoticons>0:\\n features['sademoticons'] = tweet.nrof_sademoticons\\n if tweet.nrof_happyemoticons>0:\\n features['happyemoticons'] = tweet.nrof_happyemoticons\\n \\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n features[tag] = features.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n features['adjectives'] = features.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n features['adverbs'] = features.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n features['pronoun'] = 1\\n except KeyError:\\n continue\\n for key in features.keys():\\n features[key] = features[key]*1.0\\n \\n #Add lexical features\\n # total polarity score, number of positive words, number of negative words\\n pos_score = 0\\n neg_score = 0\\n nrof_pos_words = 0\\n nrof_neg_words = 0\\n for word in sentimentvalues.keys():\\n if sentimentvalues[word][0]>0:\\n nrof_pos_words = nrof_pos_words + 1\\n pos_score = pos_score + sentimentvalues[word][0]\\n if sentimentvalues[word][1]>0:\\n nrof_neg_words = nrof_neg_words + 1\\n neg_score = neg_score + sentimentvalues[word][1]\\n\\n if neg_score>0:\\n features['neg_score'] = neg_score+1.0\\n if pos_score>0:\\n features['pos_score'] = pos_score+1.0\\n if nrof_pos_words>0:\\n features['positive_words'] = nrof_pos_words*1.0\\n if nrof_neg_words>0:\\n features['negative_words'] = nrof_neg_words*1.0\\n \\n return features\",\n \"def training(string):\\n print(\\\"Training...\\\")\\n vec = create_vector(string)\\n print(\\\"Selecting features...\\\")\\n feature_list = select_features(vec)\\n print(\\\"Done!\\\")\\n return feature_list\",\n \"def _initialize_with_tune_context(self, context: \\\"TuneContext\\\") -> None:\\n raise NotImplementedError\",\n \"def test_features_property():\\n atom = ATOMClassifier(X_bin, y_bin, random_state=1)\\n atom.run(\\\"LR\\\")\\n assert [i == j for i, j in zip(atom.lr.features, atom.features)]\",\n \"def test():\\n listpost,listclass = bayes.loaddataset()\\n myvocablist = bayes.createlist(listpost)\\n tmatrix = list()\\n for doc in listpost:\\n\\t vec = bayes.word2vec(myvocablist,doc)\\n\\t tmatrix.append(vec)\\n p0,p1,pa = bayes.train(tmatrix,listclass)\\n testdoc1 = ['love','my','dalmation']\\n testvec1 = bayes.word2vec(myvocablist,testdoc1)\\n print testdoc1,'classify as :',bayes.classify(testvec1,p0,p1,pa)\\n testdoc2 = ['stupid','love']\\n testvec2 = bayes.word2vec(myvocablist,testdoc2)\\n print testdoc2,'classify as :',bayes.classify(testvec2,p0,p1,pa)\",\n \"def sent_features(tweet):\\n twitter_objs = count_twitter_objs(tweet)\\n tweet=clean_tweet(tweet) \\n sentiment = sentiment_analyzer.polarity_scores(tweet)\\n #Get text only\\n words = preprocess(tweet) \\n syllables = textstat.syllable_count(words)\\n num_chars = sum(len(w) for w in words)\\n num_chars_total = len(tweet)\\n num_terms = len(tweet.split())\\n num_words = len(words.split())\\n avg_syl = round(float((syllables+0.001))/float(num_words+0.001),4)\\n num_unique_terms = len(set(words.split()))\\n \\n ###Modified FK grade, where avg words per sentence is just num words/1\\n FKRA = round(float(0.39 * float(num_words)/1.0) + float(11.8 * avg_syl) - 15.59,1)\\n ##Modified FRE score, where sentence fixed to 1\\n FRE = round(206.835 - 1.015*(float(num_words)/1.0) - (84.6*float(avg_syl)),2)\\n \\n \\\\\\n retweet = 0\\n if \\\"rt\\\" in words:\\n retweet = 1\\n features = [FKRA, FRE,syllables, avg_syl, num_chars, num_chars_total, num_terms, num_words,\\n num_unique_terms, sentiment['neg'], sentiment['pos'], sentiment['neu'], sentiment['compound'],\\n twitter_objs[2], twitter_objs[1],\\n twitter_objs[0], retweet]\\n return features\",\n \"def parse_features(self, skip=...):\\n ...\",\n \"def parse_features(self, skip=...):\\n ...\",\n \"def list_feature_tests(self):\\n\\t\\treturn self.test_names\",\n \"def get_all_features(self) :\\n raise NotImplementedError\",\n \"def make_returnn_audio_features_func():\\n return _extract\",\n \"def test_machine_learning():\",\n \"def test_training(self):\\n\\t\\tpass\",\n \"def get_song_features(tid):\\n\\n # dictionary of features to return\\n spotify_track_data = SpotifyData[tid]\\n\\n features = {}\\n features['name'] = spotify_track_data.name\\n features['artists'] = spotify_track_data.artists\\n features['popularity'] = spotify_track_data.popularity\\n features['album'] = spotify_track_data.album_name\\n features['danceability'] = spotify_track_data.danceability\\n features['energy'] = spotify_track_data.energy\\n features['key'] = spotify_track_data.key\\n features['loudness'] = spotify_track_data.loudness\\n features['mode'] = spotify_track_data.mode\\n features['speechiness'] = spotify_track_data.speechiness\\n features['acousticness'] = spotify_track_data.acousticness\\n features['instrumentalness'] = spotify_track_data.instrumentalness\\n features['liveness'] = spotify_track_data.liveness\\n features['valence'] = spotify_track_data.valence\\n features['tempo'] = spotify_track_data.tempo\\n features['duration_ms'] = spotify_track_data.duration_ms\\n features['time_signature'] = spotify_track_data.time_signature\\n\\n return features\",\n \"def run():\\n # all data and labels\\n # tracemalloc.start()\\n # start = time.time()\\n data, labels = Startdata.getdata() # texts\\n data2, labels2 = Startdata.getdata2() # emails\\n # Startdata.bagofwords(data2, labels2)\\n data, labels = Startdata.combinedata(data, data2, labels, labels2)\\n # split into training and testing. 1/3 test, 2/3 train\\n traind, trainl, testd, testl = Startdata.splitdata(data, labels)\\n\\n # labels\\n trainlabels = Startdata.labelfix(trainl)\\n testlabels = Startdata.labelfix(testl)\\n\\n # selective features\\n #\\n # extract features for use. in the shape of NxD\\n # N is number of samples, D is number of features\\n # current, peak = tracemalloc.get_traced_memory()\\n trainfeat = Startdata.featurextract(traind, trainl)\\n testfeat = Startdata.featurextract(testd, testl)\\n # theta is the weights in a D+1 X 1 array\\n theta = Spamfilter.train(trainfeat, trainlabels)\\n #\\n # trying bag of words\\n #\\n\\n # Startdata.featurextract(data, labels)\\n # error rate was 1.69% for trainingdata\\n # 2.21% for testing data\\n # bag, tfeat = Startdata.bagofwords(traind)\\n # theta = Spamfilter.train(tfeat, trainlabels)\\n # testfeat = Startdata.features(testd, bag)\\n\\n test(theta, testfeat, testlabels)\\n # tracemalloc.stop()\\n # done = time.time()\\n # print(f\\\"Current memory usage is {current / 10**6} MB; Peak was {peak / 10**6} MB\\\")\\n # print(\\\"time to complete\\\", done - start)\\n # NTR 12/1/2020 current best featextraction at 25 iterations is about\\n # 0.7-1% error for\\n # trainingdata and testing data\\n # NTR 12/2/2020 bag of words at 25 iterations\\n # 1.69% training error, 2.21% testing error\\n # NTR 12/2/2020 bag of words, 25 iter, removal of some features\\n # NTR 12/3/2020 featextraction 20 iterations, new features, emails inc\\n # 0.59% error on training. 0.63% testing error\",\n \"def get_oth_features(tweets, cleaned_tweets,out_folder):\\n feats=[]\\n count=0\\n # skipgram = get_skipgram(cleaned_tweets, out_folder, 2,2)\\n # for line in skipgram:\\n # print(line)\\n # hashtags = get_hashtags_in_tweets(tweets, out_folder)\\n # mispellings = get_misspellings(tweets, cleaned_tweets, out_folder)\\n # specialpunc = get_specialpunct(tweets, cleaned_tweets,out_folder)\\n # specialchars = get_specialchars(tweets, cleaned_tweets,out_folder)\\n # capitalization = get_capitalization(tweets,cleaned_tweets,out_folder)\\n for t, tc in zip(tweets, cleaned_tweets):\\n feats.append(other_features_(t, tc))\\n count+=1\\n # if count%100==0:\\n # print(\\\"\\\\t {}\\\".format(count))\\n other_features_names = [\\\"FKRA\\\", \\\"FRE\\\",\\\"num_syllables\\\", \\\"num_chars\\\", \\\"num_chars_total\\\",\\n \\\"num_terms\\\", \\\"num_words\\\", \\\"num_unique_words\\\", \\\"vader compound\\\",\\n \\\"num_hashtags\\\", \\\"num_mentions\\\"]\\n feature_matrix=np.array(feats)\\n pickle.dump(other_features_names,\\n open(out_folder+\\\"/\\\"+TWEET_TD_OTHER_FEATURES_VOCAB+\\\".pk\\\", \\\"wb\\\" ))\\n\\n return feature_matrix, other_features_names\",\n \"def extract_features(self):\\n self.extract_features_static()\\n self.extract_features_dynamic()\",\n \"def test_intent_classifier_add_training_samples(self):\\n pass\",\n \"def features(self, state, action, next_state):\\n raise NotImplementedError\",\n \"def get_chase_stats_features(tweets, cleaned_tweets,out_folder):\\n feats=[]\\n count=0\\n #hashtags = get_hashtags_in_tweets(tweets, out_folder)\\n #mispellings = get_misspellings(tweets, cleaned_tweets, out_folder)\\n specialpunc = get_specialpunct(tweets, cleaned_tweets,out_folder)\\n specialchars = get_specialchars(tweets, cleaned_tweets,out_folder)\\n capitalization = get_capitalization(tweets,cleaned_tweets,out_folder)\\n for t, tc in zip(tweets, cleaned_tweets):\\n feats.append(other_features_(t, tc))\\n count+=1\\n # if count%100==0:\\n # print(\\\"\\\\t {}\\\".format(count))\\n feat_names = [\\\"SPECIALPUNC\\\",\\\"SPECIALCHAR\\\", \\\"CAPT\\\"]\\n pickle.dump(feat_names,\\n open(out_folder+\\\"/\\\"+TWEET_TD_OTHER_FEATURES_VOCAB+\\\".pk\\\", \\\"wb\\\" ))\\n feature_matrix=np.column_stack((specialpunc, specialchars,\\n capitalization))\\n\\n\\n return feature_matrix, feat_names\",\n \"def test_regressors_hypertune(setup):\\n # Load the data\\n train_features, test_features, train_target, test_target = setup\\n # Call the function that we would like to test\\n tuned, tune_time = regressors.hyperTune(RandomForestRegressor(), train_features, train_target,\\n grid=grid.rf_paramgrid(), folds=2, iters=1, jobs=1)\\n # Assert if tuned is a dictionary\\n assert type(tuned) == dict\\n # Assert if tune_time is a float\\n assert type(tune_time) == float\",\n \"def test_get_voice_datasets(self):\\n pass\",\n \"def data_mining_features(index,input_string_x1,input_string_x2,vocab_word2index,word_vec_fasttext_dict,word_vec_word2vec_dict,tfidf_dict,n_gram=8):\\r\\n input_string_x1=input_string_x1.decode(\\\"utf-8\\\")\\r\\n input_string_x2 = input_string_x2.decode(\\\"utf-8\\\")\\r\\n #1. get blue score vector\\r\\n feature_list=[]\\r\\n #get blue score with n-gram\\r\\n for i in range(n_gram):\\r\\n x1_list=split_string_as_list_by_ngram(input_string_x1,i+1)\\r\\n x2_list = split_string_as_list_by_ngram(input_string_x2, i + 1)\\r\\n blue_score_i_1 = compute_blue_ngram(x1_list,x2_list)\\r\\n blue_score_i_2 = compute_blue_ngram(x2_list,x1_list)\\r\\n feature_list.append(blue_score_i_1)\\r\\n feature_list.append(blue_score_i_2)\\r\\n\\r\\n #2. get length of questions, difference of length\\r\\n length1=float(len(input_string_x1))\\r\\n length2=float(len(input_string_x2))\\r\\n length_diff=(float(abs(length1-length2)))/((length1+length2)/2.0)\\r\\n feature_list.append(length_diff)\\r\\n\\r\\n #3. how many words are same, how many words are unique\\r\\n sentence_diff_overlap_features_list=get_sentence_diff_overlap_pert(index,input_string_x1,input_string_x2)\\r\\n feature_list.extend(sentence_diff_overlap_features_list)\\r\\n\\r\\n #4. question 1,2 start with how/why/when\\r\\n #how_why_feature_list=get_special_start_token(input_string_x1,input_string_x2,special_start_token)\\r\\n #print(\\\"how_why_feature_list:\\\",how_why_feature_list)\\r\\n #feature_list.extend(how_why_feature_list)\\r\\n\\r\\n #5.edit distance\\r\\n edit_distance=float(edit(input_string_x1, input_string_x2))/30.0\\r\\n feature_list.append(edit_distance)\\r\\n\\r\\n #6.cos distance from sentence embedding\\r\\n x1_list=token_string_as_list(input_string_x1, tokenize_style='word')\\r\\n x2_list = token_string_as_list(input_string_x2, tokenize_style='word')\\r\\n distance_list_fasttext = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict)\\r\\n distance_list_word2vec = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_word2vec_dict, tfidf_dict)\\r\\n #distance_list2 = cos_distance_bag_tfidf(x1_list, x2_list, word_vec_fasttext_dict, tfidf_dict,tfidf_flag=False)\\r\\n #sentence_diffence=np.abs(np.subtract(sentence_vec_1,sentence_vec_2))\\r\\n #sentence_multiply=np.multiply(sentence_vec_1,sentence_vec_2)\\r\\n feature_list.extend(distance_list_fasttext)\\r\\n feature_list.extend(distance_list_word2vec)\\r\\n #feature_list.extend(list(sentence_diffence))\\r\\n #feature_list.extend(list(sentence_multiply))\\r\\n return feature_list\",\n \"def getFeatures(self, state, action, thisAgent):\\n util.raiseNotDefined()\",\n \"def test_intent_classifier_update_training_samples(self):\\n pass\",\n \"def _get_features(task, features, model, similarity_strategy=None):\\n X = []\\n langs = analysis_utils.get_langs_for_task(task)\\n for feature in features:\\n if feature != \\\"size\\\":\\n # this is a nested array\\n X_feature = analysis_utils.load_lang2vec_vectors(task=task, features=feature)\\n if X_feature is None:\\n #continue\\n return None\\n if similarity_strategy != \\\"-\\\":\\n # We start with similarities to english\\n X_feature = [[sim] for sim in analysis_utils.compute_similarities_of_lang_vecs(X_feature, strategy=similarity_strategy)]\\n elif feature == \\\"size\\\" and model == \\\"xlmr\\\":\\n # this is an array, we put it in a list\\n X_feature = [[size] for size in analysis_utils.xlmr_input_corpus_sizes(langs)]\\n elif feature == \\\"size\\\" and model == \\\"mbert\\\":\\n X_feature = [[size] for size in analysis_utils.mbert_input_corpus_sizes(langs)]\\n else:\\n raise ValueError()\\n # we now have a feature vector for a single feature or feature set\\n if len(X) == 0:\\n X = np.array(X_feature)\\n else:\\n X = np.concatenate((X,np.array(X_feature)), axis=1)\\n if len(X) == 0:\\n return None\\n return np.array(X, dtype=float)\",\n \"def test_features(iris):\\n assert iris.num_features == 4\\n assert iris.feature_names == [\\n \\\"sepal length (cm)\\\",\\n \\\"sepal width (cm)\\\",\\n \\\"petal length (cm)\\\",\\n \\\"petal width (cm)\\\",\\n ]\",\n \"def __init__(self, features=None):\\n self.features = features\",\n \"def getFeatures2(url, label):\\r\\n result = []\\r\\n url = str(url)\\r\\n \\r\\n #add the url to feature set\\r\\n result.append(url)\\r\\n \\r\\n #parse the URL and extract the domain information\\r\\n path = urlparse(url)\\r\\n ext = tldextract.extract(url)\\r\\n \\r\\n #counting number of dots in subdomain \\r\\n result.append(countdots(ext.subdomain))\\r\\n \\r\\n #checking hyphen in domain \\r\\n result.append(CountSoftHyphen(path.netloc))\\r\\n \\r\\n #length of URL \\r\\n result.append(length(url))\\r\\n \\r\\n #checking @ in the url \\r\\n result.append(CountAt(path.netloc))\\r\\n \\r\\n #checking presence of double slash \\r\\n result.append(CountDSlash(path.path))\\r\\n \\r\\n #Count number of subdir \\r\\n result.append(countSubDir(path.path))\\r\\n \\r\\n #number of sub domain \\r\\n result.append(countSubDomain(ext.subdomain))\\r\\n \\r\\n #length of domain name \\r\\n path2 = urlparse(url_format(url))\\r\\n result.append(len(path2.netloc)) \\r\\n \\r\\n #count number of queries \\r\\n result.append(len(path.query))\\r\\n \\r\\n #Adding domain information\\r\\n \\r\\n #if IP address is being used as a URL \\r\\n result.append(containsip(ext.domain))\\r\\n \\r\\n #presence of Suspicious_TLD\\r\\n result.append(1 if ext.suffix in Suspicious_TLD else 0)\\r\\n \\r\\n #append default for create_age(months)country\\r\\n result.append(-1)\\r\\n \\r\\n #append default for expiry_age(months)\\r\\n result.append(-1)\\r\\n \\r\\n #append default for update_age(days)\\r\\n result.append(-1)\\r\\n \\r\\n #append default for country\\r\\n result.append('None')\\r\\n \\r\\n #append extension\\r\\n path = urlparse(url)\\r\\n \\r\\n if get_ext(path.path) == '':\\r\\n result.append('None')\\r\\n else:\\r\\n result.append(get_ext(path.path))\\r\\n \\r\\n #append label\\r\\n result.append(str(label))\\r\\n \\r\\n return result\",\n \"def test_category_and_its_feature(self):\\n class RunnerBlah(Runner):\\n def __init__(self, renv):\\n super(RunnerBlah, self).__init__(renv)\\n self.register_feature_class('bravo', Feature)\\n self.register_feature_class('charlie', Feature)\\n self.register_feature_category_class(\\n 'alpha', features=['bravo', 'charlie'], mono=True)\\n\\n renv = create_runtime(RunnerBlah)\\n renv.create_runner('runner')\\n\\n ctrl = renv.feature_ctrl\\n\\n total_order, _ = ctrl.get_activation_order(['alpha', 'bravo'])\\n self.assertEqual(['bravo'], total_order)\",\n \"def getTrainAndTestFeatures(feature_select, trainingFile):\\n cleaner = TweetCleaner()\\n\\n #reading pre-labeled input and splitting into lines\\n posSentences = []\\n negSentences = []\\n\\n with open(trainingFile, 'r') as f:\\n for line in f.readlines():\\n if line.startswith('1'):\\n posSentences.append(cleaner.clean(line[2:]))\\n elif line.startswith('0'):\\n negSentences.append(cleaner.clean(line[2:]))\\n\\n posFeatures = get_features(posSentences, 'pos', feature_select)\\n negFeatures = get_features(negSentences, 'neg', feature_select)\\n\\n #selects 3/4 of the features to be used for training and 1/4 to be used for testing\\n posCutoff = int(math.floor(len(posFeatures)*3/4))\\n negCutoff = int(math.floor(len(negFeatures)*3/4))\\n trainFeatures = posFeatures[:posCutoff] + negFeatures[:negCutoff]\\n testFeatures = posFeatures[posCutoff:] + negFeatures[negCutoff:]\\n return trainFeatures, testFeatures\",\n \"def test_intent_classifier_vaporise(self):\\n pass\",\n \"def test_svm_quantique():\\n backend = BasicAer.get_backend('statevector_simulator')\\n random_seed = 10598\\n\\n quantum_instance = QuantumInstance(backend, seed=random_seed, seed_transpiler=random_seed)\\n pres = \\\"Test pour des données générées par ordinateur quantique (facile, quantique)\\\"\\n print(pres)\\n _, samp_train, samp_test, labels = ad_hoc_data(15, 10, 2, 0.3, True)\\n sample_m, sample_p = stock_get(20, 0.3)\\n\\n labels_me = [-1, 1]\\n samp_train_me = {-1: np.array(sample_m[:15]), 1: np.array(sample_p[:15])}\\n samp_test_me = {-1: np.array(sample_m[15:]), 1: np.array(sample_p[15:])}\\n print(samp_train)\\n print(samp_train_me)\\n print(samp_test)\\n print(samp_test_me)\\n classical_kernel_estimation(samp_train, samp_test, labels)\\n classical_kernel_estimation(samp_train_me, samp_test_me, labels_me)\\n\\n # Generate the feature map\\n feature_map = FirstOrderExpansion(feature_dimension=2, depth=2)\\n\\n # Run the Quantum Kernel Estimator and classify the test data\\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\\n test_dataset=samp_test)\\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\\n test_dataset=samp_test_me)\\n\\n result = qsvm.run(quantum_instance)\\n result_me = qsvm_me.run(quantum_instance)\\n print(\\\"Success of the FirstOrder feature map kernel:\\\")\\n print(result['testing_accuracy'])\\n print(result_me['testing_accuracy'])\\n\\n # Generate the feature map\\n feature_map = SecondOrderExpansion(feature_dimension=2, depth=2)\\n\\n # Run the Quantum Kernel Estimator and classify the test data\\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\\n test_dataset=samp_test)\\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\\n test_dataset=samp_test_me)\\n\\n result = qsvm.run(quantum_instance)\\n result_me = qsvm_me.run(quantum_instance)\\n print(\\\"Success of the SecondOrder feature map kernel:\\\")\\n print(result['testing_accuracy'])\\n print(result_me['testing_accuracy'])\\n\\n # Last implementation using the custom circuit generator\\n print(\\\"Success for my implementation (second order):\\\")\\n my_impl(samp_train, samp_test, labels)\\n my_impl(samp_train_me, samp_test_me, labels_me)\\n\\n feature_map = CustomExpansion(num_qubits=2, constructor_function=custom_constr, feature_param=[1])\\n\\n qsvm = QSVM(feature_map=feature_map, training_dataset=samp_train,\\n test_dataset=samp_test)\\n qsvm_me = QSVM(feature_map=feature_map, training_dataset=samp_train_me,\\n test_dataset=samp_test_me)\\n\\n result = qsvm.run(quantum_instance)\\n result_me = qsvm_me.run(quantum_instance)\\n print(\\\"Success of the Custom feature map kernel:\\\")\\n print(result['testing_accuracy'])\\n print(result_me['testing_accuracy'])\",\n \"def get_feature_set_SC2(tweet, sentimentvalues):\\n pos_tag_freq = {}\\n additional_freq = {}\\n for phrase in tweet.tagged_words:\\n for word in phrase:\\n try:\\n tag = word['pos']\\n pos_tag_freq[tag] = pos_tag_freq.get(tag, 0) + 1\\n if tag in ADJECTIVES:\\n additional_freq['adjectives'] = additional_freq.get(tag, 0) + 1\\n elif tag in ADVERBS: \\n additional_freq['adverbs'] = additional_freq.get(tag, 0) + 1\\n elif tag in PRONOUNS:\\n additional_freq['pronoun'] = 1\\n except KeyError:\\n continue\\n for key in pos_tag_freq.keys():\\n pos_tag_freq[key] = pos_tag_freq[key]*1.0\\n #number of adjectives in sentence, number of adverbs in sentence(except ikke), pronoun in sentence(binary) \\n #Number of exclamation marks, number of emoticons,\\n emoticons = tweet.nrof_happyemoticons+tweet.nrof_sademoticons\\n if emoticons>0:\\n additional_freq['emoticons'] = emoticons*1.0\\n if tweet.nrof_exclamations>0:\\n additional_freq['exclamations'] = tweet.nrof_exclamations*1.0\\n \\n #Add lexicon values\\n #total subjectivity score from word polarities, total objectivity score, number of subjective words, number of objective words, e\\n sub_score = sentimentvalues[0]+sentimentvalues[1]\\n obj_score = sentimentvalues[2]\\n if sub_score>0:\\n additional_freq[\\\"sub_score\\\"] = sub_score+1.0\\n if obj_score>0:\\n additional_freq[\\\"obj_score\\\"] = obj_score+1.0\\n \\n #Concatenate the dicts\\n features= dict(pos_tag_freq.items() + additional_freq.items())\\n \\n return features\",\n \"def songfeature_get(): # noqa: E501\\n query = 'SELECT * FROM SongFeatures'\\n results = query_to_dict(query)\\n features_list = []\\n for r in results:\\n features_list.append(\\n Songfeature(acousticness= r['Acousticness'],\\n danceability= r['Danceability'],\\n duration_ms= r['Duration_ms'],\\n energy= r['Energy'],\\n instrumentalness= r['Instrumentalness'],\\n musicalkey= r['MusicalKey'],\\n liveness= r['Liveness'],\\n loudness= r['Loudness'],\\n mode= r['Mode'],\\n speechiness= r['Speechiness'],\\n tempo= r['Tempo'],\\n timesignature= r['Time_signature'],\\n valence= r['Valence'],\\n songid= r['SongID']))\\n return features_list\",\n \"def test_intent_classifier_add_testing_samples(self):\\n pass\",\n \"def test_active_inference_SPM_1b(self):\",\n \"def main():\\n \\n # The following 5 command lines can be outcommented if the features are already created.\\n # There is no need to process the data every single time.\\n # Fine tuning the learning algorythm is much faster without that extra step.\\n \\n # by reading the train dataset the feature index is created.\\n # First calling of the processdata function\\n # Data limited to 300000\\n featureIndexes = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000)\\n print \\\"featureIndex generated!\\\"\\n print len(featureIndexes)\\n\\n # Trainfeature is created using the indexfeatures...\\n # Second calling of the processdata function\\n trainFeatures, trainTargets, trainItemIds, trainPrices, trainUrls, trainPhones, trainEmails, trainLength = processData(os.path.join(dataFolder,\\\"avito_train.tsv\\\"), itemsLimit=600000) # Original itemsLimit=300000\\n\\n # Building the test dataset... just like the training...\\n testFeatures, testItemIds, testPrices, testUrls, testPhones, testEmails, testLength = processData(os.path.join(dataFolder,\\\"avito_test.tsv\\\"), featureIndexes)\\n\\n # Dumping data into file...\\n # joblib.dump((trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds), os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n joblib.dump((trainFeatures,trainTargets,trainItemIds,trainPrices,trainUrls,trainPhones,trainEmails,trainLength,\\n testFeatures, testItemIds,testPrices,testUrls,testPhones,testEmails,testLength), os.path.join(dataFolder,\\\"SeparatedByCategory.pkl\\\"))\\n\\n\\n # loading data pack...\\n # trainFeatures, trainTargets, trainItemIds, testFeatures, testItemIds = joblib.load(os.path.join(dataFolder,\\\"train_data.pkl\\\"))\\n\\n #logging.info(\\\"Feature preparation done, fitting model...\\\")\\n\\n # Stochastic gradient model\",\n \"def extractFeatures(self, data, tf=False):\\n tfidf_training_matrix, tfidf_terms = self.useTfidfVectorizer(data)\\n \\n if tf:\\n tf_vectorizer = CountVectorizer(max_df=0.5, min_df=2, max_features=10000,\\n stop_words='english')\\n \\n tf_training_matrix = tf_vectorizer.fit_transform(data)\\n tf_terms = tf_vectorizer.get_feature_names()\\n \\n return tfidf_training_matrix, tfidf_terms, tf_training_matrix, tf_terms\\n \\n else:\\n return tfidf_training_matrix, tfidf_terms\",\n \"def test_text_classifier_tsne_get(self):\\n pass\",\n \"def test_api_predictors_get(self):\\n pass\",\n \"def run_feature_extraction_tests():\\n test_feature_extraction()\\n test_distributed_feature_extraction()\\n test_multimodel_feature_extraction()\\n test_distributed_multimodel_feature_extraction()\",\n \"def get_ngram_features(train_data, test_data):\\n print(\\\"getting ngram features\\\")\\n ngram_vectorizer = CountVectorizer(ngram_range = (1, 2))\\n ngram_vectorizer = ngram_vectorizer.fit(train_data)\\n return ngram_vectorizer.transform(train_data), ngram_vectorizer.transform(test_data)\",\n \"def test_text_classifier_add_testing_samples(self):\\n pass\",\n \"def test_get_hyperflex_feature_limit_internal_list(self):\\n pass\",\n \"def get_features_test(tweets):\\n feats = get_feature_array(tweets)\\n tfidf = vectorizer.transform(tweets).toarray()\\n M = np.concatenate([tfidf,feats],axis=1)\\n return M\",\n \"def test_create_hyperflex_feature_limit_external(self):\\n pass\",\n \"def test_stage_0():\\n\\tra_1 = readImage(TRAIN_RAW_IMAGE_1)\\n\\tre_1 = readImage(TRAIN_RESULT_IMAGE_1)\\n\\n\\tra_2 = readImage(TRAIN_RAW_IMAGE_2)\\n\\tre_2 = readImage(TRAIN_RESULT_IMAGE_2)\\n\\n\\t# Uncomment below if more examples are required.\\n\\t# ra_3 = readImage(TRAIN_RAW_IMAGE_3)\\n\\t# re_3 = readImage(TRAIN_RESULT_IMAGE_3)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_1 += (\\n\\t# \\tlaplace_operator(TRAIN_RAW_IMAGE_1),\\\\\\n\\t# \\t# k_means(TRAIN_RAW_IMAGE_1)[0],\\\\\\n\\t# \\t)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_2 += (\\n\\t# \\tlaplace_operator(TRAIN_RAW_IMAGE_2),\\\\\\n\\t# \\t# k_means(TRAIN_RAW_IMAGE_2)[0],\\\\\\n\\t# \\t)\\n\\n\\t# The prediction model is obtained and trained.\\n\\tengine = get_model((ra_1, ra_2,), (re_1, re_2,), model_type=SVM, percentage=0.1)\\n\\n\\ttest_percentage = float(1) # how many tests\\n\\n\\tra_1 = readImage(TEST_RAW_IMAGE_1)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_1 += (\\n\\t# \\tlaplace_operator(TEST_RAW_IMAGE_1),\\\\\\n\\t# \\t# k_means(TEST_RAW_IMAGE_1)[0],\\\\\\n\\t# \\t)\\n\\n\\tre_1 = readImage(TEST_RESULT_IMAGE_1)\\n\\n\\t# ra_2 = readImage(TEST_RAW_IMAGE_2)\\n\\t# re_2 = readImage(TEST_RESULT_IMAGE_2)\\n\\n\\tinput_vec = []\\n\\t# The features are extracted.\\n\\tinput_vec += buildFeatureArray_2(ra_1[0], ra_1[1], ra_1[2],\\\\\\n\\t\\tRADIUS_ARRAY,\\\\\\n\\t\\tadditional_feats=([] if len(ra_1) == 3 else ra_1[3:]))\\n\\n\\tex_no = int(test_percentage * len(input_vec)) # actual number of the test sample\\n\\n\\toutput_vec = []\\n\\toutput_vec += matrixToArray(re_1[0], lambda el: 1 if el == 255 else 0)\\n\\n\\tprint('Will start predicting...')\\n\\n\\tpredicted_vec = engine.predict(input_vec[:ex_no])\\n\\n\\tcounter = float(0)\\n\\tfor y, p in zip(output_vec[:ex_no], predicted_vec[:ex_no]):\\n\\t\\tif y == p: counter += 1\\n\\n\\tprint('Accuracy: ' + str(counter/ex_no))\\n\\n\\tpredicted_mat = arrayToMatrix( predicted_vec, len(re_1[0]), len(re_1[0][0]),\\\\\\n\\t\\tlambda el: 255 if el == 1 else 0)\\n\\n\\t# The predicted segmentation is saved.\\n\\tsave_rgb_img(\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t 'pred.bmp',\\\\\\n\\t)\",\n \"def setup_svm_classifier(training_data, y_training, testing_data, features, method=\\\"count\\\", ngrams=(1,1)):\\n # generate x and y training data\\n\\n if method == \\\"count\\\":\\n vec, x_training, x_testing = define_features_vectorizer(features, training_data, testing_data,ngramrange=ngrams)\\n elif method == \\\"tfidf\\\":\\n vec, x_training, x_testing = define_features_tfidf(features, training_data, testing_data,ngramrange=ngrams)\\n else:\\n print(\\\"Method has to be either count or tfidf\\\")\\n return 1\\n\\n # train classifier\\n\\n model = SVMClassifier_scratch()\\n model.fit(x_training, y_training)\\n\\n return model, vec, x_testing\",\n \"def test_create_hyperflex_feature_limit_internal(self):\\n pass\",\n \"def track_features(tracks, authorizer, verbose=False):\\n spotify_endpoint = 'https://api.spotify.com/v1/audio-features'\\n headers = {\\\"Accept\\\":\\\"application/json\\\", \\\"Content-Type\\\":\\\"application/json\\\", \\\"Authorization\\\": \\\"Bearer {bearer}\\\".format(bearer=authorizer.bearer)}\\n\\n remainder = len(tracks)\\n offset = 0\\n stride = 100\\n features = []\\n while remainder > 0:\\n params = {'ids': ','.join(tracks[offset:offset + stride])} # spotify can only process 100 tracks at a time\\n\\n response = requests.get(spotify_endpoint, params=params, headers=headers)\\n\\n if response.status_code == 200:\\n features += response.json()['audio_features']\\n offset += stride\\n remainder -= stride\\n elif response.status_code == 429:\\n limit = int(response.headers['Retry-After'])\\n print('Hit rate limit, waiting for {} seconds to continue'.format(limit))\\n time.sleep(limit)\\n elif response.status_code == 401:\\n print('Access token expired, refreshing...')\\n authorizer.refresh()\\n headers = {\\\"Accept\\\":\\\"application/json\\\", \\\"Content-Type\\\":\\\"application/json\\\", \\\"Authorization\\\": \\\"Bearer {bearer}\\\".format(bearer=authorizer.bearer)}\\n else:\\n print('Error %d' % response.status_code)\\n if verbose:\\n print(json.loads(response.text))\\n return None\\n\\n return zip(tracks, features)\",\n \"def extractFeatures(self, datum):\\n abstract\",\n \"def test_gtf(self):\\n #TODO write bed tests\",\n \"def test_get_hyperflex_feature_limit_internal_by_moid(self):\\n pass\",\n \"def __init__(self, tfiles, featurizer):\\n\\t\\t### [ Featurize the classifier ] ###\\n\\t\\t# random.shuffle(tfiles)\\n\\t\\tself.featurizer = featurizer\\n\\t\\tself.tfiles = tfiles\\n\\n\\t\\t# Now build a model based on these vectors\\n\\t\\tnum_files = len(tfiles)\\n\\t\\tnum_training_files = int(PERCENT_TRAINING * num_files)\\n\\t\\tnum_test_files = num_files - num_training_files\\n\\n\\t\\tself.train_files = self.tfiles[:num_training_files]\\n\\t\\tself.test_files = self.tfiles[num_training_files:]\\n\\n\\t\\tself.all_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.tfiles]\\n\\t\\tall_data_vectors = [d[0] for d in self.all_data]\\n\\t\\tprint([v.shape for v in all_data_vectors])\\n\\t\\tself.all_features = np.vstack(d[0] for d in self.all_data)\\n\\t\\tself.all_labels = np.hstack(d[1] for d in self.all_data)\\n\\n\\t\\tself.train_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.train_files]\\n\\t\\tself.train_features = np.vstack([d[0] for d in self.train_data])\\n\\t\\tself.train_labels = np.hstack([d[1] for d in self.train_data])\\n\\n\\t\\tself.test_data = [featurizer.get_feature_matrix_and_output_vector(f) for f in self.test_files]\\n\\t\\tself.test_features = np.vstack([d[0] for d in self.test_data])\\n\\t\\tself.test_labels = np.hstack(d[1] for d in self.test_data)\\n\\n\\t\\tself.trained_clf = []\\n\\t\\tfor cl in used_classifiers:\\n\\t\\t\\tself.trained_clf += [cl(self.train_features, self.train_labels)]\",\n \"def get_feature_vector(user_id: str, session: str) -> DataFrame:\\n\\n #Find the time windows during which the reader is doing the desired task\\n activity_data = read_file(user_id, session, 'Activity.csv')\\n task_number = mode(activity_data['TaskID'])\\n task_name = task_names[(task_number - 1) % len(task_names)]\\n tap_windows = get_tap_events(user_id, session)\\n data = get_user_session_data(user_id, session)\\n add_magnitude_columns(data)\\n add_columns_for_taps(data, tap_windows)\\n mark_tap_start_and_end(data, delta_in_ms = 200)\\n\\n column_names = get_feature_names()\\n\\n #A feature vector for each tap, to be filled in subsequently:\\n featureVectors = pd.DataFrame(columns = column_names)\\n\\n for tap_file in tap_file_names:\\n tap_feature = tap_file_to_feature_name[tap_file]\\n print(tap_feature)\\n window_start_indices = data[data[tap_feature] == 4].index\\n window_end_indices = data[data[tap_feature] == 5].index\\n if len(window_start_indices) == 0:\\n continue\\n \\n for i in range(len(window_start_indices)):\\n start, end = window_start_indices[i], window_end_indices[i]\\n window_of_interest = data[start : end + 1]\\n features = feature_list(user_id, session, tap_feature, task_name, window_of_interest)\\n if features != None:\\n featureVectors.loc[featureVectors.shape[0]] = features\\n \\n return featureVectors\",\n \"def specialFeatures(self):\\r\\n return self._specialFeatures\",\n \"def test_synth_tr():\\n test_path = tempfile.mkdtemp()\\n x_train, metadata = synth_tr(test_path)\\n try:\\n assert x_train.shape == (250, 3)\\n except:\\n shutil.rmtree(test_path)\\n raise()\",\n \"def test_text_classifier_update_training_samples(self):\\n pass\",\n \"def testSetup(self):\\n \\n train = QuizBowlData(None, \\\"\\\", self.vectorizer)\\n train.vectorize(kTOY_TRAIN) \\n model, optimizer = setup(train, 1.0)\\n\\n self.assertEqual(list(model.weight.size()), [2, 2])\\n self.assertEqual(list(model.bias.size()), [2])\",\n \"def detect(self, features):\\n pass # TODO\",\n \"def processFeature(prevWord, word, vector):\\n \\n # We add feature whether it exists or not\\n unigram, exists = vector.getUnigram(prevWord)\\n if not exists:\\n vector.addUnigram(prevWord)\\n \\n \\n bigram, exists = vector.getBigram(prevWord, word)\\n if not exists:\\n vector.addBigram(prevWord, word)\",\n \"def feature_extract(self, CT_pairs):\\n instances = []\\n for pair in CT_pairs:\\n config = pair[0]\\n label = pair[1]\\n data = []\\n featureset = {}\\n \\n # for nltk NaiveBayes feature selection stuff when doing MaxEnt decoding parser commit this\\n# featureset[\\\"topOfBuffer\\\"] = self.token_dict[config.beta.top()]\\n# featureset[\\\"topOfStack\\\"] = self.token_dict[config.sigma.top()]\\n# featureset[\\\"bufferStackPair\\\"] = (self.token_dict[config.sigma.top()], self.token_dict[config.beta.top()])\\n# featureset[\\\"topOfBuffer\\\"] = self.POS_dict[config.beta.top()]\\n# featureset[\\\"topOfStack\\\"] = self.POS_dict[config.sigma.top()]\\n# featureset[\\\"bufferStackPair\\\"] = tuple((self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]))\\n \\n # add the (StackTopPOS,BufferTopPOS,bufferchildren_POS) feature\\n #value_set = tuple([self.POS_dict[config.sigma.top()], self.POS_dict[config.beta.top()]] + [self.POS_dict[child] for child in self.getBufferChildren(config.beta.top())])\\n #featureset[\\\"bufferStackbufferChildrenPair\\\"] = value_set\\n \\n # for MaxEnt decoding stuff\\n # token variants\\n data.append((\\\"topOfBuffer\\\",self.token_dict[config.beta.top()]))\\n data.append((\\\"topOfStack\\\",self.token_dict[config.sigma.top()]))\\n data.append((\\\"bufferStackPair\\\",self.token_dict[config.sigma.top()],self.token_dict[config.beta.top()]))\\n #POS variants\\n data.append((\\\"topOfBuffer\\\",self.POS_dict[config.beta.top()]))\\n data.append((\\\"topOfStack\\\",self.POS_dict[config.sigma.top()]))\\n data.append((\\\"bufferStackPair\\\",self.POS_dict[config.sigma.top()],self.POS_dict[config.beta.top()]))\\n ins = Instance(label=label, data=data)\\n #ins = Instance(label=label, data=featureset)\\n instances.append(ins)\\n \\n return instances\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def features(self, words, tags, config):\\n buffer = config['buffer']\\n stack = config['stack']\\n pred_tree = config['pred_tree']\\n\\n feat = []\\n\\n # Single word features\\n b1_w = words[buffer[0]] if buffer else \\\"<empty>\\\"\\n b1_t = tags[buffer[0]] if buffer else \\\"<empty>\\\"\\n b1_wt = b1_w + \\\" \\\" + b1_t\\n\\n b2_w = words[buffer[1]] if len(buffer) > 1 else \\\"<empty>\\\"\\n b2_t = tags[buffer[1]] if len(buffer) > 1 else \\\"<empty>\\\"\\n b2_wt = b2_w + \\\" \\\" + b2_t\\n\\n b3_w = words[buffer[2]] if len(buffer) > 2 else \\\"<empty>\\\"\\n b3_t = tags[buffer[2]] if len(buffer) > 2 else \\\"<empty>\\\"\\n b3_wt = b3_w + \\\" \\\" + b3_t\\n\\n s1_w = words[stack[-1]] if stack else \\\"<empty>\\\"\\n s1_t = tags[stack[-1]] if stack else \\\"<empty>\\\"\\n s1_wt = s1_w + \\\" \\\" + s1_t\\n\\n s2_w = words[stack[-2]] if len(stack) > 1 else \\\"<empty>\\\"\\n s2_t = tags[stack[-2]] if len(stack) > 1 else \\\"<empty>\\\"\\n s2_wt = s2_w + \\\" \\\" + s2_t\\n\\n '''\\n for i in pred_tree:\\n if stack and pred_tree[stack[-1]] == i:\\n feat.append(\\\"tag\\\" + str(i) + str(tags[i]))\\n '''\\n\\n # Triple word features\\n\\n def is_parent(parent, child):\\n if child == 0:\\n return False\\n if parent == child:\\n return True\\n return is_parent(parent, pred_tree[child])\\n\\n # Child that is the most on the left\\n def lc1(parent):\\n for i in range(0, len(words)):\\n if is_parent(parent, i):\\n return i\\n return -1\\n \\n # Child that is the most on the right\\n def rc1(parent):\\n for i in range(0, len(words), -1):\\n if is_parent(parent, i):\\n return i\\n return -1\\n\\n lc1_s1 = lc1(stack[-1]) if stack else -1\\n rc1_s1 = rc1(stack[-1]) if stack else -1\\n lc1_s2 = lc1(stack[-2]) if len(stack) > 1 else -1\\n rc1_s2 = rc1(stack[-2]) if len(stack) > 1 else -1\\n\\n s2_t_s1_t_b1_t = s2_t + \\\" \\\" + s1_t + \\\" \\\" + b1_t\\n if lc1_s1 >= 0:\\n s2_t_s1_t_lc1_s1_t = s2_t + \\\" \\\" + s1_t + \\\" \\\" + tags[lc1_s1]\\n else:\\n s2_t_s1_t_lc1_s1_t = \\\"<empty>\\\"\\n if rc1_s1 >= 0:\\n s2_t_s1_t_rc1_s1_t = s2_t + \\\" \\\" + s1_t + \\\" \\\" + tags[rc1_s1]\\n else:\\n s2_t_s1_t_rc1_s1_t = \\\"<empty>\\\"\\n if lc1_s2 >= 0:\\n s2_t_s1_t_lc1_s2_t = s2_t + \\\" \\\" + s1_t + \\\" \\\" + tags[rc1_s2]\\n else:\\n s2_t_s1_t_lc1_s2_t = \\\"<empty>\\\"\\n if rc1_s2 >= 0:\\n s2_t_s1_t_rc1_s2_t = s2_t + \\\" \\\" + s1_t + \\\" \\\" + tags[rc1_s2]\\n else:\\n s2_t_s1_t_rc1_s2_t = \\\"<empty>\\\"\\n if lc1_s2 >= 0:\\n s2_t_s1_w_rc1_s2_t = s2_t + \\\" \\\" + s1_w + \\\" \\\" + tags[rc1_s2]\\n else:\\n s2_t_s1_w_rc1_s2_t = \\\"<empty>\\\"\\n if lc1_s1 >= 0:\\n s2_t_s1_w_lc1_s1_t = s2_t + \\\" \\\" + s1_w + \\\" \\\" + tags[lc1_s1]\\n else:\\n s2_t_s1_w_lc1_s1_t = \\\"<empty>\\\"\\n\\n feat.append(\\\"b1_w:\\\" + b1_w)\\n feat.append(\\\"b1_t:\\\" + b1_t)\\n feat.append(\\\"b1_wt:\\\" + b1_wt)\\n\\n feat.append(\\\"b2_w:\\\" + b2_w)\\n feat.append(\\\"b2_t:\\\" + b2_t)\\n feat.append(\\\"b2_wt:\\\" + b2_wt)\\n\\n feat.append(\\\"b3_w:\\\" + b3_w)\\n feat.append(\\\"b3_t:\\\" + b3_t)\\n feat.append(\\\"b3_wt:\\\" + b3_wt)\\n\\n feat.append(\\\"s1_w:\\\" + s1_w)\\n feat.append(\\\"s1_t:\\\" + s1_t)\\n feat.append(\\\"s1_wt:\\\" + s1_wt)\\n\\n feat.append(\\\"s2_w:\\\" + s2_w)\\n feat.append(\\\"s2_t:\\\" + s2_t)\\n feat.append(\\\"s2_wt:\\\" + s2_wt)\\n\\n feat.append(\\\"s1_wt_s2_wt:\\\" + s1_wt + \\\" \\\" + s2_wt)\\n feat.append(\\\"s1_wt_s2_w:\\\" + s1_wt + \\\" \\\" + s2_w)\\n feat.append(\\\"s1_wt_s2_t:\\\" + s1_wt + \\\" \\\" + s2_t)\\n feat.append(\\\"s1_w_s2_wt:\\\" + s1_w + \\\" \\\" + s2_wt)\\n feat.append(\\\"s1_t_s2_wt:\\\" + s1_t + \\\" \\\" + s2_wt)\\n feat.append(\\\"s1_w_s2_w:\\\" + s1_w + \\\" \\\" + s2_w)\\n feat.append(\\\"s1_t_s2_t:\\\" + s1_t + \\\" \\\" + s2_t)\\n feat.append(\\\"s1_t_b1_t:\\\" + s1_t + \\\" \\\" + b1_t)\\n\\n feat.append(\\\"s2_t_s1_t_b1_t:\\\" + s2_t_s1_t_b1_t)\\n feat.append(\\\"s2_t_s1_t_lc1_s1_t:\\\" + s2_t_s1_t_lc1_s1_t)\\n feat.append(\\\"s2_t_s1_t_rc1_s1_t:\\\" + s2_t_s1_t_rc1_s1_t)\\n feat.append(\\\"s2_t_s1_t_lc1_s2_t:\\\" + s2_t_s1_t_lc1_s2_t)\\n feat.append(\\\"s2_t_s1_t_rc1_s2_t:\\\" + s2_t_s1_t_rc1_s2_t)\\n feat.append(\\\"s2_t_s1_w_rc1_s2_t:\\\" + s2_t_s1_w_rc1_s2_t)\\n feat.append(\\\"s2_t_s1_w_lc1_s1_t:\\\" + s2_t_s1_w_lc1_s1_t)\\n\\n\\n return feat\",\n \"def load_features(self, features):\\n pass\\n # self.features = features\",\n \"def get_features(file, song_index=0):\\n\\n chroma = get_chroma(file, song_index)\\n timbre = get_timbre(file, song_index)\\n max_loudness = get_max_loudness(file, song_index)\\n\\n # normalize to get ~ 0-1\\n timbre = (timbre + 1000) / 1200\\n max_loudness = (max_loudness + 70) / 70\\n max_loudness = max_loudness.reshape(-1, 1)\\n features = np.hstack([timbre, chroma, max_loudness])\\n return features\",\n \"def test_available_features():\\n features = (\\n \\\"Feature Name : Capa1\\\\r\\\\n State : Enabled\\\\r\\\\n\\\"\\n \\\"Feature Name : Capa2\\\\r\\\\n State : Disabled\\\\r\\\\n\\\"\\n )\\n\\n mock = MagicMock(return_value=features)\\n with patch.dict(dism.__salt__, {\\\"cmd.run\\\": mock}):\\n out = dism.available_features()\\n mock.assert_called_once_with(\\n [dism.bin_dism, \\\"/English\\\", \\\"/Online\\\", \\\"/Get-Features\\\"]\\n )\\n assert out == [\\\"Capa2\\\"]\",\n \"def computeTemplateFeatures(self, templates, mode=''):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71556205","0.6340565","0.61837447","0.5806672","0.5796584","0.57937485","0.57770115","0.57497746","0.5737169","0.5710892","0.5675815","0.5668341","0.5659601","0.55376226","0.5520661","0.55035144","0.5499606","0.5498502","0.54887605","0.5487713","0.54858834","0.5479532","0.5478857","0.54773146","0.5467673","0.54622316","0.54622316","0.54622316","0.54590034","0.5450048","0.5440323","0.5432452","0.5428152","0.541161","0.5409628","0.53822625","0.53812546","0.5375416","0.5375416","0.5374705","0.5370536","0.5364134","0.53622717","0.5345977","0.53420067","0.5338563","0.53378576","0.53340787","0.531922","0.53152645","0.53144664","0.53088456","0.53018904","0.5289807","0.5287242","0.5285412","0.5283311","0.5280947","0.5270476","0.5269406","0.5257332","0.52451867","0.52419233","0.52381593","0.5234752","0.52275866","0.5222","0.52132785","0.5211183","0.52108675","0.5206138","0.5205599","0.5204133","0.52040476","0.52006084","0.5198874","0.5196419","0.5195495","0.5195102","0.51951","0.5184546","0.51830024","0.51797086","0.51759374","0.516915","0.51670474","0.51638293","0.5162359","0.51579624","0.51572007","0.5153569","0.5149831","0.51442766","0.5141477","0.5140089","0.5139354","0.5132663","0.5131007","0.51307005","0.5129153"],"string":"[\n \"0.71556205\",\n \"0.6340565\",\n \"0.61837447\",\n \"0.5806672\",\n \"0.5796584\",\n \"0.57937485\",\n \"0.57770115\",\n \"0.57497746\",\n \"0.5737169\",\n \"0.5710892\",\n \"0.5675815\",\n \"0.5668341\",\n \"0.5659601\",\n \"0.55376226\",\n \"0.5520661\",\n \"0.55035144\",\n \"0.5499606\",\n \"0.5498502\",\n \"0.54887605\",\n \"0.5487713\",\n \"0.54858834\",\n \"0.5479532\",\n \"0.5478857\",\n \"0.54773146\",\n \"0.5467673\",\n \"0.54622316\",\n \"0.54622316\",\n \"0.54622316\",\n \"0.54590034\",\n \"0.5450048\",\n \"0.5440323\",\n \"0.5432452\",\n \"0.5428152\",\n \"0.541161\",\n \"0.5409628\",\n \"0.53822625\",\n \"0.53812546\",\n \"0.5375416\",\n \"0.5375416\",\n \"0.5374705\",\n \"0.5370536\",\n \"0.5364134\",\n \"0.53622717\",\n \"0.5345977\",\n \"0.53420067\",\n \"0.5338563\",\n \"0.53378576\",\n \"0.53340787\",\n \"0.531922\",\n \"0.53152645\",\n \"0.53144664\",\n \"0.53088456\",\n \"0.53018904\",\n \"0.5289807\",\n \"0.5287242\",\n \"0.5285412\",\n \"0.5283311\",\n \"0.5280947\",\n \"0.5270476\",\n \"0.5269406\",\n \"0.5257332\",\n \"0.52451867\",\n \"0.52419233\",\n \"0.52381593\",\n \"0.5234752\",\n \"0.52275866\",\n \"0.5222\",\n \"0.52132785\",\n \"0.5211183\",\n \"0.52108675\",\n \"0.5206138\",\n \"0.5205599\",\n \"0.5204133\",\n \"0.52040476\",\n \"0.52006084\",\n \"0.5198874\",\n \"0.5196419\",\n \"0.5195495\",\n \"0.5195102\",\n \"0.51951\",\n \"0.5184546\",\n \"0.51830024\",\n \"0.51797086\",\n \"0.51759374\",\n \"0.516915\",\n \"0.51670474\",\n \"0.51638293\",\n \"0.5162359\",\n \"0.51579624\",\n \"0.51572007\",\n \"0.5153569\",\n \"0.5149831\",\n \"0.51442766\",\n \"0.5141477\",\n \"0.5140089\",\n \"0.5139354\",\n \"0.5132663\",\n \"0.5131007\",\n \"0.51307005\",\n \"0.5129153\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7249121"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":13296,"cells":{"query":{"kind":"string","value":"Create \"can_approve_estimated_completion_date\" permission and add it to the \"Admin\" group."},"document":{"kind":"string","value":"def add_permissions(apps, schema_editor):\n\n Permission = apps.get_model(\"auth\", \"Permission\")\n Group = apps.get_model(\"auth\", \"Group\")\n ContentType = apps.get_model(\"contenttypes\", \"ContentType\")\n\n permission, created = Permission.objects.get_or_create(\n codename=\"can_approve_estimated_completion_date\",\n defaults={\n \"name\": \"Can approve estimated completion date\",\n \"content_type\": ContentType.objects.get_for_model(\n apps.get_model(\"barriers\", \"Barrier\")\n ),\n },\n )\n\n admin_group = Group.objects.get(name=\"Administrator\")\n admin_group.permissions.add(permission)\n\n print(\n 'Permission \"can_approve_estimated_completion_date\" added to the \"Admin\" group.'\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def write_authorize(cls, user, obj):\n if not obj.delivery.deadline.assignment_group.is_examiner(user):\n raise PermissionDenied()","def write_authorize(cls, user, obj):\n if not models.AssignmentGroup.published_where_is_examiner(user).filter(id=obj.deadline.assignment_group.id):\n raise PermissionDenied()\n cls.write_authorize_examinercommon(user, obj)","def add_user_with_status_granted(caller, user):\r\n if _add_user(user, CourseCreator.GRANTED):\r\n update_course_creator_group(caller, user, True)","def need_admin_approval(self, need_admin_approval):\n\n self._need_admin_approval = need_admin_approval","def create_permission(permission, event):\n setDefaultRoles(permission.title, ('Manager',))","def write_authorize(cls, user, obj):\n if not obj.assignment_group.is_examiner(user):\n raise PermissionDenied()","def assign_permissions(sender, instance, created, **kwargs):\n if created:\n assign_perm('view_strand', instance.owner.group, instance)\n assign_perm('change_strand', instance.saver, instance)\n assign_perm('delete_strand', instance.saver, instance)\n assign_perm('view_strand', instance.saver, instance)","def post_access_control_list_create(self, resource_dict):\n pass","def remove_permissions(apps, schema_editor):\n\n Permission = apps.get_model(\"auth\", \"Permission\")\n Group = apps.get_model(\"auth\", \"Group\")\n\n permission = Permission.objects.get(\n codename=\"can_approve_estimated_completion_date\",\n )\n\n admin_group = Group.objects.get(name=\"Administrator\")\n admin_group.permissions.remove(permission)\n permission.delete()\n\n print(\n 'Permission \"can_approve_estimated_completion_date\" removed from the \"Admin\" group.'\n )","def update_admin_permission(self) -> None:\n session = self.appbuilder.get_session\n dag_resources = session.scalars(\n select(Resource).where(Resource.name.like(f\"{permissions.RESOURCE_DAG_PREFIX}%\"))\n )\n resource_ids = [resource.id for resource in dag_resources]\n\n perms = session.scalars(select(Permission).where(~Permission.resource_id.in_(resource_ids)))\n perms = [p for p in perms if p.action and p.resource]\n\n admin = self.find_role(\"Admin\")\n admin.permissions = list(set(admin.permissions) | set(perms))\n\n session.commit()","def allowed_organization_access_create(user):\n return user.has_perm(\"vnswww.add_organization\")","def add_admin(user):\n _add_owner(\n _lookup_user(user).biv_id,\n _add_model(pam.Admin())\n )","def need_admin_approval(self):\n return self._need_admin_approval","def test_add_permission(self):\r\n self.assertFalse(self.creator_admin.has_add_permission(self.request))","def set_permission(sender, instance, created, **kwargs):\n if created:\n assign_perm(\n \"website.can_see\",\n instance.author,\n instance,\n )","def add_view_permissions(sender, instance, created, **kwargs):\n if created:\n group = Group.objects.get(name=settings.DEFAULT_GROUP_NAME)\n assign_perm('view_tag', group, instance)","def can_assign(userid, group):","def pre_access_control_list_create(self, resource_dict):\n pass","def get_assign_permission(userid, group):","def assign_contributor_permissions(obj, contributor=None):\n obj.set_permission(Permission.highest(), contributor or obj.contributor)","def can_approve(self, user, **data):\n raise Return(False)","def add_permission(self, label, aws_account_id, action_name):\r\n return self.connection.add_permission(self, label, aws_account_id, action_name)","def grant_set_account_detail_perms(self, user):\n tx = self.iroha.transaction(\n [\n self.iroha.command(\n \"GrantPermission\",\n account_id=f\"{self.creator_account_details.gov_id}@afyamkononi\",\n permission=can_set_my_account_detail,\n )\n ],\n creator_account=f\"{user.gov_id}@afyamkononi\",\n )\n IrohaCrypto.sign_transaction(tx, user.private_key)\n return self.send_transaction_and_return_status(tx)","def create_custom_permissions(self) -> None:\n self.add_permission_view_menu(\"all_datasource_access\", \"all_datasource_access\")\n self.add_permission_view_menu(\"all_database_access\", \"all_database_access\")\n self.add_permission_view_menu(\"all_query_access\", \"all_query_access\")\n self.add_permission_view_menu(\"can_share_dashboard\", \"Superset\")\n self.add_permission_view_menu(\"can_share_chart\", \"Superset\")","def user_requested_access(user):\r\n user = CourseCreator.objects.get(user=user)\r\n if user.state != CourseCreator.GRANTED:\r\n user.state = CourseCreator.PENDING\r\n user.save()","def test_add_facility_pt1(self):\n self.assertFalse(self.admin.has_perm('auth.add_facility'))","def RequestedPermissions(self) -> _n_6_t_0:","def UpdateAccessApprovalSettings(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")","def get_permissions_map(self, created):\n current_user = self.context['request'].user\n company = get_object_or_404(models.Company, pk=self.data['id'])\n admins = company.admins\n accountants = company.accountants\n current_user.groups.add(admins)\n current_user.groups.add(accountants)\n assign_perm(\"change_group\", admins, admins)\n assign_perm(\"change_group\", admins, accountants)\n assign_perm(\"delete_group\", admins, admins)\n assign_perm(\"delete_group\", admins, accountants)\n return {\n 'view_company': [admins, accountants],\n 'change_company': [admins],\n 'delete_company': [admins]\n }","def job_post_save(sender, instance, created, **kwargs):\n\n if created:\n jp = JobPermission.objects.create(\n job=instance,\n content_object=instance.user,\n permission=JobPermissionLevel.ADMIN.value,\n )\n jp.save()","def test_staff_permission_required(self):\r\n with self.assertRaises(PermissionDenied):\r\n add_user_with_status_granted(self.user, self.user)\r\n\r\n with self.assertRaises(PermissionDenied):\r\n update_course_creator_group(self.user, self.user, True)","def add_group_email_grant(self, permission, email_address, headers=None):\r\n acl = self.get_acl(headers=headers)\r\n acl.add_group_email_grant(permission, email_address)\r\n self.set_acl(acl, headers=headers)","def require_permissions(self, user, feature, gate, new_state):\n is_requesting_review = (new_state == Vote.REVIEW_REQUESTED)\n is_editor = permissions.can_edit_feature(user, feature.key.integer_id())\n approvers = approval_defs.get_approvers(gate.gate_type)\n is_approver = permissions.can_approve_feature(user, feature, approvers)\n\n if is_requesting_review and is_editor:\n return\n\n if is_approver:\n return\n\n if is_requesting_review:\n self.abort(403, msg='User may not request a review')\n else:\n self.abort(403, msg='User is not an approver')","def add_email_grant(self, permission, email_address):\r\n acl = self.get_acl()\r\n acl.add_email_grant(permission, email_address)\r\n self.set_acl(acl)","def approve(self, feedback=None):\n self.hit.generate_connection()\n self.hit.connection.approve_assignment(self.mturk_id, feedback=feedback)\n self.update()","def manage_afterAdd(self, item, container) :\n item.manage_permission(Permissions.AddPortalContent,\n ['Manager'])\n item.manage_permission(Permissions.AccessContentsInformation,\n ['Member', 'Manager'])\n item.manage_permission(Permissions.View,\n ['Manager',])\n BaseTool.inheritedAttribute('manage_afterAdd')(self, item, container)","def add_administrator(self, project_id, name, email):\n self._run(\n url_path=\"contributors/add\",\n id=project_id,\n name=name,\n email=email,\n admin=True\n )\n return True","def create_permission( # pylint: disable=inconsistent-return-statements\n self,\n share_permission: IO,\n timeout: Optional[int] = None,\n *,\n content_type: str = \"application/json\",\n **kwargs: Any\n ) -> None:","def add_email_grant(self, permission, email_address, headers=None):\r\n policy = self.get_acl(headers=headers)\r\n policy.acl.add_email_grant(permission, email_address)\r\n self.set_acl(policy, headers=headers)","def approve(self):\n self._check_if_open()\n data = {\"approved\": True}\n return self.post(\"approve\", data)","def handle(self, *args, **options):\r\n username = 'populate_creators_command'\r\n email = 'grant+creator+access@edx.org'\r\n try:\r\n admin = User.objects.create_user(username, email, 'foo')\r\n admin.is_staff = True\r\n admin.save()\r\n except IntegrityError:\r\n # If the script did not complete the last time it was run,\r\n # the admin user will already exist.\r\n admin = User.objects.get(username=username, email=email)\r\n\r\n for user in get_users_with_role(CourseInstructorRole.ROLE):\r\n add_user_with_status_granted(admin, user)\r\n\r\n # Some users will be both staff and instructors. Those folks have been\r\n # added with status granted above, and add_user_with_status_unrequested\r\n # will not try to add them again if they already exist in the course creator database.\r\n for user in get_users_with_role(CourseStaffRole.ROLE):\r\n add_user_with_status_unrequested(user)\r\n\r\n # There could be users who are not in either staff or instructor (they've\r\n # never actually done anything in Studio). I plan to add those as unrequested\r\n # when they first go to their dashboard.\r\n\r\n admin.delete()","def authorization_date(self, authorization_date):\n\n self._authorization_date = authorization_date","def add_email_grant(self, permission, email_address):\n acl = self.get_acl()\n acl.add_email_grant(permission, email_address)\n self.set_acl(acl)","def has_add_permission(self, request):\r\n return False","def has_add_permission(self, request):\r\n return False","def test_create_with_permissions(self):\n permissions = Permission.objects.filter(name__in=('Can add course mode', 'Can change course mode'))\n for permission in permissions:\n self.user.user_permissions.add(permission)\n\n self.assert_can_create_course()","def admin_actions():\n\n create_default_admin()\n return response('Admin account has been created', 201)","def on_model_change(self, form, model, is_created):\n if not current_user.is_active or not current_user.is_authenticated:\n abort(403)\n elif is_created:\n if not user_has_permission(current_user, 'can_create', 'advisorapplicants'):\n abort(403)\n else:\n if not user_has_permission(current_user, 'can_edit', 'advisorapplicants'):\n abort(403)","def add_group_grant(self, permission, group_id):\r\n acl = self.get_acl()\r\n acl.add_group_grant(permission, group_id)\r\n self.set_acl(acl)","def addFlowPermission(self, msgContent):\n self.permissionCt += 1\n if (self.permissionCt % 1000) == 0:\n compTime = time.time() - self.time\n self.time = time.time()\n print (\"%s permissions added (in OFX manager) (%s sec)\"%(self.permissionCt, compTime))\n self.ofxAgent.sendToDp(self.MODULEID, ADDFLOWPERMISSION, msgContent)","def test_create_delegate_limit(self):\n # Create new user and grant delegate role\n new_user = self.make_user('new_user')\n self.make_assignment(self.project, new_user, self.role_delegate)\n url = reverse(\n 'projectroles:api_role_create',\n kwargs={'project': self.project.sodar_uuid},\n )\n post_data = {\n 'role': PROJECT_ROLE_DELEGATE,\n 'user': str(self.assign_user.sodar_uuid),\n }\n # NOTE: Post as owner\n response = self.request_knox(url, method='POST', data=post_data)\n self.assertEqual(response.status_code, 400, msg=response.content)","def task_create_permission(supertask, user, onelevel=True, onlyauthors=False):\n if supertask == None: # If there is no supertask, then everyone can create the task\n return True\n if user.user.is_staff:\n return True\n if onlyauthors == True: # Checking if user is author of supertask of current task if onlyauthors set to True\n if user == supertask.author:\n return True\n elif user in supertask.responsible_users.all() or user == supertask.author: # Otherwise check if user is author or is in responsible users' list\n return True\n if onelevel == False: # If onelevel set to False, check the same for supertask, with onlyauthors set to True\n return task_create_permission(supertask.super_task, user, onelevel=False, onlyauthors=True)","def has_add_permission(self, request: HttpRequest) -> bool:\n return False","def approve_public_credit_name(self):\n self.public_credit_name_approved = True\n self.save()","def approve(self, admin_membership):\n if admin_membership.is_admin is False:\n # TODO: Log suspicious activity\n return None\n\n new_membership = InitiativeMembership()\n new_membership.initiative = self.initiative\n new_membership.user = self.user\n new_membership.save()\n\n self.approved_by = admin_membership\n self.is_open = False\n self.save()\n\n return new_membership","def create_acl(self, context, sg):\n self.security_group_driver.create_acl(context, sg)","def manage_access_approval(\n request: AuthenticatedHttpRequest,\n *,\n access_request_pk: int,\n entity: Literal[\"importer\", \"exporter\"],\n) -> HttpResponse:\n\n with transaction.atomic():\n if entity == \"importer\":\n model_cls = ImporterAccessRequest\n form_cls = ImporterApprovalRequestForm\n else:\n model_cls = ExporterAccessRequest\n form_cls = ExporterApprovalRequestForm\n\n access_request = get_object_or_404(\n model_cls.objects.select_for_update(), pk=access_request_pk\n )\n\n case_progress.access_request_in_processing(access_request)\n\n if request.method == \"POST\":\n form = form_cls(request.POST, access_request=access_request)\n\n if form.is_valid():\n approval_request = form.save(commit=False)\n approval_request.status = ApprovalRequest.Statuses.OPEN\n approval_request.access_request = access_request\n approval_request.requested_by = request.user\n approval_request.save()\n send_approval_request_opened_email(approval_request)\n return redirect(\n reverse(\n \"access:case-management-access-approval\",\n kwargs={\"access_request_pk\": access_request.pk, \"entity\": entity},\n )\n )\n else:\n approval_request = access_request.approval_requests.filter(is_active=True).first()\n form = form_cls(instance=approval_request, access_request=access_request)\n\n context = {\n \"case_type\": \"access\",\n \"process\": access_request,\n \"form\": form,\n \"approval_request\": approval_request,\n \"entity\": entity,\n }\n\n return render(\n request=request,\n template_name=\"web/domains/case/access/management-access-approval.html\",\n context=context,\n )","def test_add_admin_to_org(self):\n pass","def AddAclSample():\n client = CreateClient()\n doc = gdata.docs.data.Resource(type='document', title='My Sample Doc')\n doc = client.CreateResource(doc)\n acl_entry = gdata.docs.data.AclEntry(\n scope=gdata.acl.data.AclScope(value='user@example.com', type='user'),\n role=gdata.acl.data.AclRole(value='reader'),\n )\n client.AddAclEntry(doc, acl_entry, send_notifications=False)","def give_permissions(self):\n self._activate()\n self.configure(state=\"enabled\")","def allowed_group_access_create(user, org=None):\n try:\n up = user.get_profile()\n except AttributeError:\n return False\n\n if org is None:\n return (user.has_perm(\"vnswww.group_add_any\")\n or user.has_perm(\"vnswww.group_add_org\"))\n else:\n return (user.has_perm(\"vnswww.group_add_any\")\n or (user.has_perm(\"vnswww.group_add_org\")\n and org == up.org))","def at_object_creation(self):\n self.locks.add(\"view:perm(Immortals)\")","def approve(self):\n if (self.status == self.APPROVED):\n pass\n\n print ('starting approval process by adding events to the primary cal')\n\n primary_calendar = self.course.calendar_courses.get(primary=True)\n # print ('primary = ' + primary_calendar)\n for event in self.events.all():\n d = event.date\n start = datetime.datetime(d.year, d.month, d.day)\n start = timezone.make_aware(start, timezone.get_current_timezone())\n start = start + datetime.timedelta(hours=8)\n end = start + datetime.timedelta(hours=1)\n\n params = {\n 'calendar': primary_calendar,\n 'title': event.title,\n 'start': start,\n 'end': end\n }\n CalendarEvent.objects.create(**params)\n event.approved = True\n event.save()\n\n print ('trying to set syllabus to approved')\n\n try:\n syllabus = self.syllabus.all()[0]\n syllabus.approved = True\n syllabus.course = self.course\n syllabus.save()\n except:\n print ('dang, that failed, but continuing nonetheless.')\n pass\n\n\n print ('creating students from roster-students')\n\n\n for student in self.students.all():\n email = student.email\n if email:\n user = utils.get_or_create_user(email, student.first_name, student.last_name)\n school = self.course.domain\n user_student = utils.get_or_create_student(school, user)\n\n self.course.enroll_by_roster(user_student, self)\n\n student.approved = True\n student.save()\n\n print ('instructors')\n\n for instructor in self.instructors.all():\n instructor.approved = True\n instructor.save()\n\n print ('approving done')\n\n\n self.status = self.APPROVED\n self.save()\n\n add_notification(\n self.created_by.user,\n 'Your class set for {}, is approved and published!'.format(self.course)\n )","def test_approve(self):\n\n username,userpass = self.testdata.find_account_for('toolsubmitter')\n\n self.utils.account.login_as(username,userpass)\n\n self.contribtool.approve(TOOLNAME,TOOLLICENSEDATA)","def get_everyone_granted(self):","def _setup_ip_allowing(self, ip_list, role_suffix):\n # Create new user\n user = self.make_user(role_suffix)\n # Set user access\n if role_suffix == 'owner':\n self.owner_as.user = user\n self.owner_as.save()\n # user_as = self.owner_as\n self.owner_as_cat.user = user\n self.owner_as_cat.save()\n else:\n self.make_assignment(\n self.project, user, getattr(self, 'role_' + role_suffix)\n )\n # Init IP restrict setting\n self.make_setting(\n app_name='projectroles',\n name='ip_restrict',\n setting_type='BOOLEAN',\n value=True,\n project=self.project,\n )\n # Init IP allowlist setting\n self.make_setting(\n app_name='projectroles',\n name='ip_allowlist',\n setting_type='JSON',\n value=None,\n value_json=ip_list,\n project=self.project,\n )\n return user # , user_as, self.cat_owner_as","def approve_user_application(self, user):\n if self.is_moderator and \\\n self.has_perm('accounts.approve_user_application'):\n user.moderator = self\n user.moderator_decision = user.APPROVED\n user.decision_datetime = timezone.now()\n user.auth_token = generate_unique_id()\n user.save()\n\n return user\n\n else:\n raise PermissionDenied","def allow_access(course, user, level):\r\n _change_access(course, user, level, 'allow')","def access_granted(valid_token_dict, template, title):\n policy = config_get('policy', 'permission')\n return render_template(template, token=valid_token_dict['token'], account=valid_token_dict['account'], vo=valid_token_dict['vo'], policy=policy, title=title)","def should_auto_approve(self):\r\n if self.group and self.group.allow_auto_approval:\r\n return True\r\n\r\n # some orders (like those duplicated by CIT) will not have owners\r\n if self.is_multilevel_approval():\r\n if self.has_all_approver_roles(self.owner, self.group):\r\n return True\r\n return False\r\n\r\n else:\r\n if self.owner and self.owner.has_permission('order.approve', self.group):\r\n return True\r\n\r\n return False","def at_the_bottom_of_the_Edit_Permissions_page_click_on_Set_ACL(driver):\n assert wait_on_element(driver, 5, '//h1[text()=\"Edit Permissions\"]')\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SET ACL\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SET ACL\"]').click()\n time.sleep(1)\n assert wait_on_element_disappear(driver, 30, '//h6[contains(.,\"Please wait\")]')","def on_access_approved(self, handler):\n print \"User with {0} has been GRANTED access.\".format(\n handler.client_address[0]\n )","def completion_date(self, completion_date):\n\n self._completion_date = completion_date","def test_add_facility_pt2(self):\n self.assertFalse(self.coach1.has_perm('auth.add_facility'))","def create_task(self, name, date, isComplete):\n user = User.objects.create(username='userdemo')\n user.set_password('calnote24')\n user.save()\n Task.objects.create(task=name, dueDate=date, isComplete=isComplete, user_id=user.id)","def has_add_permission(self, request):\n return False","def has_add_permission(self, request):\n return False","async def add_client_permission_async(\n action: int,\n client_id: str,\n resource: str,\n x_additional_headers: Optional[Dict[str, str]] = None,\n **kwargs\n):\n request = AddClientPermission.create(\n action=action,\n client_id=client_id,\n resource=resource,\n )\n return await run_request_async(\n request, additional_headers=x_additional_headers, **kwargs\n )","def save(self, commit):\n preset = super().save(commit)\n # Remove all permissions on the preset.\n preset.permission_group.permissions.all().delete()\n # Add permission to selected groups.\n for group in Group.objects.filter(pk__in=self.cleaned_data[\"groups\"]):\n preset.set_permission(Permission.VIEW, group)\n return preset","def approve(self, request, object_id, extra_context=None):\n obj = self.get_object(request, unquote(object_id))\n title = self._approve_title(obj)\n\n AdminAddApprovalForm = self._approve_approval_form(request)\n\n form = AdminAddApprovalForm(initial={'prescription': obj})\n if request.method == 'POST':\n url = reverse('admin:prescription_prescription_detail',\n args=[str(obj.id)])\n if obj.approval_status == obj.APPROVAL_DRAFT and obj.can_approve:\n # create an approval\n obj.approval_status = obj.APPROVAL_SUBMITTED\n obj.approval_status_modified = timezone.now()\n obj.save()\n self.message_user(\n request, \"Successfully submitted for approval.\")\n return HttpResponseRedirect(url)\n elif obj.approval_status == obj.APPROVAL_SUBMITTED:\n if request.POST.get('_cancel'):\n obj.clear_approvals()\n msg = 'Delete: Clearing Approvals/Endorsements', 'Burn ID: {}, Deleted by: {}'. format(obj.burn_id, request.user.get_full_name())\n logger.warning(msg)\n support_email('Delete: Clearing Approvals/Endorsements', msg)\n\n self.message_user(\n request, \"Approval rejected. ePFP is now draft.\")\n return HttpResponseRedirect(url)\n\n form = AdminAddApprovalForm(request.POST,\n initial={'prescription': obj})\n if form.is_valid():\n approval = form.save(commit=False)\n approval.prescription = obj\n approval.creator = request.user\n approval.modifier = request.user\n approval.save()\n obj.approval_status = obj.APPROVAL_APPROVED\n obj.approval_status_modified = timezone.now()\n obj.save()\n self.message_user(\n request, \"Successfully approved.\")\n return HttpResponseRedirect(url)\n elif obj.is_approved:\n if obj.is_closed:\n self.message_user(\n request, \"You can't extend an approval after the \"\n \"prescribed fire plan has been closed.\")\n return HttpResponseRedirect(url)\n if request.POST.get('_cancel'):\n self.message_user(\n request, \"Didn't extend approval.\")\n return HttpResponseRedirect(url)\n else:\n approval = obj.current_approval\n if approval and approval.extension_count < 3:\n approval.extension_count = approval.extension_count + 1\n approval.valid_to = approval.next_valid_to\n approval.save()\n self.message_user(\n request, \"Successfully extended approval.\")\n else:\n self.message_user(request, \"You can't extend an \"\n \"approval more than 3 times.\")\n return HttpResponseRedirect(url)\n\n admin_form, media = self._approve_form(request, obj, form)\n\n context = {\n 'title': title,\n 'current': obj,\n 'form': admin_form,\n 'media': media,\n 'errors': None,\n }\n return TemplateResponse(request, \"admin/prescription/prescription/\"\n \"approval.html\", context,\n current_app=self.admin_site.name)","def test_aid_creation_requires_contributor(client, user):\n\n client.force_login(user)\n form_url = reverse('aid_create_view')\n res = client.get(form_url, follow=True)\n assert res.status_code == 200\n assert len(res.redirect_chain) == 1\n assert res.redirect_chain[0][0].startswith('/comptes/profil-contributeur/')","def create(self, validated_data):\n user = super(UserSerializer, self).create(validated_data)\n for i in user.groups.all():\n if i.accountants.exists():\n company = get_object_or_404(\n models.Company, pk=i.accountants.all().first().id)\n assign_perm(\"change_user\", company.admins, user)\n assign_perm(\"view_user\", company.admins, user)\n assign_perm(\"delete_user\", company.admins, user)\n assign_perm(\"change_user\", user, user)\n assign_perm(\"view_user\", user, user)\n assign_perm(\"delete_user\", user, user)\n\n user.user_permissions.add(\n Permission.objects.get(name='Can add sale'))\n user.user_permissions.add(\n Permission.objects.get(name='Can delete sale'))\n user.user_permissions.add(\n Permission.objects.get(name='Can add purchase'))\n user.user_permissions.add(\n Permission.objects.get(name='Can change sale'))\n user.user_permissions.add(\n Permission.objects.get(name='Can change purchase'))\n user.user_permissions.add(\n Permission.objects.get(name='Can delete purchase'))\n user.user_permissions.add(\n Permission.objects.get(name='Can add media'))\n user.user_permissions.add(\n Permission.objects.get(name='Can delete media'))\n user.set_password(validated_data['password'])\n user.save()\n return user","def increaseApproval(_spender: address, _addedValue: uint256) -> bool:\n\n self.allowed[msg.sender][_spender] += _addedValue\n log.Approval(msg.sender, _spender, self.allowed[msg.sender][_spender])\n return True","def add_client_permission(\n action: int,\n client_id: str,\n resource: str,\n x_additional_headers: Optional[Dict[str, str]] = None,\n **kwargs\n):\n request = AddClientPermission.create(\n action=action,\n client_id=client_id,\n resource=resource,\n )\n return run_request(request, additional_headers=x_additional_headers, **kwargs)","def test_add_facility_pt3(self):\n self.assertFalse(self.learner1.has_perm('auth.add_facility'))","def test_create_delegate_limit_inherit(self):\n # Set up category owner\n new_user = self.make_user('new_user')\n self.owner_as_cat.user = new_user\n\n url = reverse(\n 'projectroles:api_role_create',\n kwargs={'project': self.project.sodar_uuid},\n )\n post_data = {\n 'role': PROJECT_ROLE_DELEGATE,\n 'user': str(self.assign_user.sodar_uuid),\n }\n # NOTE: Post as owner\n response = self.request_knox(url, method='POST', data=post_data)\n\n self.assertEqual(response.status_code, 201, msg=response.content)\n self.assertEqual(\n RoleAssignment.objects.filter(project=self.project).count(), 2\n )\n role_as = RoleAssignment.objects.filter(\n project=self.project, role=self.role_delegate, user=self.assign_user\n ).first()\n self.assertIsNotNone(role_as)","def add_permission(self, queue, label, aws_account_id, action_name):\r\n params = {'Label': label,\r\n 'AWSAccountId' : aws_account_id,\r\n 'ActionName' : action_name}\r\n return self.get_status('AddPermission', params, queue.id)","def create_dag_specific_permissions(self) -> None:\n perms = self.get_all_permissions()\n dagbag = DagBag(read_dags_from_db=True)\n dagbag.collect_dags_from_db()\n dags = dagbag.dags.values()\n\n for dag in dags:\n root_dag_id = dag.parent_dag.dag_id if dag.parent_dag else dag.dag_id\n dag_resource_name = permissions.resource_name_for_dag(root_dag_id)\n for action_name in self.DAG_ACTIONS:\n if (action_name, dag_resource_name) not in perms:\n self._merge_perm(action_name, dag_resource_name)\n\n if dag.access_control:\n self.sync_perm_for_dag(dag_resource_name, dag.access_control)","def add_permission(self, permission: str):\n setattr(self.scopes, permission, True)\n self.save(update_fields=[\"scopes\"])","def approve (self, response) :\n if 'event' in response and 'moderator' in response :\n eventId = response ['event']\n userId = response ['moderator']\n else :\n raise ModerationError (response)\n\n mod_status = 'OK'\n if 'status' in response :\n mod_status = response ['status']\n \n event = Event.object.get (id = eventId)\n approval = Approval (approved = event, moderatorId = userId, status = mod_status)\n approval.save ()\n self.editValues (event.answer, response)","def test_valid_admin_approval(self):\n\n new_user = self.registration_profile.objects.create_inactive_user(\n site=Site.objects.get_current(), **self.user_info)\n profile = self.registration_profile.objects.get(user=new_user)\n user, activated = self.registration_profile.objects.activate_user(\n profile.activation_key, Site.objects.get_current())\n\n self.assertIsInstance(user, UserModel())\n\n user = self.registration_profile.objects.admin_approve_user(\n profile.id, Site.objects.get_current())\n self.assertIsInstance(user, UserModel())\n self.assertIs(user.is_active, True)","def create_user_as_admin(self, *args, **kwargs):\n profile = self.create_user(*args, **kwargs)\n profile.make_administrator()\n return profile","def has_permission(self, request, view):\n return request.user.group == 'admin'","def __add_permission_to_group(self, group: Group) -> None:\n for permission_codename in main_app_groups[group.name]:\n permission = Permission.objects.get(codename=permission_codename)\n group.permissions.add(permission)","def addUserPermission(self, name, _type):\n self._client.addUserPermission(name, _type)","def update_course_creator_group(caller, user, add):\r\n if add:\r\n auth.add_users(caller, CourseCreatorRole(), user)\r\n else:\r\n auth.remove_users(caller, CourseCreatorRole(), user)","def test_approve_agreement(self):\n pass","def test_census_area_create_agency_restriction(client, user_staff, superuser):\n client.force_login(user_staff)\n url = reverse('census-areas-create')\n staff_response = client.get(url)\n assert staff_response.status_code == 200\n\n field = staff_response.context['form'].fields['restrict_by_agency']\n assert field.initial is True\n assert isinstance(field.widget, HiddenInput)\n\n client.force_login(superuser)\n sup_response = client.get(url)\n assert sup_response.status_code == 200\n\n field = sup_response.context['form'].fields['restrict_by_agency']\n assert field.initial is True\n assert isinstance(field.widget, CheckboxInput)","def on_model_change(self, form, model, is_created):\n if not current_user.is_active or not current_user.is_authenticated:\n abort(403)\n elif is_created:\n if not user_has_permission(current_user, 'can_create','admins'):\n abort(403)\n else:\n if not user_has_permission(current_user, 'can_edit','admins'):\n abort(403)","def __create_new_permission(self, codename, **kwargs) -> None:\n permission = Permission(codename=codename, **kwargs)\n permission.save()"],"string":"[\n \"def write_authorize(cls, user, obj):\\n if not obj.delivery.deadline.assignment_group.is_examiner(user):\\n raise PermissionDenied()\",\n \"def write_authorize(cls, user, obj):\\n if not models.AssignmentGroup.published_where_is_examiner(user).filter(id=obj.deadline.assignment_group.id):\\n raise PermissionDenied()\\n cls.write_authorize_examinercommon(user, obj)\",\n \"def add_user_with_status_granted(caller, user):\\r\\n if _add_user(user, CourseCreator.GRANTED):\\r\\n update_course_creator_group(caller, user, True)\",\n \"def need_admin_approval(self, need_admin_approval):\\n\\n self._need_admin_approval = need_admin_approval\",\n \"def create_permission(permission, event):\\n setDefaultRoles(permission.title, ('Manager',))\",\n \"def write_authorize(cls, user, obj):\\n if not obj.assignment_group.is_examiner(user):\\n raise PermissionDenied()\",\n \"def assign_permissions(sender, instance, created, **kwargs):\\n if created:\\n assign_perm('view_strand', instance.owner.group, instance)\\n assign_perm('change_strand', instance.saver, instance)\\n assign_perm('delete_strand', instance.saver, instance)\\n assign_perm('view_strand', instance.saver, instance)\",\n \"def post_access_control_list_create(self, resource_dict):\\n pass\",\n \"def remove_permissions(apps, schema_editor):\\n\\n Permission = apps.get_model(\\\"auth\\\", \\\"Permission\\\")\\n Group = apps.get_model(\\\"auth\\\", \\\"Group\\\")\\n\\n permission = Permission.objects.get(\\n codename=\\\"can_approve_estimated_completion_date\\\",\\n )\\n\\n admin_group = Group.objects.get(name=\\\"Administrator\\\")\\n admin_group.permissions.remove(permission)\\n permission.delete()\\n\\n print(\\n 'Permission \\\"can_approve_estimated_completion_date\\\" removed from the \\\"Admin\\\" group.'\\n )\",\n \"def update_admin_permission(self) -> None:\\n session = self.appbuilder.get_session\\n dag_resources = session.scalars(\\n select(Resource).where(Resource.name.like(f\\\"{permissions.RESOURCE_DAG_PREFIX}%\\\"))\\n )\\n resource_ids = [resource.id for resource in dag_resources]\\n\\n perms = session.scalars(select(Permission).where(~Permission.resource_id.in_(resource_ids)))\\n perms = [p for p in perms if p.action and p.resource]\\n\\n admin = self.find_role(\\\"Admin\\\")\\n admin.permissions = list(set(admin.permissions) | set(perms))\\n\\n session.commit()\",\n \"def allowed_organization_access_create(user):\\n return user.has_perm(\\\"vnswww.add_organization\\\")\",\n \"def add_admin(user):\\n _add_owner(\\n _lookup_user(user).biv_id,\\n _add_model(pam.Admin())\\n )\",\n \"def need_admin_approval(self):\\n return self._need_admin_approval\",\n \"def test_add_permission(self):\\r\\n self.assertFalse(self.creator_admin.has_add_permission(self.request))\",\n \"def set_permission(sender, instance, created, **kwargs):\\n if created:\\n assign_perm(\\n \\\"website.can_see\\\",\\n instance.author,\\n instance,\\n )\",\n \"def add_view_permissions(sender, instance, created, **kwargs):\\n if created:\\n group = Group.objects.get(name=settings.DEFAULT_GROUP_NAME)\\n assign_perm('view_tag', group, instance)\",\n \"def can_assign(userid, group):\",\n \"def pre_access_control_list_create(self, resource_dict):\\n pass\",\n \"def get_assign_permission(userid, group):\",\n \"def assign_contributor_permissions(obj, contributor=None):\\n obj.set_permission(Permission.highest(), contributor or obj.contributor)\",\n \"def can_approve(self, user, **data):\\n raise Return(False)\",\n \"def add_permission(self, label, aws_account_id, action_name):\\r\\n return self.connection.add_permission(self, label, aws_account_id, action_name)\",\n \"def grant_set_account_detail_perms(self, user):\\n tx = self.iroha.transaction(\\n [\\n self.iroha.command(\\n \\\"GrantPermission\\\",\\n account_id=f\\\"{self.creator_account_details.gov_id}@afyamkononi\\\",\\n permission=can_set_my_account_detail,\\n )\\n ],\\n creator_account=f\\\"{user.gov_id}@afyamkononi\\\",\\n )\\n IrohaCrypto.sign_transaction(tx, user.private_key)\\n return self.send_transaction_and_return_status(tx)\",\n \"def create_custom_permissions(self) -> None:\\n self.add_permission_view_menu(\\\"all_datasource_access\\\", \\\"all_datasource_access\\\")\\n self.add_permission_view_menu(\\\"all_database_access\\\", \\\"all_database_access\\\")\\n self.add_permission_view_menu(\\\"all_query_access\\\", \\\"all_query_access\\\")\\n self.add_permission_view_menu(\\\"can_share_dashboard\\\", \\\"Superset\\\")\\n self.add_permission_view_menu(\\\"can_share_chart\\\", \\\"Superset\\\")\",\n \"def user_requested_access(user):\\r\\n user = CourseCreator.objects.get(user=user)\\r\\n if user.state != CourseCreator.GRANTED:\\r\\n user.state = CourseCreator.PENDING\\r\\n user.save()\",\n \"def test_add_facility_pt1(self):\\n self.assertFalse(self.admin.has_perm('auth.add_facility'))\",\n \"def RequestedPermissions(self) -> _n_6_t_0:\",\n \"def UpdateAccessApprovalSettings(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details(\\\"Method not implemented!\\\")\\n raise NotImplementedError(\\\"Method not implemented!\\\")\",\n \"def get_permissions_map(self, created):\\n current_user = self.context['request'].user\\n company = get_object_or_404(models.Company, pk=self.data['id'])\\n admins = company.admins\\n accountants = company.accountants\\n current_user.groups.add(admins)\\n current_user.groups.add(accountants)\\n assign_perm(\\\"change_group\\\", admins, admins)\\n assign_perm(\\\"change_group\\\", admins, accountants)\\n assign_perm(\\\"delete_group\\\", admins, admins)\\n assign_perm(\\\"delete_group\\\", admins, accountants)\\n return {\\n 'view_company': [admins, accountants],\\n 'change_company': [admins],\\n 'delete_company': [admins]\\n }\",\n \"def job_post_save(sender, instance, created, **kwargs):\\n\\n if created:\\n jp = JobPermission.objects.create(\\n job=instance,\\n content_object=instance.user,\\n permission=JobPermissionLevel.ADMIN.value,\\n )\\n jp.save()\",\n \"def test_staff_permission_required(self):\\r\\n with self.assertRaises(PermissionDenied):\\r\\n add_user_with_status_granted(self.user, self.user)\\r\\n\\r\\n with self.assertRaises(PermissionDenied):\\r\\n update_course_creator_group(self.user, self.user, True)\",\n \"def add_group_email_grant(self, permission, email_address, headers=None):\\r\\n acl = self.get_acl(headers=headers)\\r\\n acl.add_group_email_grant(permission, email_address)\\r\\n self.set_acl(acl, headers=headers)\",\n \"def require_permissions(self, user, feature, gate, new_state):\\n is_requesting_review = (new_state == Vote.REVIEW_REQUESTED)\\n is_editor = permissions.can_edit_feature(user, feature.key.integer_id())\\n approvers = approval_defs.get_approvers(gate.gate_type)\\n is_approver = permissions.can_approve_feature(user, feature, approvers)\\n\\n if is_requesting_review and is_editor:\\n return\\n\\n if is_approver:\\n return\\n\\n if is_requesting_review:\\n self.abort(403, msg='User may not request a review')\\n else:\\n self.abort(403, msg='User is not an approver')\",\n \"def add_email_grant(self, permission, email_address):\\r\\n acl = self.get_acl()\\r\\n acl.add_email_grant(permission, email_address)\\r\\n self.set_acl(acl)\",\n \"def approve(self, feedback=None):\\n self.hit.generate_connection()\\n self.hit.connection.approve_assignment(self.mturk_id, feedback=feedback)\\n self.update()\",\n \"def manage_afterAdd(self, item, container) :\\n item.manage_permission(Permissions.AddPortalContent,\\n ['Manager'])\\n item.manage_permission(Permissions.AccessContentsInformation,\\n ['Member', 'Manager'])\\n item.manage_permission(Permissions.View,\\n ['Manager',])\\n BaseTool.inheritedAttribute('manage_afterAdd')(self, item, container)\",\n \"def add_administrator(self, project_id, name, email):\\n self._run(\\n url_path=\\\"contributors/add\\\",\\n id=project_id,\\n name=name,\\n email=email,\\n admin=True\\n )\\n return True\",\n \"def create_permission( # pylint: disable=inconsistent-return-statements\\n self,\\n share_permission: IO,\\n timeout: Optional[int] = None,\\n *,\\n content_type: str = \\\"application/json\\\",\\n **kwargs: Any\\n ) -> None:\",\n \"def add_email_grant(self, permission, email_address, headers=None):\\r\\n policy = self.get_acl(headers=headers)\\r\\n policy.acl.add_email_grant(permission, email_address)\\r\\n self.set_acl(policy, headers=headers)\",\n \"def approve(self):\\n self._check_if_open()\\n data = {\\\"approved\\\": True}\\n return self.post(\\\"approve\\\", data)\",\n \"def handle(self, *args, **options):\\r\\n username = 'populate_creators_command'\\r\\n email = 'grant+creator+access@edx.org'\\r\\n try:\\r\\n admin = User.objects.create_user(username, email, 'foo')\\r\\n admin.is_staff = True\\r\\n admin.save()\\r\\n except IntegrityError:\\r\\n # If the script did not complete the last time it was run,\\r\\n # the admin user will already exist.\\r\\n admin = User.objects.get(username=username, email=email)\\r\\n\\r\\n for user in get_users_with_role(CourseInstructorRole.ROLE):\\r\\n add_user_with_status_granted(admin, user)\\r\\n\\r\\n # Some users will be both staff and instructors. Those folks have been\\r\\n # added with status granted above, and add_user_with_status_unrequested\\r\\n # will not try to add them again if they already exist in the course creator database.\\r\\n for user in get_users_with_role(CourseStaffRole.ROLE):\\r\\n add_user_with_status_unrequested(user)\\r\\n\\r\\n # There could be users who are not in either staff or instructor (they've\\r\\n # never actually done anything in Studio). I plan to add those as unrequested\\r\\n # when they first go to their dashboard.\\r\\n\\r\\n admin.delete()\",\n \"def authorization_date(self, authorization_date):\\n\\n self._authorization_date = authorization_date\",\n \"def add_email_grant(self, permission, email_address):\\n acl = self.get_acl()\\n acl.add_email_grant(permission, email_address)\\n self.set_acl(acl)\",\n \"def has_add_permission(self, request):\\r\\n return False\",\n \"def has_add_permission(self, request):\\r\\n return False\",\n \"def test_create_with_permissions(self):\\n permissions = Permission.objects.filter(name__in=('Can add course mode', 'Can change course mode'))\\n for permission in permissions:\\n self.user.user_permissions.add(permission)\\n\\n self.assert_can_create_course()\",\n \"def admin_actions():\\n\\n create_default_admin()\\n return response('Admin account has been created', 201)\",\n \"def on_model_change(self, form, model, is_created):\\n if not current_user.is_active or not current_user.is_authenticated:\\n abort(403)\\n elif is_created:\\n if not user_has_permission(current_user, 'can_create', 'advisorapplicants'):\\n abort(403)\\n else:\\n if not user_has_permission(current_user, 'can_edit', 'advisorapplicants'):\\n abort(403)\",\n \"def add_group_grant(self, permission, group_id):\\r\\n acl = self.get_acl()\\r\\n acl.add_group_grant(permission, group_id)\\r\\n self.set_acl(acl)\",\n \"def addFlowPermission(self, msgContent):\\n self.permissionCt += 1\\n if (self.permissionCt % 1000) == 0:\\n compTime = time.time() - self.time\\n self.time = time.time()\\n print (\\\"%s permissions added (in OFX manager) (%s sec)\\\"%(self.permissionCt, compTime))\\n self.ofxAgent.sendToDp(self.MODULEID, ADDFLOWPERMISSION, msgContent)\",\n \"def test_create_delegate_limit(self):\\n # Create new user and grant delegate role\\n new_user = self.make_user('new_user')\\n self.make_assignment(self.project, new_user, self.role_delegate)\\n url = reverse(\\n 'projectroles:api_role_create',\\n kwargs={'project': self.project.sodar_uuid},\\n )\\n post_data = {\\n 'role': PROJECT_ROLE_DELEGATE,\\n 'user': str(self.assign_user.sodar_uuid),\\n }\\n # NOTE: Post as owner\\n response = self.request_knox(url, method='POST', data=post_data)\\n self.assertEqual(response.status_code, 400, msg=response.content)\",\n \"def task_create_permission(supertask, user, onelevel=True, onlyauthors=False):\\n if supertask == None: # If there is no supertask, then everyone can create the task\\n return True\\n if user.user.is_staff:\\n return True\\n if onlyauthors == True: # Checking if user is author of supertask of current task if onlyauthors set to True\\n if user == supertask.author:\\n return True\\n elif user in supertask.responsible_users.all() or user == supertask.author: # Otherwise check if user is author or is in responsible users' list\\n return True\\n if onelevel == False: # If onelevel set to False, check the same for supertask, with onlyauthors set to True\\n return task_create_permission(supertask.super_task, user, onelevel=False, onlyauthors=True)\",\n \"def has_add_permission(self, request: HttpRequest) -> bool:\\n return False\",\n \"def approve_public_credit_name(self):\\n self.public_credit_name_approved = True\\n self.save()\",\n \"def approve(self, admin_membership):\\n if admin_membership.is_admin is False:\\n # TODO: Log suspicious activity\\n return None\\n\\n new_membership = InitiativeMembership()\\n new_membership.initiative = self.initiative\\n new_membership.user = self.user\\n new_membership.save()\\n\\n self.approved_by = admin_membership\\n self.is_open = False\\n self.save()\\n\\n return new_membership\",\n \"def create_acl(self, context, sg):\\n self.security_group_driver.create_acl(context, sg)\",\n \"def manage_access_approval(\\n request: AuthenticatedHttpRequest,\\n *,\\n access_request_pk: int,\\n entity: Literal[\\\"importer\\\", \\\"exporter\\\"],\\n) -> HttpResponse:\\n\\n with transaction.atomic():\\n if entity == \\\"importer\\\":\\n model_cls = ImporterAccessRequest\\n form_cls = ImporterApprovalRequestForm\\n else:\\n model_cls = ExporterAccessRequest\\n form_cls = ExporterApprovalRequestForm\\n\\n access_request = get_object_or_404(\\n model_cls.objects.select_for_update(), pk=access_request_pk\\n )\\n\\n case_progress.access_request_in_processing(access_request)\\n\\n if request.method == \\\"POST\\\":\\n form = form_cls(request.POST, access_request=access_request)\\n\\n if form.is_valid():\\n approval_request = form.save(commit=False)\\n approval_request.status = ApprovalRequest.Statuses.OPEN\\n approval_request.access_request = access_request\\n approval_request.requested_by = request.user\\n approval_request.save()\\n send_approval_request_opened_email(approval_request)\\n return redirect(\\n reverse(\\n \\\"access:case-management-access-approval\\\",\\n kwargs={\\\"access_request_pk\\\": access_request.pk, \\\"entity\\\": entity},\\n )\\n )\\n else:\\n approval_request = access_request.approval_requests.filter(is_active=True).first()\\n form = form_cls(instance=approval_request, access_request=access_request)\\n\\n context = {\\n \\\"case_type\\\": \\\"access\\\",\\n \\\"process\\\": access_request,\\n \\\"form\\\": form,\\n \\\"approval_request\\\": approval_request,\\n \\\"entity\\\": entity,\\n }\\n\\n return render(\\n request=request,\\n template_name=\\\"web/domains/case/access/management-access-approval.html\\\",\\n context=context,\\n )\",\n \"def test_add_admin_to_org(self):\\n pass\",\n \"def AddAclSample():\\n client = CreateClient()\\n doc = gdata.docs.data.Resource(type='document', title='My Sample Doc')\\n doc = client.CreateResource(doc)\\n acl_entry = gdata.docs.data.AclEntry(\\n scope=gdata.acl.data.AclScope(value='user@example.com', type='user'),\\n role=gdata.acl.data.AclRole(value='reader'),\\n )\\n client.AddAclEntry(doc, acl_entry, send_notifications=False)\",\n \"def give_permissions(self):\\n self._activate()\\n self.configure(state=\\\"enabled\\\")\",\n \"def allowed_group_access_create(user, org=None):\\n try:\\n up = user.get_profile()\\n except AttributeError:\\n return False\\n\\n if org is None:\\n return (user.has_perm(\\\"vnswww.group_add_any\\\")\\n or user.has_perm(\\\"vnswww.group_add_org\\\"))\\n else:\\n return (user.has_perm(\\\"vnswww.group_add_any\\\")\\n or (user.has_perm(\\\"vnswww.group_add_org\\\")\\n and org == up.org))\",\n \"def at_object_creation(self):\\n self.locks.add(\\\"view:perm(Immortals)\\\")\",\n \"def approve(self):\\n if (self.status == self.APPROVED):\\n pass\\n\\n print ('starting approval process by adding events to the primary cal')\\n\\n primary_calendar = self.course.calendar_courses.get(primary=True)\\n # print ('primary = ' + primary_calendar)\\n for event in self.events.all():\\n d = event.date\\n start = datetime.datetime(d.year, d.month, d.day)\\n start = timezone.make_aware(start, timezone.get_current_timezone())\\n start = start + datetime.timedelta(hours=8)\\n end = start + datetime.timedelta(hours=1)\\n\\n params = {\\n 'calendar': primary_calendar,\\n 'title': event.title,\\n 'start': start,\\n 'end': end\\n }\\n CalendarEvent.objects.create(**params)\\n event.approved = True\\n event.save()\\n\\n print ('trying to set syllabus to approved')\\n\\n try:\\n syllabus = self.syllabus.all()[0]\\n syllabus.approved = True\\n syllabus.course = self.course\\n syllabus.save()\\n except:\\n print ('dang, that failed, but continuing nonetheless.')\\n pass\\n\\n\\n print ('creating students from roster-students')\\n\\n\\n for student in self.students.all():\\n email = student.email\\n if email:\\n user = utils.get_or_create_user(email, student.first_name, student.last_name)\\n school = self.course.domain\\n user_student = utils.get_or_create_student(school, user)\\n\\n self.course.enroll_by_roster(user_student, self)\\n\\n student.approved = True\\n student.save()\\n\\n print ('instructors')\\n\\n for instructor in self.instructors.all():\\n instructor.approved = True\\n instructor.save()\\n\\n print ('approving done')\\n\\n\\n self.status = self.APPROVED\\n self.save()\\n\\n add_notification(\\n self.created_by.user,\\n 'Your class set for {}, is approved and published!'.format(self.course)\\n )\",\n \"def test_approve(self):\\n\\n username,userpass = self.testdata.find_account_for('toolsubmitter')\\n\\n self.utils.account.login_as(username,userpass)\\n\\n self.contribtool.approve(TOOLNAME,TOOLLICENSEDATA)\",\n \"def get_everyone_granted(self):\",\n \"def _setup_ip_allowing(self, ip_list, role_suffix):\\n # Create new user\\n user = self.make_user(role_suffix)\\n # Set user access\\n if role_suffix == 'owner':\\n self.owner_as.user = user\\n self.owner_as.save()\\n # user_as = self.owner_as\\n self.owner_as_cat.user = user\\n self.owner_as_cat.save()\\n else:\\n self.make_assignment(\\n self.project, user, getattr(self, 'role_' + role_suffix)\\n )\\n # Init IP restrict setting\\n self.make_setting(\\n app_name='projectroles',\\n name='ip_restrict',\\n setting_type='BOOLEAN',\\n value=True,\\n project=self.project,\\n )\\n # Init IP allowlist setting\\n self.make_setting(\\n app_name='projectroles',\\n name='ip_allowlist',\\n setting_type='JSON',\\n value=None,\\n value_json=ip_list,\\n project=self.project,\\n )\\n return user # , user_as, self.cat_owner_as\",\n \"def approve_user_application(self, user):\\n if self.is_moderator and \\\\\\n self.has_perm('accounts.approve_user_application'):\\n user.moderator = self\\n user.moderator_decision = user.APPROVED\\n user.decision_datetime = timezone.now()\\n user.auth_token = generate_unique_id()\\n user.save()\\n\\n return user\\n\\n else:\\n raise PermissionDenied\",\n \"def allow_access(course, user, level):\\r\\n _change_access(course, user, level, 'allow')\",\n \"def access_granted(valid_token_dict, template, title):\\n policy = config_get('policy', 'permission')\\n return render_template(template, token=valid_token_dict['token'], account=valid_token_dict['account'], vo=valid_token_dict['vo'], policy=policy, title=title)\",\n \"def should_auto_approve(self):\\r\\n if self.group and self.group.allow_auto_approval:\\r\\n return True\\r\\n\\r\\n # some orders (like those duplicated by CIT) will not have owners\\r\\n if self.is_multilevel_approval():\\r\\n if self.has_all_approver_roles(self.owner, self.group):\\r\\n return True\\r\\n return False\\r\\n\\r\\n else:\\r\\n if self.owner and self.owner.has_permission('order.approve', self.group):\\r\\n return True\\r\\n\\r\\n return False\",\n \"def at_the_bottom_of_the_Edit_Permissions_page_click_on_Set_ACL(driver):\\n assert wait_on_element(driver, 5, '//h1[text()=\\\"Edit Permissions\\\"]')\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SET ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SET ACL\\\"]').click()\\n time.sleep(1)\\n assert wait_on_element_disappear(driver, 30, '//h6[contains(.,\\\"Please wait\\\")]')\",\n \"def on_access_approved(self, handler):\\n print \\\"User with {0} has been GRANTED access.\\\".format(\\n handler.client_address[0]\\n )\",\n \"def completion_date(self, completion_date):\\n\\n self._completion_date = completion_date\",\n \"def test_add_facility_pt2(self):\\n self.assertFalse(self.coach1.has_perm('auth.add_facility'))\",\n \"def create_task(self, name, date, isComplete):\\n user = User.objects.create(username='userdemo')\\n user.set_password('calnote24')\\n user.save()\\n Task.objects.create(task=name, dueDate=date, isComplete=isComplete, user_id=user.id)\",\n \"def has_add_permission(self, request):\\n return False\",\n \"def has_add_permission(self, request):\\n return False\",\n \"async def add_client_permission_async(\\n action: int,\\n client_id: str,\\n resource: str,\\n x_additional_headers: Optional[Dict[str, str]] = None,\\n **kwargs\\n):\\n request = AddClientPermission.create(\\n action=action,\\n client_id=client_id,\\n resource=resource,\\n )\\n return await run_request_async(\\n request, additional_headers=x_additional_headers, **kwargs\\n )\",\n \"def save(self, commit):\\n preset = super().save(commit)\\n # Remove all permissions on the preset.\\n preset.permission_group.permissions.all().delete()\\n # Add permission to selected groups.\\n for group in Group.objects.filter(pk__in=self.cleaned_data[\\\"groups\\\"]):\\n preset.set_permission(Permission.VIEW, group)\\n return preset\",\n \"def approve(self, request, object_id, extra_context=None):\\n obj = self.get_object(request, unquote(object_id))\\n title = self._approve_title(obj)\\n\\n AdminAddApprovalForm = self._approve_approval_form(request)\\n\\n form = AdminAddApprovalForm(initial={'prescription': obj})\\n if request.method == 'POST':\\n url = reverse('admin:prescription_prescription_detail',\\n args=[str(obj.id)])\\n if obj.approval_status == obj.APPROVAL_DRAFT and obj.can_approve:\\n # create an approval\\n obj.approval_status = obj.APPROVAL_SUBMITTED\\n obj.approval_status_modified = timezone.now()\\n obj.save()\\n self.message_user(\\n request, \\\"Successfully submitted for approval.\\\")\\n return HttpResponseRedirect(url)\\n elif obj.approval_status == obj.APPROVAL_SUBMITTED:\\n if request.POST.get('_cancel'):\\n obj.clear_approvals()\\n msg = 'Delete: Clearing Approvals/Endorsements', 'Burn ID: {}, Deleted by: {}'. format(obj.burn_id, request.user.get_full_name())\\n logger.warning(msg)\\n support_email('Delete: Clearing Approvals/Endorsements', msg)\\n\\n self.message_user(\\n request, \\\"Approval rejected. ePFP is now draft.\\\")\\n return HttpResponseRedirect(url)\\n\\n form = AdminAddApprovalForm(request.POST,\\n initial={'prescription': obj})\\n if form.is_valid():\\n approval = form.save(commit=False)\\n approval.prescription = obj\\n approval.creator = request.user\\n approval.modifier = request.user\\n approval.save()\\n obj.approval_status = obj.APPROVAL_APPROVED\\n obj.approval_status_modified = timezone.now()\\n obj.save()\\n self.message_user(\\n request, \\\"Successfully approved.\\\")\\n return HttpResponseRedirect(url)\\n elif obj.is_approved:\\n if obj.is_closed:\\n self.message_user(\\n request, \\\"You can't extend an approval after the \\\"\\n \\\"prescribed fire plan has been closed.\\\")\\n return HttpResponseRedirect(url)\\n if request.POST.get('_cancel'):\\n self.message_user(\\n request, \\\"Didn't extend approval.\\\")\\n return HttpResponseRedirect(url)\\n else:\\n approval = obj.current_approval\\n if approval and approval.extension_count < 3:\\n approval.extension_count = approval.extension_count + 1\\n approval.valid_to = approval.next_valid_to\\n approval.save()\\n self.message_user(\\n request, \\\"Successfully extended approval.\\\")\\n else:\\n self.message_user(request, \\\"You can't extend an \\\"\\n \\\"approval more than 3 times.\\\")\\n return HttpResponseRedirect(url)\\n\\n admin_form, media = self._approve_form(request, obj, form)\\n\\n context = {\\n 'title': title,\\n 'current': obj,\\n 'form': admin_form,\\n 'media': media,\\n 'errors': None,\\n }\\n return TemplateResponse(request, \\\"admin/prescription/prescription/\\\"\\n \\\"approval.html\\\", context,\\n current_app=self.admin_site.name)\",\n \"def test_aid_creation_requires_contributor(client, user):\\n\\n client.force_login(user)\\n form_url = reverse('aid_create_view')\\n res = client.get(form_url, follow=True)\\n assert res.status_code == 200\\n assert len(res.redirect_chain) == 1\\n assert res.redirect_chain[0][0].startswith('/comptes/profil-contributeur/')\",\n \"def create(self, validated_data):\\n user = super(UserSerializer, self).create(validated_data)\\n for i in user.groups.all():\\n if i.accountants.exists():\\n company = get_object_or_404(\\n models.Company, pk=i.accountants.all().first().id)\\n assign_perm(\\\"change_user\\\", company.admins, user)\\n assign_perm(\\\"view_user\\\", company.admins, user)\\n assign_perm(\\\"delete_user\\\", company.admins, user)\\n assign_perm(\\\"change_user\\\", user, user)\\n assign_perm(\\\"view_user\\\", user, user)\\n assign_perm(\\\"delete_user\\\", user, user)\\n\\n user.user_permissions.add(\\n Permission.objects.get(name='Can add sale'))\\n user.user_permissions.add(\\n Permission.objects.get(name='Can delete sale'))\\n user.user_permissions.add(\\n Permission.objects.get(name='Can add purchase'))\\n user.user_permissions.add(\\n Permission.objects.get(name='Can change sale'))\\n user.user_permissions.add(\\n Permission.objects.get(name='Can change purchase'))\\n user.user_permissions.add(\\n Permission.objects.get(name='Can delete purchase'))\\n user.user_permissions.add(\\n Permission.objects.get(name='Can add media'))\\n user.user_permissions.add(\\n Permission.objects.get(name='Can delete media'))\\n user.set_password(validated_data['password'])\\n user.save()\\n return user\",\n \"def increaseApproval(_spender: address, _addedValue: uint256) -> bool:\\n\\n self.allowed[msg.sender][_spender] += _addedValue\\n log.Approval(msg.sender, _spender, self.allowed[msg.sender][_spender])\\n return True\",\n \"def add_client_permission(\\n action: int,\\n client_id: str,\\n resource: str,\\n x_additional_headers: Optional[Dict[str, str]] = None,\\n **kwargs\\n):\\n request = AddClientPermission.create(\\n action=action,\\n client_id=client_id,\\n resource=resource,\\n )\\n return run_request(request, additional_headers=x_additional_headers, **kwargs)\",\n \"def test_add_facility_pt3(self):\\n self.assertFalse(self.learner1.has_perm('auth.add_facility'))\",\n \"def test_create_delegate_limit_inherit(self):\\n # Set up category owner\\n new_user = self.make_user('new_user')\\n self.owner_as_cat.user = new_user\\n\\n url = reverse(\\n 'projectroles:api_role_create',\\n kwargs={'project': self.project.sodar_uuid},\\n )\\n post_data = {\\n 'role': PROJECT_ROLE_DELEGATE,\\n 'user': str(self.assign_user.sodar_uuid),\\n }\\n # NOTE: Post as owner\\n response = self.request_knox(url, method='POST', data=post_data)\\n\\n self.assertEqual(response.status_code, 201, msg=response.content)\\n self.assertEqual(\\n RoleAssignment.objects.filter(project=self.project).count(), 2\\n )\\n role_as = RoleAssignment.objects.filter(\\n project=self.project, role=self.role_delegate, user=self.assign_user\\n ).first()\\n self.assertIsNotNone(role_as)\",\n \"def add_permission(self, queue, label, aws_account_id, action_name):\\r\\n params = {'Label': label,\\r\\n 'AWSAccountId' : aws_account_id,\\r\\n 'ActionName' : action_name}\\r\\n return self.get_status('AddPermission', params, queue.id)\",\n \"def create_dag_specific_permissions(self) -> None:\\n perms = self.get_all_permissions()\\n dagbag = DagBag(read_dags_from_db=True)\\n dagbag.collect_dags_from_db()\\n dags = dagbag.dags.values()\\n\\n for dag in dags:\\n root_dag_id = dag.parent_dag.dag_id if dag.parent_dag else dag.dag_id\\n dag_resource_name = permissions.resource_name_for_dag(root_dag_id)\\n for action_name in self.DAG_ACTIONS:\\n if (action_name, dag_resource_name) not in perms:\\n self._merge_perm(action_name, dag_resource_name)\\n\\n if dag.access_control:\\n self.sync_perm_for_dag(dag_resource_name, dag.access_control)\",\n \"def add_permission(self, permission: str):\\n setattr(self.scopes, permission, True)\\n self.save(update_fields=[\\\"scopes\\\"])\",\n \"def approve (self, response) :\\n if 'event' in response and 'moderator' in response :\\n eventId = response ['event']\\n userId = response ['moderator']\\n else :\\n raise ModerationError (response)\\n\\n mod_status = 'OK'\\n if 'status' in response :\\n mod_status = response ['status']\\n \\n event = Event.object.get (id = eventId)\\n approval = Approval (approved = event, moderatorId = userId, status = mod_status)\\n approval.save ()\\n self.editValues (event.answer, response)\",\n \"def test_valid_admin_approval(self):\\n\\n new_user = self.registration_profile.objects.create_inactive_user(\\n site=Site.objects.get_current(), **self.user_info)\\n profile = self.registration_profile.objects.get(user=new_user)\\n user, activated = self.registration_profile.objects.activate_user(\\n profile.activation_key, Site.objects.get_current())\\n\\n self.assertIsInstance(user, UserModel())\\n\\n user = self.registration_profile.objects.admin_approve_user(\\n profile.id, Site.objects.get_current())\\n self.assertIsInstance(user, UserModel())\\n self.assertIs(user.is_active, True)\",\n \"def create_user_as_admin(self, *args, **kwargs):\\n profile = self.create_user(*args, **kwargs)\\n profile.make_administrator()\\n return profile\",\n \"def has_permission(self, request, view):\\n return request.user.group == 'admin'\",\n \"def __add_permission_to_group(self, group: Group) -> None:\\n for permission_codename in main_app_groups[group.name]:\\n permission = Permission.objects.get(codename=permission_codename)\\n group.permissions.add(permission)\",\n \"def addUserPermission(self, name, _type):\\n self._client.addUserPermission(name, _type)\",\n \"def update_course_creator_group(caller, user, add):\\r\\n if add:\\r\\n auth.add_users(caller, CourseCreatorRole(), user)\\r\\n else:\\r\\n auth.remove_users(caller, CourseCreatorRole(), user)\",\n \"def test_approve_agreement(self):\\n pass\",\n \"def test_census_area_create_agency_restriction(client, user_staff, superuser):\\n client.force_login(user_staff)\\n url = reverse('census-areas-create')\\n staff_response = client.get(url)\\n assert staff_response.status_code == 200\\n\\n field = staff_response.context['form'].fields['restrict_by_agency']\\n assert field.initial is True\\n assert isinstance(field.widget, HiddenInput)\\n\\n client.force_login(superuser)\\n sup_response = client.get(url)\\n assert sup_response.status_code == 200\\n\\n field = sup_response.context['form'].fields['restrict_by_agency']\\n assert field.initial is True\\n assert isinstance(field.widget, CheckboxInput)\",\n \"def on_model_change(self, form, model, is_created):\\n if not current_user.is_active or not current_user.is_authenticated:\\n abort(403)\\n elif is_created:\\n if not user_has_permission(current_user, 'can_create','admins'):\\n abort(403)\\n else:\\n if not user_has_permission(current_user, 'can_edit','admins'):\\n abort(403)\",\n \"def __create_new_permission(self, codename, **kwargs) -> None:\\n permission = Permission(codename=codename, **kwargs)\\n permission.save()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61045885","0.5988743","0.5814144","0.5738462","0.5411797","0.5401533","0.5399722","0.5363404","0.53633904","0.53270596","0.52686125","0.523226","0.52310044","0.5126954","0.51135796","0.5107107","0.5074804","0.5071565","0.50627375","0.5031271","0.5008885","0.49773142","0.49759695","0.49613628","0.49506733","0.4934149","0.49292016","0.4926475","0.49207848","0.48922914","0.488994","0.48587042","0.4855047","0.48442554","0.48431927","0.483907","0.48142722","0.48119146","0.4803091","0.48015687","0.4800192","0.4795675","0.47902793","0.47881532","0.47881532","0.47835726","0.47660536","0.47600245","0.47402528","0.47369716","0.47350743","0.4732755","0.4731663","0.47295806","0.4726093","0.4724714","0.47223926","0.4719962","0.47189084","0.47136348","0.4710915","0.47095954","0.47050583","0.46834284","0.4675792","0.46719882","0.4671449","0.46696737","0.46666482","0.46594593","0.46506268","0.46497193","0.46403915","0.46388018","0.46340314","0.46214327","0.46214327","0.46190122","0.46171203","0.4613511","0.46107098","0.45922762","0.45882964","0.45873073","0.4583621","0.45788416","0.45719564","0.4568199","0.45661214","0.45644188","0.4562626","0.45589718","0.45566127","0.45510504","0.4545837","0.45442596","0.4542973","0.4542787","0.45292467","0.4527597"],"string":"[\n \"0.61045885\",\n \"0.5988743\",\n \"0.5814144\",\n \"0.5738462\",\n \"0.5411797\",\n \"0.5401533\",\n \"0.5399722\",\n \"0.5363404\",\n \"0.53633904\",\n \"0.53270596\",\n \"0.52686125\",\n \"0.523226\",\n \"0.52310044\",\n \"0.5126954\",\n \"0.51135796\",\n \"0.5107107\",\n \"0.5074804\",\n \"0.5071565\",\n \"0.50627375\",\n \"0.5031271\",\n \"0.5008885\",\n \"0.49773142\",\n \"0.49759695\",\n \"0.49613628\",\n \"0.49506733\",\n \"0.4934149\",\n \"0.49292016\",\n \"0.4926475\",\n \"0.49207848\",\n \"0.48922914\",\n \"0.488994\",\n \"0.48587042\",\n \"0.4855047\",\n \"0.48442554\",\n \"0.48431927\",\n \"0.483907\",\n \"0.48142722\",\n \"0.48119146\",\n \"0.4803091\",\n \"0.48015687\",\n \"0.4800192\",\n \"0.4795675\",\n \"0.47902793\",\n \"0.47881532\",\n \"0.47881532\",\n \"0.47835726\",\n \"0.47660536\",\n \"0.47600245\",\n \"0.47402528\",\n \"0.47369716\",\n \"0.47350743\",\n \"0.4732755\",\n \"0.4731663\",\n \"0.47295806\",\n \"0.4726093\",\n \"0.4724714\",\n \"0.47223926\",\n \"0.4719962\",\n \"0.47189084\",\n \"0.47136348\",\n \"0.4710915\",\n \"0.47095954\",\n \"0.47050583\",\n \"0.46834284\",\n \"0.4675792\",\n \"0.46719882\",\n \"0.4671449\",\n \"0.46696737\",\n \"0.46666482\",\n \"0.46594593\",\n \"0.46506268\",\n \"0.46497193\",\n \"0.46403915\",\n \"0.46388018\",\n \"0.46340314\",\n \"0.46214327\",\n \"0.46214327\",\n \"0.46190122\",\n \"0.46171203\",\n \"0.4613511\",\n \"0.46107098\",\n \"0.45922762\",\n \"0.45882964\",\n \"0.45873073\",\n \"0.4583621\",\n \"0.45788416\",\n \"0.45719564\",\n \"0.4568199\",\n \"0.45661214\",\n \"0.45644188\",\n \"0.4562626\",\n \"0.45589718\",\n \"0.45566127\",\n \"0.45510504\",\n \"0.4545837\",\n \"0.45442596\",\n \"0.4542973\",\n \"0.4542787\",\n \"0.45292467\",\n \"0.4527597\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76646936"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":13297,"cells":{"query":{"kind":"string","value":"Remove \"can_approve_estimated_completion_date\" permission and remove it from the \"Admin\" group."},"document":{"kind":"string","value":"def remove_permissions(apps, schema_editor):\n\n Permission = apps.get_model(\"auth\", \"Permission\")\n Group = apps.get_model(\"auth\", \"Group\")\n\n permission = Permission.objects.get(\n codename=\"can_approve_estimated_completion_date\",\n )\n\n admin_group = Group.objects.get(name=\"Administrator\")\n admin_group.permissions.remove(permission)\n permission.delete()\n\n print(\n 'Permission \"can_approve_estimated_completion_date\" removed from the \"Admin\" group.'\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def delPermission(self,request):\n request.needAuthType(request.ADMIN)\n request.checkArgs(\"admin_username\",\"perm_name\")\n request.getAuthNameObj().canDo(\"CHANGE ADMIN PERMISSIONS\")\n perm_actions.getActionManager().deletePermission(request[\"admin_username\"],request[\"perm_name\"])","def update_admin_permission(self) -> None:\n session = self.appbuilder.get_session\n dag_resources = session.scalars(\n select(Resource).where(Resource.name.like(f\"{permissions.RESOURCE_DAG_PREFIX}%\"))\n )\n resource_ids = [resource.id for resource in dag_resources]\n\n perms = session.scalars(select(Permission).where(~Permission.resource_id.in_(resource_ids)))\n perms = [p for p in perms if p.action and p.resource]\n\n admin = self.find_role(\"Admin\")\n admin.permissions = list(set(admin.permissions) | set(perms))\n\n session.commit()","def remove_permissions(self):\n self._activate()\n self.configure(state=\"disabled\")","def add_permissions(apps, schema_editor):\n\n Permission = apps.get_model(\"auth\", \"Permission\")\n Group = apps.get_model(\"auth\", \"Group\")\n ContentType = apps.get_model(\"contenttypes\", \"ContentType\")\n\n permission, created = Permission.objects.get_or_create(\n codename=\"can_approve_estimated_completion_date\",\n defaults={\n \"name\": \"Can approve estimated completion date\",\n \"content_type\": ContentType.objects.get_for_model(\n apps.get_model(\"barriers\", \"Barrier\")\n ),\n },\n )\n\n admin_group = Group.objects.get(name=\"Administrator\")\n admin_group.permissions.add(permission)\n\n print(\n 'Permission \"can_approve_estimated_completion_date\" added to the \"Admin\" group.'\n )","def remove_access(acl, list_to_edit):\n post_key = '%s_remove_' % list_to_edit\n removal_keys = [k for k in request.POST.keys() if k.startswith(post_key)]\n for key in removal_keys:\n model_type = models.UserGroup\n if list_to_edit.startswith('user'):\n model_type = models.UserProfile\n key_id = int(key.replace(post_key, ''))\n datastore_object = model_type.get_by_id(key_id)\n acl.__getattribute__(list_to_edit).remove(datastore_object.key())","def DeleteAccessApprovalSettings(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")","def remove_permission(self, label):\r\n return self.connection.remove_permission(self, label)","def need_admin_approval(self, need_admin_approval):\n\n self._need_admin_approval = need_admin_approval","def delPermissionValue(self,request):\n request.needAuthType(request.ADMIN)\n request.checkArgs(\"admin_username\",\"perm_name\",\"perm_value\")\n request.getAuthNameObj().canDo(\"CHANGE ADMIN PERMISSIONS\")\n perm_actions.getActionManager().deleteFromPermValues(request[\"admin_username\"],request[\"perm_name\"],\n request[\"perm_value\"])","def make_donor(self):\n self.user.is_staff = False\n self.user.is_superuser = False\n self.user.groups.remove(get_group_by_name(self.ADMIN_GROUP))\n self.user.groups.remove(get_group_by_name(self.AMBASSADOR_GROUP))\n self.user.save()","def test_remove_facility_pt1(self):\n self.assertFalse(self.admin.has_perm('auth.remove_facility'))","def unmake_admin(self):\n user_datastore = SQLAlchemyUserDatastore(db, User, Role)\n user_datastore.remove_role_from_user(self, 'admin')\n db.session.commit()","def Run(self, args):\n p = parent.GetParent(args)\n return settings.Delete(name=('%s/accessApprovalSettings' % p))","def strip_restrict_access(self):\n att_name = \"restrictAccess\"\n att_dict = self.top_level_dataset.attrib\n if att_name in att_dict:\n del att_dict[att_name]","def __check_removed_permissions(self) -> None:\n for permission in Permission.objects.all():\n if not self.__is_permission_allowed_to_delete(permission):\n continue\n\n if self.__is_permission_in_groups(permission.codename):\n raise PermissionInUse(f'Permission {permission.codename} is used in groups. Delete it first.')\n\n permission.delete()\n\n self.stdout.write(f'Removed {permission.codename} permission')","def test_permission_remove_all_actions_for_user(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('permission remove anonymous *')\n rv, output = self._execute('permission list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)","def remove_admin(user):\n user_biv_id = _lookup_user(user).biv_id\n admin = pam.Admin.query.select_from(pam.BivAccess).filter(\n pam.BivAccess.source_biv_id == user_biv_id,\n pam.BivAccess.target_biv_id == pam.Admin.biv_id\n ).one()\n db.session.delete(\n pam.BivAccess.query.filter(\n pam.BivAccess.source_biv_id == user_biv_id,\n pam.BivAccess.target_biv_id == admin.biv_id\n ).one()\n )\n db.session.delete(admin)","def _remove_group_rights(object_id, workspace, request_user):\n group = group_api.get_group_by_id(object_id)\n workspace_api.remove_group_read_access_to_workspace(workspace, group, request_user)\n workspace_api.remove_group_write_access_to_workspace(workspace, group, request_user)","def revoke_set_account_detail_perms(self, user):\n tx = self.iroha.transaction(\n [\n self.iroha.command(\n \"RevokePermission\",\n account_id=f\"{self.creator_account_details.gov_id}@afyamkononi\",\n permission=can_set_my_account_detail,\n )\n ],\n creator_account=f\"{user.gov_id}@afyamkononi\",\n )\n IrohaCrypto.sign_transaction(tx, user.private_key)\n return self.send_transaction_and_return_status(tx)","def pre_access_control_list_delete(self, resource_id):\n pass","def remove_admin(self, project_id, user_id):\n current_user = request.environ.get('repoze.who.identity')['user']\n user = controller_globals._get_user_from_email(current_user.email)\n\n # make sure we're actually the project lead\n if not self._current_user_leads_review(project_id):\n return \"<font color='red'>tsk, tsk. you're not the project lead, %s.</font>\" % user.fullname\n\n leader_to_remove = Session.query(model.User).filter_by(id=user_id).one()\n review = self._get_review_from_id(project_id)\n review.leaders.remove(leader_to_remove)\n Session.add(review)\n Session.commit()\n\n redirect(url(controller=\"review\", action=\"admin\", project_id=project_id))","def remove_access(self, access_group):\n\n if self.has_auth_access(access_group):\n self.access_groups.remove(access_group)","def admins_remove(request):\n if len(models.User.admins()) > 1:\n username = request.params['remove']\n user = models.User.get_by_username(username)\n user.admin = False\n return httpexceptions.HTTPSeeOther(\n location=request.route_url('admin_admins'))","def write_authorize(cls, user, obj):\n if not obj.delivery.deadline.assignment_group.is_examiner(user):\n raise PermissionDenied()","def test_remove_facility_pt2(self):\n self.assertFalse(self.coach1.has_perm('auth.remove_facility'))","def test_remove_learner_group_specific_for_coach_pt2(self):\n self.assertFalse(self.coach1.has_perm('auth.remove_learner_group', self.learner_groups[1]))","def on_model_delete(self, model):\n if not current_user.is_active or not current_user.is_authenticated:\n abort(403)\n if not user_has_permission(current_user, 'can_delete', 'advisorapplicants'):\n abort(403)","def has_remove_permissions(self, obj):\n return True","def remove_permission(self, perm):\n if self.has_permission(perm):\n self.permissions -= perm","def test_permission_remove_one_action_ok(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('permission remove anonymous TICKET_MODIFY')\n rv, output = self._execute('permission list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)","def unapprove(self):\n self._check_if_open()\n return super(BitbucketCloudBase, self).delete(\"approve\")","def write_authorize(cls, user, obj):\n if not models.AssignmentGroup.published_where_is_examiner(user).filter(id=obj.deadline.assignment_group.id):\n raise PermissionDenied()\n cls.write_authorize_examinercommon(user, obj)","def reindex_licence_permissions(container, event):\n if IUrbanEvent.providedBy(container):\n licence = container.aq_parent\n licence.reindexObject(idxs=['allowedRolesAndUsers'])","def remove_staff_list_group(apps, schema_editor):\n Group.objects.filter(name=constants.GROUP_STAFF_LISTS_EDITORS).delete()","def test_permission_remove_action_not_granted(self):\n test_name = sys._getframe().f_code.co_name\n rv, output = self._execute('permission remove anonymous TICKET_CREATE')\n self.assertEqual(2, rv)\n self.assertEqual(self.expected_results[test_name], output)","def test_remove_learner_group_specific_for_coach_pt1(self):\n self.assertTrue(self.coach1.has_perm('auth.remove_learner_group', self.learner_groups[0]))","def octopus_permissions_clear(self, msg, args):\r\n return self.permissions.clear_permissions()","def test_remove_facility_pt3(self):\n self.assertFalse(self.learner1.has_perm('auth.remove_facility'))","def remove_permission(self, queue, label):\r\n params = {'Label': label}\r\n return self.get_status('RemovePermission', params, queue.id)","def reset_permissions(self):\n self.permissions = 0","def test_permission_remove_action_for_all_users(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('permission add anonymous TICKET_CREATE')\n self._execute('permission remove * TICKET_CREATE')\n rv, output = self._execute('permission list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)","def post_access_control_list_delete(self, resource_id, resource_dict):\n pass","def restricted(func):\n @wraps(func)\n def wrapped(bot, update, *args, **kwargs):\n user_id = update.effective_user.id\n if user_id not in LIST_OF_ADMINS:\n print(\"Unauthorized access denied for {}.\".format(user_id))\n # tell the unauthorized user to go away\n update.message.reply_text('Go away.')\n return\n return func(bot, update, *args, **kwargs)\n return wrapped","def cleanup_docrules_permissions():\n content_type, created = ContentType.objects.get_or_create(app_label='rule', model='', name='document type')\n permissions = Permission.objects.filter(content_type=content_type)\n for p in permissions:\n p.delete()\n #print 'Deleted all permissions for each DocumentTypeRule()'","def delete_acl(self, sg):\n self.security_group_driver.delete_acl(sg)","def delete_access_list(self):\n return self.manager.delete_access_list(self)","def test_delete_admin_from_org(self):\n pass","def cmd_remadmin_private(self, argument):\n if self.is_admin:\n users = argument.split()\n for user in users:\n self.bot.admins.remove(user)\n self.send(self.nick, _(\"User %s removed from admins\"), user)\n self.logger.info(\"User %s removed %s from admins\" % (self.nick, user))\n else:\n self.logger.warning(\"User %s tried to use '%s' without being admin\" % (self.nick, \"remadmin\"))","def drop_privileges(user, group):\n new_uid = pwd.getpwnam(user).pw_uid\n new_gid = grp.getgrnam(group).gr_gid\n# os.chdir(root)\n# os.chroot(root)\n os.setgroups([])\n os.setgid(new_gid)\n os.setuid(new_uid)","def test_forbidden_non_dcc_analyst(self):\n phenotype_taggers = Group.objects.get(name='dcc_analysts')\n self.user.groups.remove(phenotype_taggers)\n self.user.is_staff = False\n self.user.save()\n self.user.refresh_from_db()\n response = self.client.get(self.get_url(self.trait.pk))\n self.assertEqual(response.status_code, 403)","def revoke_access(course, user, level):\r\n _change_access(course, user, level, 'revoke')","def UpdateAccessApprovalSettings(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details(\"Method not implemented!\")\n raise NotImplementedError(\"Method not implemented!\")","async def approve(self, ctx, user: discord.Member):\n server = ctx.message.server\n if user.id in self.norole[server.id]:\n if self.norole[server.id][user.id]['Role'] == True:\n self.norole[server.id][user.id] = {'Role': False}\n dataIO.save_json(self.warninglist, self.norole)\n nobnl = discord.utils.get(server.roles, name = \"NoBNL\")\n await self.bot.remove_roles(user,nobnl)\n msg = await self.bot.say (\"Role removed!\")\n await asyncio.sleep(8)\n await self.bot.delete_message(msg) \n await self.bot.delete_message(ctx.message)\n else:\n msg = await self.bot.say(\"There is no role to remove!\")\n await asyncio.sleep(8)\n await self.bot.delete_message(msg)\n await self.bot.delete_message(ctx.message)","def test_permission_remove_multiple_actions_ok(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('permission remove anonymous WIKI_CREATE WIKI_MODIFY')\n rv, output = self._execute('permission list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)","def updateOrgAdmins(request):\n\n return updateRole('gsoc_org_admin')","def test_public_status_page_remove_authorization_from_public_status_page(self):\n pass","def pre_security_group_delete(self, resource_id):\n pass","def test_delete_permission(self):\r\n self.assertFalse(self.creator_admin.has_delete_permission(self.request))","async def rmadmin(self, ctx, user: discord.Member):\n self.settings.rmAdmin(user.id)\n await ctx.send(\"done\")","def _reset_admin(self):\r\n DBSession.execute(\r\n \"UPDATE users SET activated='1' WHERE username='admin';\")\r\n Activation.query.delete()\r\n transaction.commit()","def cmd_disable_private(self, argument):\n if self.is_admin:\n self.bot.admins.remove(self.nick)\n self.send(self.nick, _(\"User %s removed from admins\"), self.nick)\n self.logger.info(\"User %s removed from admins\" % self.nick)","def test_remove_authz_wrong(self):\n self.test_add_authz()\n self.app.delete(\"/config/authorize?operation=config\", status=400)\n self.app.delete(\"/config/authorize?dn=/DN=a.test.user\", status=204)","def on_model_delete(self, model):\n if not current_user.is_active or not current_user.is_authenticated:\n abort(403)\n if not user_has_permission(current_user, 'can_delete','admins'):\n abort(403)","def need_admin_approval(self):\n return self._need_admin_approval","def deleteUserPermission(self, name, _type):\n self._client.deleteUserPermission(name, _type)","def _remove_user_rights(object_id, workspace, request_user):\n user = user_api.get_user_by_id(object_id)\n workspace_api.remove_user_read_access_to_workspace(workspace, user, request_user)\n workspace_api.remove_user_write_access_to_workspace(workspace, user, request_user)","def test_remove_facility_pt4(self):\n with self.assertRaises(InvalidPermission):\n self.assertFalse(self.learner1.has_perm('auth.remove_facility', obj=[]))","def write_authorize(cls, user, obj):\n if not obj.assignment_group.is_examiner(user):\n raise PermissionDenied()","def _DeleteAclRule(self, entry):\n\n self.cal_client.Delete(entry.GetEditLink().href)","def allowed_group_access_delete(user, group):\n try:\n up = user.get_profile()\n except AttributeError:\n return False\n\n return (user.has_perm(\"vnswww.group_delete_any\")\n or (user.has_perm(\"vnswww.group_delete_org\")\n and group.org == up.org))","def test_delete_assigned_resource_by_non_admin(self):\n CommonTestCases.user_token_assert_in(\n self,\n delete_assigned_resource_mutation,\n \"You are not authorized to perform this action\"\n )","def reset_permissions(user_uuid_hexed):\n key = f\"perms_{user_uuid_hexed}\"\n return cache.delete(key)","def at_the_bottom_of_the_Edit_Permissions_page_click_on_Set_ACL(driver):\n assert wait_on_element(driver, 5, '//h1[text()=\"Edit Permissions\"]')\n assert wait_on_element(driver, 5, '//button[@ix-auto=\"button__SET ACL\"]', 'clickable')\n driver.find_element_by_xpath('//button[@ix-auto=\"button__SET ACL\"]').click()\n time.sleep(1)\n assert wait_on_element_disappear(driver, 30, '//h6[contains(.,\"Please wait\")]')","async def permissions_remove(\n self,\n ctx,\n type_: str.lower,\n name: str,\n *,\n user_or_role: Union[Role, utils.User, str] = None,\n ):\n if type_ not in {\"command\", \"level\", \"override\"} or (\n type_ != \"override\" and user_or_role is None\n ):\n return await ctx.send_help(ctx.command)\n\n if type_ == \"override\":\n extension = ctx.kwargs[\"user_or_role\"]\n if extension is not None:\n name += f\" {extension}\"\n name = name.lower()\n name = getattr(self.bot.get_command(name), \"qualified_name\", name)\n level = self.bot.config[\"override_command_level\"].get(name)\n if level is None:\n perm = self.bot.command_perm(name)\n embed = Embed(\n title=\"Error\",\n color=Color.red(),\n description=f\"The command permission level was never overridden: `{name}`, \"\n f\"current permission level is {perm.name}.\",\n )\n else:\n logger.info(\"Restored command permission level for `%s`.\", name)\n self.bot.config[\"override_command_level\"].pop(name)\n await self.bot.config.update()\n perm = self.bot.command_perm(name)\n embed = Embed(\n title=\"Success\",\n color=self.bot.main_color,\n description=f\"Command permission level for `{name}` was successfully restored to {perm.name}.\",\n )\n return await ctx.send(embed=embed)\n\n level = None\n if type_ == \"command\":\n name = name.lower()\n name = getattr(self.bot.get_command(name), \"qualified_name\", name)\n else:\n level = self._parse_level(name)\n if level is PermissionLevel.INVALID:\n embed = Embed(\n title=\"Error\",\n color=Color.red(),\n description=f\"The referenced level does not exist: `{name}`.\",\n )\n return await ctx.send(embed=embed)\n name = level.name\n\n value = self._verify_user_or_role(user_or_role)\n await self.bot.update_perms(level or name, value, add=False)\n\n if type_ == \"level\":\n if level > PermissionLevel.REGULAR:\n if value == -1:\n logger.info(\"Denying @everyone access to Modmail category.\")\n await self.bot.main_category.set_permissions(\n self.bot.modmail_guild.default_role, read_messages=False\n )\n elif isinstance(user_or_role, Role):\n logger.info(\n \"Denying %s access to Modmail category.\", user_or_role.name\n )\n await self.bot.main_category.set_permissions(\n user_or_role, overwrite=None\n )\n else:\n member = self.bot.modmail_guild.get_member(value)\n if member is not None and member != self.bot.modmail_guild.me:\n logger.info(\n \"Denying %s access to Modmail category.\", member.name\n )\n await self.bot.main_category.set_permissions(\n member, overwrite=None\n )\n\n embed = Embed(\n title=\"Success\",\n color=self.bot.main_color,\n description=f\"Permission for `{name}` was successfully updated.\",\n )\n return await ctx.send(embed=embed)","def drop_privileges(new_user=None): \n global _saved_uid, _saved_gid, _save_groups\n _saved_uid = None\n _saved_gid = None\n _save_groups = None\n\n new_uid, new_gid = _get_uid_gid(new_user)\n result = True\n \n # Set group/groups\n if not _set_group(new_gid):\n result = False\n \n # Set real, effective and saved uid \n if setresuid:\n if setresuid(new_uid, new_uid, new_uid) != 0:\n result = False\n else:\n try:\n os.setuid(new_uid)\n except:\n result = False\n if setreuid and setreuid(new_uid, new_uid) != 0:\n result = False\n\n # Check the new effective user id\n if os.geteuid() != new_uid:\n result = False\n return result","def remove_access_request_field(self):\n self.fields = XML_List(Elements.FIELDS, [field for field in self.fields if\n field.FIELD_CONTENT_ATTRIBUTES != Elements.ACCESS_REQUESTS])","def removePermission(self, permission, auth_name, is_group, extra_params):\n\n with DBSession(self.__config_db) as session:\n perm, params = ThriftAuthHandler.__create_permission_args(\n permission, extra_params, session)\n\n if not require_manager(perm, params, self.__auth_session):\n raise codechecker_api_shared.ttypes.RequestFailed(\n codechecker_api_shared.ttypes.ErrorCode.UNAUTHORIZED,\n \"You can not manage the permission '{0}'\"\n .format(perm.name))\n\n handler = make_handler(perm, params)\n handler.remove_permission(auth_name, is_group,\n user_name=self.getLoggedInUser())\n\n session.commit()\n return True","def share_group_type_access_remove(context, type_id, project_id):\n share_group_type_id = _share_group_type_get_id_from_share_group_type(\n context, type_id)\n count = _share_group_type_access_query(context).filter_by(\n share_group_type_id=share_group_type_id,\n ).filter_by(\n project_id=project_id,\n ).soft_delete(\n synchronize_session=False,\n )\n if count == 0:\n raise exception.ShareGroupTypeAccessNotFound(\n type_id=share_group_type_id, project_id=project_id)","def delete_image_permissions(Name=None, SharedAccountId=None):\n pass","def DeniedPermissions(self) -> _n_6_t_0:","def test_remove_user_from_course_group_permission_denied(self):\r\n add_users(self.global_admin, CourseInstructorRole(self.course_key), self.creator)\r\n another_staff = User.objects.create_user('another', 'teststaff+anothercourses@edx.org', 'foo')\r\n add_users(self.global_admin, CourseStaffRole(self.course_key), self.creator, self.staff, another_staff)\r\n with self.assertRaises(PermissionDenied):\r\n remove_users(self.staff, CourseStaffRole(self.course_key), another_staff)","def test_remove_is_staff(self):\n self.user.is_staff = False\n self.user.save()\n self.user.refresh_from_db()\n response = self.client.get(self.get_url())\n self.assertEqual(response.status_code, 403)","def test_remove_is_staff(self):\n self.user.is_staff = False\n self.user.save()\n self.user.refresh_from_db()\n response = self.client.get(self.get_url())\n self.assertEqual(response.status_code, 403)","def test_remove_is_staff(self):\n self.user.is_staff = False\n self.user.save()\n self.user.refresh_from_db()\n response = self.client.get(self.get_url())\n self.assertEqual(response.status_code, 403)","def KLP_Revoke_Permissions(request, permissionType):\n\n # check logged in user permissions\n\n KLP_user_Perm(request.user, 'Users', None)\n\n # get user id to revoke permissions\n\n user_id = request.POST.get('userId')\n opStatus = 'success'\n try:\n if permissionType == 'permissions':\n\n # if permissiontype is permissions revoke institution permissions for the user\n\n userObj = User.objects.get(pk=user_id)\n\n # get institution list to revoke\n\n instList = request.POST.getlist('assignedInst')\n for inst_id in instList:\n instObj = Institution.objects.get(pk=inst_id)\n\n # revoke permission for user\n\n userObj.revoke('Acess', instObj)\n else:\n\n # else revoke assessment permissions\n\n assignedAsmList = request.POST.getlist('assignedAsm')\n for userAsm_id in assignedAsmList:\n\n # get UserAssessmentPermissions object\n\n permObj = \\\n UserAssessmentPermissions.objects.get(pk=userAsm_id)\n permObj.access = False # revoke permissions\n permObj.save()\n except:\n opStatus = 'fail'\n\n # if revoke permission fail return response as fail else return success.\n\n return HttpResponse(opStatus)","def revoke(self, group, repo):\r\n url = '{0}/group-privileges/{1}/{2}/{1}/{3}/'.format(\r\n self.parent.parent.get_url(), self.user, repo, group)\r\n\r\n return http.Request('DELETE', url), parsers.parse_empty","def remove_acl(self, **kwargs):\n # Validate required and accepted parameters\n params_validator.validate_params_slx_ver17s_apply_acl(**kwargs)\n\n # Parse params\n acl_name = self.ip.parse_acl_name(**kwargs)\n callback = kwargs.pop('callback', self._callback)\n acl = self._get_acl_info(acl_name, get_seqs=False)\n address_type = acl['protocol']\n\n kwargs['address_type'] = address_type\n # Parse params\n user_data = self._parse_params_for_apply_or_remove_acl(**kwargs)\n\n self.validate_interfaces(callback, user_data)\n\n result = {}\n for intf in user_data['interface_list']:\n user_data['intf'] = intf\n t = jinja2.Template(acl_template.acl_remove)\n config = t.render(**user_data)\n config = ' '.join(config.split())\n try:\n callback(config)\n result[intf] = True\n except Exception as e:\n if '<bad-element>access-group</bad-element>' in str(e):\n result[intf] = None\n else:\n raise\n return result","def save(self, commit):\n preset = super().save(commit)\n # Remove all permissions on the preset.\n preset.permission_group.permissions.all().delete()\n # Add permission to selected groups.\n for group in Group.objects.filter(pk__in=self.cleaned_data[\"groups\"]):\n preset.set_permission(Permission.VIEW, group)\n return preset","def decreaseApproval(_spender: address, _subtractedValue: uint256) -> bool:\n\n if(_subtractedValue >= self.allowed[msg.sender][_spender]):\n self.allowed[msg.sender][_spender] = 0\n else:\n self.allowed[msg.sender][_spender] -= _subtractedValue\n\n log.Approval(msg.sender, _spender, self.allowed[msg.sender][_spender])\n return True","def delete_groups_and_permissions_for_recipes(apps, schema_editor):\n Group = apps.get_model('auth', 'Group')\n Permission = apps.get_model('auth', 'Permission')\n # Delete the recipe_submitters group.\n recipe_submitters = Group.objects.get(name='recipe_submitters')\n recipe_submitters.delete()\n # Remove permissions for recipes to the dcc groups.\n recipe_permissions = Permission.objects.filter(content_type__app_label='recipes',\n content_type__model__in=('unitrecipe', 'harmonizationrecipe'))\n developers = Group.objects.get(name='dcc_developers')\n developers.permissions.remove(*recipe_permissions)\n analysts = Group.objects.get(name='dcc_analysts')\n analysts.permissions.remove(*recipe_permissions)","def delete(self):\n\n context = t_context.extract_context_from_environ()\n if not context.is_admin:\n # TODO(joahuang): changed to policy control later\n # to support reseller admin mode\n return Response(_('Admin role required to delete quota'), 409)\n\n kw = {}\n return self._quota_action('delete', **kw)","def remove_permission_from_bucket(bucket_name, role_type, member_type):\n\n # initialize client & get bucket\n _, bucket, _ = create_client(bucket_name)\n\n policy = bucket.get_iam_policy(requested_policy_version=3)\n \n # get member type\n member_value = get_member_bucket_level(member_type)\n\n # get role type\n role_value = get_role_bucket_level(role_type)\n\n for binding in policy.bindings:\n # print(binding)\n if binding[\"role\"] == role_value and binding.get(\"condition\") is None:\n # revoke role from member\n binding[\"members\"].discard(member_value)\n\n bucket.set_iam_policy(policy)\n\n print(\"removed {} with role {} from {}\".format(member_value, role_value, bucket_name))","def test_requester_is_no_admin(self) -> None:\n\n channel = self.make_request(\n \"DELETE\",\n self.url,\n access_token=self.other_user_tok,\n )\n\n self.assertEqual(403, channel.code, msg=channel.json_body)\n self.assertEqual(Codes.FORBIDDEN, channel.json_body[\"errcode\"])","def on_model_delete(self, model):\n if not current_user.is_active or not current_user.is_authenticated:\n abort(403)\n if not user_has_permission(current_user, 'can_delete', 'advisors'):\n abort(403)","def remove_from_group(_request, group_id, email):\n group = models.UserGroup.get_by_id(int(group_id))\n user_key = models.UserProfile.load(email).key()\n if group.users is None:\n group.users = []\n logging.warning('Group \"%s\" had a None users list' % group.name)\n group.users.remove(user_key)\n group.put()\n\n url = urlresolvers.reverse('views.admin.edit_user', args=[email])\n return http.HttpResponseRedirect(url)","def _sync_dag_view_permissions(self, dag_id: str, access_control: dict[str, Collection[str]]) -> None:\n dag_resource_name = permissions.resource_name_for_dag(dag_id)\n\n def _get_or_create_dag_permission(action_name: str) -> Permission | None:\n perm = self.get_permission(action_name, dag_resource_name)\n if not perm:\n self.log.info(\"Creating new action '%s' on resource '%s'\", action_name, dag_resource_name)\n perm = self.create_permission(action_name, dag_resource_name)\n\n return perm\n\n def _revoke_stale_permissions(resource: Resource):\n existing_dag_perms = self.get_resource_permissions(resource)\n for perm in existing_dag_perms:\n non_admin_roles = [role for role in perm.role if role.name != \"Admin\"]\n for role in non_admin_roles:\n target_perms_for_role = access_control.get(role.name, ())\n if perm.action.name not in target_perms_for_role:\n self.log.info(\n \"Revoking '%s' on DAG '%s' for role '%s'\",\n perm.action,\n dag_resource_name,\n role.name,\n )\n self.remove_permission_from_role(role, perm)\n\n resource = self.get_resource(dag_resource_name)\n if resource:\n _revoke_stale_permissions(resource)\n\n for rolename, action_names in access_control.items():\n role = self.find_role(rolename)\n if not role:\n raise AirflowException(\n f\"The access_control mapping for DAG '{dag_id}' includes a role named \"\n f\"'{rolename}', but that role does not exist\"\n )\n\n action_names = set(action_names)\n invalid_action_names = action_names - self.DAG_ACTIONS\n if invalid_action_names:\n raise AirflowException(\n f\"The access_control map for DAG '{dag_resource_name}' includes \"\n f\"the following invalid permissions: {invalid_action_names}; \"\n f\"The set of valid permissions is: {self.DAG_ACTIONS}\"\n )\n\n for action_name in action_names:\n dag_perm = _get_or_create_dag_permission(action_name)\n if dag_perm:\n self.add_permission_to_role(role, dag_perm)","def delete_TestGroupResourcePermission(test_case, # type: AnyMagpieTestCaseType\n resource_info=null, # type: Optional[JSON]\n override_resource_id=null, # type: Optional[int]\n override_permission=null, # type: Optional[AnyPermissionType]\n override_group_name=null, # type: Optional[Str]\n override_headers=null, # type: Optional[HeadersType]\n override_cookies=null, # type: Optional[CookiesType]\n ignore_missing=True, # type: bool\n ): # type: (...) -> JSON\n result = TestSetup.update_TestAnyResourcePermission(\n test_case, \"group\", \"DELETE\", resource_info=resource_info,\n override_resource_id=override_resource_id, override_permission=override_permission,\n override_item_name=override_group_name, override_headers=override_headers, override_cookies=override_cookies\n )\n if not ignore_missing:\n check_val_equal(result[\"code\"], 200)\n return result","def changeOwnership(self, document):\n document.changeOwnership(getSecurityManager().getUser(), False)","def test_remove_user_from_course_group(self):\r\n add_users(self.global_admin, CourseInstructorRole(self.course_key), self.creator)\r\n add_users(self.global_admin, CourseStaffRole(self.course_key), self.creator)\r\n\r\n add_users(self.creator, CourseStaffRole(self.course_key), self.staff)\r\n self.assertTrue(has_access(self.staff, CourseStaffRole(self.course_key)))\r\n\r\n remove_users(self.creator, CourseStaffRole(self.course_key), self.staff)\r\n self.assertFalse(has_access(self.staff, CourseStaffRole(self.course_key)))\r\n\r\n remove_users(self.creator, CourseInstructorRole(self.course_key), self.creator)\r\n self.assertFalse(has_access(self.creator, CourseInstructorRole(self.course_key)))","def delete_required(required):\n required.delete_required()"],"string":"[\n \"def delPermission(self,request):\\n request.needAuthType(request.ADMIN)\\n request.checkArgs(\\\"admin_username\\\",\\\"perm_name\\\")\\n request.getAuthNameObj().canDo(\\\"CHANGE ADMIN PERMISSIONS\\\")\\n perm_actions.getActionManager().deletePermission(request[\\\"admin_username\\\"],request[\\\"perm_name\\\"])\",\n \"def update_admin_permission(self) -> None:\\n session = self.appbuilder.get_session\\n dag_resources = session.scalars(\\n select(Resource).where(Resource.name.like(f\\\"{permissions.RESOURCE_DAG_PREFIX}%\\\"))\\n )\\n resource_ids = [resource.id for resource in dag_resources]\\n\\n perms = session.scalars(select(Permission).where(~Permission.resource_id.in_(resource_ids)))\\n perms = [p for p in perms if p.action and p.resource]\\n\\n admin = self.find_role(\\\"Admin\\\")\\n admin.permissions = list(set(admin.permissions) | set(perms))\\n\\n session.commit()\",\n \"def remove_permissions(self):\\n self._activate()\\n self.configure(state=\\\"disabled\\\")\",\n \"def add_permissions(apps, schema_editor):\\n\\n Permission = apps.get_model(\\\"auth\\\", \\\"Permission\\\")\\n Group = apps.get_model(\\\"auth\\\", \\\"Group\\\")\\n ContentType = apps.get_model(\\\"contenttypes\\\", \\\"ContentType\\\")\\n\\n permission, created = Permission.objects.get_or_create(\\n codename=\\\"can_approve_estimated_completion_date\\\",\\n defaults={\\n \\\"name\\\": \\\"Can approve estimated completion date\\\",\\n \\\"content_type\\\": ContentType.objects.get_for_model(\\n apps.get_model(\\\"barriers\\\", \\\"Barrier\\\")\\n ),\\n },\\n )\\n\\n admin_group = Group.objects.get(name=\\\"Administrator\\\")\\n admin_group.permissions.add(permission)\\n\\n print(\\n 'Permission \\\"can_approve_estimated_completion_date\\\" added to the \\\"Admin\\\" group.'\\n )\",\n \"def remove_access(acl, list_to_edit):\\n post_key = '%s_remove_' % list_to_edit\\n removal_keys = [k for k in request.POST.keys() if k.startswith(post_key)]\\n for key in removal_keys:\\n model_type = models.UserGroup\\n if list_to_edit.startswith('user'):\\n model_type = models.UserProfile\\n key_id = int(key.replace(post_key, ''))\\n datastore_object = model_type.get_by_id(key_id)\\n acl.__getattribute__(list_to_edit).remove(datastore_object.key())\",\n \"def DeleteAccessApprovalSettings(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details(\\\"Method not implemented!\\\")\\n raise NotImplementedError(\\\"Method not implemented!\\\")\",\n \"def remove_permission(self, label):\\r\\n return self.connection.remove_permission(self, label)\",\n \"def need_admin_approval(self, need_admin_approval):\\n\\n self._need_admin_approval = need_admin_approval\",\n \"def delPermissionValue(self,request):\\n request.needAuthType(request.ADMIN)\\n request.checkArgs(\\\"admin_username\\\",\\\"perm_name\\\",\\\"perm_value\\\")\\n request.getAuthNameObj().canDo(\\\"CHANGE ADMIN PERMISSIONS\\\")\\n perm_actions.getActionManager().deleteFromPermValues(request[\\\"admin_username\\\"],request[\\\"perm_name\\\"],\\n request[\\\"perm_value\\\"])\",\n \"def make_donor(self):\\n self.user.is_staff = False\\n self.user.is_superuser = False\\n self.user.groups.remove(get_group_by_name(self.ADMIN_GROUP))\\n self.user.groups.remove(get_group_by_name(self.AMBASSADOR_GROUP))\\n self.user.save()\",\n \"def test_remove_facility_pt1(self):\\n self.assertFalse(self.admin.has_perm('auth.remove_facility'))\",\n \"def unmake_admin(self):\\n user_datastore = SQLAlchemyUserDatastore(db, User, Role)\\n user_datastore.remove_role_from_user(self, 'admin')\\n db.session.commit()\",\n \"def Run(self, args):\\n p = parent.GetParent(args)\\n return settings.Delete(name=('%s/accessApprovalSettings' % p))\",\n \"def strip_restrict_access(self):\\n att_name = \\\"restrictAccess\\\"\\n att_dict = self.top_level_dataset.attrib\\n if att_name in att_dict:\\n del att_dict[att_name]\",\n \"def __check_removed_permissions(self) -> None:\\n for permission in Permission.objects.all():\\n if not self.__is_permission_allowed_to_delete(permission):\\n continue\\n\\n if self.__is_permission_in_groups(permission.codename):\\n raise PermissionInUse(f'Permission {permission.codename} is used in groups. Delete it first.')\\n\\n permission.delete()\\n\\n self.stdout.write(f'Removed {permission.codename} permission')\",\n \"def test_permission_remove_all_actions_for_user(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('permission remove anonymous *')\\n rv, output = self._execute('permission list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def remove_admin(user):\\n user_biv_id = _lookup_user(user).biv_id\\n admin = pam.Admin.query.select_from(pam.BivAccess).filter(\\n pam.BivAccess.source_biv_id == user_biv_id,\\n pam.BivAccess.target_biv_id == pam.Admin.biv_id\\n ).one()\\n db.session.delete(\\n pam.BivAccess.query.filter(\\n pam.BivAccess.source_biv_id == user_biv_id,\\n pam.BivAccess.target_biv_id == admin.biv_id\\n ).one()\\n )\\n db.session.delete(admin)\",\n \"def _remove_group_rights(object_id, workspace, request_user):\\n group = group_api.get_group_by_id(object_id)\\n workspace_api.remove_group_read_access_to_workspace(workspace, group, request_user)\\n workspace_api.remove_group_write_access_to_workspace(workspace, group, request_user)\",\n \"def revoke_set_account_detail_perms(self, user):\\n tx = self.iroha.transaction(\\n [\\n self.iroha.command(\\n \\\"RevokePermission\\\",\\n account_id=f\\\"{self.creator_account_details.gov_id}@afyamkononi\\\",\\n permission=can_set_my_account_detail,\\n )\\n ],\\n creator_account=f\\\"{user.gov_id}@afyamkononi\\\",\\n )\\n IrohaCrypto.sign_transaction(tx, user.private_key)\\n return self.send_transaction_and_return_status(tx)\",\n \"def pre_access_control_list_delete(self, resource_id):\\n pass\",\n \"def remove_admin(self, project_id, user_id):\\n current_user = request.environ.get('repoze.who.identity')['user']\\n user = controller_globals._get_user_from_email(current_user.email)\\n\\n # make sure we're actually the project lead\\n if not self._current_user_leads_review(project_id):\\n return \\\"<font color='red'>tsk, tsk. you're not the project lead, %s.</font>\\\" % user.fullname\\n\\n leader_to_remove = Session.query(model.User).filter_by(id=user_id).one()\\n review = self._get_review_from_id(project_id)\\n review.leaders.remove(leader_to_remove)\\n Session.add(review)\\n Session.commit()\\n\\n redirect(url(controller=\\\"review\\\", action=\\\"admin\\\", project_id=project_id))\",\n \"def remove_access(self, access_group):\\n\\n if self.has_auth_access(access_group):\\n self.access_groups.remove(access_group)\",\n \"def admins_remove(request):\\n if len(models.User.admins()) > 1:\\n username = request.params['remove']\\n user = models.User.get_by_username(username)\\n user.admin = False\\n return httpexceptions.HTTPSeeOther(\\n location=request.route_url('admin_admins'))\",\n \"def write_authorize(cls, user, obj):\\n if not obj.delivery.deadline.assignment_group.is_examiner(user):\\n raise PermissionDenied()\",\n \"def test_remove_facility_pt2(self):\\n self.assertFalse(self.coach1.has_perm('auth.remove_facility'))\",\n \"def test_remove_learner_group_specific_for_coach_pt2(self):\\n self.assertFalse(self.coach1.has_perm('auth.remove_learner_group', self.learner_groups[1]))\",\n \"def on_model_delete(self, model):\\n if not current_user.is_active or not current_user.is_authenticated:\\n abort(403)\\n if not user_has_permission(current_user, 'can_delete', 'advisorapplicants'):\\n abort(403)\",\n \"def has_remove_permissions(self, obj):\\n return True\",\n \"def remove_permission(self, perm):\\n if self.has_permission(perm):\\n self.permissions -= perm\",\n \"def test_permission_remove_one_action_ok(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('permission remove anonymous TICKET_MODIFY')\\n rv, output = self._execute('permission list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def unapprove(self):\\n self._check_if_open()\\n return super(BitbucketCloudBase, self).delete(\\\"approve\\\")\",\n \"def write_authorize(cls, user, obj):\\n if not models.AssignmentGroup.published_where_is_examiner(user).filter(id=obj.deadline.assignment_group.id):\\n raise PermissionDenied()\\n cls.write_authorize_examinercommon(user, obj)\",\n \"def reindex_licence_permissions(container, event):\\n if IUrbanEvent.providedBy(container):\\n licence = container.aq_parent\\n licence.reindexObject(idxs=['allowedRolesAndUsers'])\",\n \"def remove_staff_list_group(apps, schema_editor):\\n Group.objects.filter(name=constants.GROUP_STAFF_LISTS_EDITORS).delete()\",\n \"def test_permission_remove_action_not_granted(self):\\n test_name = sys._getframe().f_code.co_name\\n rv, output = self._execute('permission remove anonymous TICKET_CREATE')\\n self.assertEqual(2, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def test_remove_learner_group_specific_for_coach_pt1(self):\\n self.assertTrue(self.coach1.has_perm('auth.remove_learner_group', self.learner_groups[0]))\",\n \"def octopus_permissions_clear(self, msg, args):\\r\\n return self.permissions.clear_permissions()\",\n \"def test_remove_facility_pt3(self):\\n self.assertFalse(self.learner1.has_perm('auth.remove_facility'))\",\n \"def remove_permission(self, queue, label):\\r\\n params = {'Label': label}\\r\\n return self.get_status('RemovePermission', params, queue.id)\",\n \"def reset_permissions(self):\\n self.permissions = 0\",\n \"def test_permission_remove_action_for_all_users(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('permission add anonymous TICKET_CREATE')\\n self._execute('permission remove * TICKET_CREATE')\\n rv, output = self._execute('permission list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def post_access_control_list_delete(self, resource_id, resource_dict):\\n pass\",\n \"def restricted(func):\\n @wraps(func)\\n def wrapped(bot, update, *args, **kwargs):\\n user_id = update.effective_user.id\\n if user_id not in LIST_OF_ADMINS:\\n print(\\\"Unauthorized access denied for {}.\\\".format(user_id))\\n # tell the unauthorized user to go away\\n update.message.reply_text('Go away.')\\n return\\n return func(bot, update, *args, **kwargs)\\n return wrapped\",\n \"def cleanup_docrules_permissions():\\n content_type, created = ContentType.objects.get_or_create(app_label='rule', model='', name='document type')\\n permissions = Permission.objects.filter(content_type=content_type)\\n for p in permissions:\\n p.delete()\\n #print 'Deleted all permissions for each DocumentTypeRule()'\",\n \"def delete_acl(self, sg):\\n self.security_group_driver.delete_acl(sg)\",\n \"def delete_access_list(self):\\n return self.manager.delete_access_list(self)\",\n \"def test_delete_admin_from_org(self):\\n pass\",\n \"def cmd_remadmin_private(self, argument):\\n if self.is_admin:\\n users = argument.split()\\n for user in users:\\n self.bot.admins.remove(user)\\n self.send(self.nick, _(\\\"User %s removed from admins\\\"), user)\\n self.logger.info(\\\"User %s removed %s from admins\\\" % (self.nick, user))\\n else:\\n self.logger.warning(\\\"User %s tried to use '%s' without being admin\\\" % (self.nick, \\\"remadmin\\\"))\",\n \"def drop_privileges(user, group):\\n new_uid = pwd.getpwnam(user).pw_uid\\n new_gid = grp.getgrnam(group).gr_gid\\n# os.chdir(root)\\n# os.chroot(root)\\n os.setgroups([])\\n os.setgid(new_gid)\\n os.setuid(new_uid)\",\n \"def test_forbidden_non_dcc_analyst(self):\\n phenotype_taggers = Group.objects.get(name='dcc_analysts')\\n self.user.groups.remove(phenotype_taggers)\\n self.user.is_staff = False\\n self.user.save()\\n self.user.refresh_from_db()\\n response = self.client.get(self.get_url(self.trait.pk))\\n self.assertEqual(response.status_code, 403)\",\n \"def revoke_access(course, user, level):\\r\\n _change_access(course, user, level, 'revoke')\",\n \"def UpdateAccessApprovalSettings(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details(\\\"Method not implemented!\\\")\\n raise NotImplementedError(\\\"Method not implemented!\\\")\",\n \"async def approve(self, ctx, user: discord.Member):\\n server = ctx.message.server\\n if user.id in self.norole[server.id]:\\n if self.norole[server.id][user.id]['Role'] == True:\\n self.norole[server.id][user.id] = {'Role': False}\\n dataIO.save_json(self.warninglist, self.norole)\\n nobnl = discord.utils.get(server.roles, name = \\\"NoBNL\\\")\\n await self.bot.remove_roles(user,nobnl)\\n msg = await self.bot.say (\\\"Role removed!\\\")\\n await asyncio.sleep(8)\\n await self.bot.delete_message(msg) \\n await self.bot.delete_message(ctx.message)\\n else:\\n msg = await self.bot.say(\\\"There is no role to remove!\\\")\\n await asyncio.sleep(8)\\n await self.bot.delete_message(msg)\\n await self.bot.delete_message(ctx.message)\",\n \"def test_permission_remove_multiple_actions_ok(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('permission remove anonymous WIKI_CREATE WIKI_MODIFY')\\n rv, output = self._execute('permission list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def updateOrgAdmins(request):\\n\\n return updateRole('gsoc_org_admin')\",\n \"def test_public_status_page_remove_authorization_from_public_status_page(self):\\n pass\",\n \"def pre_security_group_delete(self, resource_id):\\n pass\",\n \"def test_delete_permission(self):\\r\\n self.assertFalse(self.creator_admin.has_delete_permission(self.request))\",\n \"async def rmadmin(self, ctx, user: discord.Member):\\n self.settings.rmAdmin(user.id)\\n await ctx.send(\\\"done\\\")\",\n \"def _reset_admin(self):\\r\\n DBSession.execute(\\r\\n \\\"UPDATE users SET activated='1' WHERE username='admin';\\\")\\r\\n Activation.query.delete()\\r\\n transaction.commit()\",\n \"def cmd_disable_private(self, argument):\\n if self.is_admin:\\n self.bot.admins.remove(self.nick)\\n self.send(self.nick, _(\\\"User %s removed from admins\\\"), self.nick)\\n self.logger.info(\\\"User %s removed from admins\\\" % self.nick)\",\n \"def test_remove_authz_wrong(self):\\n self.test_add_authz()\\n self.app.delete(\\\"/config/authorize?operation=config\\\", status=400)\\n self.app.delete(\\\"/config/authorize?dn=/DN=a.test.user\\\", status=204)\",\n \"def on_model_delete(self, model):\\n if not current_user.is_active or not current_user.is_authenticated:\\n abort(403)\\n if not user_has_permission(current_user, 'can_delete','admins'):\\n abort(403)\",\n \"def need_admin_approval(self):\\n return self._need_admin_approval\",\n \"def deleteUserPermission(self, name, _type):\\n self._client.deleteUserPermission(name, _type)\",\n \"def _remove_user_rights(object_id, workspace, request_user):\\n user = user_api.get_user_by_id(object_id)\\n workspace_api.remove_user_read_access_to_workspace(workspace, user, request_user)\\n workspace_api.remove_user_write_access_to_workspace(workspace, user, request_user)\",\n \"def test_remove_facility_pt4(self):\\n with self.assertRaises(InvalidPermission):\\n self.assertFalse(self.learner1.has_perm('auth.remove_facility', obj=[]))\",\n \"def write_authorize(cls, user, obj):\\n if not obj.assignment_group.is_examiner(user):\\n raise PermissionDenied()\",\n \"def _DeleteAclRule(self, entry):\\n\\n self.cal_client.Delete(entry.GetEditLink().href)\",\n \"def allowed_group_access_delete(user, group):\\n try:\\n up = user.get_profile()\\n except AttributeError:\\n return False\\n\\n return (user.has_perm(\\\"vnswww.group_delete_any\\\")\\n or (user.has_perm(\\\"vnswww.group_delete_org\\\")\\n and group.org == up.org))\",\n \"def test_delete_assigned_resource_by_non_admin(self):\\n CommonTestCases.user_token_assert_in(\\n self,\\n delete_assigned_resource_mutation,\\n \\\"You are not authorized to perform this action\\\"\\n )\",\n \"def reset_permissions(user_uuid_hexed):\\n key = f\\\"perms_{user_uuid_hexed}\\\"\\n return cache.delete(key)\",\n \"def at_the_bottom_of_the_Edit_Permissions_page_click_on_Set_ACL(driver):\\n assert wait_on_element(driver, 5, '//h1[text()=\\\"Edit Permissions\\\"]')\\n assert wait_on_element(driver, 5, '//button[@ix-auto=\\\"button__SET ACL\\\"]', 'clickable')\\n driver.find_element_by_xpath('//button[@ix-auto=\\\"button__SET ACL\\\"]').click()\\n time.sleep(1)\\n assert wait_on_element_disappear(driver, 30, '//h6[contains(.,\\\"Please wait\\\")]')\",\n \"async def permissions_remove(\\n self,\\n ctx,\\n type_: str.lower,\\n name: str,\\n *,\\n user_or_role: Union[Role, utils.User, str] = None,\\n ):\\n if type_ not in {\\\"command\\\", \\\"level\\\", \\\"override\\\"} or (\\n type_ != \\\"override\\\" and user_or_role is None\\n ):\\n return await ctx.send_help(ctx.command)\\n\\n if type_ == \\\"override\\\":\\n extension = ctx.kwargs[\\\"user_or_role\\\"]\\n if extension is not None:\\n name += f\\\" {extension}\\\"\\n name = name.lower()\\n name = getattr(self.bot.get_command(name), \\\"qualified_name\\\", name)\\n level = self.bot.config[\\\"override_command_level\\\"].get(name)\\n if level is None:\\n perm = self.bot.command_perm(name)\\n embed = Embed(\\n title=\\\"Error\\\",\\n color=Color.red(),\\n description=f\\\"The command permission level was never overridden: `{name}`, \\\"\\n f\\\"current permission level is {perm.name}.\\\",\\n )\\n else:\\n logger.info(\\\"Restored command permission level for `%s`.\\\", name)\\n self.bot.config[\\\"override_command_level\\\"].pop(name)\\n await self.bot.config.update()\\n perm = self.bot.command_perm(name)\\n embed = Embed(\\n title=\\\"Success\\\",\\n color=self.bot.main_color,\\n description=f\\\"Command permission level for `{name}` was successfully restored to {perm.name}.\\\",\\n )\\n return await ctx.send(embed=embed)\\n\\n level = None\\n if type_ == \\\"command\\\":\\n name = name.lower()\\n name = getattr(self.bot.get_command(name), \\\"qualified_name\\\", name)\\n else:\\n level = self._parse_level(name)\\n if level is PermissionLevel.INVALID:\\n embed = Embed(\\n title=\\\"Error\\\",\\n color=Color.red(),\\n description=f\\\"The referenced level does not exist: `{name}`.\\\",\\n )\\n return await ctx.send(embed=embed)\\n name = level.name\\n\\n value = self._verify_user_or_role(user_or_role)\\n await self.bot.update_perms(level or name, value, add=False)\\n\\n if type_ == \\\"level\\\":\\n if level > PermissionLevel.REGULAR:\\n if value == -1:\\n logger.info(\\\"Denying @everyone access to Modmail category.\\\")\\n await self.bot.main_category.set_permissions(\\n self.bot.modmail_guild.default_role, read_messages=False\\n )\\n elif isinstance(user_or_role, Role):\\n logger.info(\\n \\\"Denying %s access to Modmail category.\\\", user_or_role.name\\n )\\n await self.bot.main_category.set_permissions(\\n user_or_role, overwrite=None\\n )\\n else:\\n member = self.bot.modmail_guild.get_member(value)\\n if member is not None and member != self.bot.modmail_guild.me:\\n logger.info(\\n \\\"Denying %s access to Modmail category.\\\", member.name\\n )\\n await self.bot.main_category.set_permissions(\\n member, overwrite=None\\n )\\n\\n embed = Embed(\\n title=\\\"Success\\\",\\n color=self.bot.main_color,\\n description=f\\\"Permission for `{name}` was successfully updated.\\\",\\n )\\n return await ctx.send(embed=embed)\",\n \"def drop_privileges(new_user=None): \\n global _saved_uid, _saved_gid, _save_groups\\n _saved_uid = None\\n _saved_gid = None\\n _save_groups = None\\n\\n new_uid, new_gid = _get_uid_gid(new_user)\\n result = True\\n \\n # Set group/groups\\n if not _set_group(new_gid):\\n result = False\\n \\n # Set real, effective and saved uid \\n if setresuid:\\n if setresuid(new_uid, new_uid, new_uid) != 0:\\n result = False\\n else:\\n try:\\n os.setuid(new_uid)\\n except:\\n result = False\\n if setreuid and setreuid(new_uid, new_uid) != 0:\\n result = False\\n\\n # Check the new effective user id\\n if os.geteuid() != new_uid:\\n result = False\\n return result\",\n \"def remove_access_request_field(self):\\n self.fields = XML_List(Elements.FIELDS, [field for field in self.fields if\\n field.FIELD_CONTENT_ATTRIBUTES != Elements.ACCESS_REQUESTS])\",\n \"def removePermission(self, permission, auth_name, is_group, extra_params):\\n\\n with DBSession(self.__config_db) as session:\\n perm, params = ThriftAuthHandler.__create_permission_args(\\n permission, extra_params, session)\\n\\n if not require_manager(perm, params, self.__auth_session):\\n raise codechecker_api_shared.ttypes.RequestFailed(\\n codechecker_api_shared.ttypes.ErrorCode.UNAUTHORIZED,\\n \\\"You can not manage the permission '{0}'\\\"\\n .format(perm.name))\\n\\n handler = make_handler(perm, params)\\n handler.remove_permission(auth_name, is_group,\\n user_name=self.getLoggedInUser())\\n\\n session.commit()\\n return True\",\n \"def share_group_type_access_remove(context, type_id, project_id):\\n share_group_type_id = _share_group_type_get_id_from_share_group_type(\\n context, type_id)\\n count = _share_group_type_access_query(context).filter_by(\\n share_group_type_id=share_group_type_id,\\n ).filter_by(\\n project_id=project_id,\\n ).soft_delete(\\n synchronize_session=False,\\n )\\n if count == 0:\\n raise exception.ShareGroupTypeAccessNotFound(\\n type_id=share_group_type_id, project_id=project_id)\",\n \"def delete_image_permissions(Name=None, SharedAccountId=None):\\n pass\",\n \"def DeniedPermissions(self) -> _n_6_t_0:\",\n \"def test_remove_user_from_course_group_permission_denied(self):\\r\\n add_users(self.global_admin, CourseInstructorRole(self.course_key), self.creator)\\r\\n another_staff = User.objects.create_user('another', 'teststaff+anothercourses@edx.org', 'foo')\\r\\n add_users(self.global_admin, CourseStaffRole(self.course_key), self.creator, self.staff, another_staff)\\r\\n with self.assertRaises(PermissionDenied):\\r\\n remove_users(self.staff, CourseStaffRole(self.course_key), another_staff)\",\n \"def test_remove_is_staff(self):\\n self.user.is_staff = False\\n self.user.save()\\n self.user.refresh_from_db()\\n response = self.client.get(self.get_url())\\n self.assertEqual(response.status_code, 403)\",\n \"def test_remove_is_staff(self):\\n self.user.is_staff = False\\n self.user.save()\\n self.user.refresh_from_db()\\n response = self.client.get(self.get_url())\\n self.assertEqual(response.status_code, 403)\",\n \"def test_remove_is_staff(self):\\n self.user.is_staff = False\\n self.user.save()\\n self.user.refresh_from_db()\\n response = self.client.get(self.get_url())\\n self.assertEqual(response.status_code, 403)\",\n \"def KLP_Revoke_Permissions(request, permissionType):\\n\\n # check logged in user permissions\\n\\n KLP_user_Perm(request.user, 'Users', None)\\n\\n # get user id to revoke permissions\\n\\n user_id = request.POST.get('userId')\\n opStatus = 'success'\\n try:\\n if permissionType == 'permissions':\\n\\n # if permissiontype is permissions revoke institution permissions for the user\\n\\n userObj = User.objects.get(pk=user_id)\\n\\n # get institution list to revoke\\n\\n instList = request.POST.getlist('assignedInst')\\n for inst_id in instList:\\n instObj = Institution.objects.get(pk=inst_id)\\n\\n # revoke permission for user\\n\\n userObj.revoke('Acess', instObj)\\n else:\\n\\n # else revoke assessment permissions\\n\\n assignedAsmList = request.POST.getlist('assignedAsm')\\n for userAsm_id in assignedAsmList:\\n\\n # get UserAssessmentPermissions object\\n\\n permObj = \\\\\\n UserAssessmentPermissions.objects.get(pk=userAsm_id)\\n permObj.access = False # revoke permissions\\n permObj.save()\\n except:\\n opStatus = 'fail'\\n\\n # if revoke permission fail return response as fail else return success.\\n\\n return HttpResponse(opStatus)\",\n \"def revoke(self, group, repo):\\r\\n url = '{0}/group-privileges/{1}/{2}/{1}/{3}/'.format(\\r\\n self.parent.parent.get_url(), self.user, repo, group)\\r\\n\\r\\n return http.Request('DELETE', url), parsers.parse_empty\",\n \"def remove_acl(self, **kwargs):\\n # Validate required and accepted parameters\\n params_validator.validate_params_slx_ver17s_apply_acl(**kwargs)\\n\\n # Parse params\\n acl_name = self.ip.parse_acl_name(**kwargs)\\n callback = kwargs.pop('callback', self._callback)\\n acl = self._get_acl_info(acl_name, get_seqs=False)\\n address_type = acl['protocol']\\n\\n kwargs['address_type'] = address_type\\n # Parse params\\n user_data = self._parse_params_for_apply_or_remove_acl(**kwargs)\\n\\n self.validate_interfaces(callback, user_data)\\n\\n result = {}\\n for intf in user_data['interface_list']:\\n user_data['intf'] = intf\\n t = jinja2.Template(acl_template.acl_remove)\\n config = t.render(**user_data)\\n config = ' '.join(config.split())\\n try:\\n callback(config)\\n result[intf] = True\\n except Exception as e:\\n if '<bad-element>access-group</bad-element>' in str(e):\\n result[intf] = None\\n else:\\n raise\\n return result\",\n \"def save(self, commit):\\n preset = super().save(commit)\\n # Remove all permissions on the preset.\\n preset.permission_group.permissions.all().delete()\\n # Add permission to selected groups.\\n for group in Group.objects.filter(pk__in=self.cleaned_data[\\\"groups\\\"]):\\n preset.set_permission(Permission.VIEW, group)\\n return preset\",\n \"def decreaseApproval(_spender: address, _subtractedValue: uint256) -> bool:\\n\\n if(_subtractedValue >= self.allowed[msg.sender][_spender]):\\n self.allowed[msg.sender][_spender] = 0\\n else:\\n self.allowed[msg.sender][_spender] -= _subtractedValue\\n\\n log.Approval(msg.sender, _spender, self.allowed[msg.sender][_spender])\\n return True\",\n \"def delete_groups_and_permissions_for_recipes(apps, schema_editor):\\n Group = apps.get_model('auth', 'Group')\\n Permission = apps.get_model('auth', 'Permission')\\n # Delete the recipe_submitters group.\\n recipe_submitters = Group.objects.get(name='recipe_submitters')\\n recipe_submitters.delete()\\n # Remove permissions for recipes to the dcc groups.\\n recipe_permissions = Permission.objects.filter(content_type__app_label='recipes',\\n content_type__model__in=('unitrecipe', 'harmonizationrecipe'))\\n developers = Group.objects.get(name='dcc_developers')\\n developers.permissions.remove(*recipe_permissions)\\n analysts = Group.objects.get(name='dcc_analysts')\\n analysts.permissions.remove(*recipe_permissions)\",\n \"def delete(self):\\n\\n context = t_context.extract_context_from_environ()\\n if not context.is_admin:\\n # TODO(joahuang): changed to policy control later\\n # to support reseller admin mode\\n return Response(_('Admin role required to delete quota'), 409)\\n\\n kw = {}\\n return self._quota_action('delete', **kw)\",\n \"def remove_permission_from_bucket(bucket_name, role_type, member_type):\\n\\n # initialize client & get bucket\\n _, bucket, _ = create_client(bucket_name)\\n\\n policy = bucket.get_iam_policy(requested_policy_version=3)\\n \\n # get member type\\n member_value = get_member_bucket_level(member_type)\\n\\n # get role type\\n role_value = get_role_bucket_level(role_type)\\n\\n for binding in policy.bindings:\\n # print(binding)\\n if binding[\\\"role\\\"] == role_value and binding.get(\\\"condition\\\") is None:\\n # revoke role from member\\n binding[\\\"members\\\"].discard(member_value)\\n\\n bucket.set_iam_policy(policy)\\n\\n print(\\\"removed {} with role {} from {}\\\".format(member_value, role_value, bucket_name))\",\n \"def test_requester_is_no_admin(self) -> None:\\n\\n channel = self.make_request(\\n \\\"DELETE\\\",\\n self.url,\\n access_token=self.other_user_tok,\\n )\\n\\n self.assertEqual(403, channel.code, msg=channel.json_body)\\n self.assertEqual(Codes.FORBIDDEN, channel.json_body[\\\"errcode\\\"])\",\n \"def on_model_delete(self, model):\\n if not current_user.is_active or not current_user.is_authenticated:\\n abort(403)\\n if not user_has_permission(current_user, 'can_delete', 'advisors'):\\n abort(403)\",\n \"def remove_from_group(_request, group_id, email):\\n group = models.UserGroup.get_by_id(int(group_id))\\n user_key = models.UserProfile.load(email).key()\\n if group.users is None:\\n group.users = []\\n logging.warning('Group \\\"%s\\\" had a None users list' % group.name)\\n group.users.remove(user_key)\\n group.put()\\n\\n url = urlresolvers.reverse('views.admin.edit_user', args=[email])\\n return http.HttpResponseRedirect(url)\",\n \"def _sync_dag_view_permissions(self, dag_id: str, access_control: dict[str, Collection[str]]) -> None:\\n dag_resource_name = permissions.resource_name_for_dag(dag_id)\\n\\n def _get_or_create_dag_permission(action_name: str) -> Permission | None:\\n perm = self.get_permission(action_name, dag_resource_name)\\n if not perm:\\n self.log.info(\\\"Creating new action '%s' on resource '%s'\\\", action_name, dag_resource_name)\\n perm = self.create_permission(action_name, dag_resource_name)\\n\\n return perm\\n\\n def _revoke_stale_permissions(resource: Resource):\\n existing_dag_perms = self.get_resource_permissions(resource)\\n for perm in existing_dag_perms:\\n non_admin_roles = [role for role in perm.role if role.name != \\\"Admin\\\"]\\n for role in non_admin_roles:\\n target_perms_for_role = access_control.get(role.name, ())\\n if perm.action.name not in target_perms_for_role:\\n self.log.info(\\n \\\"Revoking '%s' on DAG '%s' for role '%s'\\\",\\n perm.action,\\n dag_resource_name,\\n role.name,\\n )\\n self.remove_permission_from_role(role, perm)\\n\\n resource = self.get_resource(dag_resource_name)\\n if resource:\\n _revoke_stale_permissions(resource)\\n\\n for rolename, action_names in access_control.items():\\n role = self.find_role(rolename)\\n if not role:\\n raise AirflowException(\\n f\\\"The access_control mapping for DAG '{dag_id}' includes a role named \\\"\\n f\\\"'{rolename}', but that role does not exist\\\"\\n )\\n\\n action_names = set(action_names)\\n invalid_action_names = action_names - self.DAG_ACTIONS\\n if invalid_action_names:\\n raise AirflowException(\\n f\\\"The access_control map for DAG '{dag_resource_name}' includes \\\"\\n f\\\"the following invalid permissions: {invalid_action_names}; \\\"\\n f\\\"The set of valid permissions is: {self.DAG_ACTIONS}\\\"\\n )\\n\\n for action_name in action_names:\\n dag_perm = _get_or_create_dag_permission(action_name)\\n if dag_perm:\\n self.add_permission_to_role(role, dag_perm)\",\n \"def delete_TestGroupResourcePermission(test_case, # type: AnyMagpieTestCaseType\\n resource_info=null, # type: Optional[JSON]\\n override_resource_id=null, # type: Optional[int]\\n override_permission=null, # type: Optional[AnyPermissionType]\\n override_group_name=null, # type: Optional[Str]\\n override_headers=null, # type: Optional[HeadersType]\\n override_cookies=null, # type: Optional[CookiesType]\\n ignore_missing=True, # type: bool\\n ): # type: (...) -> JSON\\n result = TestSetup.update_TestAnyResourcePermission(\\n test_case, \\\"group\\\", \\\"DELETE\\\", resource_info=resource_info,\\n override_resource_id=override_resource_id, override_permission=override_permission,\\n override_item_name=override_group_name, override_headers=override_headers, override_cookies=override_cookies\\n )\\n if not ignore_missing:\\n check_val_equal(result[\\\"code\\\"], 200)\\n return result\",\n \"def changeOwnership(self, document):\\n document.changeOwnership(getSecurityManager().getUser(), False)\",\n \"def test_remove_user_from_course_group(self):\\r\\n add_users(self.global_admin, CourseInstructorRole(self.course_key), self.creator)\\r\\n add_users(self.global_admin, CourseStaffRole(self.course_key), self.creator)\\r\\n\\r\\n add_users(self.creator, CourseStaffRole(self.course_key), self.staff)\\r\\n self.assertTrue(has_access(self.staff, CourseStaffRole(self.course_key)))\\r\\n\\r\\n remove_users(self.creator, CourseStaffRole(self.course_key), self.staff)\\r\\n self.assertFalse(has_access(self.staff, CourseStaffRole(self.course_key)))\\r\\n\\r\\n remove_users(self.creator, CourseInstructorRole(self.course_key), self.creator)\\r\\n self.assertFalse(has_access(self.creator, CourseInstructorRole(self.course_key)))\",\n \"def delete_required(required):\\n required.delete_required()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63204193","0.60559267","0.5868938","0.5853292","0.5768508","0.5714673","0.5648865","0.56440014","0.5544115","0.55229086","0.55072224","0.54663765","0.5419387","0.5413648","0.53388613","0.5335905","0.53285515","0.5316271","0.5315049","0.5301109","0.529115","0.5287806","0.5279603","0.5268119","0.5261689","0.52296805","0.5201819","0.5200636","0.5189475","0.5185729","0.51735777","0.5165785","0.5138762","0.51329434","0.5132158","0.51241624","0.5103521","0.51011837","0.5099293","0.5060393","0.5055358","0.50536495","0.5048353","0.50311625","0.50280607","0.50270146","0.5025435","0.5024276","0.5023092","0.502111","0.5019819","0.5009799","0.5005265","0.49873483","0.49778983","0.49655673","0.4951387","0.49386102","0.49385524","0.4930434","0.49204817","0.491921","0.49150175","0.4905639","0.48962358","0.48697212","0.4868233","0.48634642","0.48503086","0.48399064","0.48255143","0.48192","0.4815054","0.48128518","0.48126554","0.48069715","0.48058605","0.47996768","0.4794989","0.47796148","0.47773913","0.47669306","0.47669306","0.47669306","0.476297","0.4750308","0.47428223","0.4731326","0.4724432","0.47240758","0.47227356","0.47184518","0.47119027","0.47040617","0.47006565","0.4700523","0.46986532","0.46914613","0.4689443","0.46852434"],"string":"[\n \"0.63204193\",\n \"0.60559267\",\n \"0.5868938\",\n \"0.5853292\",\n \"0.5768508\",\n \"0.5714673\",\n \"0.5648865\",\n \"0.56440014\",\n \"0.5544115\",\n \"0.55229086\",\n \"0.55072224\",\n \"0.54663765\",\n \"0.5419387\",\n \"0.5413648\",\n \"0.53388613\",\n \"0.5335905\",\n \"0.53285515\",\n \"0.5316271\",\n \"0.5315049\",\n \"0.5301109\",\n \"0.529115\",\n \"0.5287806\",\n \"0.5279603\",\n \"0.5268119\",\n \"0.5261689\",\n \"0.52296805\",\n \"0.5201819\",\n \"0.5200636\",\n \"0.5189475\",\n \"0.5185729\",\n \"0.51735777\",\n \"0.5165785\",\n \"0.5138762\",\n \"0.51329434\",\n \"0.5132158\",\n \"0.51241624\",\n \"0.5103521\",\n \"0.51011837\",\n \"0.5099293\",\n \"0.5060393\",\n \"0.5055358\",\n \"0.50536495\",\n \"0.5048353\",\n \"0.50311625\",\n \"0.50280607\",\n \"0.50270146\",\n \"0.5025435\",\n \"0.5024276\",\n \"0.5023092\",\n \"0.502111\",\n \"0.5019819\",\n \"0.5009799\",\n \"0.5005265\",\n \"0.49873483\",\n \"0.49778983\",\n \"0.49655673\",\n \"0.4951387\",\n \"0.49386102\",\n \"0.49385524\",\n \"0.4930434\",\n \"0.49204817\",\n \"0.491921\",\n \"0.49150175\",\n \"0.4905639\",\n \"0.48962358\",\n \"0.48697212\",\n \"0.4868233\",\n \"0.48634642\",\n \"0.48503086\",\n \"0.48399064\",\n \"0.48255143\",\n \"0.48192\",\n \"0.4815054\",\n \"0.48128518\",\n \"0.48126554\",\n \"0.48069715\",\n \"0.48058605\",\n \"0.47996768\",\n \"0.4794989\",\n \"0.47796148\",\n \"0.47773913\",\n \"0.47669306\",\n \"0.47669306\",\n \"0.47669306\",\n \"0.476297\",\n \"0.4750308\",\n \"0.47428223\",\n \"0.4731326\",\n \"0.4724432\",\n \"0.47240758\",\n \"0.47227356\",\n \"0.47184518\",\n \"0.47119027\",\n \"0.47040617\",\n \"0.47006565\",\n \"0.4700523\",\n \"0.46986532\",\n \"0.46914613\",\n \"0.4689443\",\n \"0.46852434\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81578374"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":13298,"cells":{"query":{"kind":"string","value":"Prevent values being changed."},"document":{"kind":"string","value":"def __setattr__(self, name, value):\n raise AttributeError(\"You cannot modify attributes on a %s\" % self.__class__.__name__)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def ignore_value_changes(self):\n return self._parent.ignore_value_changes","def ignore_value_changes(self, value):\n self._parent.ignore_value_changes = value","def allow_values_only(self, allow_values_only):\n\n self._allow_values_only = allow_values_only","def modifyNotValuableComponents(self):\n # Nothing to do\n pass","def _disabled(self, *args, **kwargs):\n raise TypeError(\"'%s' does not support mutable operations.\" %\n self.__class__)","def _disabled(self, *args, **kwargs):\n raise TypeError(\"'%s' does not support mutable operations.\" %\n self.__class__.__name__)","def _on_click(self, _):\n self.value = not self.value","def exclude(self):\n\n self.eod.value = 0\n self.public.value = 0","def mark_no_changes(self):","def invalidate(self):\n self.put_param('is_valid', False)\n self._vals = np.empty_like(self._vals)","def _valueRemoved(self):\n self.__changed = 1\n if self.size() == 0:\n raise ConsistencyFailure()","def value_not(self, value_not):\n\n self._value_not = value_not","def disable(self):\n for val in data:\n val.disable()\n self.enabled = False","def set_sensors_invalid(self):\n\n for sensor_name in self.sensors.keys():\n self.sensors[sensor_name].valid = False","def exogenous_change(self):\n pass","def exogenous_change(self):\n pass","def exogenous_change(self):\n pass","def ignores(self, value):\n if value is None:\n value = tuple()\n self._ignores = value","def disable(self):","def __setattr__(self,name,value):\n\n if name == '_dont_touch':\n super.__setattr__(self,name,value) \n elif name in self._dont_touch:\n raise ValueError(\"Parameter %s is protected, please don't touch!\"%name)\n else:\n super.__setattr__(self,name,value)\n self._dont_touch.append(name)","def __setattr__(self,name,value):\n\n if name == '_dont_touch':\n super.__setattr__(self,name,value) \n elif name in self._dont_touch:\n raise ValueError(\"Parameter %s is protected, please don't touch!\"%name)\n else:\n super.__setattr__(self,name,value)\n self._dont_touch.append(name)","def __disableControls(self):\n self.ignoreAll()","def disable(self) -> None:","def _context_allow_change(self):\n try:\n self.__dict__['ALLOW_CHANGE'] = True\n yield\n finally:\n del self.__dict__['ALLOW_CHANGE']","def user_controlled(self) -> None:\n self.cpu_controlled = False","def value_changed(self, new_val):\n if new_val is None:\n # SpinBox is unable to work with None and\n # but sometimes it can arrive as an initial value\n return\n super(PyDMSpinbox, self).value_changed(new_val)\n self.valueBeingSet = True\n self.setValue(new_val)\n self.valueBeingSet = False","def enforce_valuecheck(cls, val):\n if val:\n cls.__setitem__ = cls._setitem \n cls.__array_wrap__ = cls._array_wrap\n else:\n cls.__setitem__ = array.__setitem__\n cls.__array_wrap__ = array.__array_wrap__","def __disable__(self) -> None:\n pass","def unsafe(self): \n return self.distmin < self.distmax*0.5","def disable_not_selected(self, window, values, branch_log_dict, key_event):\n #we need to convert values[element] into the numeric\n #could used deepcopy, but we do not actually need it\n utils.convert_to_numeric(values)\n key_set = set(branch_log_dict[key_event].keys())\n for key in key_set.difference(set([values[key_event]])):\n for element_key in branch_log_dict[key_event][key]:\n if not isinstance(window[element_key], sg.Text) and not isinstance(window[element_key], sg.Listbox):\n window[element_key].update(disabled = True)\n window[element_key].update(value = \"\")\n window[element_key].metadata = False\n window[element_key+\"_label\"].update(text_color = \"#000000\")#every non-text field has a label\n window[element_key].update(visible = False)","def unsetValue(self):\n return _libsbml.Parameter_unsetValue(self)","def disable(self):\n super().disable()","def state_not_changed(self, curstate, event, *args, **kwargs):","def state_not_changed(self, curstate, event, *args, **kwargs):","def pick(self):\n self._val = False","def value(self):\n\n\t\traise Exception(\"{0} | '{1}' attribute is not deletable!\".format(self.__class__.__name__, \"value\"))","def set_data_protected(self): \n pass","def value_not_contains(self, value_not_contains):\n\n self._value_not_contains = value_not_contains","def reset(self):\n if np.any(self.val != self.valinit):\n self.set_val(self.valinit)","def __allowed_values_incorrect_vector(self):\n strTestName = 'Values of a Numpy Array 1D (incorrect)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'Numpy Array 1D')\n RxCSObject.paramAllowed('parameter1', range(int(1e4)))\n\n vA = np.random.randint(1, 1e3, 1e3)\n vA[vA.size - 1] = 2e4\n RxCSObject.parameter1 = vA\n\n self.__parametersCheck_error(RxCSObject, AllowedValuesError, strTestName)","def violated(self) -> bool:\n ...","def pre_update(self, **values):\r\n pass","def _is_normal_value(self, key):\n return not MappingSelectionsDict.is_special_value(self.selections[key])","def clean(cls, value):\n return","def invalidate_min_max(self):\n self.max_amplitude = None\n self.min_amplitude = None\n self.max_wavenumber = None\n self.min_wavenumber = None","def instance_invalid_values(self):\n\n return self._instance_invalid_values","def not_valid_before(self):","def __set__(self, model_instance, value):\r\n raise ValueError, 'Virtual property is read-only'","def only_sdv_value_changed(self, only_sdv_value_changed):\n\n self._only_sdv_value_changed = only_sdv_value_changed","def disable(self):\r\n self.update(enabled=False)","def setValues(self):\n pass","def setValues(self):\n pass","def setValues(self):\n pass","def setValues(self):\n pass","def setValues(self):\n pass","def setValues(self):\n pass","def _changeable_fields(self, request, obj):\n return not obj or not self.is_readonly(request, obj)","def isNoModifiable(self):\n return self.f4 is '-'","def disable(self):\n pass","def discard(self, value):\r\n raise NotImplementedError","def invalid(self):\n pass","def __allowed_values_incorrect_list_with_allowed_values(self):\n strTestName = 'Value NaN given in a list with allowed values (incorrect)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'Numpy Array 2D')\n RxCSObject.paramAllowed('parameter1', range(int(2e3)) + [np.NaN])\n RxCSObject.parameter1 = np.random.randint(1, 1e3, (1e2, 1e1))\n\n self.__parametersCheck_error(RxCSObject, ValueError, strTestName)","def value(self, value):\n\t\toldvalue = self._value\n\t\tself._value = value\n\t\tif oldvalue != value:\n\t\t\tself.changed()","def _disable(self):\n self.enabled = False","def _clean(self):\n self.cleaned_data = super().clean()\n # Use bound data to set the value if we both have bound and initial data.\n if self.is_bound and self.initial:\n self._set_and_validate_data(self.data)\n return\n else:\n # Set values according to bound data\n if self.is_bound:\n self._set_and_validate_data(self.data)\n return\n # Set values according to initial data\n if self.initial:\n self._set_and_validate_data(self.initial)\n return","def clean_value(self, inst, value):\n return value","def disabledPeriodic(self):\n self.putData()","def set_disabled(self, val):\n self._disabled = val","def set_disabled(self, val):\n self._disabled = val","def suppress_exceptions(cls, value=True):\n cls._suppress_exceptions = value","def remove_invalid_values(self, lower_bound=float('-inf'), upper_bound=float('inf')) :\n valid_indices = (lower_bound < self.signal) * (self.signal < upper_bound)\n self.time_scale = self.time_scale[valid_indices]\n self.signal = self.signal[valid_indices]","def _setAllWithoutUpdate(self, data):\n super(SummonerModel, self)._setAllWithoutUpdate(data)","def check_value(self, value):\n value = super().check_value(value)\n if value == self.states_enum.OUT and self.interlocked:\n raise InterlockError('Valve is currently forced closed')\n return value","def changed(self):\r\n return self.value != self.previous_value","def changed(self):\r\n return self.value != self.previous_value","def cambiar_celeste(self):\r\n self.celeste.setDisabled(True)","def setNone(self):\n self.setValue([])","def test_allow(self, excl, value):\n e = exclude(*excl)\n assert e(fields(C).a, value) is True","def reset(self):\n self.value = self.min_value","def disable(self):\n self.enabled = False\n self.__store(self)","def partial_change(self):\n return self.attempted_change() and not all(self._get_field_data())","def delval(self):\r\n self.value = None","def reject(self):\n pass","def reset_uncertainties(self):\n\n # Make a new temporary ExoParameter using the original self.template\n # dictionary and copy the uncertainty values.\n blank = ExoParameter(\"fake\", attr_dict=self.template)\n self.uncertainty = blank.uncertainty\n self.uncertainty_lower = blank.uncertainty_lower\n self.uncertainty_upper = blank.uncertainty_upper","def cambiar_verde(self):\r\n self.morado.setDisabled(True)","def _set_var_ignore(self):\n self._var_ignore = [k for k in self.__dict__.keys() if k[0] != '_']","def reset_changed(self):\n self._changed = False","def setFalse(self):\n self.cond = CT.FALSE\n self.left = self.right = None\n self.z3 = BoolSort().cast(False)\n self.customSimplifiedValue = CE.FALSE\n self.cleaned = self.Z3Simplified = self.customSimplified = self.checked = True","def __allowed_values_inccorrect_number(self):\n strTestName = 'Values of a number (incorrect)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'number #1')\n RxCSObject.paramAddMan('parameter2', 'number #2')\n RxCSObject.paramAllowed('parameter2', range(10))\n\n RxCSObject.parameter1 = 11\n RxCSObject.parameter2 = 1.4\n\n self.__parametersCheck_error(RxCSObject, AllowedValuesError, strTestName)","def invalidate(self):\n self.valid = False","def discard_changes(self):\n raise NotImplementedError(\n \"{} Method `discard_changes` not implemented!\".format(\n repr(self)\n )\n )","def disable(self):\n raise NotImplementedError","def unsetValue(self):\n return _libsbml.FluxBound_unsetValue(self)","def value_not_in(self, value_not_in):\n\n self._value_not_in = value_not_in","def set_fetch_values_log_critical(cls):\n cls._log_critical = True","def reset_values(self):\n\n self.values = []","def suppress_buysafe(self):\n return self._suppress_buysafe","def change_value(self,val):\n self.val = val","def allow_version_invalid_attributes(self):\n return self._allow_version_invalid_attributes","def _set_silent(self, model_instance, value):\n setattr(model_instance, self._cached_name, value)","def allow_undefined(self, value):\n self.is_allowUndefined = value\n return self"],"string":"[\n \"def ignore_value_changes(self):\\n return self._parent.ignore_value_changes\",\n \"def ignore_value_changes(self, value):\\n self._parent.ignore_value_changes = value\",\n \"def allow_values_only(self, allow_values_only):\\n\\n self._allow_values_only = allow_values_only\",\n \"def modifyNotValuableComponents(self):\\n # Nothing to do\\n pass\",\n \"def _disabled(self, *args, **kwargs):\\n raise TypeError(\\\"'%s' does not support mutable operations.\\\" %\\n self.__class__)\",\n \"def _disabled(self, *args, **kwargs):\\n raise TypeError(\\\"'%s' does not support mutable operations.\\\" %\\n self.__class__.__name__)\",\n \"def _on_click(self, _):\\n self.value = not self.value\",\n \"def exclude(self):\\n\\n self.eod.value = 0\\n self.public.value = 0\",\n \"def mark_no_changes(self):\",\n \"def invalidate(self):\\n self.put_param('is_valid', False)\\n self._vals = np.empty_like(self._vals)\",\n \"def _valueRemoved(self):\\n self.__changed = 1\\n if self.size() == 0:\\n raise ConsistencyFailure()\",\n \"def value_not(self, value_not):\\n\\n self._value_not = value_not\",\n \"def disable(self):\\n for val in data:\\n val.disable()\\n self.enabled = False\",\n \"def set_sensors_invalid(self):\\n\\n for sensor_name in self.sensors.keys():\\n self.sensors[sensor_name].valid = False\",\n \"def exogenous_change(self):\\n pass\",\n \"def exogenous_change(self):\\n pass\",\n \"def exogenous_change(self):\\n pass\",\n \"def ignores(self, value):\\n if value is None:\\n value = tuple()\\n self._ignores = value\",\n \"def disable(self):\",\n \"def __setattr__(self,name,value):\\n\\n if name == '_dont_touch':\\n super.__setattr__(self,name,value) \\n elif name in self._dont_touch:\\n raise ValueError(\\\"Parameter %s is protected, please don't touch!\\\"%name)\\n else:\\n super.__setattr__(self,name,value)\\n self._dont_touch.append(name)\",\n \"def __setattr__(self,name,value):\\n\\n if name == '_dont_touch':\\n super.__setattr__(self,name,value) \\n elif name in self._dont_touch:\\n raise ValueError(\\\"Parameter %s is protected, please don't touch!\\\"%name)\\n else:\\n super.__setattr__(self,name,value)\\n self._dont_touch.append(name)\",\n \"def __disableControls(self):\\n self.ignoreAll()\",\n \"def disable(self) -> None:\",\n \"def _context_allow_change(self):\\n try:\\n self.__dict__['ALLOW_CHANGE'] = True\\n yield\\n finally:\\n del self.__dict__['ALLOW_CHANGE']\",\n \"def user_controlled(self) -> None:\\n self.cpu_controlled = False\",\n \"def value_changed(self, new_val):\\n if new_val is None:\\n # SpinBox is unable to work with None and\\n # but sometimes it can arrive as an initial value\\n return\\n super(PyDMSpinbox, self).value_changed(new_val)\\n self.valueBeingSet = True\\n self.setValue(new_val)\\n self.valueBeingSet = False\",\n \"def enforce_valuecheck(cls, val):\\n if val:\\n cls.__setitem__ = cls._setitem \\n cls.__array_wrap__ = cls._array_wrap\\n else:\\n cls.__setitem__ = array.__setitem__\\n cls.__array_wrap__ = array.__array_wrap__\",\n \"def __disable__(self) -> None:\\n pass\",\n \"def unsafe(self): \\n return self.distmin < self.distmax*0.5\",\n \"def disable_not_selected(self, window, values, branch_log_dict, key_event):\\n #we need to convert values[element] into the numeric\\n #could used deepcopy, but we do not actually need it\\n utils.convert_to_numeric(values)\\n key_set = set(branch_log_dict[key_event].keys())\\n for key in key_set.difference(set([values[key_event]])):\\n for element_key in branch_log_dict[key_event][key]:\\n if not isinstance(window[element_key], sg.Text) and not isinstance(window[element_key], sg.Listbox):\\n window[element_key].update(disabled = True)\\n window[element_key].update(value = \\\"\\\")\\n window[element_key].metadata = False\\n window[element_key+\\\"_label\\\"].update(text_color = \\\"#000000\\\")#every non-text field has a label\\n window[element_key].update(visible = False)\",\n \"def unsetValue(self):\\n return _libsbml.Parameter_unsetValue(self)\",\n \"def disable(self):\\n super().disable()\",\n \"def state_not_changed(self, curstate, event, *args, **kwargs):\",\n \"def state_not_changed(self, curstate, event, *args, **kwargs):\",\n \"def pick(self):\\n self._val = False\",\n \"def value(self):\\n\\n\\t\\traise Exception(\\\"{0} | '{1}' attribute is not deletable!\\\".format(self.__class__.__name__, \\\"value\\\"))\",\n \"def set_data_protected(self): \\n pass\",\n \"def value_not_contains(self, value_not_contains):\\n\\n self._value_not_contains = value_not_contains\",\n \"def reset(self):\\n if np.any(self.val != self.valinit):\\n self.set_val(self.valinit)\",\n \"def __allowed_values_incorrect_vector(self):\\n strTestName = 'Values of a Numpy Array 1D (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'Numpy Array 1D')\\n RxCSObject.paramAllowed('parameter1', range(int(1e4)))\\n\\n vA = np.random.randint(1, 1e3, 1e3)\\n vA[vA.size - 1] = 2e4\\n RxCSObject.parameter1 = vA\\n\\n self.__parametersCheck_error(RxCSObject, AllowedValuesError, strTestName)\",\n \"def violated(self) -> bool:\\n ...\",\n \"def pre_update(self, **values):\\r\\n pass\",\n \"def _is_normal_value(self, key):\\n return not MappingSelectionsDict.is_special_value(self.selections[key])\",\n \"def clean(cls, value):\\n return\",\n \"def invalidate_min_max(self):\\n self.max_amplitude = None\\n self.min_amplitude = None\\n self.max_wavenumber = None\\n self.min_wavenumber = None\",\n \"def instance_invalid_values(self):\\n\\n return self._instance_invalid_values\",\n \"def not_valid_before(self):\",\n \"def __set__(self, model_instance, value):\\r\\n raise ValueError, 'Virtual property is read-only'\",\n \"def only_sdv_value_changed(self, only_sdv_value_changed):\\n\\n self._only_sdv_value_changed = only_sdv_value_changed\",\n \"def disable(self):\\r\\n self.update(enabled=False)\",\n \"def setValues(self):\\n pass\",\n \"def setValues(self):\\n pass\",\n \"def setValues(self):\\n pass\",\n \"def setValues(self):\\n pass\",\n \"def setValues(self):\\n pass\",\n \"def setValues(self):\\n pass\",\n \"def _changeable_fields(self, request, obj):\\n return not obj or not self.is_readonly(request, obj)\",\n \"def isNoModifiable(self):\\n return self.f4 is '-'\",\n \"def disable(self):\\n pass\",\n \"def discard(self, value):\\r\\n raise NotImplementedError\",\n \"def invalid(self):\\n pass\",\n \"def __allowed_values_incorrect_list_with_allowed_values(self):\\n strTestName = 'Value NaN given in a list with allowed values (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'Numpy Array 2D')\\n RxCSObject.paramAllowed('parameter1', range(int(2e3)) + [np.NaN])\\n RxCSObject.parameter1 = np.random.randint(1, 1e3, (1e2, 1e1))\\n\\n self.__parametersCheck_error(RxCSObject, ValueError, strTestName)\",\n \"def value(self, value):\\n\\t\\toldvalue = self._value\\n\\t\\tself._value = value\\n\\t\\tif oldvalue != value:\\n\\t\\t\\tself.changed()\",\n \"def _disable(self):\\n self.enabled = False\",\n \"def _clean(self):\\n self.cleaned_data = super().clean()\\n # Use bound data to set the value if we both have bound and initial data.\\n if self.is_bound and self.initial:\\n self._set_and_validate_data(self.data)\\n return\\n else:\\n # Set values according to bound data\\n if self.is_bound:\\n self._set_and_validate_data(self.data)\\n return\\n # Set values according to initial data\\n if self.initial:\\n self._set_and_validate_data(self.initial)\\n return\",\n \"def clean_value(self, inst, value):\\n return value\",\n \"def disabledPeriodic(self):\\n self.putData()\",\n \"def set_disabled(self, val):\\n self._disabled = val\",\n \"def set_disabled(self, val):\\n self._disabled = val\",\n \"def suppress_exceptions(cls, value=True):\\n cls._suppress_exceptions = value\",\n \"def remove_invalid_values(self, lower_bound=float('-inf'), upper_bound=float('inf')) :\\n valid_indices = (lower_bound < self.signal) * (self.signal < upper_bound)\\n self.time_scale = self.time_scale[valid_indices]\\n self.signal = self.signal[valid_indices]\",\n \"def _setAllWithoutUpdate(self, data):\\n super(SummonerModel, self)._setAllWithoutUpdate(data)\",\n \"def check_value(self, value):\\n value = super().check_value(value)\\n if value == self.states_enum.OUT and self.interlocked:\\n raise InterlockError('Valve is currently forced closed')\\n return value\",\n \"def changed(self):\\r\\n return self.value != self.previous_value\",\n \"def changed(self):\\r\\n return self.value != self.previous_value\",\n \"def cambiar_celeste(self):\\r\\n self.celeste.setDisabled(True)\",\n \"def setNone(self):\\n self.setValue([])\",\n \"def test_allow(self, excl, value):\\n e = exclude(*excl)\\n assert e(fields(C).a, value) is True\",\n \"def reset(self):\\n self.value = self.min_value\",\n \"def disable(self):\\n self.enabled = False\\n self.__store(self)\",\n \"def partial_change(self):\\n return self.attempted_change() and not all(self._get_field_data())\",\n \"def delval(self):\\r\\n self.value = None\",\n \"def reject(self):\\n pass\",\n \"def reset_uncertainties(self):\\n\\n # Make a new temporary ExoParameter using the original self.template\\n # dictionary and copy the uncertainty values.\\n blank = ExoParameter(\\\"fake\\\", attr_dict=self.template)\\n self.uncertainty = blank.uncertainty\\n self.uncertainty_lower = blank.uncertainty_lower\\n self.uncertainty_upper = blank.uncertainty_upper\",\n \"def cambiar_verde(self):\\r\\n self.morado.setDisabled(True)\",\n \"def _set_var_ignore(self):\\n self._var_ignore = [k for k in self.__dict__.keys() if k[0] != '_']\",\n \"def reset_changed(self):\\n self._changed = False\",\n \"def setFalse(self):\\n self.cond = CT.FALSE\\n self.left = self.right = None\\n self.z3 = BoolSort().cast(False)\\n self.customSimplifiedValue = CE.FALSE\\n self.cleaned = self.Z3Simplified = self.customSimplified = self.checked = True\",\n \"def __allowed_values_inccorrect_number(self):\\n strTestName = 'Values of a number (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'number #1')\\n RxCSObject.paramAddMan('parameter2', 'number #2')\\n RxCSObject.paramAllowed('parameter2', range(10))\\n\\n RxCSObject.parameter1 = 11\\n RxCSObject.parameter2 = 1.4\\n\\n self.__parametersCheck_error(RxCSObject, AllowedValuesError, strTestName)\",\n \"def invalidate(self):\\n self.valid = False\",\n \"def discard_changes(self):\\n raise NotImplementedError(\\n \\\"{} Method `discard_changes` not implemented!\\\".format(\\n repr(self)\\n )\\n )\",\n \"def disable(self):\\n raise NotImplementedError\",\n \"def unsetValue(self):\\n return _libsbml.FluxBound_unsetValue(self)\",\n \"def value_not_in(self, value_not_in):\\n\\n self._value_not_in = value_not_in\",\n \"def set_fetch_values_log_critical(cls):\\n cls._log_critical = True\",\n \"def reset_values(self):\\n\\n self.values = []\",\n \"def suppress_buysafe(self):\\n return self._suppress_buysafe\",\n \"def change_value(self,val):\\n self.val = val\",\n \"def allow_version_invalid_attributes(self):\\n return self._allow_version_invalid_attributes\",\n \"def _set_silent(self, model_instance, value):\\n setattr(model_instance, self._cached_name, value)\",\n \"def allow_undefined(self, value):\\n self.is_allowUndefined = value\\n return self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72520024","0.7134793","0.6745022","0.6565378","0.6425409","0.63827246","0.6363821","0.62904686","0.62816423","0.62450707","0.6216821","0.61870974","0.6140225","0.60032874","0.5918717","0.5918717","0.5918717","0.5873133","0.585663","0.58394444","0.58394444","0.5825982","0.5797711","0.57508737","0.5740541","0.57378584","0.5695157","0.56830454","0.56772566","0.5676561","0.5660523","0.56457317","0.5638701","0.5638701","0.5631212","0.56180555","0.56156105","0.5611965","0.56033933","0.5602137","0.5598195","0.55953294","0.5584356","0.5583662","0.55787873","0.55786425","0.55764335","0.55641466","0.5555882","0.55539656","0.5553839","0.5553839","0.5553839","0.5553839","0.5553839","0.5553839","0.5551222","0.5550114","0.5548099","0.5543093","0.55425984","0.55323315","0.5512625","0.5510224","0.5499777","0.54974383","0.54767585","0.54669154","0.54669154","0.5466466","0.5463386","0.5454465","0.5451924","0.5451002","0.5451002","0.54499793","0.5449292","0.5444368","0.5440998","0.54360014","0.54295367","0.5429158","0.54286283","0.542213","0.5412815","0.5406071","0.5405247","0.5403982","0.5403502","0.5397041","0.5393316","0.53825814","0.53784794","0.53616095","0.5348413","0.53455794","0.5341338","0.5326728","0.53258514","0.53116125","0.5309532"],"string":"[\n \"0.72520024\",\n \"0.7134793\",\n \"0.6745022\",\n \"0.6565378\",\n \"0.6425409\",\n \"0.63827246\",\n \"0.6363821\",\n \"0.62904686\",\n \"0.62816423\",\n \"0.62450707\",\n \"0.6216821\",\n \"0.61870974\",\n \"0.6140225\",\n \"0.60032874\",\n \"0.5918717\",\n \"0.5918717\",\n \"0.5918717\",\n \"0.5873133\",\n \"0.585663\",\n \"0.58394444\",\n \"0.58394444\",\n \"0.5825982\",\n \"0.5797711\",\n \"0.57508737\",\n \"0.5740541\",\n \"0.57378584\",\n \"0.5695157\",\n \"0.56830454\",\n \"0.56772566\",\n \"0.5676561\",\n \"0.5660523\",\n \"0.56457317\",\n \"0.5638701\",\n \"0.5638701\",\n \"0.5631212\",\n \"0.56180555\",\n \"0.56156105\",\n \"0.5611965\",\n \"0.56033933\",\n \"0.5602137\",\n \"0.5598195\",\n \"0.55953294\",\n \"0.5584356\",\n \"0.5583662\",\n \"0.55787873\",\n \"0.55786425\",\n \"0.55764335\",\n \"0.55641466\",\n \"0.5555882\",\n \"0.55539656\",\n \"0.5553839\",\n \"0.5553839\",\n \"0.5553839\",\n \"0.5553839\",\n \"0.5553839\",\n \"0.5553839\",\n \"0.5551222\",\n \"0.5550114\",\n \"0.5548099\",\n \"0.5543093\",\n \"0.55425984\",\n \"0.55323315\",\n \"0.5512625\",\n \"0.5510224\",\n \"0.5499777\",\n \"0.54974383\",\n \"0.54767585\",\n \"0.54669154\",\n \"0.54669154\",\n \"0.5466466\",\n \"0.5463386\",\n \"0.5454465\",\n \"0.5451924\",\n \"0.5451002\",\n \"0.5451002\",\n \"0.54499793\",\n \"0.5449292\",\n \"0.5444368\",\n \"0.5440998\",\n \"0.54360014\",\n \"0.54295367\",\n \"0.5429158\",\n \"0.54286283\",\n \"0.542213\",\n \"0.5412815\",\n \"0.5406071\",\n \"0.5405247\",\n \"0.5403982\",\n \"0.5403502\",\n \"0.5397041\",\n \"0.5393316\",\n \"0.53825814\",\n \"0.53784794\",\n \"0.53616095\",\n \"0.5348413\",\n \"0.53455794\",\n \"0.5341338\",\n \"0.5326728\",\n \"0.53258514\",\n \"0.53116125\",\n \"0.5309532\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":13299,"cells":{"query":{"kind":"string","value":"export GPU for AD"},"document":{"kind":"string","value":"def export_gpu(entity=None): \n\tstatus = False \n\texportGrp = config.geoGrp\n\tres = entity.task_res()\n\tlibPath = entity.libPath()\n\n\tif res: \n\t\tabcName = entity.libName(config.libName.get('gpu'), res, ext='abc')\n\n\t\t# name without ext \n\t\tbasename = os.path.splitext(abcName)[0]\n\t\t\n\t\tgpuName = '{0}/{1}'.format(libPath, abcName)\n\n\t\tstart = pub_utils.file_time(gpuName)\n\n\t\t# export GPU command \n\t\tresult = maya_utils.exportGPUCacheGrp(exportGrp, libPath, basename, time='still')\n\t\t\n\t\tend = pub_utils.file_time(gpuName)\n\t\tsuccess = pub_utils.is_file_new(start, end)\n\n\t\tif success: \n\t\t\treturn True, 'Success %s' % gpuName\n\n\t\telse: \n\t\t\treturn False, 'Failed to export Gpu %s' % gpuName\n\n\telse: \n\t\treturn False, 'No res found'"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def GetGPU():\n return option['device_id']","def create_gpu_device_if_present():\n d = dpctl.SyclDevice(\"gpu,cpu\")\n print(\"Selected \" + (\"GPU\" if d.is_gpu else \"CPU\") + \" device\")","def add_gpu_and_mpi_marks():\n pass","def create_gpu_device():\n d1 = dpctl.SyclDevice(\"gpu\")\n d2 = dpctl.select_gpu_device()\n assert d1 == d2\n print_device(d1)\n return d1","def SetGPU(id):\n global option\n option['device_id'] = id","def test_gpu_cuda_code() -> None:\n if get_from_environ(\"DISABLE_GPU_FOR_TESTING\") is not None:\n print(\"GPU payload disabled for testing\")\n return\n\n # if the command exists it can run on the hardware below\n proc = subprocess.Popen([\"nvidia-smi\"], stdout=subprocess.PIPE)\n stdout, _ = proc.communicate()\n str_stdout = stdout.decode()\n assert \"NVIDIA-SMI\" in str_stdout, str_stdout\n assert proc.returncode == 0\n # search the history for the CUDA implementation","def setup_gpu(use_gpu: int, silent=None) -> None:\n if silent is None:\n local_msg = Printer()\n else:\n local_msg = Printer(no_print=silent, pretty=not silent)\n if use_gpu >= 0:\n local_msg.info(f\"Using GPU: {use_gpu}\")\n require_gpu(use_gpu)\n else:\n local_msg.info(\"Using CPU\")\n if gpu_is_available():\n local_msg.info(\"To switch to GPU 0, use the option: --gpu-id 0\")","def OnGPU(gpu_id):\n device_option = caffe2_pb2.DeviceOption()\n device_option.device_type = workspace.GpuDeviceType\n device_option.device_id = gpu_id\n return device_option","def _copy_to_gpu(self):\n self.dispatch('on_texture')","def set_gpu(gpus):\n os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = gpus","def cuda(self):\n if torch.cuda.is_available():\n self.automata = self.automata.cuda()\n self.inv_automata = self.inv_automata.cuda()\n self.action = self.action.cuda()\n self.inv_action = self.inv_action.cuda()","def gpu(device_id=0):\n return Context('gpu', device_id)","def gpu(device_id=0):\n return Context('gpu', device_id)","def gpu(self, gpu):\n\n self._gpu = gpu","def add_gpu(self, gpu):\n gpu_worker = GPUCmdRunner(self.host, 'gpu', gpu)\n self.gpu_workers[gpu] = gpu_worker\n gpu_worker.start()\n self.log.info('GPU worker %d added' % gpu)","def run():\n # get arguments\n args = parse_args()\n assert args.batch_size % args.gpu_num == 0\n assert args.gru_hidden_size % 2 == 0\n\n # create a logger\n logger = logging.getLogger(\"GACM\")\n logger.setLevel(logging.INFO)\n formatter = logging.Formatter('%(asctime)s - %(name)s - %(message)s')\n check_path(args.save_dir)\n check_path(args.load_dir)\n check_path(args.result_dir)\n check_path(args.summary_dir)\n if args.log_dir:\n check_path(args.log_dir)\n file_handler = logging.FileHandler(args.log_dir + time.strftime('%Y-%m-%d-%H:%M:%S',time.localtime(time.time())) + '.txt')\n file_handler.setLevel(logging.INFO)\n file_handler.setFormatter(formatter)\n logger.addHandler(file_handler)\n else:\n console_handler = logging.StreamHandler()\n console_handler.setLevel(logging.INFO)\n console_handler.setFormatter(formatter)\n logger.addHandler(console_handler)\n logger.info('Running with args : {}'.format(args))\n\n logger.info('Checking the directories...')\n for dir_path in [args.save_dir, args.result_dir, args.summary_dir]:\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)\n \n global Dataset\n global Agent\n logger.info('Agent version: {}.0'.format(args.agent_version))\n logger.info('Dataset version: {}.0'.format(args.dataset_version))\n logger.info('Checking the directories...')\n Dataset = importlib.import_module('dataset{}'.format(args.dataset_version)).Dataset\n Agent = importlib.import_module('Agent{}'.format(args.agent_version)).Agent\n \n if args.pretrain:\n pretrain(args)\n if args.train:\n train(args)\n if args.test:\n test(args)\n if args.rank:\n rank(args)\n if args.generate_synthetic_dataset:\n generate_synthetic_dataset(args)\n logger.info('run done.')","def set_gpu(gpu):\r\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\r\n tf_config = tf.ConfigProto()\r\n tf_config.gpu_options.allow_growth = True\r\n return tf_config","def cuda(self):\n for i in self.modules:\n if torch.cuda.is_available():\n self.modules[i] = self.modules[i].cuda()","def benchmark_xla_fakedistort_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1,\n data_dir=self.fake_data_dir,\n data_name='imagenet',\n distortions=True,\n variable_update='parameter_server',\n xla=True)\n self._run_benchmark(params)","def __init__(self, *args, **kwargs):\n super(MadryEtAlMultiGPU, self).__init__(*args, **kwargs)\n self.structural_kwargs += ['ngpu']","def main(argv):\n parser = OptionParser()\n parser.add_option(\n \"--output-dir\",\n help=\"Output directory for generated files. Defaults to chromium root \"\n \"directory.\")\n parser.add_option(\n \"-v\", \"--verbose\", action=\"store_true\", help=\"Verbose logging output.\")\n parser.add_option(\n \"-c\", \"--check\", action=\"store_true\",\n help=\"Check if output files match generated files in chromium root \"\n \"directory. Use this in PRESUBMIT scripts with --output-dir.\")\n\n (options, _) = parser.parse_args(args=argv)\n\n # This script lives under src/gpu/command_buffer.\n script_dir = os.path.dirname(os.path.abspath(__file__))\n assert script_dir.endswith(os.path.normpath(\"src/gpu/command_buffer\"))\n # os.path.join doesn't do the right thing with relative paths.\n chromium_root_dir = os.path.abspath(script_dir + \"/../..\")\n\n # Support generating files under gen/ and for PRESUBMIT.\n if options.output_dir:\n output_dir = options.output_dir\n else:\n output_dir = chromium_root_dir\n os.chdir(output_dir)\n\n # This script lives under gpu/command_buffer, cd to base directory.\n build_cmd_buffer_lib.InitializePrefix(\"WebGPU\")\n gen = build_cmd_buffer_lib.GLGenerator(\n options.verbose, \"2018\", _FUNCTION_INFO, _NAMED_TYPE_INFO,\n chromium_root_dir)\n gen.ParseGLH(\"gpu/command_buffer/webgpu_cmd_buffer_functions.txt\")\n\n gen.WriteCommandIds(\"gpu/command_buffer/common/webgpu_cmd_ids_autogen.h\")\n gen.WriteFormat(\"gpu/command_buffer/common/webgpu_cmd_format_autogen.h\")\n gen.WriteFormatTest(\n \"gpu/command_buffer/common/webgpu_cmd_format_test_autogen.h\")\n gen.WriteGLES2InterfaceHeader(\n \"gpu/command_buffer/client/webgpu_interface_autogen.h\")\n gen.WriteGLES2ImplementationHeader(\n \"gpu/command_buffer/client/webgpu_implementation_autogen.h\")\n gen.WriteGLES2InterfaceStub(\n \"gpu/command_buffer/client/webgpu_interface_stub_autogen.h\")\n gen.WriteGLES2InterfaceStubImpl(\n \"gpu/command_buffer/client/webgpu_interface_stub_impl_autogen.h\")\n gen.WriteGLES2Implementation(\n \"gpu/command_buffer/client/webgpu_implementation_impl_autogen.h\")\n gen.WriteGLES2ImplementationUnitTests(\n \"gpu/command_buffer/client/webgpu_implementation_unittest_autogen.h\")\n gen.WriteCmdHelperHeader(\n \"gpu/command_buffer/client/webgpu_cmd_helper_autogen.h\")\n # Note: No gen.WriteServiceImplementation\n # Note: No gen.WriteServiceUnitTests\n gen.WriteServiceUtilsHeader(\n \"gpu/command_buffer/service/webgpu_cmd_validation_autogen.h\")\n gen.WriteServiceUtilsImplementation(\n \"gpu/command_buffer/service/\"\n \"webgpu_cmd_validation_implementation_autogen.h\")\n\n build_cmd_buffer_lib.Format(gen.generated_cpp_filenames, output_dir,\n chromium_root_dir)\n\n if gen.errors > 0:\n print(\"build_webgpu_cmd_buffer.py: Failed with %d errors\" % gen.errors)\n return 1\n\n check_failed_filenames = []\n if options.check:\n for filename in gen.generated_cpp_filenames:\n if not filecmp.cmp(os.path.join(output_dir, filename),\n os.path.join(chromium_root_dir, filename)):\n check_failed_filenames.append(filename)\n\n if len(check_failed_filenames) > 0:\n print('Please run gpu/command_buffer/build_webgpu_cmd_buffer.py')\n print('Failed check on autogenerated command buffer files:')\n for filename in check_failed_filenames:\n print(filename)\n return 1\n\n return 0","def configure_gpu_tf():\n\n try:\n # locate available devices & set required environment variables\n available_device_ids = GPUtil.getFirstAvailable(order='first', maxLoad=0.7, maxMemory=0.7, attempts=1, interval=10)\n available_device_id = available_device_ids[0]\n os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'\n os.environ['CUDA_VISIBLE_DEVICES'] = str(available_device_id)\n print(f\"\\n GPU Found! running on GPU:{available_device_id}\\n\")\n\n # set GPU configuration (use all GPU memory if device 0, else use <50% of memory)\n tf.debugging.set_log_device_placement(False)\n physical_gpu = tf.config.experimental.list_physical_devices('GPU')[0]\n\n if available_device_id == 0:\n tf.config.experimental.set_memory_growth(physical_gpu, True)\n else:\n tf.config.experimental.set_virtual_device_configuration(\n physical_gpu,\n [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4500)]\n )\n logical_gpus = tf.config.experimental.list_logical_devices('GPU')\n assert len(logical_gpus) == 1, \"error creating virtual GPU to fractionally use memory\"\n\n # if we can't find a GPU, or they are all busy, default to using CPU\n except RuntimeError:\n print(\"\\n No GPUs available... running on CPU\\n\")\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'","def main():\n # Set hyperparameters: batch size, learning rate, hidden layers, activ. fn\n bs = 64\n epochs = 1000\n lr = 10 ** (-5)\n h_layers = [32, 16]\n a_fn = F.relu\n\n # Construct Dataset from file; form DataLoaders\n train_ds, valid_ds = form_datasets(DATA_PATH / SAMPLE_FILE)\n train_dl, valid_dl = form_dataloaders(train_ds, valid_ds, bs, preprocess)\n\n # Gather target inverse scaler fn\n t_inv_scaler = train_ds.target_scaler[\"stargazers\"]\n\n # Intialize model (w/ GPU support), optimization method, and loss function\n model = dff.DFF(D_in=21, D_hid=h_layers, D_out=1, a_fn=a_fn)\n model.to(DEV)\n opt = optim.Adam(model.parameters(), lr=lr)\n loss_func = F.mse_loss\n fit_args = (model, loss_func, opt, train_dl, valid_dl, t_inv_scaler)\n\n # Generate descriptive filename string for csv logs\n prefix = \"FINAL_\"\n model_str = dff.hyper_str(h_layers, lr, opt, a_fn, bs, epochs, prefix)\n print(model_str)\n\n # Train, validate, and store loss\n dff.fit(epochs, *fit_args, LOG_PATH, model_str)","def load_device():","def get_gpu_info(**kwargs):\n # Set GPU info fields\n conn_gpu_count = None\n source_db_gpu_count = None\n source_db_gpu_mem = None\n source_db_gpu_driver_ver = \"\"\n source_db_gpu_name = \"\"\n if kwargs[\"no_gather_conn_gpu_info\"]:\n logging.debug(\n \"--no-gather-conn-gpu-info passed, \"\n + \"using blank values for source database GPU info fields \"\n + \"[run_gpu_count, run_gpu_mem_mb] \"\n )\n else:\n logging.debug(\n \"Gathering source database GPU info fields \"\n + \"[run_gpu_count, run_gpu_mem_mb] \"\n + \"using pymapd connection info. \"\n )\n conn_hardware_info = kwargs[\"con\"]._client.get_hardware_info(\n kwargs[\"con\"]._session\n )\n conn_gpu_count = conn_hardware_info.hardware_info[0].num_gpu_allocated\n if conn_gpu_count == 0 or conn_gpu_count is None:\n no_gather_nvml_gpu_info = True\n if conn_gpu_count == 0:\n logging.warning(\n \"0 GPUs detected from connection info, \"\n + \"using blank values for source database GPU info fields \"\n + \"If running against cpu-only server, make sure to set \"\n + \"--no-gather-nvml-gpu-info and --no-gather-conn-gpu-info.\"\n )\n else:\n no_gather_nvml_gpu_info = kwargs[\"no_gather_nvml_gpu_info\"]\n source_db_gpu_count = conn_gpu_count\n try:\n source_db_gpu_mem = int(\n conn_hardware_info.hardware_info[0].gpu_info[0].memory\n / 1000000\n )\n except IndexError:\n logging.error(\"GPU memory info not available from connection.\")\n if no_gather_nvml_gpu_info:\n logging.debug(\n \"--no-gather-nvml-gpu-info passed, \"\n + \"using blank values for source database GPU info fields \"\n + \"[gpu_driver_ver, run_gpu_name] \"\n )\n elif (\n kwargs[\"conn_machine_name\"] == \"localhost\"\n or kwargs[\"gather_nvml_gpu_info\"]\n ):\n logging.debug(\n \"Gathering source database GPU info fields \"\n + \"[gpu_driver_ver, run_gpu_name] \"\n + \"from local GPU using pynvml. \"\n )\n import pynvml\n\n pynvml.nvmlInit()\n source_db_gpu_driver_ver = pynvml.nvmlSystemGetDriverVersion().decode()\n for i in range(source_db_gpu_count):\n handle = pynvml.nvmlDeviceGetHandleByIndex(i)\n # Assume all cards are the same, overwrite name value\n source_db_gpu_name = pynvml.nvmlDeviceGetName(handle).decode()\n pynvml.nvmlShutdown()\n # If gpu_count argument passed in, override gathered value\n if kwargs[\"gpu_count\"]:\n source_db_gpu_count = kwargs[\"gpu_count\"]\n if kwargs[\"gpu_name\"]:\n source_db_gpu_name = kwargs[\"gpu_name\"]\n gpu_info = {\n \"conn_gpu_count\": conn_gpu_count,\n \"source_db_gpu_count\": source_db_gpu_count,\n \"source_db_gpu_mem\": source_db_gpu_mem,\n \"source_db_gpu_driver_ver\": source_db_gpu_driver_ver,\n \"source_db_gpu_name\": source_db_gpu_name,\n }\n return gpu_info","def test_nvidia_driver2():\r\n a = numpy.random.rand(10000).astype(\"float32\")\r\n cuda.shared_constructor(a)\r\n assert theano.sandbox.cuda.use.device_number is not None","def _display_cuda_devices():\n\n cuda_query_output = subprocess.run(\"nvidia-smi --query-gpu=gpu_uuid,gpu_name,compute_mode --format=csv\", shell=True, capture_output=True, text=True)\n # Check if command worked\n if cuda_query_output.returncode == 0:\n # Split by line jump and comma\n cuda_devices_list = [entry for entry in cuda_query_output.stdout.splitlines()]\n logger.debug(f\"CUDA devices available: {*cuda_devices_list,}\")\n # We only support \"Default\" and not \"Exclusive_Process\" for the compute mode\n if \"Default\" not in cuda_query_output.stdout:\n logger.warning(f\"GPU in 'Exclusive_Process' mode (or Prohibited), one context is allowed per device. This may prevent some openmmtools features from working. GPU must be in 'Default' compute mode\")\n # Handel the case where the command had some error\n else:\n logger.debug(f\"nvidia-smi command failed: {cuda_query_output.stderr}, this is expected if there is no GPU available\")","def device(request):\n d = request.param()\n\n # enable GPU error checking\n if isinstance(d, hoomd.device.GPU):\n d.gpu_error_checking = True\n\n return d","def benchmark_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(num_gpus=1)\n self._run_benchmark(params)","def dist_setting(current_gpu, model, args):\n print(\"channels_last : {}\".format(args.channels_last))\n if args.channels_last:\n args.memory_format = torch.channels_last\n else:\n args.memory_format = torch.contiguous_format\n\n if args.apex:\n args.lr = args.lr*float(args.batch_size*args.world_size)/256.\n args.current_gpu = current_gpu\n if args.current_gpu is not None:\n print(\"Use GPU: {} for training\".format(args.current_gpu))\n\n if args.multigpus_distributed:\n args.rank = args.num_gpus * args.host_num + args.current_gpu\n dist.init_process_group(backend=args.backend,\n rank=args.rank, world_size=args.world_size)\n logger.info('Initialized the distributed environment: \\'{}\\' backend on {} nodes. '.format(\n args.backend, dist.get_world_size()) + 'Current host rank is {}. Number of gpus: {}'.format(\n dist.get_rank(), args.num_gpus))\n else:\n args.rank = 0\n\n if args.sync_bn:\n import apex\n print(\"using apex synced BN\")\n model = apex.parallel.convert_syncbn_model(model)\n\n if args.multigpus_distributed:\n if args.current_gpu is not None:\n torch.cuda.set_device(args.current_gpu)\n args.batch_size = int(args.batch_size / args.num_gpus)\n logger.info(\"Batch size for each GPU: {}\".format(args.batch_size))\n if not args.apex:\n model.cuda(args.current_gpu)\n model = torch.nn.parallel.DistributedDataParallel(\n model, device_ids=[args.current_gpu])\n else:\n if not args.apex:\n model.cuda()\n model = torch.nn.parallel.DistributedDataParallel(model)\n elif args.current_gpu is not None:\n torch.cuda.set_device(args.current_gpu)\n if not args.apex:\n model = model.cuda(args.current_gpu)\n else:\n if not args.apex:\n model = torch.nn.DataParallel(model).cuda()\n\n return model, args","def benchmark_fp16_synth_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(num_gpus=1)\n self._run_benchmark(params)","def setGPU(state):\n\n\timport tensorflow as tf\n\tfrom keras import backend as K\n\n\tcheckGPU()\n\n\tnum_cores = 1\n\tnum_CPU = 1\n\tnum_GPU = 0\n\tif state:\n\t\tnum_GPU = 1\n\n\tconfig = tf.ConfigProto(intra_op_parallelism_threads=num_cores,\\\n\t inter_op_parallelism_threads=num_cores, allow_soft_placement=True,\\\n\t device_count = {'CPU' : num_CPU, 'GPU' : num_GPU})\n\tsession = tf.Session(config=config)\n\tK.set_session(session)","def create_devmap_dataset(path: Path):\n # First create the output directories. Fail if they already exist.\n (path / \"graphs_amd\").mkdir(parents=True)\n (path / \"graphs_nvidia\").mkdir()\n (path / \"ir\").mkdir()\n (path / \"src\").mkdir()\n\n amd = download_csv(\n url=\"http://raw.githubusercontent.com/ChrisCummins/phd/65643fa5ad6769ce4678535cd2f9f37b6a467c45/datasets/opencl/device_mapping/amd.csv\",\n checksum=\"0076271192aa9a0a7c21aa9a637e34cd4460f8e21e756215dd23ffb2ae62dc62\",\n )\n nvidia = download_csv(\n url=\"http://raw.githubusercontent.com/ChrisCummins/phd/65643fa5ad6769ce4678535cd2f9f37b6a467c45/datasets/opencl/device_mapping/nvidia.csv\",\n checksum=\"095c1ccef333e0a65e0e70b3ebde0aef851b61528ec46496a5d1687905abd099\",\n )\n opencl_ir_zip = download(\n # Upstream URL: https://github.com/spcl/ncc/tree/master/task\n url=\"https://www.dropbox.com/s/j5ck80fsbuebf5g/devmap_data.zip?dl=1\",\n checksum=\"3c840f84936a83e329c7a94d011c45ddfcfce8bdbb1a9b1904123e83851913d5\",\n )\n\n amd = reshape_df(amd)\n nvidia = reshape_df(nvidia)\n\n with tempfile.TemporaryDirectory() as tmpdir:\n with ZipFile(io.BytesIO(opencl_ir_zip), \"r\") as f:\n f.extractall(tmpdir)\n dump_src(path, amd, Path(tmpdir))\n dump_ir(path, amd, Path(tmpdir))\n\n build_graphs(amd, path / \"ir\", path / \"graphs_amd\")\n build_graphs(nvidia, path / \"ir\", path / \"graphs_nvidia\")","def move2gpu(self):\n if self.generator.backend.upper() == \"LOOPY\":\n try:\n import pyopencl as cl\n import pyopencl.array # pylint: disable=unused-variable\n from .context import queue\n except ImportError:\n raise ImportError(\"Please install loo.py\")\n\n self.rhs = cl.array.to_device(queue, self.rhs)\n if hasattr(self, \"s\"):\n self.s = cl.array.to_device(\n queue, self.s\n ) # pylint: disable=attribute-defined-outside-init\n self.istore = cl.array.to_device(queue, self.istore)\n for i in range(len(self.iload)):\n self.iload[i] = cl.array.to_device(queue, self.iload[i])","def run_exp(exp_gpu, mode='train', cells_no=None, save_cells_path=None):\n\n # read the available GPU for training\n avail_gpus = exp_gpu[1]\n gpu_id = avail_gpus.pop(0)\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"{}\".format(gpu_id)\n\n # read the parameters\n exp_folder = exp_gpu[0]\n with open(os.path.join(exp_folder, 'parameters.json')) as fp:\n hparams = json.load(fp)\n\n # find training and validation TF records\n input_tfr = os.path.join(exp_folder, 'TF_records')\n train_files = [os.path.join(input_tfr, f)\n for f in os.listdir(input_tfr) if \"train\" in f]\n valid_files = [os.path.join(input_tfr, f)\n for f in os.listdir(input_tfr) if \"valid\" in f]\n\n # log directory\n log_dir = os.path.join(exp_folder, 'job')\n\n if save_cells_path is None:\n save_cells_path = os.path.join(exp_folder, 'generated_cells.h5ad')\n\n tf.reset_default_graph()\n\n if hparams['model']['type'] == 'scGAN':\n\n gan_model = scGAN(\n train_files=train_files,\n valid_files=valid_files,\n genes_no=hparams['preprocessed']['genes_no'],\n scaling=hparams['preprocessed']['scale']['scaling'],\n scale_value=hparams['preprocessed']['scale'][\"scale_value\"],\n max_steps=hparams['training']['max_steps'],\n batch_size=hparams['training']['batch_size'],\n latent_dim=hparams['model']['latent_dim'],\n gen_layers=hparams['model']['gen_layers'],\n output_lsn=hparams['model']['output_LSN'],\n critic_layers=hparams['model']['critic_layers'],\n optimizer=hparams['training']['optimizer']['algorithm'],\n lambd=hparams['model']['lambd'],\n beta1=hparams['training']['optimizer']['beta1'],\n beta2=hparams['training']['optimizer']['beta2'],\n decay=hparams['training']['learning_rate']['decay'],\n alpha_0=hparams['training']['learning_rate']['alpha_0'],\n alpha_final=hparams['training']['learning_rate']['alpha_final'])\n\n if mode == \"train\":\n gan_model.training(\n exp_folder=log_dir,\n valid_cells_no=hparams[\"preprocessed\"][\"valid_count\"],\n checkpoint=hparams['training']['checkpoint'],\n progress_freq=hparams['training']['progress_freq'],\n validation_freq=hparams['training']['validation_freq'],\n critic_iter=hparams['training']['critic_iters'],\n summary_freq=hparams['training']['summary_freq'],\n save_freq=hparams['training']['save_freq'])\n\n else:\n gan_model.generate_cells(\n cells_no=int(cells_no),\n checkpoint=log_dir,\n save_path=save_cells_path)\n\n elif hparams['model']['type'] == 'cscGAN':\n\n gan_model = cscGAN(\n train_files=train_files,\n valid_files=valid_files,\n genes_no=hparams['preprocessed']['genes_no'],\n clusters_no=hparams['preprocessed']['clusters_no'],\n scaling=hparams['preprocessed']['scale']['scaling'],\n scale_value=hparams['preprocessed']['scale'][\"scale_value\"],\n max_steps=hparams['training']['max_steps'],\n batch_size=hparams['training']['batch_size'],\n latent_dim=hparams['model']['latent_dim'],\n gen_layers=hparams['model']['gen_layers'],\n output_lsn=hparams['model']['output_LSN'],\n gene_cond_type=hparams['model']['gen_cond_type'],\n critic_layers=hparams['model']['critic_layers'],\n optimizer=hparams['training']['optimizer']['algorithm'],\n lambd=hparams['model']['lambd'],\n beta1=hparams['training']['optimizer']['beta1'],\n beta2=hparams['training']['optimizer']['beta2'],\n decay=hparams['training']['learning_rate']['decay'],\n alpha_0=hparams['training']['learning_rate']['alpha_0'],\n alpha_final=hparams['training']['learning_rate']['alpha_final'])\n\n if mode == \"train\":\n gan_model.training(\n exp_folder=log_dir,\n valid_cells_no=hparams[\"preprocessed\"][\"valid_count\"],\n clusters_ratios=hparams['preprocessed']['clusters_ratios'],\n checkpoint=hparams['training']['checkpoint'],\n progress_freq=hparams['training']['progress_freq'],\n validation_freq=hparams['training']['validation_freq'],\n critic_iter=hparams['training']['critic_iters'],\n summary_freq=hparams['training']['summary_freq'],\n save_freq=hparams['training']['save_freq'])\n else:\n gan_model.generate_cells(\n cells_no=cells_no,\n checkpoint=log_dir,\n save_path=save_cells_path)\n\n avail_gpus.append(gpu_id)","def setup_device(gpuid=None):\n\n if gpuid is not None and not isinstance(gpuid, str):\n gpuid = str(gpuid)\n\n if gpuid is not None:\n nb_devices = len(gpuid.split(','))\n else:\n nb_devices = 1\n\n if gpuid is not None and (gpuid != '-1'):\n device = '/gpu:' + gpuid\n os.environ['CUDA_VISIBLE_DEVICES'] = gpuid\n\n # GPU memory configuration differs between TF 1 and 2\n if hasattr(tf, 'ConfigProto'):\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n config.allow_soft_placement = True\n tf.keras.backend.set_session(tf.Session(config=config))\n else:\n tf.config.set_soft_device_placement(True)\n for pd in tf.config.list_physical_devices('GPU'):\n tf.config.experimental.set_memory_growth(pd, True)\n else:\n device = '/cpu:0'\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n\n return device, nb_devices","def set_current_device_id():\n import paddle\n curr_dev = paddle.device.get_device()\n select_gpu = os.getenv(\"FLAGS_selected_gpus\", \"0\")\n paddle.set_flags({\n 'FLAGS_selected_gpus': os.getenv(\"FLAGS_selected_gpus\", \"0\")\n })\n if \"gpu\" in curr_dev and select_gpu != curr_dev.split(\":\")[-1]:\n paddle.set_device(\"gpu:\" + select_gpu)\n\n curr_dev_id = paddle.framework.core.get_cuda_current_device_id()\n if \"gpu\" in curr_dev and select_gpu != str(curr_dev_id):\n paddle.zeros([])","def EnableCUDA(gpu_id=0, use_cudnn=True):\n global option\n option['device'] = 'CUDA'\n option['device_id'] = gpu_id\n option['use_cudnn'] = use_cudnn","def import_tf(gpu_list):\n import tensorflow as tf\n os.environ['CUDA_VISIBLE_DEVICES'] = ','.join(gpu_list)\n\n return tf","def benchmark_fake_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, data_dir=self.fake_data_dir, data_name='imagenet')\n self._run_benchmark(params)","def release_gpu_memory(device=0):\n from numba import cuda\n\n K.clear_session()\n cuda.select_device(device)\n cuda.close()\n return","def prepare_device(n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n print(\"Warning: There\\'s no GPU available on this machine,\"\n \"training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n print(f\"Warning: The number of GPU\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \"\n \"available on this machine.\")\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids","def prepare_device(n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n print(\"Warning: There\\'s no GPU available on this machine,\"\n \"training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n print(f\"Warning: The number of GPU\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \"\n \"available on this machine.\")\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids","def prepare_device(n_gpu_use):\n n_gpu = torch.cuda.device_count()\n if n_gpu_use > 0 and n_gpu == 0:\n print(\"Warning: There\\'s no GPU available on this machine,\"\n \"training will be performed on CPU.\")\n n_gpu_use = 0\n if n_gpu_use > n_gpu:\n print(\"Warning: The number of GPU\\'s configured to use is {}, but only {} are available \"\n \"on this machine.\".format(n_gpu_use, n_gpu))\n n_gpu_use = n_gpu\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\n list_ids = list(range(n_gpu_use))\n return device, list_ids","def setup_gpu_and_random(config):\n random.seed(config.general.manualSeed)\n np.random.seed(config.general.manualSeed)\n torch.manual_seed(config.general.manualSeed)\n torch.cuda.manual_seed(config.general.manualSeed)\n\n cudnn.benchmark = True\n cudnn.deterministic = True\n config.num_gpu = torch.cuda.device_count()\n\n if config.num_gpu > 1:\n print('------ Use multi-GPU setting ------')\n print('if you stuck too long time with multi-GPU setting, try to set --workers 0')\n # check multi-GPU issue https://github.com/clovaai/deep-text-recognition-benchmark/issues/1\n config.workers = config.workers * config.num_gpu\n config.batch_size = config.batch_size * config.num_gpu\n\n \"\"\" previous version\n print('To equlize batch stats to 1-GPU setting, the batch_size is multiplied with num_gpu and multiplied batch_size is ', opt.batch_size)\n opt.batch_size = opt.batch_size * opt.num_gpu\n print('To equalize the number of epochs to 1-GPU setting, num_iter is divided with num_gpu by default.')\n If you dont care about it, just commnet out these line.)\n opt.num_iter = int(opt.num_iter / opt.num_gpu)\n \"\"\"","def benchmark_fp16_fake_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(\n num_gpus=1, data_dir=self.fake_data_dir, data_name='imagenet')\n self._run_benchmark(params)","def detect_gpus():\n def worker(q):\n # `device_lib` will not release the memory it took,\n # so we run it in a sub-process.\n try:\n from tensorflow.python.client import device_lib\n\n if is_tensorflow_version_higher_or_equal('1.8.0'):\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n devices = list(device_lib.list_local_devices(config))\n else:\n devices = list(device_lib.list_local_devices())\n gpus = [\n (device.name, device)\n for device in devices\n if device.device_type == 'GPU'\n ]\n union_set = {i: i for i in range(len(gpus))}\n\n for i, (name, device) in enumerate(gpus):\n assert (device.name == '/device:GPU:{}'.format(i))\n for link in device.locality.links.link:\n if link.device_id != i:\n union_set[i] = union_set[link.device_id]\n\n for i in six.iterkeys(union_set):\n while union_set[i] != union_set[union_set[i]]:\n union_set[i] = union_set[union_set[i]]\n\n root_devices = sorted(set(union_set.values()))\n gpu_groups = [[] for _ in range(len(root_devices))]\n dev_to_group = {j: i for i, j in enumerate(root_devices)}\n for i, (name, device) in enumerate(gpus):\n gpu_groups[dev_to_group[union_set[i]]].append(name)\n\n q.put((1, gpu_groups))\n except Exception:\n q.put((0, traceback.format_exc()))\n\n q = mp.Queue()\n p = mp.Process(target=worker, args=(q,))\n\n try:\n p.start()\n result = q.get()\n if result[0] == 1:\n return result[1]\n else:\n raise RuntimeError(\n 'Failed to retrieve GPU information, the traceback of '\n 'sub-process is:\\n {}'.\n format('\\n '.join(result[1].split('\\n')))\n )\n finally:\n p.terminate()\n p.join()","def return_free_GPU():\r\n if torch.cuda.is_available():\r\n gpu_num = torch.cuda.device_count()\r\n device = torch.device('cuda:{}'.format(gpu_num-1))\r\n print('Using GPU:[{}]/[{}] for training...'.format(gpu_num-1,gpu_num-1))\r\n return device\r\n \r\n raise ValueError('GPU not available for training. Check CUDA env with function \"check_cuda_env\"')","def predict_distributed_gpu(filepath, file_chunks, output_filepath, model_path, batch_size, total_callers, threads_per_caller, device_ids, num_workers):\n args = (filepath, output_filepath, model_path, batch_size, threads_per_caller, device_ids, num_workers)\n mp.spawn(setup,\n args=(total_callers, args, file_chunks),\n nprocs=total_callers,\n join=True)","def setupGPUSwept(solver):\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\n getGPUReadBlockSwept(solver) #Finish creating gpuReadBlock here\n blockShape =[element.stop for element in solver.gpuBlock]\n blockShape[-1] += int(2*solver.blocksize[0]) #Adding 2 blocks in the column direction\n # Creating local GPU array with split\n grid = (int((blockShape[2])/solver.blocksize[0]),int((blockShape[3])/solver.blocksize[1])) #Grid size\n #Creating constants\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\n const_dict = ({\"NV\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\"VARS\":bsp(2),\"TIMES\":bsp(1),\"MPSS\":solver.maxPyramidSize,\"MOSS\":solver.maxOctSize,\"OPS\":solver.operating,\"ITS\":solver.intermediate})\n solver.GPUArray = mallocGPUArray(blockShape) #Allocated GPU\n solver.localGPUArray = numpy.zeros(blockShape)\n #Building CUDA source code\n solver.gpu = io.buildGPUSource(solver.gpu)\n io.copyConstants(solver.gpu,const_dict) #This copys cpu constants not global constants\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\n # Make GPU geometry\n solver.Up.initializeGPU(solver.gpu.get_function(\"UpPyramid\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Oct.initializeGPU(solver.gpu.get_function(\"Octahedron\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Down.initializeGPU(solver.gpu.get_function(\"DownPyramid\"),solver.blocksize,(grid[0],grid[1]-1))\n solver.Yb.initializeGPU(solver.gpu.get_function(\"YBridge\"),solver.blocksize,grid)\n solver.Xb.initializeGPU(solver.gpu.get_function(\"XBridge\"),solver.blocksize,grid)","def handle_gpu_compatibility():\n try:\n gpus = tf.config.experimental.list_physical_devices(\"GPU\")\n for gpu in gpus:\n tf.config.experimental.set_memory_growth(gpu, True)\n except Exception as e:\n print(e)","def test_gpu_memory(self):\n m = pyflamegpu.ModelDescription(\"test_gpu_memory_test\")\n a = m.newAgent(\"agent\")\n a.newVariableInt(\"id\")\n p = pyflamegpu.AgentVector(a, AGENT_COUNT)\n for i in range(AGENT_COUNT):\n instance = p[i]\n instance.setVariableInt(\"id\", i)\n cm = pyflamegpu.CUDASimulation(m)\n # copy to device then back by setting and getting population data\n cm.setPopulationData(p)\n cm.getPopulationData(p)\n # check values are the same\n for i in range(AGENT_COUNT):\n instance = p[i]\n assert instance.getVariableInt(\"id\") == i","def ConvertGpuToVendorName(gpu):\n if not gpu:\n return 'No GPU'\n elif '8086' in gpu:\n return 'Intel'\n elif '10de' in gpu:\n return 'NVIDIA'\n elif '1002' in gpu:\n return 'AMD'\n return gpu","def check_gpu(self, values):\n try:\n process = subprocess.Popen(['nvidia-smi', '--query-gpu=name,pci.bus_id,driver_version,pstate,pcie.link.gen.max,pcie.link.gen.current,temperature.gpu,utilization.gpu,utilization.memory,memory.total,memory.free,memory.used', '--format=csv'], stdout=subprocess.PIPE)\n out_str, _ = process.communicate()\n gpu_strs = out_str.split('\\n')\n\n # Get rid of the column headers.\n if len(gpu_strs) > 0:\n gpu_strs = gpu_strs[1:]\n\n # Process each GPU string.\n multi_gpu = len(gpu_strs) > 1\n gpu_index = 1\n for gpu_str in gpu_strs:\n out = gpu_str.split(',')\n if len(out) > 1:\n if multi_gpu:\n values[keys.KEY_GPUX_NAME.replace('X', str(gpu_index))] = out[0].strip(' \\t\\n\\r')\n values[keys.KEY_GPUX_TEMPERATURE.replace('X', str(gpu_index))] = int(out[6].strip(' \\t\\n\\r'))\n values[keys.KEY_GPUX_PERCENT.replace('X', str(gpu_index))] = int(out[7].strip(' \\t\\n\\r%%s'))\n gpu_index = gpu_index + 1\n else:\n values[keys.KEY_GPU_NAME] = out[0].strip(' \\t\\n\\r')\n values[keys.KEY_GPU_TEMPERATURE] = int(out[6].strip(' \\t\\n\\r'))\n values[keys.KEY_GPU_PERCENT] = int(out[7].strip(' \\t\\n\\r%%s'))\n except:\n logging.error(\"Error collecting GPU stats.\")","def benchmark_fp16_xla_compile_fake_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(\n num_gpus=1,\n data_dir=self.fake_data_dir,\n data_name='imagenet',\n xla_compile=True)\n self._run_benchmark(params)","def set_max_gpu(self):\r\n gpu_getter = GPUGetter()\r\n gpu = str(gpu_getter.get_free_gpu())\r\n\r\n if gpu:\r\n print(\"Using GPU: %s\" % gpu)\r\n os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\" # see issue #152\r\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\r\n\r\n if not gpu:\r\n print('No GPU detected')","def _get_gpu_names() -> Sequence[str]:\n result = []\n for device in device_lib.list_local_devices():\n if device.device_type != \"GPU\":\n continue\n desc = device.physical_device_desc\n\n fields = desc.split(\",\")\n for field in fields:\n name, value = field.split(\":\", maxsplit=1)\n name = name.strip()\n value = value.strip()\n if name == \"name\":\n result.append(value)\n return result","def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(num_gpus=1, xla=True)\n self._run_benchmark(params)","def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\n config = Config()\n params = experiment_params()\n model_tools.model_builder(\n params=params,\n config=config,\n model_spec=build_model,\n gpu_device=gpu_device,\n cpu_device=cpu_device)","def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\n config = Config()\n params = experiment_params()\n model_tools.model_builder(\n params=params,\n config=config,\n model_spec=build_model,\n gpu_device=gpu_device,\n cpu_device=cpu_device)","def benchmark_fp16_synth_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(\n num_gpus=1, variable_update='parameter_server')\n self._run_benchmark(params)","def CUDA(self):\n\n if helpers.CUDA:\n self.generator.cuda()\n self.discriminator.cuda()\n self.adv_loss.cuda()","def set_device(in_arg): \n \n return torch.device(\"cuda\" if torch.cuda.is_available() and in_arg.gpu == 1 else \"cpu\")","def _next_device(self):\n if self._num_gpus == 0:\n return ''\n dev = '/gpu:%d' % self._cur_gpu\n if self._num_gpus > 1:\n self._cur_gpu = (self._cur_gpu + 1) % (self._num_gpus-1)\n return dev","def main():\n args = arg_parser()\n if(args.gpu):\n gpu = args.gpu\n else:\n print(\"GPU mode not specified, will use the default value - Use GPU\")\n gpu = \"Y\"\n # Device setting:\n device = device_setting(gpu)\n \n # Prepare the datasets and dataloaders:\n print(\"\\nPreparing dataset for train/valid/test ...\")\n train_loader, valid_loader, test_loader, train_data, valid_data, test_data = load_dataset()\n \n # Model architects, criterion and optimizer:\n print(\"\\nNetwork archetecture building ...\")\n model, criterion, optimizer = network(device=device,\n architecture=args.architecture,\n learning_rate=args.learning_rate,\n hidden_size=args.hidden_size,\n dropout=args.dropout,\n output_size=args.output_size)\n \n # Train the model:\n print(\"\\n\")\n model = train(model=model,\n epochs=5,\n learning_rate=args.learning_rate,\n criterion=criterion,\n optimizer=optimizer,\n train_loader=train_loader,\n valid_loader=valid_loader,\n device=device)\n \n # Validate the model performance on the test set:\n print(\"\\nValidate model performance on test set ...\")\n test(model=model, test_loader=test_loader, device=device)\n \n # Save model checkpoint:\n print(\"\\nSave model checkpoint ...\")\n save(model=model, train_data=train_data, epochs=args.epochs, architecture=args.architecture)","def test_nvidia_driver1():\r\n a = numpy.random.rand(10000).astype(\"float32\")\r\n A = cuda.shared_constructor(a)\r\n f = theano.function(inputs=[], outputs=A.sum(), mode=mode_with_gpu,\r\n profile=False)\r\n topo = f.maker.fgraph.toposort()\r\n assert len(topo) == 2\r\n if sum(isinstance(node.op, B.GpuCAReduce) for node in topo) != 1:\r\n msg = '\\n\\t'.join(['Expected exactly one occurrence of GpuCAReduce ' +\r\n 'but got:']+[str(app) for app in topo])\r\n raise AssertionError(msg)\r\n if not numpy.allclose(f(), a.sum()):\r\n raise Exception(\"The nvidia driver version installed with this OS \"\r\n \"does not give good results for reduction.\"\r\n \"Installing the nvidia driver available on the same \"\r\n \"download page as the cuda package will fix the \"\r\n \"problem: http://developer.nvidia.com/cuda-downloads\")","def mat_device(self): # pylint: disable=C0103\n if cp is None:\n raise ModuleNotFoundError(\"Could not import cupy -- cannot use GPU!\")\n if self._mat_device is None:\n gp_device = cp.array(self._gp)\n object.__setattr__(\n self,\n \"_mat_device\",\n cp.diag(self._disp_over_m) - gp_device.reshape(-1, 1) * gp_device,\n )\n return self._mat_device","def set_device(gpu_arg):\n\n dev = 'cpu'\n if gpu_arg and torch.cuda.is_available():\n dev = 'cuda'\n elif gpu_arg:\n print('Not gpu found. Using cpu instead.') \n\n return torch.device(dev)","def main():\n\n obj = PowerStoreNfsExport()\n obj.perform_module_operation()","def execute(gpu, exp_batch, exp_alias, suppress_output=True, number_of_workers=12):\n try:\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = ','.join(gpu)\n g_conf.VARIABLE_WEIGHT = {}\n\n # At this point the log file with the correct naming is created.\n # You merge the yaml file with the global configuration structure.\n merge_with_yaml(os.path.join('configs', exp_batch, exp_alias + '.yaml'))\n set_type_of_process('train')\n\n # Set the process into loading status.\n coil_logger.add_message('Loading', {'GPU': gpu})\n\n # Put the output to a separate file if it is the case\n if suppress_output:\n if not os.path.exists('_output_logs'):\n os.mkdir('_output_logs')\n sys.stdout = open(os.path.join('_output_logs', exp_alias + '_' +\n g_conf.PROCESS_NAME + '_' + str(os.getpid()) + \".out\"), \"a\",\n buffering=1)\n sys.stderr = open(os.path.join('_output_logs',\n exp_alias + '_err_'+g_conf.PROCESS_NAME + '_'\n + str(os.getpid()) + \".out\"),\n \"a\", buffering=1)\n\n if coil_logger.check_finish('train'):\n coil_logger.add_message('Finished', {})\n return\n\n # Preload option\n if g_conf.PRELOAD_MODEL_ALIAS is not None:\n checkpoint = torch.load(os.path.join('_logs', g_conf.PRELOAD_MODEL_BATCH,\n g_conf.PRELOAD_MODEL_ALIAS,\n 'checkpoints',\n str(g_conf.PRELOAD_MODEL_CHECKPOINT)+'.pth'))\n\n\n # Get the latest checkpoint to be loaded\n # returns none if there are no checkpoints saved for this model\n checkpoint_file = get_latest_saved_checkpoint()\n if checkpoint_file is not None:\n checkpoint = torch.load(os.path.join('_logs', exp_batch, exp_alias,\n 'checkpoints', str(get_latest_saved_checkpoint())))\n iteration = checkpoint['iteration']\n best_loss = checkpoint['best_loss']\n best_loss_iter = checkpoint['best_loss_iter']\n print ('iteration: ', iteration, 'best_loss: ', best_loss)\n else:\n iteration = 0\n best_loss = 10000.0\n best_loss_iter = 0\n\n\n # Define the dataset. This structure is has the __get_item__ redefined in a way\n # that you can access the positions from the root directory as a in a vector.\n full_dataset = os.path.join(os.environ[\"COIL_DATASET_PATH\"], g_conf.TRAIN_DATASET_NAME)\n\n # By instantiating the augmenter we get a callable that augment images and transform them into tensors.\n augmenter = Augmenter(g_conf.AUGMENTATION)\n\n # Instantiate the class used to read the dataset\n dataset = CoILDataset(full_dataset, transform=augmenter, preload_name=str(g_conf.NUMBER_OF_HOURS)+'hours_'+g_conf.TRAIN_DATASET_NAME)\n print (\"Loaded dataset\")\n \n # Creates the sampler, this part is responsible for managing the keys. It divides\n # all keys depending on the measurements and produces a set of keys for each bach.\n # define the sampling strategy for mini-batch, different samplers can be found in 'splitter.py'\n data_loader = select_balancing_strategy(dataset, iteration, number_of_workers)\n\n # Instatiate the network architecture\n model = CoILModel(g_conf.MODEL_TYPE, g_conf.MODEL_CONFIGURATION)\n model.cuda()\n\n optimizer = optim.Adam(model.parameters(), lr=g_conf.LEARNING_RATE) # adabound and adamio can also be used here\n\n if checkpoint_file is not None or g_conf.PRELOAD_MODEL_ALIAS is not None:\n model.load_state_dict(checkpoint['state_dict'])\n optimizer.load_state_dict(checkpoint['optimizer'])\n accumulated_time = checkpoint['total_time']\n loss_window = coil_logger.recover_loss_window('train', iteration)\n else: \n # We accumulate iteration time and keep the average speed\n accumulated_time = 0\n loss_window = []\n\n # freeze the perception module weights if required\n # for m in model.perception.parameters():\n # m.requires_grad = False\n \n # total trainable parameters\n model_parameters = filter(lambda p: p.requires_grad, model.parameters())\n total_params = sum([np.prod(p.size()) for p in model_parameters])\n print ('trainable parameters: ', total_params)\n\n # multi-gpu\n print ('number of gpus: ', torch.cuda.device_count())\n if torch.cuda.device_count() > 1:\n model = nn.DataParallel(model)\n\n criterion = Loss(g_conf.LOSS_FUNCTION)\n\n print ('Start Training')\n\n st = time.time()\n for data in data_loader:\n\n # use this for early stopping if the validation loss is not coming down\n if g_conf.FINISH_ON_VALIDATION_STALE is not None and \\\n check_loss_validation_stopped(iteration, g_conf.FINISH_ON_VALIDATION_STALE):\n break\n\n \"\"\"\n ####################################\n Main optimization loop\n ####################################\n \"\"\"\n\n iteration += 1\n\n if iteration % 1000 == 0:\n adjust_learning_rate_auto(optimizer, loss_window)\n \n # additional learning rate scheduler - cyclic cosine annealing (https://arxiv.org/pdf/1704.00109.pdf)\n # adjust_learning_rate_cosine_annealing(optimizer, loss_window, iteration)\n\n capture_time = time.time()\n controls = data['directions']\n model.zero_grad()\n branches = model(torch.squeeze(data['rgb'].cuda()),\n dataset.extract_inputs(data).cuda())\n loss_function_params = {\n 'branches': branches,\n 'targets': dataset.extract_targets(data).cuda(),\n 'controls': controls.cuda(),\n 'inputs': dataset.extract_inputs(data).cuda(),\n 'branch_weights': g_conf.BRANCH_LOSS_WEIGHT,\n 'variable_weights': g_conf.VARIABLE_WEIGHT\n }\n loss, _ = criterion(loss_function_params)\n loss.backward()\n optimizer.step()\n \"\"\"\n ####################################\n Saving the model if necessary\n ####################################\n \"\"\"\n\n if is_ready_to_save(iteration):\n if torch.cuda.device_count() > 1:\n state_dict_save = model.module.state_dict()\n else:\n state_dict_save = model.state_dict()\n\n state = {\n 'iteration': iteration,\n 'state_dict': state_dict_save,\n 'best_loss': best_loss,\n 'total_time': accumulated_time,\n 'optimizer': optimizer.state_dict(),\n 'best_loss_iter': best_loss_iter\n }\n torch.save(state, os.path.join('_logs', exp_batch, exp_alias\n , 'checkpoints', str(iteration) + '.pth'))\n\n \"\"\"\n ################################################\n Adding tensorboard logs.\n Making calculations for logging purposes.\n These logs are monitored by the printer module.\n #################################################\n \"\"\"\n coil_logger.add_scalar('Loss', loss.data, iteration)\n coil_logger.add_image('Image', torch.squeeze(data['rgb']), iteration)\n if loss.data < best_loss:\n best_loss = loss.data.tolist()\n best_loss_iter = iteration\n\n # Log a random position\n position = random.randint(0, len(data) - 1)\n\n if torch.cuda.device_count() > 1:\n output = model.module.extract_branch(torch.stack(branches[0:4]), controls)\n else:\n output = model.extract_branch(torch.stack(branches[0:4]), controls)\n error = torch.abs(output - dataset.extract_targets(data).cuda())\n\n accumulated_time += time.time() - capture_time\n\n coil_logger.add_message('Iterating',\n {'Iteration': iteration,\n 'Loss': loss.data.tolist(),\n 'Images/s': (iteration * g_conf.BATCH_SIZE) / accumulated_time,\n 'BestLoss': best_loss, 'BestLossIteration': best_loss_iter,\n 'Output': output[position].data.tolist(),\n 'GroundTruth': dataset.extract_targets(data)[\n position].data.tolist(),\n 'Error': error[position].data.tolist(),\n 'Inputs': dataset.extract_inputs(data)[\n position].data.tolist()},\n iteration)\n loss_window.append(loss.data.tolist())\n coil_logger.write_on_error_csv('train', loss.data)\n print(\"Iteration: %d Loss: %f\" % (iteration, loss.data))\n st = time.time()\n\n coil_logger.add_message('Finished', {})\n \n except KeyboardInterrupt:\n coil_logger.add_message('Error', {'Message': 'Killed By User'})\n\n except RuntimeError as e:\n\n coil_logger.add_message('Error', {'Message': str(e)})\n\n except:\n traceback.print_exc()\n coil_logger.add_message('Error', {'Message': 'Something Happened'})","def benchmark_ng_xla_batch64_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, batch_size=64, variable_update='parameter_server', xla=True)\n self._run_benchmark(params)","def bc_train_nvidia():\n\timg_rows,img_cols = 64,64\n\tinput_shape = (img_rows,img_cols,3)\n\n\t# the model\t\n\tmodel = bc_nvidia_model(input_shape = input_shape)\n\n\t\n\timg_dim = (img_rows,img_cols)\n\n\t# reading the drivelog\t\n\tcsv_data = pd.read_csv(data_path+csv_path,usecols=[\"center\",\"left\",\"right\",\"steering\"])\n\n\tthreshold = 1\n\tbatch_size = 240\n\tepochs = 6\n\tyvals = []\n\n\tfor i in range(epochs):\n\t\tgen = generate_data_train(data_path,csv_data,img_dim,batch_size,threshold,yvals)\n\t\t\n\t\tmodel.fit_generator(gen, samples_per_epoch = 24000, nb_epoch = 1, verbose = 1)\n\n\t\t# thresholding against values close to 0 to balance the data\n\t\tthreshold = 1/(i+1)\n\t\n\t# serialize model to JSON\n\tmodel_json = model.to_json()\n\twith open(\"model.json\", \"w\") as json_file:\n\t json_file.write(model_json)\n\t# serialize weights to HDF5\n\tmodel.save_weights(\"model.h5\")\n\twith open(\"s_angles\",\"wb\") as y_file:\n\t\tpickle.dump(yvals,y_file)\n\treturn","def setup_CL():\n\n #Set up openCL platform\n NAME = 'NVIDIA CUDA'\n platforms = cl.get_platforms()\n\n dev = None\n for p in platforms:\n #Easy switching for local vs remote machine\n if p.name == 'Apple':\n NAME = 'Apple'\n if p.name == NAME:\n dev = p.get_devices()\n\n # Command queue, enable GPU profiling\n ctx = cl.Context(dev)\n queue = cl.CommandQueue(ctx,properties=cl.command_queue_properties.PROFILING_ENABLE)\n\n return [dev,ctx,queue]","def load_to_gpu(path: str) ->Dict[str, Any]:\n with PathManager.open(path, 'rb') as f:\n state = torch.load(f, map_location=lambda s, _: torch.serialization.default_restore_location(s, 'cuda'))\n return state","def benchmark_fp16_xla_batch64_synth_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(\n num_gpus=1,\n batch_size=64,\n variable_update='parameter_server',\n xla=True)\n self._run_benchmark(params)","def _add_gpu(self, gpu_count):\n if not gpu_count or gpu_count == 0:\n return\n\n logger.debug(\n \"found resource request for {} GPUs. This will limit to n1 \"\n \"instance types.\".format(gpu_count)\n )\n self.workflow.default_resources.parsed[\"nvidia_gpu\"] = gpu_count\n self.workflow.default_resources.args.append(\"nvidia_gpu=%s\" % gpu_count)\n self._machine_type_prefix = self._machine_type_prefix or \"\"\n if not self._machine_type_prefix.startswith(\"n1\"):\n self._machine_type_prefix = \"n1\"","def cuda_test():\n # This flag enable the inbuilt cudnn auto-tuner\n torch.backends.cudnn.benchmark = True\n\n print('\\n__Python VERSION :', sys.version)\n print('__pyTorch VERSION :', torch.__version__)\n print('__CUDA VERSION : ', torch.version.cuda)\n print('__CUDNN VERSION : ', torch.backends.cudnn.version())\n print('__Number CUDA Devices : ', torch.cuda.device_count())\n print('__Devices : ')\n\n call([\"nvidia-smi\", \"--format=csv\", \n \"--query-gpu=index,name,driver_version,memory.total,memory.used,memory.free\"])\n\n print('Active CUDA Device: GPU', torch.cuda.current_device())\n print ('Available devices ', torch.cuda.device_count())\n print ('Current cuda device ', torch.cuda.current_device())\n\n return torch.cuda.is_available()","def benchmark_fp16_fake_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(\n num_gpus=1,\n data_dir=self.fake_data_dir,\n data_name='imagenet',\n variable_update='parameter_server')\n self._run_benchmark(params)","def module_transfer_to_device(self) -> None:\n for name, module in self.modules.items():\n module.to(self.device)\n if self.device.type == 'cuda':\n self.modules[name] = torch.nn.DataParallel(module, self.gpu_ids)\n return","def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(\n num_gpus=1, variable_update='parameter_server', xla=True)\n self._run_benchmark(params)","def dicom_cli():","def to_multi_gpu(model, n_gpus=4):\n\n with tf.device('/cpu:0'):\n x = Input(model.input_shape[1:], name=model.input_names[0])\n towers = []\n device=[0,1,2,3]\n for g in range(n_gpus):\n with tf.device('/gpu:' + str(device[g])):\n slice_g = Lambda(slice_batch, lambda shape: shape,\n arguments={'n_gpus':n_gpus, 'part':g})(x)\n towers.append(model(slice_g))\n\n with tf.device('/cpu:0'):\n merged = merge(towers, mode='concat', concat_axis=0)\n\n return Model(inputs=[x], outputs=merged)","def benchmark_fp16_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, use_fp16=True, variable_update='parameter_server')\n self._run_benchmark(params)","def benchmark_fp16_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, use_fp16=True, variable_update='parameter_server')\n self._run_benchmark(params)","def benchmark_fp16_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, use_fp16=True, variable_update='parameter_server')\n self._run_benchmark(params)","def benchmark_fp16_xla_compile_synth_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(num_gpus=1, xla_compile=True)\n self._run_benchmark(params)","def benchmark_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, variable_update='parameter_server')\n self._run_benchmark(params)","def benchmark_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, variable_update='parameter_server')\n self._run_benchmark(params)","def benchmark_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, variable_update='parameter_server')\n self._run_benchmark(params)","def _create_device(self):\n return torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")","def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, variable_update='parameter_server', xla=True, use_fp16=True)\n self._run_benchmark(params)","def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, variable_update='parameter_server', xla=True, use_fp16=True)\n self._run_benchmark(params)","def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1, variable_update='parameter_server', xla=True, use_fp16=True)\n self._run_benchmark(params)","def main():\n TOTAL_NUM = 500\n IMG_NAME = 'img'\n LABEL_NAME = 'label'\n\n img = fluid.layers.data(name=IMG_NAME, shape=[1, 28, 28], dtype='float32')\n # gradient should flow\n img.stop_gradient = False\n label = fluid.layers.data(name=LABEL_NAME, shape=[1], dtype='int64')\n logits = mnist_cnn_model(img)\n cost = fluid.layers.cross_entropy(input=logits, label=label)\n avg_cost = fluid.layers.mean(x=cost)\n\n # use CPU\n place = fluid.CPUPlace()\n # use GPU\n # place = fluid.CUDAPlace(0)\n exe = fluid.Executor(place)\n\n BATCH_SIZE = 1\n train_reader = paddle.batch(\n paddle.reader.shuffle(\n paddle.dataset.mnist.train(), buf_size=128 * 10),\n batch_size=BATCH_SIZE)\n\n test_reader = paddle.batch(\n paddle.reader.shuffle(\n paddle.dataset.mnist.test(), buf_size=128 * 10),\n batch_size=BATCH_SIZE)\n\n fluid.io.load_params(\n exe, \"./mnist/\", main_program=fluid.default_main_program())\n\n # advbox demo\n m = PaddleModel(\n fluid.default_main_program(),\n IMG_NAME,\n LABEL_NAME,\n logits.name,\n avg_cost.name, (-1, 1),\n channel_axis=1)\n attack = JSMA(m)\n attack_config = {\n \"max_iter\": 2000,\n \"theta\": 0.1,\n \"max_perturbations_per_pixel\": 7\n }\n\n # use train data to generate adversarial examples\n total_count = 0\n fooling_count = 0\n for data in train_reader():\n total_count += 1\n adversary = Adversary(data[0][0], data[0][1])\n\n # JSMA non-targeted attack\n adversary = attack(adversary, **attack_config)\n\n # JSMA targeted attack\n # tlabel = 0\n # adversary.set_target(is_targeted_attack=True, target_label=tlabel)\n # adversary = attack(adversary, **attack_config)\n\n # JSMA may return None\n if adversary is not None and adversary.is_successful():\n fooling_count += 1\n print(\n 'attack success, original_label=%d, adversarial_label=%d, count=%d'\n % (data[0][1], adversary.adversarial_label, total_count))\n # plt.imshow(adversary.target, cmap='Greys_r')\n # plt.show()\n # np.save('adv_img', adversary.target)\n else:\n print('attack failed, original_label=%d, count=%d' %\n (data[0][1], total_count))\n\n if total_count >= TOTAL_NUM:\n print(\n \"[TRAIN_DATASET]: fooling_count=%d, total_count=%d, fooling_rate=%f\"\n % (fooling_count, total_count,\n float(fooling_count) / total_count))\n break\n\n # use test data to generate adversarial examples\n total_count = 0\n fooling_count = 0\n for data in test_reader():\n total_count += 1\n adversary = Adversary(data[0][0], data[0][1])\n\n # JSMA non-targeted attack\n adversary = attack(adversary, **attack_config)\n\n # JSMA targeted attack\n # tlabel = 0\n # adversary.set_target(is_targeted_attack=True, target_label=tlabel)\n # adversary = attack(adversary, **attack_config)\n\n # JSMA may return None\n if adversary is not None and adversary.is_successful():\n fooling_count += 1\n print(\n 'attack success, original_label=%d, adversarial_label=%d, count=%d'\n % (data[0][1], adversary.adversarial_label, total_count))\n # plt.imshow(adversary.target, cmap='Greys_r')\n # plt.show()\n # np.save('adv_img', adversary.target)\n else:\n print('attack failed, original_label=%d, count=%d' %\n (data[0][1], total_count))\n\n if total_count >= TOTAL_NUM:\n print(\n \"[TEST_DATASET]: fooling_count=%d, total_count=%d, fooling_rate=%f\"\n % (fooling_count, total_count,\n float(fooling_count) / total_count))\n break\n print(\"jsma attack done\")","def test_gpu_simulation(self):\n m = pyflamegpu.ModelDescription(\"test_gpu_memory_test\")\n a = m.newAgent(\"agent\")\n a.newVariableInt(\"id\")\n a.newVariableInt(\"x\")\n func = a.newRTCFunction(\"add_func\", self.add_func)\n p = pyflamegpu.AgentVector(a, AGENT_COUNT)\n for i in range(AGENT_COUNT):\n instance = p[i]\n instance.setVariableInt(\"x\", i)\n layer = m.newLayer(\"add_layer\")\n layer.addAgentFunction(func)\n cm = pyflamegpu.CUDASimulation(m)\n cm.SimulationConfig().steps = 5\n cm.setPopulationData(p)\n cm.simulate()\n # Re-use the same population to read back the simulation step results\n cm.getPopulationData(p)\n # check values are the same\n for i in range(AGENT_COUNT):\n instance = p[i]\n # use AgentInstance equality operator\n assert instance.getVariableInt(\"x\") == (i + (2 * 5))","def trainer(current_gpu, args):\n\n model_history = train_utils.init_model_history()\n batch_size = args.batch_size\n num_epochs = args.num_epochs\n feature_extract = False\n\n model = train_utils.initialize_ft_model(args.model_name, num_classes=args.num_classes, feature_extract=feature_extract)\n model, args = dist_setting(current_gpu, model, args)\n logger.info(f\"==> Training on rank {args.rank}.\")\n logger.info(args)\n \n dataloaders, transforms, train_sampler = train_utils.create_dataloaders(\n args.train_dir, args.valid_dir, rank=args.rank, \n world_size=args.world_size, batch_size=batch_size,\n num_workers=args.num_workers\n )\n \n optimizer = train_utils.initialize_optimizer(model, feature_extract, lr=args.lr*args.world_size, momentum=0.9) \n criterion = nn.CrossEntropyLoss()\n\n since = time.time()\n val_acc_history = []\n best_model_wts = copy.deepcopy(model.state_dict())\n best_acc1 = 0.0\n num_samples = {k: len(dataloaders[k].dataset) for k, v in dataloaders.items()}\n num_steps = {k: int(np.ceil(len(dataloaders[k].dataset) / (batch_size*args.world_size))) for k, v in dataloaders.items()}\n device = torch.device(f'cuda:{current_gpu}') \n\n for epoch in range(1, num_epochs+1):\n \n batch_time = train_utils.AverageMeter('Time', ':6.3f')\n data_time = train_utils.AverageMeter('Data', ':6.3f')\n losses = train_utils.AverageMeter('Loss', ':.4e')\n top1 = train_utils.AverageMeter('Acc@1', ':6.2f')\n \n logger.info('-' * 40)\n logger.info('[Rank {}, Epoch {}/{}] Processing...'.format(args.rank, epoch, num_epochs))\n logger.info('-' * 40)\n\n # Each epoch has a training and validation phase\n for phase in ['train', 'valid']: \n\n if phase == 'train':\n model.train() # Set model to training mode\n if args.multigpus_distributed:\n dataloaders[phase].sampler.set_epoch(epoch) # Set epoch count for DistributedSampler \n else:\n model.eval() # Set model to evaluate mode\n\n running_loss = 0.0\n running_corrects = 0\n epoch_tic = time.time() \n tic = time.time()\n \n for i, (inputs, labels) in enumerate(dataloaders[phase]):\n # measure data loading time\n data_time.update(time.time() - tic) \n \n inputs = inputs.to(device)\n labels = labels.to(device)\n\n optimizer.zero_grad()\n\n with torch.set_grad_enabled(phase=='train'):\n outputs = model(inputs)\n loss = criterion(outputs, labels)\n probs, preds = torch.max(outputs, 1)\n \n # Compute gradient and do stochastic gradient descent\n if phase == 'train':\n loss.backward()\n optimizer.step()\n \n running_loss += loss.item() * inputs.size(0)\n running_corrects += torch.sum(preds == labels.data)\n acc1 = train_utils.accuracy(outputs, labels, topk=(1,))\n \n # Average loss and accuracy across processes for logging\n if args.multigpus_distributed:\n reduced_loss = train_utils.reduce_tensor(loss.data, args)\n reduced_acc1 = train_utils.reduce_tensor(acc1[0], args)\n else:\n reduced_loss = loss.data\n reduced_acc1 = acc1[0]\n\n losses.update(train_utils.to_python_float(reduced_loss), inputs.size(0))\n top1.update(train_utils.to_python_float(reduced_acc1), inputs.size(0))\n \n # measure elapsed time\n batch_time.update(time.time() - tic)\n tic = time.time()\n\n if phase == 'train' and i % args.log_interval == 0:\n step_loss = running_loss / ((i+1)*batch_size)\n step_acc = running_corrects.double() / ((i+1)*batch_size)\n logger.info(f'[Rank {args.rank}, Epoch {epoch}/{num_epochs}, Step {i+1}/{num_steps[phase]}] {phase}-acc: {step_acc:.4f}, '\n f'{phase}-loss: {step_loss:.4f}, data-time: {data_time.val:.4f}, batch-time: {batch_time.val:.4f}') \n \n\n ## Waiting until finishing operations on GPU (Pytorch default: async)\n torch.cuda.synchronize()\n \n if current_gpu == 0: \n logger.info(f'[Epoch {epoch}/{num_epochs}] {phase}-acc: {top1.avg:.4f}, '\n f'{phase}-loss: {losses.val:.4f}, time: {time.time()-epoch_tic:.4f}') \n \n model_history['epoch'].append(epoch)\n model_history['batch_idx'].append(i)\n model_history['data_time'].append(data_time.val) \n model_history['batch_time'].append(batch_time.val)\n model_history['losses'].append(losses.val)\n model_history['top1'].append(top1.val)\n\n if phase == 'valid':\n is_best = top1.avg > best_acc1\n best_acc1 = max(top1.avg, best_acc1)\n \n if (args.multigpus_distributed and args.rank % args.num_gpus == 0):\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \n train_utils.save_model({\n 'epoch': epoch + 1,\n 'model_name': args.model_name,\n 'state_dict': model.module.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'best_acc1': best_acc1,\n 'loss': losses\n }, is_best, args.model_chkpt_dir, args.model_dir)\n elif not args.multigpus_distributed:\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \n train_utils.save_model({\n 'epoch': epoch + 1,\n 'model_name': args.model_name,\n 'state_dict': model.state_dict(),\n 'optimizer': optimizer.state_dict(),\n 'best_acc1': best_acc1,\n 'loss': losses\n }, is_best, args.model_chkpt_dir, args.model_dir) \n \n \n time_elapsed = time.time() - since\n if current_gpu == 0:\n logger.info('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n logger.info('Best val acc: {:.4f}'.format(best_acc1))\n \n if args.multigpus_distributed:\n dist_cleanup()","def benchmark_xla_fake_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1,\n data_dir=self.fake_data_dir,\n data_name='imagenet',\n variable_update='parameter_server',\n xla=True)\n self._run_benchmark(params)","def benchmark_xla_fake_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1,\n data_dir=self.fake_data_dir,\n data_name='imagenet',\n variable_update='parameter_server',\n xla=True)\n self._run_benchmark(params)","def benchmark_xla_fake_1gpu_gpuparams(self):\n params = self._shared_params()._replace(\n num_gpus=1,\n data_dir=self.fake_data_dir,\n data_name='imagenet',\n variable_update='parameter_server',\n xla=True)\n self._run_benchmark(params)","def benchmark_fp16_batch128_synth_1gpu_gpuparams(self):\n params = self._shared_params_fp16()._replace(num_gpus=1, batch_size=128)\n self._run_benchmark(params)"],"string":"[\n \"def GetGPU():\\n return option['device_id']\",\n \"def create_gpu_device_if_present():\\n d = dpctl.SyclDevice(\\\"gpu,cpu\\\")\\n print(\\\"Selected \\\" + (\\\"GPU\\\" if d.is_gpu else \\\"CPU\\\") + \\\" device\\\")\",\n \"def add_gpu_and_mpi_marks():\\n pass\",\n \"def create_gpu_device():\\n d1 = dpctl.SyclDevice(\\\"gpu\\\")\\n d2 = dpctl.select_gpu_device()\\n assert d1 == d2\\n print_device(d1)\\n return d1\",\n \"def SetGPU(id):\\n global option\\n option['device_id'] = id\",\n \"def test_gpu_cuda_code() -> None:\\n if get_from_environ(\\\"DISABLE_GPU_FOR_TESTING\\\") is not None:\\n print(\\\"GPU payload disabled for testing\\\")\\n return\\n\\n # if the command exists it can run on the hardware below\\n proc = subprocess.Popen([\\\"nvidia-smi\\\"], stdout=subprocess.PIPE)\\n stdout, _ = proc.communicate()\\n str_stdout = stdout.decode()\\n assert \\\"NVIDIA-SMI\\\" in str_stdout, str_stdout\\n assert proc.returncode == 0\\n # search the history for the CUDA implementation\",\n \"def setup_gpu(use_gpu: int, silent=None) -> None:\\n if silent is None:\\n local_msg = Printer()\\n else:\\n local_msg = Printer(no_print=silent, pretty=not silent)\\n if use_gpu >= 0:\\n local_msg.info(f\\\"Using GPU: {use_gpu}\\\")\\n require_gpu(use_gpu)\\n else:\\n local_msg.info(\\\"Using CPU\\\")\\n if gpu_is_available():\\n local_msg.info(\\\"To switch to GPU 0, use the option: --gpu-id 0\\\")\",\n \"def OnGPU(gpu_id):\\n device_option = caffe2_pb2.DeviceOption()\\n device_option.device_type = workspace.GpuDeviceType\\n device_option.device_id = gpu_id\\n return device_option\",\n \"def _copy_to_gpu(self):\\n self.dispatch('on_texture')\",\n \"def set_gpu(gpus):\\n os.environ[\\\"CUDA_DEVICE_ORDER\\\"] = \\\"PCI_BUS_ID\\\"\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = gpus\",\n \"def cuda(self):\\n if torch.cuda.is_available():\\n self.automata = self.automata.cuda()\\n self.inv_automata = self.inv_automata.cuda()\\n self.action = self.action.cuda()\\n self.inv_action = self.inv_action.cuda()\",\n \"def gpu(device_id=0):\\n return Context('gpu', device_id)\",\n \"def gpu(device_id=0):\\n return Context('gpu', device_id)\",\n \"def gpu(self, gpu):\\n\\n self._gpu = gpu\",\n \"def add_gpu(self, gpu):\\n gpu_worker = GPUCmdRunner(self.host, 'gpu', gpu)\\n self.gpu_workers[gpu] = gpu_worker\\n gpu_worker.start()\\n self.log.info('GPU worker %d added' % gpu)\",\n \"def run():\\n # get arguments\\n args = parse_args()\\n assert args.batch_size % args.gpu_num == 0\\n assert args.gru_hidden_size % 2 == 0\\n\\n # create a logger\\n logger = logging.getLogger(\\\"GACM\\\")\\n logger.setLevel(logging.INFO)\\n formatter = logging.Formatter('%(asctime)s - %(name)s - %(message)s')\\n check_path(args.save_dir)\\n check_path(args.load_dir)\\n check_path(args.result_dir)\\n check_path(args.summary_dir)\\n if args.log_dir:\\n check_path(args.log_dir)\\n file_handler = logging.FileHandler(args.log_dir + time.strftime('%Y-%m-%d-%H:%M:%S',time.localtime(time.time())) + '.txt')\\n file_handler.setLevel(logging.INFO)\\n file_handler.setFormatter(formatter)\\n logger.addHandler(file_handler)\\n else:\\n console_handler = logging.StreamHandler()\\n console_handler.setLevel(logging.INFO)\\n console_handler.setFormatter(formatter)\\n logger.addHandler(console_handler)\\n logger.info('Running with args : {}'.format(args))\\n\\n logger.info('Checking the directories...')\\n for dir_path in [args.save_dir, args.result_dir, args.summary_dir]:\\n if not os.path.exists(dir_path):\\n os.makedirs(dir_path)\\n \\n global Dataset\\n global Agent\\n logger.info('Agent version: {}.0'.format(args.agent_version))\\n logger.info('Dataset version: {}.0'.format(args.dataset_version))\\n logger.info('Checking the directories...')\\n Dataset = importlib.import_module('dataset{}'.format(args.dataset_version)).Dataset\\n Agent = importlib.import_module('Agent{}'.format(args.agent_version)).Agent\\n \\n if args.pretrain:\\n pretrain(args)\\n if args.train:\\n train(args)\\n if args.test:\\n test(args)\\n if args.rank:\\n rank(args)\\n if args.generate_synthetic_dataset:\\n generate_synthetic_dataset(args)\\n logger.info('run done.')\",\n \"def set_gpu(gpu):\\r\\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\\r\\n tf_config = tf.ConfigProto()\\r\\n tf_config.gpu_options.allow_growth = True\\r\\n return tf_config\",\n \"def cuda(self):\\n for i in self.modules:\\n if torch.cuda.is_available():\\n self.modules[i] = self.modules[i].cuda()\",\n \"def benchmark_xla_fakedistort_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1,\\n data_dir=self.fake_data_dir,\\n data_name='imagenet',\\n distortions=True,\\n variable_update='parameter_server',\\n xla=True)\\n self._run_benchmark(params)\",\n \"def __init__(self, *args, **kwargs):\\n super(MadryEtAlMultiGPU, self).__init__(*args, **kwargs)\\n self.structural_kwargs += ['ngpu']\",\n \"def main(argv):\\n parser = OptionParser()\\n parser.add_option(\\n \\\"--output-dir\\\",\\n help=\\\"Output directory for generated files. Defaults to chromium root \\\"\\n \\\"directory.\\\")\\n parser.add_option(\\n \\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\", help=\\\"Verbose logging output.\\\")\\n parser.add_option(\\n \\\"-c\\\", \\\"--check\\\", action=\\\"store_true\\\",\\n help=\\\"Check if output files match generated files in chromium root \\\"\\n \\\"directory. Use this in PRESUBMIT scripts with --output-dir.\\\")\\n\\n (options, _) = parser.parse_args(args=argv)\\n\\n # This script lives under src/gpu/command_buffer.\\n script_dir = os.path.dirname(os.path.abspath(__file__))\\n assert script_dir.endswith(os.path.normpath(\\\"src/gpu/command_buffer\\\"))\\n # os.path.join doesn't do the right thing with relative paths.\\n chromium_root_dir = os.path.abspath(script_dir + \\\"/../..\\\")\\n\\n # Support generating files under gen/ and for PRESUBMIT.\\n if options.output_dir:\\n output_dir = options.output_dir\\n else:\\n output_dir = chromium_root_dir\\n os.chdir(output_dir)\\n\\n # This script lives under gpu/command_buffer, cd to base directory.\\n build_cmd_buffer_lib.InitializePrefix(\\\"WebGPU\\\")\\n gen = build_cmd_buffer_lib.GLGenerator(\\n options.verbose, \\\"2018\\\", _FUNCTION_INFO, _NAMED_TYPE_INFO,\\n chromium_root_dir)\\n gen.ParseGLH(\\\"gpu/command_buffer/webgpu_cmd_buffer_functions.txt\\\")\\n\\n gen.WriteCommandIds(\\\"gpu/command_buffer/common/webgpu_cmd_ids_autogen.h\\\")\\n gen.WriteFormat(\\\"gpu/command_buffer/common/webgpu_cmd_format_autogen.h\\\")\\n gen.WriteFormatTest(\\n \\\"gpu/command_buffer/common/webgpu_cmd_format_test_autogen.h\\\")\\n gen.WriteGLES2InterfaceHeader(\\n \\\"gpu/command_buffer/client/webgpu_interface_autogen.h\\\")\\n gen.WriteGLES2ImplementationHeader(\\n \\\"gpu/command_buffer/client/webgpu_implementation_autogen.h\\\")\\n gen.WriteGLES2InterfaceStub(\\n \\\"gpu/command_buffer/client/webgpu_interface_stub_autogen.h\\\")\\n gen.WriteGLES2InterfaceStubImpl(\\n \\\"gpu/command_buffer/client/webgpu_interface_stub_impl_autogen.h\\\")\\n gen.WriteGLES2Implementation(\\n \\\"gpu/command_buffer/client/webgpu_implementation_impl_autogen.h\\\")\\n gen.WriteGLES2ImplementationUnitTests(\\n \\\"gpu/command_buffer/client/webgpu_implementation_unittest_autogen.h\\\")\\n gen.WriteCmdHelperHeader(\\n \\\"gpu/command_buffer/client/webgpu_cmd_helper_autogen.h\\\")\\n # Note: No gen.WriteServiceImplementation\\n # Note: No gen.WriteServiceUnitTests\\n gen.WriteServiceUtilsHeader(\\n \\\"gpu/command_buffer/service/webgpu_cmd_validation_autogen.h\\\")\\n gen.WriteServiceUtilsImplementation(\\n \\\"gpu/command_buffer/service/\\\"\\n \\\"webgpu_cmd_validation_implementation_autogen.h\\\")\\n\\n build_cmd_buffer_lib.Format(gen.generated_cpp_filenames, output_dir,\\n chromium_root_dir)\\n\\n if gen.errors > 0:\\n print(\\\"build_webgpu_cmd_buffer.py: Failed with %d errors\\\" % gen.errors)\\n return 1\\n\\n check_failed_filenames = []\\n if options.check:\\n for filename in gen.generated_cpp_filenames:\\n if not filecmp.cmp(os.path.join(output_dir, filename),\\n os.path.join(chromium_root_dir, filename)):\\n check_failed_filenames.append(filename)\\n\\n if len(check_failed_filenames) > 0:\\n print('Please run gpu/command_buffer/build_webgpu_cmd_buffer.py')\\n print('Failed check on autogenerated command buffer files:')\\n for filename in check_failed_filenames:\\n print(filename)\\n return 1\\n\\n return 0\",\n \"def configure_gpu_tf():\\n\\n try:\\n # locate available devices & set required environment variables\\n available_device_ids = GPUtil.getFirstAvailable(order='first', maxLoad=0.7, maxMemory=0.7, attempts=1, interval=10)\\n available_device_id = available_device_ids[0]\\n os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'\\n os.environ['CUDA_VISIBLE_DEVICES'] = str(available_device_id)\\n print(f\\\"\\\\n GPU Found! running on GPU:{available_device_id}\\\\n\\\")\\n\\n # set GPU configuration (use all GPU memory if device 0, else use <50% of memory)\\n tf.debugging.set_log_device_placement(False)\\n physical_gpu = tf.config.experimental.list_physical_devices('GPU')[0]\\n\\n if available_device_id == 0:\\n tf.config.experimental.set_memory_growth(physical_gpu, True)\\n else:\\n tf.config.experimental.set_virtual_device_configuration(\\n physical_gpu,\\n [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4500)]\\n )\\n logical_gpus = tf.config.experimental.list_logical_devices('GPU')\\n assert len(logical_gpus) == 1, \\\"error creating virtual GPU to fractionally use memory\\\"\\n\\n # if we can't find a GPU, or they are all busy, default to using CPU\\n except RuntimeError:\\n print(\\\"\\\\n No GPUs available... running on CPU\\\\n\\\")\\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\",\n \"def main():\\n # Set hyperparameters: batch size, learning rate, hidden layers, activ. fn\\n bs = 64\\n epochs = 1000\\n lr = 10 ** (-5)\\n h_layers = [32, 16]\\n a_fn = F.relu\\n\\n # Construct Dataset from file; form DataLoaders\\n train_ds, valid_ds = form_datasets(DATA_PATH / SAMPLE_FILE)\\n train_dl, valid_dl = form_dataloaders(train_ds, valid_ds, bs, preprocess)\\n\\n # Gather target inverse scaler fn\\n t_inv_scaler = train_ds.target_scaler[\\\"stargazers\\\"]\\n\\n # Intialize model (w/ GPU support), optimization method, and loss function\\n model = dff.DFF(D_in=21, D_hid=h_layers, D_out=1, a_fn=a_fn)\\n model.to(DEV)\\n opt = optim.Adam(model.parameters(), lr=lr)\\n loss_func = F.mse_loss\\n fit_args = (model, loss_func, opt, train_dl, valid_dl, t_inv_scaler)\\n\\n # Generate descriptive filename string for csv logs\\n prefix = \\\"FINAL_\\\"\\n model_str = dff.hyper_str(h_layers, lr, opt, a_fn, bs, epochs, prefix)\\n print(model_str)\\n\\n # Train, validate, and store loss\\n dff.fit(epochs, *fit_args, LOG_PATH, model_str)\",\n \"def load_device():\",\n \"def get_gpu_info(**kwargs):\\n # Set GPU info fields\\n conn_gpu_count = None\\n source_db_gpu_count = None\\n source_db_gpu_mem = None\\n source_db_gpu_driver_ver = \\\"\\\"\\n source_db_gpu_name = \\\"\\\"\\n if kwargs[\\\"no_gather_conn_gpu_info\\\"]:\\n logging.debug(\\n \\\"--no-gather-conn-gpu-info passed, \\\"\\n + \\\"using blank values for source database GPU info fields \\\"\\n + \\\"[run_gpu_count, run_gpu_mem_mb] \\\"\\n )\\n else:\\n logging.debug(\\n \\\"Gathering source database GPU info fields \\\"\\n + \\\"[run_gpu_count, run_gpu_mem_mb] \\\"\\n + \\\"using pymapd connection info. \\\"\\n )\\n conn_hardware_info = kwargs[\\\"con\\\"]._client.get_hardware_info(\\n kwargs[\\\"con\\\"]._session\\n )\\n conn_gpu_count = conn_hardware_info.hardware_info[0].num_gpu_allocated\\n if conn_gpu_count == 0 or conn_gpu_count is None:\\n no_gather_nvml_gpu_info = True\\n if conn_gpu_count == 0:\\n logging.warning(\\n \\\"0 GPUs detected from connection info, \\\"\\n + \\\"using blank values for source database GPU info fields \\\"\\n + \\\"If running against cpu-only server, make sure to set \\\"\\n + \\\"--no-gather-nvml-gpu-info and --no-gather-conn-gpu-info.\\\"\\n )\\n else:\\n no_gather_nvml_gpu_info = kwargs[\\\"no_gather_nvml_gpu_info\\\"]\\n source_db_gpu_count = conn_gpu_count\\n try:\\n source_db_gpu_mem = int(\\n conn_hardware_info.hardware_info[0].gpu_info[0].memory\\n / 1000000\\n )\\n except IndexError:\\n logging.error(\\\"GPU memory info not available from connection.\\\")\\n if no_gather_nvml_gpu_info:\\n logging.debug(\\n \\\"--no-gather-nvml-gpu-info passed, \\\"\\n + \\\"using blank values for source database GPU info fields \\\"\\n + \\\"[gpu_driver_ver, run_gpu_name] \\\"\\n )\\n elif (\\n kwargs[\\\"conn_machine_name\\\"] == \\\"localhost\\\"\\n or kwargs[\\\"gather_nvml_gpu_info\\\"]\\n ):\\n logging.debug(\\n \\\"Gathering source database GPU info fields \\\"\\n + \\\"[gpu_driver_ver, run_gpu_name] \\\"\\n + \\\"from local GPU using pynvml. \\\"\\n )\\n import pynvml\\n\\n pynvml.nvmlInit()\\n source_db_gpu_driver_ver = pynvml.nvmlSystemGetDriverVersion().decode()\\n for i in range(source_db_gpu_count):\\n handle = pynvml.nvmlDeviceGetHandleByIndex(i)\\n # Assume all cards are the same, overwrite name value\\n source_db_gpu_name = pynvml.nvmlDeviceGetName(handle).decode()\\n pynvml.nvmlShutdown()\\n # If gpu_count argument passed in, override gathered value\\n if kwargs[\\\"gpu_count\\\"]:\\n source_db_gpu_count = kwargs[\\\"gpu_count\\\"]\\n if kwargs[\\\"gpu_name\\\"]:\\n source_db_gpu_name = kwargs[\\\"gpu_name\\\"]\\n gpu_info = {\\n \\\"conn_gpu_count\\\": conn_gpu_count,\\n \\\"source_db_gpu_count\\\": source_db_gpu_count,\\n \\\"source_db_gpu_mem\\\": source_db_gpu_mem,\\n \\\"source_db_gpu_driver_ver\\\": source_db_gpu_driver_ver,\\n \\\"source_db_gpu_name\\\": source_db_gpu_name,\\n }\\n return gpu_info\",\n \"def test_nvidia_driver2():\\r\\n a = numpy.random.rand(10000).astype(\\\"float32\\\")\\r\\n cuda.shared_constructor(a)\\r\\n assert theano.sandbox.cuda.use.device_number is not None\",\n \"def _display_cuda_devices():\\n\\n cuda_query_output = subprocess.run(\\\"nvidia-smi --query-gpu=gpu_uuid,gpu_name,compute_mode --format=csv\\\", shell=True, capture_output=True, text=True)\\n # Check if command worked\\n if cuda_query_output.returncode == 0:\\n # Split by line jump and comma\\n cuda_devices_list = [entry for entry in cuda_query_output.stdout.splitlines()]\\n logger.debug(f\\\"CUDA devices available: {*cuda_devices_list,}\\\")\\n # We only support \\\"Default\\\" and not \\\"Exclusive_Process\\\" for the compute mode\\n if \\\"Default\\\" not in cuda_query_output.stdout:\\n logger.warning(f\\\"GPU in 'Exclusive_Process' mode (or Prohibited), one context is allowed per device. This may prevent some openmmtools features from working. GPU must be in 'Default' compute mode\\\")\\n # Handel the case where the command had some error\\n else:\\n logger.debug(f\\\"nvidia-smi command failed: {cuda_query_output.stderr}, this is expected if there is no GPU available\\\")\",\n \"def device(request):\\n d = request.param()\\n\\n # enable GPU error checking\\n if isinstance(d, hoomd.device.GPU):\\n d.gpu_error_checking = True\\n\\n return d\",\n \"def benchmark_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(num_gpus=1)\\n self._run_benchmark(params)\",\n \"def dist_setting(current_gpu, model, args):\\n print(\\\"channels_last : {}\\\".format(args.channels_last))\\n if args.channels_last:\\n args.memory_format = torch.channels_last\\n else:\\n args.memory_format = torch.contiguous_format\\n\\n if args.apex:\\n args.lr = args.lr*float(args.batch_size*args.world_size)/256.\\n args.current_gpu = current_gpu\\n if args.current_gpu is not None:\\n print(\\\"Use GPU: {} for training\\\".format(args.current_gpu))\\n\\n if args.multigpus_distributed:\\n args.rank = args.num_gpus * args.host_num + args.current_gpu\\n dist.init_process_group(backend=args.backend,\\n rank=args.rank, world_size=args.world_size)\\n logger.info('Initialized the distributed environment: \\\\'{}\\\\' backend on {} nodes. '.format(\\n args.backend, dist.get_world_size()) + 'Current host rank is {}. Number of gpus: {}'.format(\\n dist.get_rank(), args.num_gpus))\\n else:\\n args.rank = 0\\n\\n if args.sync_bn:\\n import apex\\n print(\\\"using apex synced BN\\\")\\n model = apex.parallel.convert_syncbn_model(model)\\n\\n if args.multigpus_distributed:\\n if args.current_gpu is not None:\\n torch.cuda.set_device(args.current_gpu)\\n args.batch_size = int(args.batch_size / args.num_gpus)\\n logger.info(\\\"Batch size for each GPU: {}\\\".format(args.batch_size))\\n if not args.apex:\\n model.cuda(args.current_gpu)\\n model = torch.nn.parallel.DistributedDataParallel(\\n model, device_ids=[args.current_gpu])\\n else:\\n if not args.apex:\\n model.cuda()\\n model = torch.nn.parallel.DistributedDataParallel(model)\\n elif args.current_gpu is not None:\\n torch.cuda.set_device(args.current_gpu)\\n if not args.apex:\\n model = model.cuda(args.current_gpu)\\n else:\\n if not args.apex:\\n model = torch.nn.DataParallel(model).cuda()\\n\\n return model, args\",\n \"def benchmark_fp16_synth_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(num_gpus=1)\\n self._run_benchmark(params)\",\n \"def setGPU(state):\\n\\n\\timport tensorflow as tf\\n\\tfrom keras import backend as K\\n\\n\\tcheckGPU()\\n\\n\\tnum_cores = 1\\n\\tnum_CPU = 1\\n\\tnum_GPU = 0\\n\\tif state:\\n\\t\\tnum_GPU = 1\\n\\n\\tconfig = tf.ConfigProto(intra_op_parallelism_threads=num_cores,\\\\\\n\\t inter_op_parallelism_threads=num_cores, allow_soft_placement=True,\\\\\\n\\t device_count = {'CPU' : num_CPU, 'GPU' : num_GPU})\\n\\tsession = tf.Session(config=config)\\n\\tK.set_session(session)\",\n \"def create_devmap_dataset(path: Path):\\n # First create the output directories. Fail if they already exist.\\n (path / \\\"graphs_amd\\\").mkdir(parents=True)\\n (path / \\\"graphs_nvidia\\\").mkdir()\\n (path / \\\"ir\\\").mkdir()\\n (path / \\\"src\\\").mkdir()\\n\\n amd = download_csv(\\n url=\\\"http://raw.githubusercontent.com/ChrisCummins/phd/65643fa5ad6769ce4678535cd2f9f37b6a467c45/datasets/opencl/device_mapping/amd.csv\\\",\\n checksum=\\\"0076271192aa9a0a7c21aa9a637e34cd4460f8e21e756215dd23ffb2ae62dc62\\\",\\n )\\n nvidia = download_csv(\\n url=\\\"http://raw.githubusercontent.com/ChrisCummins/phd/65643fa5ad6769ce4678535cd2f9f37b6a467c45/datasets/opencl/device_mapping/nvidia.csv\\\",\\n checksum=\\\"095c1ccef333e0a65e0e70b3ebde0aef851b61528ec46496a5d1687905abd099\\\",\\n )\\n opencl_ir_zip = download(\\n # Upstream URL: https://github.com/spcl/ncc/tree/master/task\\n url=\\\"https://www.dropbox.com/s/j5ck80fsbuebf5g/devmap_data.zip?dl=1\\\",\\n checksum=\\\"3c840f84936a83e329c7a94d011c45ddfcfce8bdbb1a9b1904123e83851913d5\\\",\\n )\\n\\n amd = reshape_df(amd)\\n nvidia = reshape_df(nvidia)\\n\\n with tempfile.TemporaryDirectory() as tmpdir:\\n with ZipFile(io.BytesIO(opencl_ir_zip), \\\"r\\\") as f:\\n f.extractall(tmpdir)\\n dump_src(path, amd, Path(tmpdir))\\n dump_ir(path, amd, Path(tmpdir))\\n\\n build_graphs(amd, path / \\\"ir\\\", path / \\\"graphs_amd\\\")\\n build_graphs(nvidia, path / \\\"ir\\\", path / \\\"graphs_nvidia\\\")\",\n \"def move2gpu(self):\\n if self.generator.backend.upper() == \\\"LOOPY\\\":\\n try:\\n import pyopencl as cl\\n import pyopencl.array # pylint: disable=unused-variable\\n from .context import queue\\n except ImportError:\\n raise ImportError(\\\"Please install loo.py\\\")\\n\\n self.rhs = cl.array.to_device(queue, self.rhs)\\n if hasattr(self, \\\"s\\\"):\\n self.s = cl.array.to_device(\\n queue, self.s\\n ) # pylint: disable=attribute-defined-outside-init\\n self.istore = cl.array.to_device(queue, self.istore)\\n for i in range(len(self.iload)):\\n self.iload[i] = cl.array.to_device(queue, self.iload[i])\",\n \"def run_exp(exp_gpu, mode='train', cells_no=None, save_cells_path=None):\\n\\n # read the available GPU for training\\n avail_gpus = exp_gpu[1]\\n gpu_id = avail_gpus.pop(0)\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = \\\"{}\\\".format(gpu_id)\\n\\n # read the parameters\\n exp_folder = exp_gpu[0]\\n with open(os.path.join(exp_folder, 'parameters.json')) as fp:\\n hparams = json.load(fp)\\n\\n # find training and validation TF records\\n input_tfr = os.path.join(exp_folder, 'TF_records')\\n train_files = [os.path.join(input_tfr, f)\\n for f in os.listdir(input_tfr) if \\\"train\\\" in f]\\n valid_files = [os.path.join(input_tfr, f)\\n for f in os.listdir(input_tfr) if \\\"valid\\\" in f]\\n\\n # log directory\\n log_dir = os.path.join(exp_folder, 'job')\\n\\n if save_cells_path is None:\\n save_cells_path = os.path.join(exp_folder, 'generated_cells.h5ad')\\n\\n tf.reset_default_graph()\\n\\n if hparams['model']['type'] == 'scGAN':\\n\\n gan_model = scGAN(\\n train_files=train_files,\\n valid_files=valid_files,\\n genes_no=hparams['preprocessed']['genes_no'],\\n scaling=hparams['preprocessed']['scale']['scaling'],\\n scale_value=hparams['preprocessed']['scale'][\\\"scale_value\\\"],\\n max_steps=hparams['training']['max_steps'],\\n batch_size=hparams['training']['batch_size'],\\n latent_dim=hparams['model']['latent_dim'],\\n gen_layers=hparams['model']['gen_layers'],\\n output_lsn=hparams['model']['output_LSN'],\\n critic_layers=hparams['model']['critic_layers'],\\n optimizer=hparams['training']['optimizer']['algorithm'],\\n lambd=hparams['model']['lambd'],\\n beta1=hparams['training']['optimizer']['beta1'],\\n beta2=hparams['training']['optimizer']['beta2'],\\n decay=hparams['training']['learning_rate']['decay'],\\n alpha_0=hparams['training']['learning_rate']['alpha_0'],\\n alpha_final=hparams['training']['learning_rate']['alpha_final'])\\n\\n if mode == \\\"train\\\":\\n gan_model.training(\\n exp_folder=log_dir,\\n valid_cells_no=hparams[\\\"preprocessed\\\"][\\\"valid_count\\\"],\\n checkpoint=hparams['training']['checkpoint'],\\n progress_freq=hparams['training']['progress_freq'],\\n validation_freq=hparams['training']['validation_freq'],\\n critic_iter=hparams['training']['critic_iters'],\\n summary_freq=hparams['training']['summary_freq'],\\n save_freq=hparams['training']['save_freq'])\\n\\n else:\\n gan_model.generate_cells(\\n cells_no=int(cells_no),\\n checkpoint=log_dir,\\n save_path=save_cells_path)\\n\\n elif hparams['model']['type'] == 'cscGAN':\\n\\n gan_model = cscGAN(\\n train_files=train_files,\\n valid_files=valid_files,\\n genes_no=hparams['preprocessed']['genes_no'],\\n clusters_no=hparams['preprocessed']['clusters_no'],\\n scaling=hparams['preprocessed']['scale']['scaling'],\\n scale_value=hparams['preprocessed']['scale'][\\\"scale_value\\\"],\\n max_steps=hparams['training']['max_steps'],\\n batch_size=hparams['training']['batch_size'],\\n latent_dim=hparams['model']['latent_dim'],\\n gen_layers=hparams['model']['gen_layers'],\\n output_lsn=hparams['model']['output_LSN'],\\n gene_cond_type=hparams['model']['gen_cond_type'],\\n critic_layers=hparams['model']['critic_layers'],\\n optimizer=hparams['training']['optimizer']['algorithm'],\\n lambd=hparams['model']['lambd'],\\n beta1=hparams['training']['optimizer']['beta1'],\\n beta2=hparams['training']['optimizer']['beta2'],\\n decay=hparams['training']['learning_rate']['decay'],\\n alpha_0=hparams['training']['learning_rate']['alpha_0'],\\n alpha_final=hparams['training']['learning_rate']['alpha_final'])\\n\\n if mode == \\\"train\\\":\\n gan_model.training(\\n exp_folder=log_dir,\\n valid_cells_no=hparams[\\\"preprocessed\\\"][\\\"valid_count\\\"],\\n clusters_ratios=hparams['preprocessed']['clusters_ratios'],\\n checkpoint=hparams['training']['checkpoint'],\\n progress_freq=hparams['training']['progress_freq'],\\n validation_freq=hparams['training']['validation_freq'],\\n critic_iter=hparams['training']['critic_iters'],\\n summary_freq=hparams['training']['summary_freq'],\\n save_freq=hparams['training']['save_freq'])\\n else:\\n gan_model.generate_cells(\\n cells_no=cells_no,\\n checkpoint=log_dir,\\n save_path=save_cells_path)\\n\\n avail_gpus.append(gpu_id)\",\n \"def setup_device(gpuid=None):\\n\\n if gpuid is not None and not isinstance(gpuid, str):\\n gpuid = str(gpuid)\\n\\n if gpuid is not None:\\n nb_devices = len(gpuid.split(','))\\n else:\\n nb_devices = 1\\n\\n if gpuid is not None and (gpuid != '-1'):\\n device = '/gpu:' + gpuid\\n os.environ['CUDA_VISIBLE_DEVICES'] = gpuid\\n\\n # GPU memory configuration differs between TF 1 and 2\\n if hasattr(tf, 'ConfigProto'):\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n config.allow_soft_placement = True\\n tf.keras.backend.set_session(tf.Session(config=config))\\n else:\\n tf.config.set_soft_device_placement(True)\\n for pd in tf.config.list_physical_devices('GPU'):\\n tf.config.experimental.set_memory_growth(pd, True)\\n else:\\n device = '/cpu:0'\\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\\n\\n return device, nb_devices\",\n \"def set_current_device_id():\\n import paddle\\n curr_dev = paddle.device.get_device()\\n select_gpu = os.getenv(\\\"FLAGS_selected_gpus\\\", \\\"0\\\")\\n paddle.set_flags({\\n 'FLAGS_selected_gpus': os.getenv(\\\"FLAGS_selected_gpus\\\", \\\"0\\\")\\n })\\n if \\\"gpu\\\" in curr_dev and select_gpu != curr_dev.split(\\\":\\\")[-1]:\\n paddle.set_device(\\\"gpu:\\\" + select_gpu)\\n\\n curr_dev_id = paddle.framework.core.get_cuda_current_device_id()\\n if \\\"gpu\\\" in curr_dev and select_gpu != str(curr_dev_id):\\n paddle.zeros([])\",\n \"def EnableCUDA(gpu_id=0, use_cudnn=True):\\n global option\\n option['device'] = 'CUDA'\\n option['device_id'] = gpu_id\\n option['use_cudnn'] = use_cudnn\",\n \"def import_tf(gpu_list):\\n import tensorflow as tf\\n os.environ['CUDA_VISIBLE_DEVICES'] = ','.join(gpu_list)\\n\\n return tf\",\n \"def benchmark_fake_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, data_dir=self.fake_data_dir, data_name='imagenet')\\n self._run_benchmark(params)\",\n \"def release_gpu_memory(device=0):\\n from numba import cuda\\n\\n K.clear_session()\\n cuda.select_device(device)\\n cuda.close()\\n return\",\n \"def prepare_device(n_gpu_use):\\n n_gpu = torch.cuda.device_count()\\n if n_gpu_use > 0 and n_gpu == 0:\\n print(\\\"Warning: There\\\\'s no GPU available on this machine,\\\"\\n \\\"training will be performed on CPU.\\\")\\n n_gpu_use = 0\\n if n_gpu_use > n_gpu:\\n print(f\\\"Warning: The number of GPU\\\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \\\"\\n \\\"available on this machine.\\\")\\n n_gpu_use = n_gpu\\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\\n list_ids = list(range(n_gpu_use))\\n return device, list_ids\",\n \"def prepare_device(n_gpu_use):\\n n_gpu = torch.cuda.device_count()\\n if n_gpu_use > 0 and n_gpu == 0:\\n print(\\\"Warning: There\\\\'s no GPU available on this machine,\\\"\\n \\\"training will be performed on CPU.\\\")\\n n_gpu_use = 0\\n if n_gpu_use > n_gpu:\\n print(f\\\"Warning: The number of GPU\\\\'s configured to use is {n_gpu_use}, but only {n_gpu} are \\\"\\n \\\"available on this machine.\\\")\\n n_gpu_use = n_gpu\\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\\n list_ids = list(range(n_gpu_use))\\n return device, list_ids\",\n \"def prepare_device(n_gpu_use):\\n n_gpu = torch.cuda.device_count()\\n if n_gpu_use > 0 and n_gpu == 0:\\n print(\\\"Warning: There\\\\'s no GPU available on this machine,\\\"\\n \\\"training will be performed on CPU.\\\")\\n n_gpu_use = 0\\n if n_gpu_use > n_gpu:\\n print(\\\"Warning: The number of GPU\\\\'s configured to use is {}, but only {} are available \\\"\\n \\\"on this machine.\\\".format(n_gpu_use, n_gpu))\\n n_gpu_use = n_gpu\\n device = torch.device('cuda:0' if n_gpu_use > 0 else 'cpu')\\n list_ids = list(range(n_gpu_use))\\n return device, list_ids\",\n \"def setup_gpu_and_random(config):\\n random.seed(config.general.manualSeed)\\n np.random.seed(config.general.manualSeed)\\n torch.manual_seed(config.general.manualSeed)\\n torch.cuda.manual_seed(config.general.manualSeed)\\n\\n cudnn.benchmark = True\\n cudnn.deterministic = True\\n config.num_gpu = torch.cuda.device_count()\\n\\n if config.num_gpu > 1:\\n print('------ Use multi-GPU setting ------')\\n print('if you stuck too long time with multi-GPU setting, try to set --workers 0')\\n # check multi-GPU issue https://github.com/clovaai/deep-text-recognition-benchmark/issues/1\\n config.workers = config.workers * config.num_gpu\\n config.batch_size = config.batch_size * config.num_gpu\\n\\n \\\"\\\"\\\" previous version\\n print('To equlize batch stats to 1-GPU setting, the batch_size is multiplied with num_gpu and multiplied batch_size is ', opt.batch_size)\\n opt.batch_size = opt.batch_size * opt.num_gpu\\n print('To equalize the number of epochs to 1-GPU setting, num_iter is divided with num_gpu by default.')\\n If you dont care about it, just commnet out these line.)\\n opt.num_iter = int(opt.num_iter / opt.num_gpu)\\n \\\"\\\"\\\"\",\n \"def benchmark_fp16_fake_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(\\n num_gpus=1, data_dir=self.fake_data_dir, data_name='imagenet')\\n self._run_benchmark(params)\",\n \"def detect_gpus():\\n def worker(q):\\n # `device_lib` will not release the memory it took,\\n # so we run it in a sub-process.\\n try:\\n from tensorflow.python.client import device_lib\\n\\n if is_tensorflow_version_higher_or_equal('1.8.0'):\\n config = tf.ConfigProto()\\n config.gpu_options.allow_growth = True\\n devices = list(device_lib.list_local_devices(config))\\n else:\\n devices = list(device_lib.list_local_devices())\\n gpus = [\\n (device.name, device)\\n for device in devices\\n if device.device_type == 'GPU'\\n ]\\n union_set = {i: i for i in range(len(gpus))}\\n\\n for i, (name, device) in enumerate(gpus):\\n assert (device.name == '/device:GPU:{}'.format(i))\\n for link in device.locality.links.link:\\n if link.device_id != i:\\n union_set[i] = union_set[link.device_id]\\n\\n for i in six.iterkeys(union_set):\\n while union_set[i] != union_set[union_set[i]]:\\n union_set[i] = union_set[union_set[i]]\\n\\n root_devices = sorted(set(union_set.values()))\\n gpu_groups = [[] for _ in range(len(root_devices))]\\n dev_to_group = {j: i for i, j in enumerate(root_devices)}\\n for i, (name, device) in enumerate(gpus):\\n gpu_groups[dev_to_group[union_set[i]]].append(name)\\n\\n q.put((1, gpu_groups))\\n except Exception:\\n q.put((0, traceback.format_exc()))\\n\\n q = mp.Queue()\\n p = mp.Process(target=worker, args=(q,))\\n\\n try:\\n p.start()\\n result = q.get()\\n if result[0] == 1:\\n return result[1]\\n else:\\n raise RuntimeError(\\n 'Failed to retrieve GPU information, the traceback of '\\n 'sub-process is:\\\\n {}'.\\n format('\\\\n '.join(result[1].split('\\\\n')))\\n )\\n finally:\\n p.terminate()\\n p.join()\",\n \"def return_free_GPU():\\r\\n if torch.cuda.is_available():\\r\\n gpu_num = torch.cuda.device_count()\\r\\n device = torch.device('cuda:{}'.format(gpu_num-1))\\r\\n print('Using GPU:[{}]/[{}] for training...'.format(gpu_num-1,gpu_num-1))\\r\\n return device\\r\\n \\r\\n raise ValueError('GPU not available for training. Check CUDA env with function \\\"check_cuda_env\\\"')\",\n \"def predict_distributed_gpu(filepath, file_chunks, output_filepath, model_path, batch_size, total_callers, threads_per_caller, device_ids, num_workers):\\n args = (filepath, output_filepath, model_path, batch_size, threads_per_caller, device_ids, num_workers)\\n mp.spawn(setup,\\n args=(total_callers, args, file_chunks),\\n nprocs=total_callers,\\n join=True)\",\n \"def setupGPUSwept(solver):\\n solver.gpuBlock = (slice(0,solver.sharedShape[0],1),)+solver.gpuBlock\\n getGPUReadBlockSwept(solver) #Finish creating gpuReadBlock here\\n blockShape =[element.stop for element in solver.gpuBlock]\\n blockShape[-1] += int(2*solver.blocksize[0]) #Adding 2 blocks in the column direction\\n # Creating local GPU array with split\\n grid = (int((blockShape[2])/solver.blocksize[0]),int((blockShape[3])/solver.blocksize[1])) #Grid size\\n #Creating constants\\n bsp = lambda x: int(numpy.prod(blockShape[x:])) #block shape product returned as an integer\\n const_dict = ({\\\"NV\\\":blockShape[1],'SX':blockShape[2],'SY':blockShape[3],\\\"VARS\\\":bsp(2),\\\"TIMES\\\":bsp(1),\\\"MPSS\\\":solver.maxPyramidSize,\\\"MOSS\\\":solver.maxOctSize,\\\"OPS\\\":solver.operating,\\\"ITS\\\":solver.intermediate})\\n solver.GPUArray = mallocGPUArray(blockShape) #Allocated GPU\\n solver.localGPUArray = numpy.zeros(blockShape)\\n #Building CUDA source code\\n solver.gpu = io.buildGPUSource(solver.gpu)\\n io.copyConstants(solver.gpu,const_dict) #This copys cpu constants not global constants\\n solver.cpu.set_globals(*solver.globals,source_mod=solver.gpu)\\n # Make GPU geometry\\n solver.Up.initializeGPU(solver.gpu.get_function(\\\"UpPyramid\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Oct.initializeGPU(solver.gpu.get_function(\\\"Octahedron\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Down.initializeGPU(solver.gpu.get_function(\\\"DownPyramid\\\"),solver.blocksize,(grid[0],grid[1]-1))\\n solver.Yb.initializeGPU(solver.gpu.get_function(\\\"YBridge\\\"),solver.blocksize,grid)\\n solver.Xb.initializeGPU(solver.gpu.get_function(\\\"XBridge\\\"),solver.blocksize,grid)\",\n \"def handle_gpu_compatibility():\\n try:\\n gpus = tf.config.experimental.list_physical_devices(\\\"GPU\\\")\\n for gpu in gpus:\\n tf.config.experimental.set_memory_growth(gpu, True)\\n except Exception as e:\\n print(e)\",\n \"def test_gpu_memory(self):\\n m = pyflamegpu.ModelDescription(\\\"test_gpu_memory_test\\\")\\n a = m.newAgent(\\\"agent\\\")\\n a.newVariableInt(\\\"id\\\")\\n p = pyflamegpu.AgentVector(a, AGENT_COUNT)\\n for i in range(AGENT_COUNT):\\n instance = p[i]\\n instance.setVariableInt(\\\"id\\\", i)\\n cm = pyflamegpu.CUDASimulation(m)\\n # copy to device then back by setting and getting population data\\n cm.setPopulationData(p)\\n cm.getPopulationData(p)\\n # check values are the same\\n for i in range(AGENT_COUNT):\\n instance = p[i]\\n assert instance.getVariableInt(\\\"id\\\") == i\",\n \"def ConvertGpuToVendorName(gpu):\\n if not gpu:\\n return 'No GPU'\\n elif '8086' in gpu:\\n return 'Intel'\\n elif '10de' in gpu:\\n return 'NVIDIA'\\n elif '1002' in gpu:\\n return 'AMD'\\n return gpu\",\n \"def check_gpu(self, values):\\n try:\\n process = subprocess.Popen(['nvidia-smi', '--query-gpu=name,pci.bus_id,driver_version,pstate,pcie.link.gen.max,pcie.link.gen.current,temperature.gpu,utilization.gpu,utilization.memory,memory.total,memory.free,memory.used', '--format=csv'], stdout=subprocess.PIPE)\\n out_str, _ = process.communicate()\\n gpu_strs = out_str.split('\\\\n')\\n\\n # Get rid of the column headers.\\n if len(gpu_strs) > 0:\\n gpu_strs = gpu_strs[1:]\\n\\n # Process each GPU string.\\n multi_gpu = len(gpu_strs) > 1\\n gpu_index = 1\\n for gpu_str in gpu_strs:\\n out = gpu_str.split(',')\\n if len(out) > 1:\\n if multi_gpu:\\n values[keys.KEY_GPUX_NAME.replace('X', str(gpu_index))] = out[0].strip(' \\\\t\\\\n\\\\r')\\n values[keys.KEY_GPUX_TEMPERATURE.replace('X', str(gpu_index))] = int(out[6].strip(' \\\\t\\\\n\\\\r'))\\n values[keys.KEY_GPUX_PERCENT.replace('X', str(gpu_index))] = int(out[7].strip(' \\\\t\\\\n\\\\r%%s'))\\n gpu_index = gpu_index + 1\\n else:\\n values[keys.KEY_GPU_NAME] = out[0].strip(' \\\\t\\\\n\\\\r')\\n values[keys.KEY_GPU_TEMPERATURE] = int(out[6].strip(' \\\\t\\\\n\\\\r'))\\n values[keys.KEY_GPU_PERCENT] = int(out[7].strip(' \\\\t\\\\n\\\\r%%s'))\\n except:\\n logging.error(\\\"Error collecting GPU stats.\\\")\",\n \"def benchmark_fp16_xla_compile_fake_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(\\n num_gpus=1,\\n data_dir=self.fake_data_dir,\\n data_name='imagenet',\\n xla_compile=True)\\n self._run_benchmark(params)\",\n \"def set_max_gpu(self):\\r\\n gpu_getter = GPUGetter()\\r\\n gpu = str(gpu_getter.get_free_gpu())\\r\\n\\r\\n if gpu:\\r\\n print(\\\"Using GPU: %s\\\" % gpu)\\r\\n os.environ[\\\"CUDA_DEVICE_ORDER\\\"] = \\\"PCI_BUS_ID\\\" # see issue #152\\r\\n os.environ['CUDA_VISIBLE_DEVICES'] = gpu\\r\\n\\r\\n if not gpu:\\r\\n print('No GPU detected')\",\n \"def _get_gpu_names() -> Sequence[str]:\\n result = []\\n for device in device_lib.list_local_devices():\\n if device.device_type != \\\"GPU\\\":\\n continue\\n desc = device.physical_device_desc\\n\\n fields = desc.split(\\\",\\\")\\n for field in fields:\\n name, value = field.split(\\\":\\\", maxsplit=1)\\n name = name.strip()\\n value = value.strip()\\n if name == \\\"name\\\":\\n result.append(value)\\n return result\",\n \"def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(num_gpus=1, xla=True)\\n self._run_benchmark(params)\",\n \"def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\\n config = Config()\\n params = experiment_params()\\n model_tools.model_builder(\\n params=params,\\n config=config,\\n model_spec=build_model,\\n gpu_device=gpu_device,\\n cpu_device=cpu_device)\",\n \"def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):\\n config = Config()\\n params = experiment_params()\\n model_tools.model_builder(\\n params=params,\\n config=config,\\n model_spec=build_model,\\n gpu_device=gpu_device,\\n cpu_device=cpu_device)\",\n \"def benchmark_fp16_synth_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(\\n num_gpus=1, variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def CUDA(self):\\n\\n if helpers.CUDA:\\n self.generator.cuda()\\n self.discriminator.cuda()\\n self.adv_loss.cuda()\",\n \"def set_device(in_arg): \\n \\n return torch.device(\\\"cuda\\\" if torch.cuda.is_available() and in_arg.gpu == 1 else \\\"cpu\\\")\",\n \"def _next_device(self):\\n if self._num_gpus == 0:\\n return ''\\n dev = '/gpu:%d' % self._cur_gpu\\n if self._num_gpus > 1:\\n self._cur_gpu = (self._cur_gpu + 1) % (self._num_gpus-1)\\n return dev\",\n \"def main():\\n args = arg_parser()\\n if(args.gpu):\\n gpu = args.gpu\\n else:\\n print(\\\"GPU mode not specified, will use the default value - Use GPU\\\")\\n gpu = \\\"Y\\\"\\n # Device setting:\\n device = device_setting(gpu)\\n \\n # Prepare the datasets and dataloaders:\\n print(\\\"\\\\nPreparing dataset for train/valid/test ...\\\")\\n train_loader, valid_loader, test_loader, train_data, valid_data, test_data = load_dataset()\\n \\n # Model architects, criterion and optimizer:\\n print(\\\"\\\\nNetwork archetecture building ...\\\")\\n model, criterion, optimizer = network(device=device,\\n architecture=args.architecture,\\n learning_rate=args.learning_rate,\\n hidden_size=args.hidden_size,\\n dropout=args.dropout,\\n output_size=args.output_size)\\n \\n # Train the model:\\n print(\\\"\\\\n\\\")\\n model = train(model=model,\\n epochs=5,\\n learning_rate=args.learning_rate,\\n criterion=criterion,\\n optimizer=optimizer,\\n train_loader=train_loader,\\n valid_loader=valid_loader,\\n device=device)\\n \\n # Validate the model performance on the test set:\\n print(\\\"\\\\nValidate model performance on test set ...\\\")\\n test(model=model, test_loader=test_loader, device=device)\\n \\n # Save model checkpoint:\\n print(\\\"\\\\nSave model checkpoint ...\\\")\\n save(model=model, train_data=train_data, epochs=args.epochs, architecture=args.architecture)\",\n \"def test_nvidia_driver1():\\r\\n a = numpy.random.rand(10000).astype(\\\"float32\\\")\\r\\n A = cuda.shared_constructor(a)\\r\\n f = theano.function(inputs=[], outputs=A.sum(), mode=mode_with_gpu,\\r\\n profile=False)\\r\\n topo = f.maker.fgraph.toposort()\\r\\n assert len(topo) == 2\\r\\n if sum(isinstance(node.op, B.GpuCAReduce) for node in topo) != 1:\\r\\n msg = '\\\\n\\\\t'.join(['Expected exactly one occurrence of GpuCAReduce ' +\\r\\n 'but got:']+[str(app) for app in topo])\\r\\n raise AssertionError(msg)\\r\\n if not numpy.allclose(f(), a.sum()):\\r\\n raise Exception(\\\"The nvidia driver version installed with this OS \\\"\\r\\n \\\"does not give good results for reduction.\\\"\\r\\n \\\"Installing the nvidia driver available on the same \\\"\\r\\n \\\"download page as the cuda package will fix the \\\"\\r\\n \\\"problem: http://developer.nvidia.com/cuda-downloads\\\")\",\n \"def mat_device(self): # pylint: disable=C0103\\n if cp is None:\\n raise ModuleNotFoundError(\\\"Could not import cupy -- cannot use GPU!\\\")\\n if self._mat_device is None:\\n gp_device = cp.array(self._gp)\\n object.__setattr__(\\n self,\\n \\\"_mat_device\\\",\\n cp.diag(self._disp_over_m) - gp_device.reshape(-1, 1) * gp_device,\\n )\\n return self._mat_device\",\n \"def set_device(gpu_arg):\\n\\n dev = 'cpu'\\n if gpu_arg and torch.cuda.is_available():\\n dev = 'cuda'\\n elif gpu_arg:\\n print('Not gpu found. Using cpu instead.') \\n\\n return torch.device(dev)\",\n \"def main():\\n\\n obj = PowerStoreNfsExport()\\n obj.perform_module_operation()\",\n \"def execute(gpu, exp_batch, exp_alias, suppress_output=True, number_of_workers=12):\\n try:\\n os.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = ','.join(gpu)\\n g_conf.VARIABLE_WEIGHT = {}\\n\\n # At this point the log file with the correct naming is created.\\n # You merge the yaml file with the global configuration structure.\\n merge_with_yaml(os.path.join('configs', exp_batch, exp_alias + '.yaml'))\\n set_type_of_process('train')\\n\\n # Set the process into loading status.\\n coil_logger.add_message('Loading', {'GPU': gpu})\\n\\n # Put the output to a separate file if it is the case\\n if suppress_output:\\n if not os.path.exists('_output_logs'):\\n os.mkdir('_output_logs')\\n sys.stdout = open(os.path.join('_output_logs', exp_alias + '_' +\\n g_conf.PROCESS_NAME + '_' + str(os.getpid()) + \\\".out\\\"), \\\"a\\\",\\n buffering=1)\\n sys.stderr = open(os.path.join('_output_logs',\\n exp_alias + '_err_'+g_conf.PROCESS_NAME + '_'\\n + str(os.getpid()) + \\\".out\\\"),\\n \\\"a\\\", buffering=1)\\n\\n if coil_logger.check_finish('train'):\\n coil_logger.add_message('Finished', {})\\n return\\n\\n # Preload option\\n if g_conf.PRELOAD_MODEL_ALIAS is not None:\\n checkpoint = torch.load(os.path.join('_logs', g_conf.PRELOAD_MODEL_BATCH,\\n g_conf.PRELOAD_MODEL_ALIAS,\\n 'checkpoints',\\n str(g_conf.PRELOAD_MODEL_CHECKPOINT)+'.pth'))\\n\\n\\n # Get the latest checkpoint to be loaded\\n # returns none if there are no checkpoints saved for this model\\n checkpoint_file = get_latest_saved_checkpoint()\\n if checkpoint_file is not None:\\n checkpoint = torch.load(os.path.join('_logs', exp_batch, exp_alias,\\n 'checkpoints', str(get_latest_saved_checkpoint())))\\n iteration = checkpoint['iteration']\\n best_loss = checkpoint['best_loss']\\n best_loss_iter = checkpoint['best_loss_iter']\\n print ('iteration: ', iteration, 'best_loss: ', best_loss)\\n else:\\n iteration = 0\\n best_loss = 10000.0\\n best_loss_iter = 0\\n\\n\\n # Define the dataset. This structure is has the __get_item__ redefined in a way\\n # that you can access the positions from the root directory as a in a vector.\\n full_dataset = os.path.join(os.environ[\\\"COIL_DATASET_PATH\\\"], g_conf.TRAIN_DATASET_NAME)\\n\\n # By instantiating the augmenter we get a callable that augment images and transform them into tensors.\\n augmenter = Augmenter(g_conf.AUGMENTATION)\\n\\n # Instantiate the class used to read the dataset\\n dataset = CoILDataset(full_dataset, transform=augmenter, preload_name=str(g_conf.NUMBER_OF_HOURS)+'hours_'+g_conf.TRAIN_DATASET_NAME)\\n print (\\\"Loaded dataset\\\")\\n \\n # Creates the sampler, this part is responsible for managing the keys. It divides\\n # all keys depending on the measurements and produces a set of keys for each bach.\\n # define the sampling strategy for mini-batch, different samplers can be found in 'splitter.py'\\n data_loader = select_balancing_strategy(dataset, iteration, number_of_workers)\\n\\n # Instatiate the network architecture\\n model = CoILModel(g_conf.MODEL_TYPE, g_conf.MODEL_CONFIGURATION)\\n model.cuda()\\n\\n optimizer = optim.Adam(model.parameters(), lr=g_conf.LEARNING_RATE) # adabound and adamio can also be used here\\n\\n if checkpoint_file is not None or g_conf.PRELOAD_MODEL_ALIAS is not None:\\n model.load_state_dict(checkpoint['state_dict'])\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n accumulated_time = checkpoint['total_time']\\n loss_window = coil_logger.recover_loss_window('train', iteration)\\n else: \\n # We accumulate iteration time and keep the average speed\\n accumulated_time = 0\\n loss_window = []\\n\\n # freeze the perception module weights if required\\n # for m in model.perception.parameters():\\n # m.requires_grad = False\\n \\n # total trainable parameters\\n model_parameters = filter(lambda p: p.requires_grad, model.parameters())\\n total_params = sum([np.prod(p.size()) for p in model_parameters])\\n print ('trainable parameters: ', total_params)\\n\\n # multi-gpu\\n print ('number of gpus: ', torch.cuda.device_count())\\n if torch.cuda.device_count() > 1:\\n model = nn.DataParallel(model)\\n\\n criterion = Loss(g_conf.LOSS_FUNCTION)\\n\\n print ('Start Training')\\n\\n st = time.time()\\n for data in data_loader:\\n\\n # use this for early stopping if the validation loss is not coming down\\n if g_conf.FINISH_ON_VALIDATION_STALE is not None and \\\\\\n check_loss_validation_stopped(iteration, g_conf.FINISH_ON_VALIDATION_STALE):\\n break\\n\\n \\\"\\\"\\\"\\n ####################################\\n Main optimization loop\\n ####################################\\n \\\"\\\"\\\"\\n\\n iteration += 1\\n\\n if iteration % 1000 == 0:\\n adjust_learning_rate_auto(optimizer, loss_window)\\n \\n # additional learning rate scheduler - cyclic cosine annealing (https://arxiv.org/pdf/1704.00109.pdf)\\n # adjust_learning_rate_cosine_annealing(optimizer, loss_window, iteration)\\n\\n capture_time = time.time()\\n controls = data['directions']\\n model.zero_grad()\\n branches = model(torch.squeeze(data['rgb'].cuda()),\\n dataset.extract_inputs(data).cuda())\\n loss_function_params = {\\n 'branches': branches,\\n 'targets': dataset.extract_targets(data).cuda(),\\n 'controls': controls.cuda(),\\n 'inputs': dataset.extract_inputs(data).cuda(),\\n 'branch_weights': g_conf.BRANCH_LOSS_WEIGHT,\\n 'variable_weights': g_conf.VARIABLE_WEIGHT\\n }\\n loss, _ = criterion(loss_function_params)\\n loss.backward()\\n optimizer.step()\\n \\\"\\\"\\\"\\n ####################################\\n Saving the model if necessary\\n ####################################\\n \\\"\\\"\\\"\\n\\n if is_ready_to_save(iteration):\\n if torch.cuda.device_count() > 1:\\n state_dict_save = model.module.state_dict()\\n else:\\n state_dict_save = model.state_dict()\\n\\n state = {\\n 'iteration': iteration,\\n 'state_dict': state_dict_save,\\n 'best_loss': best_loss,\\n 'total_time': accumulated_time,\\n 'optimizer': optimizer.state_dict(),\\n 'best_loss_iter': best_loss_iter\\n }\\n torch.save(state, os.path.join('_logs', exp_batch, exp_alias\\n , 'checkpoints', str(iteration) + '.pth'))\\n\\n \\\"\\\"\\\"\\n ################################################\\n Adding tensorboard logs.\\n Making calculations for logging purposes.\\n These logs are monitored by the printer module.\\n #################################################\\n \\\"\\\"\\\"\\n coil_logger.add_scalar('Loss', loss.data, iteration)\\n coil_logger.add_image('Image', torch.squeeze(data['rgb']), iteration)\\n if loss.data < best_loss:\\n best_loss = loss.data.tolist()\\n best_loss_iter = iteration\\n\\n # Log a random position\\n position = random.randint(0, len(data) - 1)\\n\\n if torch.cuda.device_count() > 1:\\n output = model.module.extract_branch(torch.stack(branches[0:4]), controls)\\n else:\\n output = model.extract_branch(torch.stack(branches[0:4]), controls)\\n error = torch.abs(output - dataset.extract_targets(data).cuda())\\n\\n accumulated_time += time.time() - capture_time\\n\\n coil_logger.add_message('Iterating',\\n {'Iteration': iteration,\\n 'Loss': loss.data.tolist(),\\n 'Images/s': (iteration * g_conf.BATCH_SIZE) / accumulated_time,\\n 'BestLoss': best_loss, 'BestLossIteration': best_loss_iter,\\n 'Output': output[position].data.tolist(),\\n 'GroundTruth': dataset.extract_targets(data)[\\n position].data.tolist(),\\n 'Error': error[position].data.tolist(),\\n 'Inputs': dataset.extract_inputs(data)[\\n position].data.tolist()},\\n iteration)\\n loss_window.append(loss.data.tolist())\\n coil_logger.write_on_error_csv('train', loss.data)\\n print(\\\"Iteration: %d Loss: %f\\\" % (iteration, loss.data))\\n st = time.time()\\n\\n coil_logger.add_message('Finished', {})\\n \\n except KeyboardInterrupt:\\n coil_logger.add_message('Error', {'Message': 'Killed By User'})\\n\\n except RuntimeError as e:\\n\\n coil_logger.add_message('Error', {'Message': str(e)})\\n\\n except:\\n traceback.print_exc()\\n coil_logger.add_message('Error', {'Message': 'Something Happened'})\",\n \"def benchmark_ng_xla_batch64_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, batch_size=64, variable_update='parameter_server', xla=True)\\n self._run_benchmark(params)\",\n \"def bc_train_nvidia():\\n\\timg_rows,img_cols = 64,64\\n\\tinput_shape = (img_rows,img_cols,3)\\n\\n\\t# the model\\t\\n\\tmodel = bc_nvidia_model(input_shape = input_shape)\\n\\n\\t\\n\\timg_dim = (img_rows,img_cols)\\n\\n\\t# reading the drivelog\\t\\n\\tcsv_data = pd.read_csv(data_path+csv_path,usecols=[\\\"center\\\",\\\"left\\\",\\\"right\\\",\\\"steering\\\"])\\n\\n\\tthreshold = 1\\n\\tbatch_size = 240\\n\\tepochs = 6\\n\\tyvals = []\\n\\n\\tfor i in range(epochs):\\n\\t\\tgen = generate_data_train(data_path,csv_data,img_dim,batch_size,threshold,yvals)\\n\\t\\t\\n\\t\\tmodel.fit_generator(gen, samples_per_epoch = 24000, nb_epoch = 1, verbose = 1)\\n\\n\\t\\t# thresholding against values close to 0 to balance the data\\n\\t\\tthreshold = 1/(i+1)\\n\\t\\n\\t# serialize model to JSON\\n\\tmodel_json = model.to_json()\\n\\twith open(\\\"model.json\\\", \\\"w\\\") as json_file:\\n\\t json_file.write(model_json)\\n\\t# serialize weights to HDF5\\n\\tmodel.save_weights(\\\"model.h5\\\")\\n\\twith open(\\\"s_angles\\\",\\\"wb\\\") as y_file:\\n\\t\\tpickle.dump(yvals,y_file)\\n\\treturn\",\n \"def setup_CL():\\n\\n #Set up openCL platform\\n NAME = 'NVIDIA CUDA'\\n platforms = cl.get_platforms()\\n\\n dev = None\\n for p in platforms:\\n #Easy switching for local vs remote machine\\n if p.name == 'Apple':\\n NAME = 'Apple'\\n if p.name == NAME:\\n dev = p.get_devices()\\n\\n # Command queue, enable GPU profiling\\n ctx = cl.Context(dev)\\n queue = cl.CommandQueue(ctx,properties=cl.command_queue_properties.PROFILING_ENABLE)\\n\\n return [dev,ctx,queue]\",\n \"def load_to_gpu(path: str) ->Dict[str, Any]:\\n with PathManager.open(path, 'rb') as f:\\n state = torch.load(f, map_location=lambda s, _: torch.serialization.default_restore_location(s, 'cuda'))\\n return state\",\n \"def benchmark_fp16_xla_batch64_synth_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(\\n num_gpus=1,\\n batch_size=64,\\n variable_update='parameter_server',\\n xla=True)\\n self._run_benchmark(params)\",\n \"def _add_gpu(self, gpu_count):\\n if not gpu_count or gpu_count == 0:\\n return\\n\\n logger.debug(\\n \\\"found resource request for {} GPUs. This will limit to n1 \\\"\\n \\\"instance types.\\\".format(gpu_count)\\n )\\n self.workflow.default_resources.parsed[\\\"nvidia_gpu\\\"] = gpu_count\\n self.workflow.default_resources.args.append(\\\"nvidia_gpu=%s\\\" % gpu_count)\\n self._machine_type_prefix = self._machine_type_prefix or \\\"\\\"\\n if not self._machine_type_prefix.startswith(\\\"n1\\\"):\\n self._machine_type_prefix = \\\"n1\\\"\",\n \"def cuda_test():\\n # This flag enable the inbuilt cudnn auto-tuner\\n torch.backends.cudnn.benchmark = True\\n\\n print('\\\\n__Python VERSION :', sys.version)\\n print('__pyTorch VERSION :', torch.__version__)\\n print('__CUDA VERSION : ', torch.version.cuda)\\n print('__CUDNN VERSION : ', torch.backends.cudnn.version())\\n print('__Number CUDA Devices : ', torch.cuda.device_count())\\n print('__Devices : ')\\n\\n call([\\\"nvidia-smi\\\", \\\"--format=csv\\\", \\n \\\"--query-gpu=index,name,driver_version,memory.total,memory.used,memory.free\\\"])\\n\\n print('Active CUDA Device: GPU', torch.cuda.current_device())\\n print ('Available devices ', torch.cuda.device_count())\\n print ('Current cuda device ', torch.cuda.current_device())\\n\\n return torch.cuda.is_available()\",\n \"def benchmark_fp16_fake_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(\\n num_gpus=1,\\n data_dir=self.fake_data_dir,\\n data_name='imagenet',\\n variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def module_transfer_to_device(self) -> None:\\n for name, module in self.modules.items():\\n module.to(self.device)\\n if self.device.type == 'cuda':\\n self.modules[name] = torch.nn.DataParallel(module, self.gpu_ids)\\n return\",\n \"def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(\\n num_gpus=1, variable_update='parameter_server', xla=True)\\n self._run_benchmark(params)\",\n \"def dicom_cli():\",\n \"def to_multi_gpu(model, n_gpus=4):\\n\\n with tf.device('/cpu:0'):\\n x = Input(model.input_shape[1:], name=model.input_names[0])\\n towers = []\\n device=[0,1,2,3]\\n for g in range(n_gpus):\\n with tf.device('/gpu:' + str(device[g])):\\n slice_g = Lambda(slice_batch, lambda shape: shape,\\n arguments={'n_gpus':n_gpus, 'part':g})(x)\\n towers.append(model(slice_g))\\n\\n with tf.device('/cpu:0'):\\n merged = merge(towers, mode='concat', concat_axis=0)\\n\\n return Model(inputs=[x], outputs=merged)\",\n \"def benchmark_fp16_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, use_fp16=True, variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def benchmark_fp16_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, use_fp16=True, variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def benchmark_fp16_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, use_fp16=True, variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def benchmark_fp16_xla_compile_synth_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(num_gpus=1, xla_compile=True)\\n self._run_benchmark(params)\",\n \"def benchmark_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def benchmark_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def benchmark_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, variable_update='parameter_server')\\n self._run_benchmark(params)\",\n \"def _create_device(self):\\n return torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\",\n \"def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, variable_update='parameter_server', xla=True, use_fp16=True)\\n self._run_benchmark(params)\",\n \"def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, variable_update='parameter_server', xla=True, use_fp16=True)\\n self._run_benchmark(params)\",\n \"def benchmark_fp16_xla_synth_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1, variable_update='parameter_server', xla=True, use_fp16=True)\\n self._run_benchmark(params)\",\n \"def main():\\n TOTAL_NUM = 500\\n IMG_NAME = 'img'\\n LABEL_NAME = 'label'\\n\\n img = fluid.layers.data(name=IMG_NAME, shape=[1, 28, 28], dtype='float32')\\n # gradient should flow\\n img.stop_gradient = False\\n label = fluid.layers.data(name=LABEL_NAME, shape=[1], dtype='int64')\\n logits = mnist_cnn_model(img)\\n cost = fluid.layers.cross_entropy(input=logits, label=label)\\n avg_cost = fluid.layers.mean(x=cost)\\n\\n # use CPU\\n place = fluid.CPUPlace()\\n # use GPU\\n # place = fluid.CUDAPlace(0)\\n exe = fluid.Executor(place)\\n\\n BATCH_SIZE = 1\\n train_reader = paddle.batch(\\n paddle.reader.shuffle(\\n paddle.dataset.mnist.train(), buf_size=128 * 10),\\n batch_size=BATCH_SIZE)\\n\\n test_reader = paddle.batch(\\n paddle.reader.shuffle(\\n paddle.dataset.mnist.test(), buf_size=128 * 10),\\n batch_size=BATCH_SIZE)\\n\\n fluid.io.load_params(\\n exe, \\\"./mnist/\\\", main_program=fluid.default_main_program())\\n\\n # advbox demo\\n m = PaddleModel(\\n fluid.default_main_program(),\\n IMG_NAME,\\n LABEL_NAME,\\n logits.name,\\n avg_cost.name, (-1, 1),\\n channel_axis=1)\\n attack = JSMA(m)\\n attack_config = {\\n \\\"max_iter\\\": 2000,\\n \\\"theta\\\": 0.1,\\n \\\"max_perturbations_per_pixel\\\": 7\\n }\\n\\n # use train data to generate adversarial examples\\n total_count = 0\\n fooling_count = 0\\n for data in train_reader():\\n total_count += 1\\n adversary = Adversary(data[0][0], data[0][1])\\n\\n # JSMA non-targeted attack\\n adversary = attack(adversary, **attack_config)\\n\\n # JSMA targeted attack\\n # tlabel = 0\\n # adversary.set_target(is_targeted_attack=True, target_label=tlabel)\\n # adversary = attack(adversary, **attack_config)\\n\\n # JSMA may return None\\n if adversary is not None and adversary.is_successful():\\n fooling_count += 1\\n print(\\n 'attack success, original_label=%d, adversarial_label=%d, count=%d'\\n % (data[0][1], adversary.adversarial_label, total_count))\\n # plt.imshow(adversary.target, cmap='Greys_r')\\n # plt.show()\\n # np.save('adv_img', adversary.target)\\n else:\\n print('attack failed, original_label=%d, count=%d' %\\n (data[0][1], total_count))\\n\\n if total_count >= TOTAL_NUM:\\n print(\\n \\\"[TRAIN_DATASET]: fooling_count=%d, total_count=%d, fooling_rate=%f\\\"\\n % (fooling_count, total_count,\\n float(fooling_count) / total_count))\\n break\\n\\n # use test data to generate adversarial examples\\n total_count = 0\\n fooling_count = 0\\n for data in test_reader():\\n total_count += 1\\n adversary = Adversary(data[0][0], data[0][1])\\n\\n # JSMA non-targeted attack\\n adversary = attack(adversary, **attack_config)\\n\\n # JSMA targeted attack\\n # tlabel = 0\\n # adversary.set_target(is_targeted_attack=True, target_label=tlabel)\\n # adversary = attack(adversary, **attack_config)\\n\\n # JSMA may return None\\n if adversary is not None and adversary.is_successful():\\n fooling_count += 1\\n print(\\n 'attack success, original_label=%d, adversarial_label=%d, count=%d'\\n % (data[0][1], adversary.adversarial_label, total_count))\\n # plt.imshow(adversary.target, cmap='Greys_r')\\n # plt.show()\\n # np.save('adv_img', adversary.target)\\n else:\\n print('attack failed, original_label=%d, count=%d' %\\n (data[0][1], total_count))\\n\\n if total_count >= TOTAL_NUM:\\n print(\\n \\\"[TEST_DATASET]: fooling_count=%d, total_count=%d, fooling_rate=%f\\\"\\n % (fooling_count, total_count,\\n float(fooling_count) / total_count))\\n break\\n print(\\\"jsma attack done\\\")\",\n \"def test_gpu_simulation(self):\\n m = pyflamegpu.ModelDescription(\\\"test_gpu_memory_test\\\")\\n a = m.newAgent(\\\"agent\\\")\\n a.newVariableInt(\\\"id\\\")\\n a.newVariableInt(\\\"x\\\")\\n func = a.newRTCFunction(\\\"add_func\\\", self.add_func)\\n p = pyflamegpu.AgentVector(a, AGENT_COUNT)\\n for i in range(AGENT_COUNT):\\n instance = p[i]\\n instance.setVariableInt(\\\"x\\\", i)\\n layer = m.newLayer(\\\"add_layer\\\")\\n layer.addAgentFunction(func)\\n cm = pyflamegpu.CUDASimulation(m)\\n cm.SimulationConfig().steps = 5\\n cm.setPopulationData(p)\\n cm.simulate()\\n # Re-use the same population to read back the simulation step results\\n cm.getPopulationData(p)\\n # check values are the same\\n for i in range(AGENT_COUNT):\\n instance = p[i]\\n # use AgentInstance equality operator\\n assert instance.getVariableInt(\\\"x\\\") == (i + (2 * 5))\",\n \"def trainer(current_gpu, args):\\n\\n model_history = train_utils.init_model_history()\\n batch_size = args.batch_size\\n num_epochs = args.num_epochs\\n feature_extract = False\\n\\n model = train_utils.initialize_ft_model(args.model_name, num_classes=args.num_classes, feature_extract=feature_extract)\\n model, args = dist_setting(current_gpu, model, args)\\n logger.info(f\\\"==> Training on rank {args.rank}.\\\")\\n logger.info(args)\\n \\n dataloaders, transforms, train_sampler = train_utils.create_dataloaders(\\n args.train_dir, args.valid_dir, rank=args.rank, \\n world_size=args.world_size, batch_size=batch_size,\\n num_workers=args.num_workers\\n )\\n \\n optimizer = train_utils.initialize_optimizer(model, feature_extract, lr=args.lr*args.world_size, momentum=0.9) \\n criterion = nn.CrossEntropyLoss()\\n\\n since = time.time()\\n val_acc_history = []\\n best_model_wts = copy.deepcopy(model.state_dict())\\n best_acc1 = 0.0\\n num_samples = {k: len(dataloaders[k].dataset) for k, v in dataloaders.items()}\\n num_steps = {k: int(np.ceil(len(dataloaders[k].dataset) / (batch_size*args.world_size))) for k, v in dataloaders.items()}\\n device = torch.device(f'cuda:{current_gpu}') \\n\\n for epoch in range(1, num_epochs+1):\\n \\n batch_time = train_utils.AverageMeter('Time', ':6.3f')\\n data_time = train_utils.AverageMeter('Data', ':6.3f')\\n losses = train_utils.AverageMeter('Loss', ':.4e')\\n top1 = train_utils.AverageMeter('Acc@1', ':6.2f')\\n \\n logger.info('-' * 40)\\n logger.info('[Rank {}, Epoch {}/{}] Processing...'.format(args.rank, epoch, num_epochs))\\n logger.info('-' * 40)\\n\\n # Each epoch has a training and validation phase\\n for phase in ['train', 'valid']: \\n\\n if phase == 'train':\\n model.train() # Set model to training mode\\n if args.multigpus_distributed:\\n dataloaders[phase].sampler.set_epoch(epoch) # Set epoch count for DistributedSampler \\n else:\\n model.eval() # Set model to evaluate mode\\n\\n running_loss = 0.0\\n running_corrects = 0\\n epoch_tic = time.time() \\n tic = time.time()\\n \\n for i, (inputs, labels) in enumerate(dataloaders[phase]):\\n # measure data loading time\\n data_time.update(time.time() - tic) \\n \\n inputs = inputs.to(device)\\n labels = labels.to(device)\\n\\n optimizer.zero_grad()\\n\\n with torch.set_grad_enabled(phase=='train'):\\n outputs = model(inputs)\\n loss = criterion(outputs, labels)\\n probs, preds = torch.max(outputs, 1)\\n \\n # Compute gradient and do stochastic gradient descent\\n if phase == 'train':\\n loss.backward()\\n optimizer.step()\\n \\n running_loss += loss.item() * inputs.size(0)\\n running_corrects += torch.sum(preds == labels.data)\\n acc1 = train_utils.accuracy(outputs, labels, topk=(1,))\\n \\n # Average loss and accuracy across processes for logging\\n if args.multigpus_distributed:\\n reduced_loss = train_utils.reduce_tensor(loss.data, args)\\n reduced_acc1 = train_utils.reduce_tensor(acc1[0], args)\\n else:\\n reduced_loss = loss.data\\n reduced_acc1 = acc1[0]\\n\\n losses.update(train_utils.to_python_float(reduced_loss), inputs.size(0))\\n top1.update(train_utils.to_python_float(reduced_acc1), inputs.size(0))\\n \\n # measure elapsed time\\n batch_time.update(time.time() - tic)\\n tic = time.time()\\n\\n if phase == 'train' and i % args.log_interval == 0:\\n step_loss = running_loss / ((i+1)*batch_size)\\n step_acc = running_corrects.double() / ((i+1)*batch_size)\\n logger.info(f'[Rank {args.rank}, Epoch {epoch}/{num_epochs}, Step {i+1}/{num_steps[phase]}] {phase}-acc: {step_acc:.4f}, '\\n f'{phase}-loss: {step_loss:.4f}, data-time: {data_time.val:.4f}, batch-time: {batch_time.val:.4f}') \\n \\n\\n ## Waiting until finishing operations on GPU (Pytorch default: async)\\n torch.cuda.synchronize()\\n \\n if current_gpu == 0: \\n logger.info(f'[Epoch {epoch}/{num_epochs}] {phase}-acc: {top1.avg:.4f}, '\\n f'{phase}-loss: {losses.val:.4f}, time: {time.time()-epoch_tic:.4f}') \\n \\n model_history['epoch'].append(epoch)\\n model_history['batch_idx'].append(i)\\n model_history['data_time'].append(data_time.val) \\n model_history['batch_time'].append(batch_time.val)\\n model_history['losses'].append(losses.val)\\n model_history['top1'].append(top1.val)\\n\\n if phase == 'valid':\\n is_best = top1.avg > best_acc1\\n best_acc1 = max(top1.avg, best_acc1)\\n \\n if (args.multigpus_distributed and args.rank % args.num_gpus == 0):\\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \\n train_utils.save_model({\\n 'epoch': epoch + 1,\\n 'model_name': args.model_name,\\n 'state_dict': model.module.state_dict(),\\n 'optimizer': optimizer.state_dict(),\\n 'best_acc1': best_acc1,\\n 'loss': losses\\n }, is_best, args.model_chkpt_dir, args.model_dir)\\n elif not args.multigpus_distributed:\\n #train_utils.save_history(os.path.join(args.output_data_dir, 'model_history.p'), model_history) \\n train_utils.save_model({\\n 'epoch': epoch + 1,\\n 'model_name': args.model_name,\\n 'state_dict': model.state_dict(),\\n 'optimizer': optimizer.state_dict(),\\n 'best_acc1': best_acc1,\\n 'loss': losses\\n }, is_best, args.model_chkpt_dir, args.model_dir) \\n \\n \\n time_elapsed = time.time() - since\\n if current_gpu == 0:\\n logger.info('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\\n logger.info('Best val acc: {:.4f}'.format(best_acc1))\\n \\n if args.multigpus_distributed:\\n dist_cleanup()\",\n \"def benchmark_xla_fake_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1,\\n data_dir=self.fake_data_dir,\\n data_name='imagenet',\\n variable_update='parameter_server',\\n xla=True)\\n self._run_benchmark(params)\",\n \"def benchmark_xla_fake_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1,\\n data_dir=self.fake_data_dir,\\n data_name='imagenet',\\n variable_update='parameter_server',\\n xla=True)\\n self._run_benchmark(params)\",\n \"def benchmark_xla_fake_1gpu_gpuparams(self):\\n params = self._shared_params()._replace(\\n num_gpus=1,\\n data_dir=self.fake_data_dir,\\n data_name='imagenet',\\n variable_update='parameter_server',\\n xla=True)\\n self._run_benchmark(params)\",\n \"def benchmark_fp16_batch128_synth_1gpu_gpuparams(self):\\n params = self._shared_params_fp16()._replace(num_gpus=1, batch_size=128)\\n self._run_benchmark(params)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62095964","0.6097989","0.59566474","0.5911981","0.585888","0.5828839","0.57508516","0.57136184","0.5679205","0.56655836","0.5627468","0.55777365","0.55777365","0.5537934","0.55370134","0.55342036","0.54773647","0.5465165","0.54110056","0.53959876","0.53759116","0.53304577","0.5323701","0.5319425","0.5319053","0.5317626","0.53170764","0.5316251","0.5303475","0.5291678","0.5283669","0.52830625","0.5282439","0.5277349","0.527272","0.5272387","0.52694976","0.5262938","0.5254364","0.52527535","0.52496344","0.52481586","0.52481586","0.52453864","0.5244558","0.52324057","0.52291894","0.5221835","0.52166545","0.5214783","0.5210695","0.5191461","0.51877004","0.51747507","0.5174188","0.51684886","0.51436853","0.51401085","0.5139777","0.5139777","0.5132513","0.5130393","0.5118346","0.5117124","0.5113594","0.51114416","0.5106104","0.5101956","0.50974","0.5092497","0.5085811","0.50749445","0.5074193","0.5073184","0.50729346","0.50702417","0.50689554","0.50628275","0.5055941","0.5050182","0.5049997","0.50447136","0.50433517","0.50433517","0.50433517","0.5043229","0.5040892","0.5040892","0.5040892","0.5023456","0.50159144","0.50159144","0.50159144","0.50130117","0.50123763","0.50008494","0.49870974","0.49870974","0.49870974","0.4985152"],"string":"[\n \"0.62095964\",\n \"0.6097989\",\n \"0.59566474\",\n \"0.5911981\",\n \"0.585888\",\n \"0.5828839\",\n \"0.57508516\",\n \"0.57136184\",\n \"0.5679205\",\n \"0.56655836\",\n \"0.5627468\",\n \"0.55777365\",\n \"0.55777365\",\n \"0.5537934\",\n \"0.55370134\",\n \"0.55342036\",\n \"0.54773647\",\n \"0.5465165\",\n \"0.54110056\",\n \"0.53959876\",\n \"0.53759116\",\n \"0.53304577\",\n \"0.5323701\",\n \"0.5319425\",\n \"0.5319053\",\n \"0.5317626\",\n \"0.53170764\",\n \"0.5316251\",\n \"0.5303475\",\n \"0.5291678\",\n \"0.5283669\",\n \"0.52830625\",\n \"0.5282439\",\n \"0.5277349\",\n \"0.527272\",\n \"0.5272387\",\n \"0.52694976\",\n \"0.5262938\",\n \"0.5254364\",\n \"0.52527535\",\n \"0.52496344\",\n \"0.52481586\",\n \"0.52481586\",\n \"0.52453864\",\n \"0.5244558\",\n \"0.52324057\",\n \"0.52291894\",\n \"0.5221835\",\n \"0.52166545\",\n \"0.5214783\",\n \"0.5210695\",\n \"0.5191461\",\n \"0.51877004\",\n \"0.51747507\",\n \"0.5174188\",\n \"0.51684886\",\n \"0.51436853\",\n \"0.51401085\",\n \"0.5139777\",\n \"0.5139777\",\n \"0.5132513\",\n \"0.5130393\",\n \"0.5118346\",\n \"0.5117124\",\n \"0.5113594\",\n \"0.51114416\",\n \"0.5106104\",\n \"0.5101956\",\n \"0.50974\",\n \"0.5092497\",\n \"0.5085811\",\n \"0.50749445\",\n \"0.5074193\",\n \"0.5073184\",\n \"0.50729346\",\n \"0.50702417\",\n \"0.50689554\",\n \"0.50628275\",\n \"0.5055941\",\n \"0.5050182\",\n \"0.5049997\",\n \"0.50447136\",\n \"0.50433517\",\n \"0.50433517\",\n \"0.50433517\",\n \"0.5043229\",\n \"0.5040892\",\n \"0.5040892\",\n \"0.5040892\",\n \"0.5023456\",\n \"0.50159144\",\n \"0.50159144\",\n \"0.50159144\",\n \"0.50130117\",\n \"0.50123763\",\n \"0.50008494\",\n \"0.49870974\",\n \"0.49870974\",\n \"0.49870974\",\n \"0.4985152\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70596236"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":132,"numItemsPerPage":100,"numTotalItems":95772,"offset":13200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjAxOTA0MiwianRpIjoiN2E0MjY1MzMtNzExOC00ZjFkLTlhYzctNzg2ZTc2MmRhYjBhIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwMjI2NDIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.2-O6ekqwdz4hR1I4BqNpRh8VK9NW3rQYTqYAMxqv2Wr6YrAFFd7UvqhrPYzvD7dPm2I0SbK2yINsz8qkRcVpAg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
train function. runs the model on the train data. | def train(self):
y_list = []
y_hat_list = []
for ex_dict in ut.EXAMPLES_LIST:
y_list.append(ex_dict[1])
y_hat_list.append(self.predict(ex_dict[0]))
acc = ut.compute_accuracy(y_hat_list, y_list)
return acc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)",
"def train(self, training_data):\n pass",
"def train():\n pass",
"def train(self, data):\n pass",
"def run(self) -> None:\n self.model = self.trainer.train_model(self.model, self.data)",
"def trai... | [
"0.8352137",
"0.8218357",
"0.8174869",
"0.81545186",
"0.81523323",
"0.80512273",
"0.80430055",
"0.8004875",
"0.79240125",
"0.7869158",
"0.7859723",
"0.78384733",
"0.7826459",
"0.7811651",
"0.7722775",
"0.764744",
"0.764744",
"0.764744",
"0.764744",
"0.764744",
"0.76102465",
... | 0.0 | -1 |
test func. runs the model on the test data. | def test(self):
y_list = []
y_hat_list = []
for ex_dict in ut.TEST_LIST:
y_list.append(ex_dict[1])
y_hat_list.append(self.predict(ex_dict[0]))
acc = ut.compute_accuracy(y_hat_list, y_list)
return y_hat_list, acc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_model():\n pass",
"def testModel( self, classTest, classPred):",
"def evaluate(self, test_data):\n result = self.model.run(test_data)\n self._save_result(result)",
"def test_training(self):\n\t\tpass",
"def runtest(self):",
"def test_predictor():",
"def run_tests():\n sourc... | [
"0.7939359",
"0.75355",
"0.7429812",
"0.72728753",
"0.7245385",
"0.71761847",
"0.717419",
"0.706351",
"0.70390844",
"0.6995146",
"0.69640917",
"0.69229054",
"0.6912081",
"0.6902356",
"0.68842983",
"0.6846401",
"0.6827048",
"0.6820484",
"0.6810831",
"0.6786037",
"0.6763651",
... | 0.0 | -1 |
Returns an object with a date and value key | def get_rating_object(tup):
return {
# Split into list, cast into integer tuple, unpack values
"date": date(*map(int, tup[0].split("/"))),
# Cast to int
"value": int(tup[1])
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def date_returner_dict(ict):\n if \"date\" in ict.keys():\n return ict[\"date\"]\n\n if \"updated_at\" in ict.keys():\n return ict[\"updated_at\"]",
"def get_entry_date(input):\n if input and \"date\" in input.keys():\n return input[\"date\"], input[\"date\"] + timedelta(minutes=1)\... | [
"0.65873224",
"0.62849426",
"0.6171362",
"0.6121679",
"0.6089129",
"0.6075831",
"0.5969787",
"0.59522283",
"0.5899934",
"0.5889765",
"0.58323175",
"0.5825535",
"0.5823314",
"0.5815788",
"0.5810556",
"0.57937735",
"0.5766198",
"0.5716365",
"0.5716365",
"0.5716365",
"0.5660642"... | 0.5890355 | 9 |
Returns a double, the average number of days between the rating objects specified in the list parameter. | def get_diffs_of_ratings(l):
if len(l) <= 1:
return str(None)
total = 0.0
for v in range(0, len(l)-1):
total = total + float((l[v+1]["date"] - l[v]["date"]).days)
return str(float(total / (len(l)-1))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def avg(list):\n return sum(list) / len(list)",
"def dishlist_avg_cal(n:list)->float:\r\n all_cal = dishlist_cal(n)\r\n return sum(all_cal)/len(all_cal)",
"def average_rating(business_list):\n\tratings = []\n\ttry:\n\t\tfor b in business_list:\n\t\t\tratings.append(b['rating'])\n\texcept KeyError:\n\t... | [
"0.68933636",
"0.66389376",
"0.6581203",
"0.65615976",
"0.65188193",
"0.6491516",
"0.64800775",
"0.64580154",
"0.6454823",
"0.6444565",
"0.6435506",
"0.64231765",
"0.64099354",
"0.63959163",
"0.6393575",
"0.63914645",
"0.63865495",
"0.63710004",
"0.6341628",
"0.6338856",
"0.6... | 0.6772968 | 1 |
Cleans/Processes dataset Indicated columns are dropped Column names are cleaned NA member_id rows are dropped | def process_wounds():
wounds = pd.read_csv(
f"{raw_data}\\wounds.csv", parse_dates=["Date Time Occurred", "Date Healed"]
)
cols_to_drop = ["Participant"]
wounds.drop(cols_to_drop, axis=1, inplace=True)
wounds.columns = clean_table_columns(wounds.columns)
wounds.dropna(subset=["member_id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(df):",
"def data_cleaning(df):\n df = df.dropna(how='all')\n \n return df",
"def cleaning_data():\n\n data.drop([\"Unnamed: 0\"], axis = 1, inplace = True)\n data.columns = map(str.upper, data.columns)\n return data",
"def clean_data():\n pd.set_option('display.max_columns', No... | [
"0.7117499",
"0.7005925",
"0.68842274",
"0.68184763",
"0.6786479",
"0.6730669",
"0.66629475",
"0.66428536",
"0.6615427",
"0.66104126",
"0.65803903",
"0.65725803",
"0.6566018",
"0.6536402",
"0.6514791",
"0.649878",
"0.64963984",
"0.6341292",
"0.6275764",
"0.6273969",
"0.626333... | 0.0 | -1 |
read optical flow from Middlebury .flo file | def read_flow(filename):
f = open(filename, 'rb')
magic = np.fromfile(f, np.float32, count=1)
data2d = None
if 202021.25 != magic:
print 'Magic number incorrect. Invalid .flo file'
raise ValueError
else:
w = np.fromfile(f, np.int32, count=1)[0]
h = np.fromfile(f, np.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def readFlow(fn):\n with open(fn, 'rb') as f:\n magic = np.fromfile(f, np.float32, count=1)\n if 202021.25 != magic:\n print('Magic number incorrect. Invalid .flo file')\n return None\n else:\n w = np.fromfile(f, np.int32, count=1)\n h = np.fromfi... | [
"0.69454867",
"0.6825181",
"0.6419488",
"0.6273423",
"0.62524235",
"0.61040115",
"0.5770221",
"0.5716468",
"0.5614053",
"0.5561235",
"0.54988915",
"0.54963934",
"0.5491575",
"0.54424614",
"0.54424614",
"0.5430062",
"0.53820395",
"0.5370581",
"0.5340542",
"0.5327158",
"0.53171... | 0.6149313 | 5 |
Load the groups of maps from disk and pass them on. Returns | def next(self):
from . import containers
# Exit this task if we have eaten all the file groups
if len(self.maps) == 0:
raise pipeline.PipelineStopIteration
group = self.maps.pop(0)
map_stack = None
# Iterate over all the files in the group, load them into... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_groups(filename):\r\n with open(filename, 'rb') as f:\r\n saved_data = pickle.load(f)\r\n return saved_data",
"def load():\n with open('groups.pkl', \"rb\") as f:\n while True:\n try:\n groups = yield pickle.load(f)\n except EOFError:\n ... | [
"0.71233",
"0.69272316",
"0.66794384",
"0.66552407",
"0.66202474",
"0.66162264",
"0.63269204",
"0.6258608",
"0.61424434",
"0.6083753",
"0.6035069",
"0.601032",
"0.5999741",
"0.5984736",
"0.59748757",
"0.59748757",
"0.5970814",
"0.596345",
"0.5949846",
"0.59451145",
"0.5866744... | 0.58243775 | 23 |
Load the given files in turn and pass on. Returns | def process(self):
from caput import memh5
# Garbage collect to workaround leaking memory from containers.
# TODO: find actual source of leak
import gc
gc.collect()
if len(self.files) == 0:
raise pipeline.PipelineStopIteration
# Fetch and remove t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_files_to_compare(self):\n self.first_source_data = load_path(self.path1)\n self.second_source_data = load_path(self.path2)",
"def LoadBatch(filename):",
"def read_files(self):\n for f in self.filenames:\n self.games.extend(pgn.loads(open(f).read()))",
"def load_data_f... | [
"0.6850166",
"0.65181124",
"0.6457848",
"0.6373063",
"0.6358262",
"0.63367456",
"0.62863064",
"0.6255783",
"0.62493247",
"0.6170194",
"0.616997",
"0.6162526",
"0.615439",
"0.6130812",
"0.60998523",
"0.6091496",
"0.6089366",
"0.601343",
"0.5997618",
"0.59721476",
"0.59679097",... | 0.0 | -1 |
Return list of files specified in the parameters. | def setup(self):
if not isinstance(self.files, (list, tuple)):
raise RuntimeError("Argument must be list of files.")
return self.files | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFileList(*args, filespec: AnyStr=\"\", folder: AnyStr=\"\", **kwargs)->List[AnyStr]:\n pass",
"def listFiles(self):\n pass",
"def getFiles(directory, showName, extension):\n os.chdir(directory)\n \n list = []\n \n for file in glob.glob(\"*\"+showName+\"*.\"+extension):\n ... | [
"0.7737809",
"0.7670469",
"0.72622687",
"0.7222471",
"0.7222006",
"0.7141934",
"0.71256304",
"0.7106082",
"0.706683",
"0.7065874",
"0.70655364",
"0.7050463",
"0.70307785",
"0.6981904",
"0.6974049",
"0.6974049",
"0.6974049",
"0.6974049",
"0.69573295",
"0.6954552",
"0.69471765"... | 0.0 | -1 |
Set the list of files to load. | def setup(self, files):
if not isinstance(files, (list, tuple)):
raise RuntimeError("Argument must be list of files.")
self.files = files | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setfiles(self, filelist):\r\n self._filelist=filelist\r\n self._energy=self.readenergy(filelist)",
"def load_files(self, filenames):\n self.filenames = filenames\n self.slider.setRange(0, len(self.filenames) - 1)\n self.slider.setSliderPosition(0)\n self.update_image()",
"... | [
"0.73231435",
"0.69058603",
"0.6728127",
"0.6700729",
"0.66641843",
"0.6648889",
"0.6603299",
"0.6600663",
"0.6465014",
"0.6455134",
"0.6442191",
"0.6424365",
"0.6413909",
"0.6399806",
"0.636362",
"0.63412595",
"0.63355416",
"0.6235698",
"0.6206581",
"0.62050563",
"0.61724335... | 0.66804683 | 4 |
Write out the data file. Assumes it has an MPIDataset interface. | def next(self, data):
if "tag" not in data.attrs:
tag = self.count
self.count += 1
else:
tag = data.attrs["tag"]
fname = "%s_%s.h5" % (self.root, str(tag))
data.to_hdf5(fname)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, filename, data):\n raise NotImplementedError",
"def write_data():",
"def writeto(self, fileout):\n \n dump_pkl(self.data, fileout)",
"def write(self, file):\n #write header\n self.ID.write(file)\n if (self.write_size): \n self.size.write(fi... | [
"0.70760417",
"0.6967587",
"0.6932236",
"0.68128157",
"0.6765629",
"0.66699415",
"0.6632731",
"0.66030324",
"0.65869176",
"0.6584542",
"0.6499914",
"0.64965516",
"0.6451832",
"0.64421976",
"0.6440108",
"0.6392151",
"0.6392151",
"0.6378035",
"0.6377129",
"0.6351838",
"0.632411... | 0.0 | -1 |
Load the beam transfer matrices. Returns | def setup(self):
import os
from drift.core import beamtransfer
if not os.path.exists(self.product_directory):
raise RuntimeError("BeamTransfers do not exist.")
bt = beamtransfer.BeamTransfer(self.product_directory)
tel = bt.telescope
try:
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_matrices(self):\n self.wine_matrix = np.array(self.parse_file_into_array('winequality-red.csv', ';'))\n self.cancer_matrix = np.array(self.parse_file_into_array('breast-cancer-wisconsin.data', ','))",
"def load_data(self, data_path, use_plus_minus_feats):\n loaded = np.load(data_pat... | [
"0.6444574",
"0.5614101",
"0.5545424",
"0.5501657",
"0.54312",
"0.5426587",
"0.5379299",
"0.5376951",
"0.5375422",
"0.5370969",
"0.5355206",
"0.5354961",
"0.53432345",
"0.5305712",
"0.5304582",
"0.52721643",
"0.52576506",
"0.52432853",
"0.52384704",
"0.52315706",
"0.5215489",... | 0.0 | -1 |
Load the beam transfer matrices. Returns | def setup(self):
import os
from drift.core import manager
if not os.path.exists(self.product_directory):
raise RuntimeError("Products do not exist.")
# Load ProductManager and Timestream
pm = manager.ProductManager.from_config(self.product_directory)
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_matrices(self):\n self.wine_matrix = np.array(self.parse_file_into_array('winequality-red.csv', ';'))\n self.cancer_matrix = np.array(self.parse_file_into_array('breast-cancer-wisconsin.data', ','))",
"def load_data(self, data_path, use_plus_minus_feats):\n loaded = np.load(data_pat... | [
"0.6441797",
"0.5614659",
"0.5542956",
"0.5501366",
"0.5431425",
"0.54276216",
"0.537962",
"0.53753656",
"0.53739345",
"0.5370095",
"0.53538334",
"0.53538305",
"0.53439856",
"0.53054017",
"0.5304288",
"0.52689856",
"0.52556485",
"0.5242395",
"0.523755",
"0.52311736",
"0.52142... | 0.0 | -1 |
Load truncation parameters from config or container defaults. | def _get_params(self, container):
if container in TRUNC_SPEC:
self.log.info("Truncating from preset for container {}".format(container))
for key in [
"dataset",
"weight_dataset",
"fixed_precision",
"variance_increase",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _setupConfigAnnotation(self):\n annotations = IAnnotations(self)\n settings = annotations.get(\"PLOMINOFIELDCONFIG\", None)\n if not settings:\n annotations[\"PLOMINOFIELDCONFIG\"] = PersistentDict()",
"def _load_hyperopt_config(self, config: Dict[str, Any]) -> Dict[str, Any]:... | [
"0.5405735",
"0.5393666",
"0.5269585",
"0.5220231",
"0.5169489",
"0.5156765",
"0.5130496",
"0.5035296",
"0.50338167",
"0.5030548",
"0.49979058",
"0.49922258",
"0.498201",
"0.4959689",
"0.4950035",
"0.49354002",
"0.4933724",
"0.49333996",
"0.4876323",
"0.485839",
"0.48395112",... | 0.7070541 | 0 |
Truncate the incoming data. The truncation is done in place. | def process(self, data):
# get truncation parameters from config or container defaults
self._get_params(type(data))
if self.weight_dataset is None:
self.weight_dataset = [None] * len(self.dataset)
for dset, wgt in zip(self.dataset, self.weight_dataset):
old_shap... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _truncate(self):\n dif = len(self) - self._maxLen\n if dif > 0:\n #return\n self[:dif] = []",
"def truncate_data(self, width):\n times_from_mid = self.time - self.midtime\n idxs = np.abs(times_from_mid) < 0.5 * width * self.duration\n self.time = self.... | [
"0.7612281",
"0.70021963",
"0.6984658",
"0.67359823",
"0.6635857",
"0.64927536",
"0.64104086",
"0.62186086",
"0.62107646",
"0.6184132",
"0.61748177",
"0.6172634",
"0.60797894",
"0.6047497",
"0.6047497",
"0.5997909",
"0.5997909",
"0.5930729",
"0.591268",
"0.5890818",
"0.577899... | 0.53309244 | 56 |
Return a telescope object out of the input (either `ProductManager`, `BeamTransfer` or `TransitTelescope`). | def get_telescope(obj):
from drift.core import telescope
try:
return get_beamtransfer(obj).telescope
except RuntimeError:
if isinstance(obj, telescope.TransitTelescope):
return obj
raise RuntimeError("Could not get telescope instance out of %s" % repr(obj)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_beamtransfer(obj):\n from drift.core import manager, beamtransfer\n\n if isinstance(obj, beamtransfer.BeamTransfer):\n return obj\n\n if isinstance(obj, manager.ProductManager):\n return obj.beamtransfer\n\n raise RuntimeError(\"Could not get BeamTransfer instance out of %s\" % re... | [
"0.59094083",
"0.55723965",
"0.52075577",
"0.49067524",
"0.4869637",
"0.47760263",
"0.46497482",
"0.46300894",
"0.45779586",
"0.45738086",
"0.4571514",
"0.4460605",
"0.44365323",
"0.4436234",
"0.44346416",
"0.44056034",
"0.43759432",
"0.43554714",
"0.4353904",
"0.43461516",
"... | 0.7030609 | 0 |
Return a BeamTransfer object out of the input (either `ProductManager`, `BeamTransfer`). | def get_beamtransfer(obj):
from drift.core import manager, beamtransfer
if isinstance(obj, beamtransfer.BeamTransfer):
return obj
if isinstance(obj, manager.ProductManager):
return obj.beamtransfer
raise RuntimeError("Could not get BeamTransfer instance out of %s" % repr(obj)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(self):\n\n import os\n\n from drift.core import beamtransfer\n\n if not os.path.exists(self.product_directory):\n raise RuntimeError(\"BeamTransfers do not exist.\")\n\n bt = beamtransfer.BeamTransfer(self.product_directory)\n\n tel = bt.telescope\n\n ... | [
"0.5573253",
"0.50620794",
"0.49997687",
"0.4947898",
"0.48023778",
"0.48023617",
"0.47191608",
"0.47186506",
"0.46855393",
"0.46065444",
"0.4585532",
"0.4478559",
"0.4471264",
"0.445144",
"0.44428593",
"0.44386634",
"0.4436773",
"0.44343606",
"0.44192073",
"0.44131085",
"0.4... | 0.76120263 | 0 |
The main function that finds all solutions for a single clue. Uses parser to find all possible parse trees, then calls the solving function for each parsing tree according to its clue type. Returns an ordered list of all possible solutions with score > MIN_SOLUTION VALUE | def solve(clue, solution_format):
# Define parser
grammar_str = GrammarDefinitions.define_grammar(clue)
grammar = nltk.CFG.fromstring(grammar_str)
parser = nltk.ChartParser(grammar)
solutions = []
# Get all possible solutions
for tree in parser.parse(clue):
_handle_abbreviations(tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showSolution(bestTree)->list:\r\n bestSon = bestTree\r\n solved = bestTree.value\r\n minDepth = bestTree.depth\r\n solution = []\r\n while bestSon.sons:\r\n #print(bestSon.state)\r\n solution.append(bestSon.state)\r\n bestSon = getBestSon(bestSon, minDepth)\r\n #print(bes... | [
"0.6172393",
"0.6126036",
"0.61067355",
"0.59318",
"0.5886695",
"0.5886695",
"0.5886695",
"0.58592933",
"0.5837581",
"0.57652533",
"0.570048",
"0.5684845",
"0.56494737",
"0.56355613",
"0.56352055",
"0.5631747",
"0.5605624",
"0.5603883",
"0.55791163",
"0.5574826",
"0.5563982",... | 0.6631623 | 0 |
Solver for double synonym clues | def _solve_double_synonym(parse_tree, solution_format=None):
def _get_value(solution_list, word):
# Gets the value of a word in a solution list
for solution in solution_list:
if solution[0] == word:
return solution[1]
return 0
# Get the two synonym parts
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):",
"def test_synonym(self): \n pass",
"def test_syndome_LUT(self):\r\n syns = []\r\n errvecs = golay._make_3bit_errors()\r\n for errvec in errvecs:\r\n syn = tuple(numpy.mod(numpy.dot(errvec, golay.DEFAULT_H.T), 2))\r\n syns.append(syn)\r\n ... | [
"0.60946655",
"0.60578865",
"0.60223013",
"0.5942013",
"0.58613205",
"0.58297867",
"0.58198977",
"0.5809236",
"0.571314",
"0.57117873",
"0.5688526",
"0.56218284",
"0.56218284",
"0.55990916",
"0.5592245",
"0.557801",
"0.55571336",
"0.55550945",
"0.55278677",
"0.5526694",
"0.55... | 0.7369051 | 0 |
Solver for anagram clues | def _solve_anagram(parse_tree, solution_format=None):
anag, syn = _get_parts_ignore_EQU(parse_tree)
# Get the anagramed word
anag_word = anag[0]
if not anag_word.label() == 'ANAG_WORD':
anag_word = anag[1]
anag_word = _create_sentence(anag_word, space=False)
syn_sent = _create_sentence... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solution(s):",
"def anagram(s):\n minchanges = 0\n\n if len(s) % 2 == 1:\n return -1\n else:\n word1 = s[0:len(s) // 2]\n word2 = s[len(s) // 2:]\n print(word1, word2)\n c1 = Counter(word1)\n for letter in word2:\n if c1[letter] > 0:\n ... | [
"0.66833496",
"0.65617925",
"0.6440984",
"0.63482744",
"0.6340745",
"0.62304044",
"0.6203706",
"0.6193661",
"0.6119746",
"0.6078559",
"0.60522294",
"0.60006964",
"0.5970734",
"0.5944802",
"0.59298414",
"0.592687",
"0.58776724",
"0.5774756",
"0.57737607",
"0.57636297",
"0.5762... | 0.6842031 | 0 |
Solver for reversal clues | def _solve_reverse(parse_tree, solution_format=None):
reverse, syn = _get_parts_ignore_EQU(parse_tree)
# Get the reversed word
reverse_word = reverse[0]
if not reverse_word.label() == 'REV_WORD':
reverse_word = reverse[1]
reverse_word = _create_sentence(reverse_word, space=False, abbr=True... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):",
"def solve(self):\n ...",
"def solve(self):\n pass",
"def solve(self):\n pass",
"def get_sol(self):",
"def solve(self):\n self.enforce_node_consistency()\n self.ac3()\n return self.backtrack(dict())",
"def solve(self):\n self.enforce_n... | [
"0.67602247",
"0.6317653",
"0.6291992",
"0.6291992",
"0.58932245",
"0.5867568",
"0.5867568",
"0.5867568",
"0.5853736",
"0.58426094",
"0.5819637",
"0.58142674",
"0.5767709",
"0.57423395",
"0.5735607",
"0.57318306",
"0.57278645",
"0.57273644",
"0.57223094",
"0.57167876",
"0.571... | 0.5862509 | 8 |
Solver for enclosure clues | def _solve_enclosure(parse_tree, solution_format=None):
enclose, syn = _get_parts_ignore_EQU(parse_tree)
# Get enclosing and inserted words
enc_word = enclose[0]
ins_word = enclose[2]
enc_word = _create_sentence(enc_word, space=False, abbr=True)
ins_word = _create_sentence(ins_word, space=False... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):",
"def solve(self):\n ...",
"def solve(self):\n pass",
"def solve(self):\n pass",
"def get_sol(self):",
"def solve(self):\n\n # Assign variables to each quantity being solved.\n r_lookup, lookup, num = {}, {}, 0\n for element in self.elements:\n ... | [
"0.72661936",
"0.6979131",
"0.6883607",
"0.6883607",
"0.6763482",
"0.6393582",
"0.63930887",
"0.6284085",
"0.62618613",
"0.621953",
"0.6006027",
"0.598754",
"0.59189796",
"0.5890026",
"0.5859848",
"0.5859848",
"0.5850623",
"0.5777722",
"0.57628524",
"0.5760397",
"0.5760397",
... | 0.5279109 | 99 |
Solver for insertion clues | def _solve_insertion(parse_tree, solution_format=None):
insert, syn = _get_parts_ignore_EQU(parse_tree)
# Get inserted and enclosing words
ins_word = insert[0]
enc_word = insert[2]
ins_word = _create_sentence(ins_word, space=False, abbr=True)
enc_word = _create_sentence(enc_word, space=False, a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):",
"def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\... | [
"0.61935043",
"0.6052085",
"0.58307177",
"0.5684423",
"0.5684423",
"0.5677976",
"0.56567764",
"0.56496036",
"0.558152",
"0.55741924",
"0.55183244",
"0.55002755",
"0.54804087",
"0.54685974",
"0.54493546",
"0.53306746",
"0.53248656",
"0.5314975",
"0.5243742",
"0.52383006",
"0.5... | 0.58429676 | 2 |
Given an enclosing word and an inserted word, calculates the match score for each possible insertion of the second in the first | def _get_all_insertions(synonym, enc_word, ins_word, solution_format=None):
words = [enc_word[0:i] + ins_word + enc_word[i:] for i in range(1, len(enc_word))]
if solution_format is not None:
words = [solution_format.add_spaces(word) for word in words if solution_format.check(word)]
solutions = [(wo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score_function(word1, word2):\n if word2 == '':\n return len(word1)\n elif word1 == '':\n return len(word2)\n elif word1 == word2:\n return 0\n elif word1[0] == word2[0]:\n return 0 + score_function(word1[1:], word2[1:])\n else:\n add_char = 1 + score_function... | [
"0.6938082",
"0.67501044",
"0.664985",
"0.66156524",
"0.6437491",
"0.6388",
"0.63633657",
"0.6323432",
"0.63137937",
"0.61882997",
"0.6159928",
"0.6151686",
"0.6133492",
"0.61209613",
"0.611938",
"0.61158586",
"0.60796326",
"0.6054395",
"0.603592",
"0.60226154",
"0.60208946",... | 0.0 | -1 |
Solver for hidden word clues | def _solve_hidden_word(parse_tree, solution_format=None):
hidden, syn = _get_parts_ignore_EQU(parse_tree)
# Get the hiding word
hiding_word = hidden[0]
if not hiding_word.label() == 'HID_WORD':
hiding_word = hidden[1]
hiding_word = _create_sentence(hiding_word, space=False)
syn_sent =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_clues(self):\r\n print(\"\\n************Searching Clues************\\n\")\r\n for word_id in self.words.keys():\r\n if not self.words[word_id].see and not self.words[word_id].wth:\r\n clue = pop_backslash(self.words[word_id].clue)\r\n temp = word_d... | [
"0.62825",
"0.621615",
"0.59519327",
"0.59129626",
"0.59106004",
"0.5901776",
"0.58596104",
"0.5811822",
"0.5787408",
"0.5749001",
"0.5749001",
"0.5701069",
"0.5651413",
"0.56111234",
"0.56057537",
"0.5567448",
"0.5547416",
"0.55322987",
"0.552673",
"0.552673",
"0.55166656",
... | 0.6624858 | 0 |
Given a parse tree with 2 parts, with a possible EQU part in the middle, finds the synonym part and the other part | def _get_parts_ignore_EQU(parse_tree):
first_part = parse_tree[0]
second_part = parse_tree[1]
if second_part.label() == 'EQU':
second_part = parse_tree[2]
if first_part.label() == 'SYN':
syn = first_part
other = second_part
else:
syn = second_part
other = fir... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _solve_double_synonym(parse_tree, solution_format=None):\n def _get_value(solution_list, word):\n # Gets the value of a word in a solution list\n for solution in solution_list:\n if solution[0] == word:\n return solution[1]\n\n return 0\n\n # Get the two syn... | [
"0.6501454",
"0.59847134",
"0.57638747",
"0.56675124",
"0.56613374",
"0.54569155",
"0.54319113",
"0.5426494",
"0.539753",
"0.5339401",
"0.53225523",
"0.5321102",
"0.5310823",
"0.5307761",
"0.52566755",
"0.5253671",
"0.5250814",
"0.5199034",
"0.51778674",
"0.5174493",
"0.51710... | 0.6401357 | 1 |
Given a partial tree, connects all words into one string (spaces added if space=True) In case this might contain abbreviation, the tree would look different, so abbr should be True. | def _create_sentence(parse_tree, space=True, abbr=False):
word = parse_tree[0][0]
if abbr:
word = word[0]
if len(parse_tree) == 1:
return word
else:
if space:
return word + " " + _create_sentence(parse_tree[1], space=space, abbr=abbr)
else:
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _join_expanded_node(expanded_node):\n sorted_expanded_node = sorted(expanded_node, key=lambda x: x[0])\n return \" \".join([word for address, word in sorted_expanded_node])",
"def all_words(root,word = [],level=0,alpha_size=21):\n # If node is leaf node, it indicates end of string\n i... | [
"0.63241714",
"0.59670556",
"0.58251095",
"0.5706153",
"0.57025576",
"0.5625008",
"0.55807376",
"0.5510879",
"0.5498444",
"0.5445535",
"0.5403236",
"0.53683877",
"0.53352714",
"0.53322303",
"0.53150856",
"0.53094614",
"0.5264888",
"0.5251927",
"0.5235628",
"0.52081066",
"0.52... | 0.57676345 | 3 |
Parses the abbreviation file to find all possible abbreviations, then calls helper function to update the tree | def _handle_abbreviations(parse_tree):
path = os.path.join(GrammarDefinitions.FOLDER, GrammarDefinitions.ABBREVIATION_FILE)
with open(path, "r") as f:
lines = f.read().splitlines()
abbr_dict = {line.split(GrammarDefinitions.ABBR_SEP)[0]: line.split(GrammarDefinitions.ABBR_SEP)[1] for line in
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _replace_abbreviation(parse_tree, abbr_dict):\n if not isinstance(parse_tree, nltk.Tree):\n # Reached a leaf\n return\n\n if parse_tree.label() == 'ABBR':\n # Replace word with its abbreviation\n word = parse_tree[0]\n parse_tree.set_label('WORD')\n parse_tree[0]... | [
"0.6594188",
"0.64209026",
"0.6191263",
"0.6113771",
"0.59502375",
"0.59138536",
"0.58576477",
"0.5774968",
"0.56978416",
"0.5646811",
"0.5631029",
"0.5490518",
"0.54843515",
"0.54673076",
"0.54151493",
"0.5384615",
"0.53294075",
"0.51091653",
"0.5101626",
"0.50498986",
"0.50... | 0.7767338 | 0 |
Updates the given tree by replacing the word with its abbreviated form | def _replace_abbreviation(parse_tree, abbr_dict):
if not isinstance(parse_tree, nltk.Tree):
# Reached a leaf
return
if parse_tree.label() == 'ABBR':
# Replace word with its abbreviation
word = parse_tree[0]
parse_tree.set_label('WORD')
parse_tree[0] = abbr_dict[w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def abbreviate(match_tree, statement):\n\n result = statement\n current_node = match_tree\n for position, letter in enumerate(statement.upper()):\n current_node = current_node.get(letter)\n if not isinstance(current_node, dict):\n if isinstance(current_node, str):\n ... | [
"0.64932525",
"0.60075444",
"0.6002033",
"0.5950056",
"0.5884344",
"0.5873636",
"0.58596784",
"0.5755214",
"0.5720153",
"0.57188857",
"0.5702307",
"0.57001936",
"0.5692823",
"0.56882954",
"0.5668327",
"0.5638983",
"0.5637053",
"0.5602583",
"0.55859566",
"0.55837816",
"0.55621... | 0.75555784 | 0 |
Creates a common python list of object, no matter what information are supported by the parsed xml file for test results junit(). | def parse(self):
def parse_testcase(xml_object):
testcase = xml_object
tc_dict = {
"classname": testcase.attrib.get("classname", "unknown"),
"file": testcase.attrib.get("file", "unknown"),
"line": int(testcase.attrib.get("line", -1)),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self):\n try:\n data = etree.parse(self.resultfilename).getroot()\n except OSError:\n data = []\n\n testresults = []\n for testcase in data:\n category = Category.OK\n status = 'ok'\n module = testcase.get('classname')... | [
"0.6335188",
"0.5985103",
"0.59026104",
"0.5846985",
"0.57126236",
"0.56514776",
"0.5649591",
"0.56286633",
"0.5615803",
"0.5615803",
"0.5605953",
"0.55911666",
"0.5566683",
"0.5566683",
"0.5559948",
"0.55295116",
"0.54831856",
"0.54688597",
"0.54634106",
"0.54622257",
"0.544... | 0.6112433 | 1 |
Produce a deepcopy of the current timing data (no risk of interference with active timing or other operaitons). | def get_times():
if f.root.stopped:
return copy.deepcopy(f.root.times)
else:
t = timer()
times = collapse.collapse_times()
f.root.self_cut += timer() - t
return times | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pure_data_copy(self):\n import copy\n data=copy.copy(self)\n data.xp = data.xp.get_pure_data_copy()\n data.timetable = data.timetable.get_pure_data_copy() \n return data",
"def get_snapshot(self):\n data = {\n \"t\": self.sim.t,\n \"time\": ... | [
"0.6639168",
"0.6453072",
"0.6333998",
"0.62160635",
"0.62112194",
"0.5905207",
"0.5840254",
"0.58312976",
"0.58196926",
"0.57917005",
"0.57815856",
"0.57566667",
"0.5745111",
"0.5699135",
"0.5627263",
"0.56236315",
"0.56159997",
"0.56139135",
"0.5610615",
"0.55917543",
"0.55... | 0.0 | -1 |
Manual assignment of a collection of (stopped) Times objects as a parallel subdivision of a running timer. | def attach_par_subdivision(par_name, par_times):
t = timer()
if not isinstance(par_times, (list, tuple)):
raise TypeError("Expected list or tuple for param 'par_times'.")
for times in par_times:
if not isinstance(times, Times):
raise TypeError("Expected each element of param 'par... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __set_time_elements(*args):\n args[0].TimeState.delay_elements = args[1]\n args[0].TimeState.set_delay_elements()",
"def attach_subdivision(times):\n t = timer()\n if not isinstance(times, Times):\n raise TypeError(\"Expected Times object for param 'times'.\")\n assert times.total > 0.,... | [
"0.62573314",
"0.6033236",
"0.5865843",
"0.5819078",
"0.579982",
"0.578757",
"0.56507623",
"0.5608748",
"0.5587022",
"0.55639225",
"0.55407816",
"0.55256355",
"0.55256355",
"0.55256355",
"0.5518789",
"0.5510289",
"0.5480487",
"0.54784924",
"0.5468466",
"0.54679537",
"0.546644... | 0.54004014 | 27 |
Manual assignment of a (stopped) times object as a subdivision of running timer. Use cases are expected to be very limited (mainly provided as a oneTimes variant of attach_par_subdivision). | def attach_subdivision(times):
t = timer()
if not isinstance(times, Times):
raise TypeError("Expected Times object for param 'times'.")
assert times.total > 0., "Attached subdivision has total time 0, appears empty."
name = times.name
f.r.self_agg += times.self_agg
if name not in f.t.sub... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_interval_sub(self, time_step, nsteps):\n world.subtime = TimeAxis(0.0, int(nsteps), float(time_step))\n print(\"Setting subtime\")",
"def __set_time_elements(*args):\n args[0].TimeState.delay_elements = args[1]\n args[0].TimeState.set_delay_elements()",
"def time_interval_prop(self, time_s... | [
"0.6630454",
"0.6081781",
"0.5878871",
"0.5870936",
"0.5784389",
"0.57493865",
"0.5726583",
"0.5696444",
"0.56729144",
"0.5598866",
"0.558305",
"0.5582902",
"0.55632716",
"0.54817516",
"0.54677033",
"0.5444429",
"0.5438984",
"0.54319745",
"0.5367586",
"0.53596765",
"0.5350131... | 0.6671484 | 0 |
Serialize and / or save a Times data object using pickle (cPickle). | def save_pkl(filename=None, times=None):
if times is None:
if not f.root.stopped:
times = collapse.collapse_times()
else:
times = f.root.times
else:
if isinstance(times, (list, tuple)):
for t in times:
if not isinstance(t, Times):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(self): \n with open(self.path+self.name, \"wb\") as pfile:\n pickle.dump(self.pyObj, pfile)",
"def pickle(self,data,filename):\n pickle.dump(data, open(filename, 'wb'))",
"def saveData(self): \n self.spIndex.close()\n output = open(PublicTransit.PICK... | [
"0.63484544",
"0.60688585",
"0.60613865",
"0.60561633",
"0.5997063",
"0.5942309",
"0.59148747",
"0.590097",
"0.58997315",
"0.5889424",
"0.58798075",
"0.58791673",
"0.5864843",
"0.5844835",
"0.5821112",
"0.5819759",
"0.580201",
"0.5794824",
"0.57903945",
"0.57628703",
"0.57584... | 0.6815023 | 0 |
Normalizes OData request payload | def _build_payload(self, query):
def _normalize_payload(payload):
if isinstance(payload, ClientObject) or isinstance(payload, ClientValue):
return payload.to_json(self._default_json_format)
elif isinstance(payload, dict):
return {k: _normalize_payload(v) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalizeData(self, data):\n return _normalizeData(data)",
"def normalizeData(self, data):\n return _normalizeData(data)",
"def normalize_dataset(self):",
"def _normalize_data_to_send(info):\n # Remove the parts of the data that are unbounded in size.\n info = copy.deepcopy(info)\n ... | [
"0.61284226",
"0.61284226",
"0.5774344",
"0.57267433",
"0.5654591",
"0.55901545",
"0.5548912",
"0.54671437",
"0.5320251",
"0.5320097",
"0.53039527",
"0.5299607",
"0.52769536",
"0.5241324",
"0.5238242",
"0.52313703",
"0.52067167",
"0.5179294",
"0.5160118",
"0.5150837",
"0.5125... | 0.48169824 | 52 |
This method validates the input file. Returns true if the JSON is valid, false otherwise. | def validate_input(update_file):
try:
json.load(open(update_file))
print "\nValid JSON"
return True
except ValueError:
print "\nInvalid JSON"
exit(-1)
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_input(update_file):\n try:\n json.load(open(update_file))\n #print \"Valid JSON\"\n return True\n except ValueError:\n print \"Invalid JSON. Exiting.\"\n exit(-1)\n return False",
"def valid_is_json(self):\n return self.file_name.endswith('.json... | [
"0.81748825",
"0.7770329",
"0.76431674",
"0.7455964",
"0.7199138",
"0.71282756",
"0.7009667",
"0.6992463",
"0.69263047",
"0.6873297",
"0.68528163",
"0.68223625",
"0.6743427",
"0.6640722",
"0.661942",
"0.66073275",
"0.65818256",
"0.6577986",
"0.651692",
"0.65011466",
"0.649889... | 0.823358 | 0 |
This method will attempt to enumerate all buckets. NEVER DO THIS EXCEPT DURING INITIAL TROUBLESHOOTING | def list_all_buckets(riak_host,riak_port):
url='http://%s:%s/buckets?buckets=true' % (riak_host,riak_port)
r=requests.get(url)
print json.dumps(r.json(), sort_keys=True, indent=4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_buckets():\n pass",
"def list_buckets():\n for bucket in BUCKET_MANAGER.all_buckets():\n print(bucket)",
"def test_get_buckets(self):\n pass",
"def list_buckets(self):\n msg = \"list_buckets not implemented\"\n raise NotImplementedError(msg)",
"def test_000_list_b... | [
"0.70552385",
"0.67575353",
"0.66606206",
"0.6565206",
"0.6550554",
"0.65227455",
"0.6427794",
"0.63869715",
"0.63031363",
"0.6285628",
"0.61275065",
"0.61203843",
"0.6112329",
"0.6099542",
"0.60019106",
"0.59359163",
"0.59240943",
"0.5843373",
"0.58405674",
"0.5830708",
"0.5... | 0.5854802 | 17 |
This method will attempt to enumerate all keys for a given bucket. NEVER DO THIS EXCEPT DURING INITIAL TROUBLESHOOTING | def list_all_keys(riak_host,riak_port,bucket):
url='http://%s:%s/buckets/%s/keys?keys=true' % (riak_host,riak_port,bucket)
#print url
r=requests.get(url)
print json.dumps(r.json(), sort_keys=True, indent=4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keys(self, bucket, user=None):\n raise NotImplementedError('TODO')",
"def iterkeys(self):\n\n for bucket in self.buckets.itervalues():\n for key in bucket.iterkeys():\n yield key",
"def bucket_lister(bucket, prefix='', delimiter='', marker='', headers=None):\r\n m... | [
"0.7052264",
"0.6707792",
"0.6634113",
"0.65546584",
"0.64856684",
"0.6361074",
"0.6353042",
"0.63117075",
"0.62654686",
"0.62642795",
"0.6262174",
"0.62522525",
"0.6190531",
"0.60471284",
"0.6026226",
"0.60245275",
"0.60095507",
"0.59610164",
"0.59507036",
"0.5926867",
"0.59... | 0.6350213 | 7 |
This method prints the current contents of a riak bucket when passed a valid url | def get_current_contents(url):
r=requests.get(url)
print json.dumps(r.json(), sort_keys=True, indent=4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PrintBucketInfo(self, bucket_uri, listing_style, headers=None, debug=0):\n bucket_objs = 0\n bucket_bytes = 0\n if listing_style == ListingStyle.SHORT:\n print bucket_uri\n else:\n try:\n for obj in self.CmdWildcardIterator(\n bucket_uri.clone_replace_name('*'), ResultTy... | [
"0.6069273",
"0.60255677",
"0.59204245",
"0.5901043",
"0.58166885",
"0.5768245",
"0.5719148",
"0.5704775",
"0.5666827",
"0.5666827",
"0.5653638",
"0.56262296",
"0.5598052",
"0.55743444",
"0.5523159",
"0.5508009",
"0.55066514",
"0.55027604",
"0.5455372",
"0.5428352",
"0.540960... | 0.57620263 | 6 |
This method prints the current contents of an api_key riak bucket when passed a valid url | def get_current_key(url):
r=requests.get(url)
#return json.dumps(r.json(), sort_keys=True, indent=4)
return json.dumps(r.json(), sort_keys=True, indent=4, separators=(',', ': ')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_all_keys(riak_host,riak_port,bucket):\n url='http://%s:%s/buckets/%s/keys?keys=true' % (riak_host,riak_port,bucket)\n #print url\n r=requests.get(url)\n print json.dumps(r.json(), sort_keys=True, indent=4)",
"def get_from_api(url, *, verbose=False):\n vprint = lambda *a, **kwa: print(*a, ... | [
"0.59069735",
"0.5775815",
"0.56716317",
"0.5670298",
"0.5502804",
"0.54711944",
"0.54018843",
"0.5394873",
"0.5385831",
"0.536729",
"0.5343384",
"0.5342679",
"0.5339456",
"0.5331075",
"0.53242856",
"0.53214943",
"0.5316168",
"0.53113574",
"0.527582",
"0.5245839",
"0.52193",
... | 0.6079053 | 0 |
This method saves the current contents of the riak bucket/key to be updated into a file called .original | def save_current_contents(url,update_file):
r=requests.get(url)
save_file=update_file+'.original'
json.dump(r.json(), open(save_file,'w'))
print "\nSaved contents of: \n\n\t%s \n\nto \n\n\t%s\n" % (url,save_file) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _s3_stash(self):\n s3_url = 's3://{}/{}'.format(BUCKET, self.atom_file)\n bucketpath = BUCKET.strip(\"/\")\n bucketbase = BUCKET.split(\"/\")[0]\n parts = urlparse.urlsplit(s3_url)\n mimetype = 'application/xml' \n \n conn = boto.connect_s3()\n\n try:\n ... | [
"0.6037694",
"0.59927624",
"0.57073236",
"0.56520575",
"0.56048256",
"0.5596014",
"0.55929804",
"0.55929804",
"0.5570519",
"0.5558988",
"0.5556693",
"0.5535628",
"0.5512414",
"0.5506305",
"0.5484331",
"0.5482167",
"0.54426193",
"0.54200596",
"0.54176253",
"0.54065824",
"0.539... | 0.6019954 | 1 |
This method performs the update/put of the specified bucket and key using the passed json input file. The current contents of the bucket are saved. | def do_update(url,indexHeaders,update_file):
updateUrl=url.replace("buckets","riak")
indexHeaders['content-type'] = 'application/json'
r=requests.post(url, data=json.dumps(update_file), headers=indexHeaders) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put_object(self, bucket_name, key, data):\n url = self.__key_url(bucket_name, key)\n resp = self.infinispan_client.put(url, data=data,\n auth=self.basicAuth,\n headers=self.headers)\n logger.debug(resp)",
"... | [
"0.67305326",
"0.67065084",
"0.6650527",
"0.6560699",
"0.64503276",
"0.6271223",
"0.6260937",
"0.62335885",
"0.62213606",
"0.61827993",
"0.6107075",
"0.6043181",
"0.60399926",
"0.6023759",
"0.6021778",
"0.5972299",
"0.5967671",
"0.59629846",
"0.59620744",
"0.5949854",
"0.5920... | 0.6346544 | 5 |
Export the accumulate QA info | def export_QA(qa: QA):
# TODO: implement
log.info("assess_quality.export_QA: not yet implemented") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dump_qa(self):\n #- QA level outputs\n #qa_outfile = {}\n qa_outfig = {}\n for PA in self.palist:\n for QA in self.qalist[PA]:\n #qa_outfile[QA] = self.io_qa(QA)[0]\n qa_outfig[QA] = self.io_qa(QA)[1]\n \n #- mak... | [
"0.62779266",
"0.5807726",
"0.5701978",
"0.5490575",
"0.548842",
"0.5469755",
"0.5413337",
"0.54031056",
"0.5353437",
"0.5329075",
"0.52541536",
"0.5240437",
"0.5219163",
"0.52120894",
"0.5197329",
"0.5191597",
"0.5154738",
"0.51318127",
"0.51313466",
"0.51085216",
"0.5108008... | 0.7101214 | 0 |
Computes boundary indices for each of the splits in split_probs. | def _compute_split_boundaries(split_probs, n_items):
if len(split_probs) > n_items:
raise ValueError(
'Not enough items for the splits. There are {splits} '
'splits while there are only {items} items'.format(
splits=len(split_probs), items=n_items
)
)
total_probs = sum(p ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_split_indices(self):\n\n cumsum = np.cumsum(\n np.concatenate((np.array([0], dtype=np.int8), self.split_sizes)))\n \n fold_inds = np.array(\n [(cumsum[n], cumsum[n + 1]) for n in range(self.n_splits)])\n\n return fold_inds",
"def indices_of_split(self, s... | [
"0.6504778",
"0.6373539",
"0.5991977",
"0.59512573",
"0.58468676",
"0.58247024",
"0.58247024",
"0.5623608",
"0.55173296",
"0.54587805",
"0.5435856",
"0.54219145",
"0.53155714",
"0.53145355",
"0.5306709",
"0.5304065",
"0.5301914",
"0.5295978",
"0.52721083",
"0.52459157",
"0.52... | 0.7075934 | 0 |
Split items to train/dev/test, so all items in group go into same split. Each group contains all the samples from the same speaker ID. The samples are splitted between train, validation and testing so that samples from each speaker belongs to exactly one split. | def _get_inter_splits_by_group(items_and_groups, split_probs, split_number):
groups = sorted(set(group_id for item_id, group_id in items_and_groups))
rng = np.random.RandomState(split_number)
rng.shuffle(groups)
split_boundaries = _compute_split_boundaries(split_probs, len(groups))
group_id_to_split = {}
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_dev(self):\n\t\tprint(\"Splitting test set into dev and test set\")\n\n\t\told_length = len(self.X[\"test\"])\n\t\tindices = list(range(old_length))\n\n\t\tnp.random.seed(0)\n\t\tnp.random.shuffle(indices)\n\t\t\n\t\tsplit = int(len(indices) * 0.5)\n\n\t\tsplit_indices = {\"test\": indices[:split], \"dev... | [
"0.71623456",
"0.6617794",
"0.6545615",
"0.65136385",
"0.6460266",
"0.6431915",
"0.63877124",
"0.63793963",
"0.6359528",
"0.63103324",
"0.6294245",
"0.6264392",
"0.62345576",
"0.62252283",
"0.6203761",
"0.61943793",
"0.61911535",
"0.6172929",
"0.61283726",
"0.6106689",
"0.609... | 0.0 | -1 |
Test parsing and streaming of DPTValue1Ucount 50. | def test_value_50(self):
self.assertEqual(DPTValue1Ucount().to_knx(50), (0x32,))
self.assertEqual(DPTValue1Ucount().from_knx((0x32,)), 50) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unit(self):\n self.assertEqual(DPTSignedRelativeValue.unit, \"\")\n self.assertEqual(DPTPercentV8.unit, \"%\")\n self.assertEqual(DPTValue1Count.unit, \"counter pulses\")",
"def test_with_status_data(self):\r\n\r\n with open(os.path.join(RESOURCE_PATH, 'ND161646.PD0'), 'rb') ... | [
"0.65973496",
"0.61154234",
"0.60894555",
"0.5885825",
"0.5680461",
"0.5545329",
"0.5519853",
"0.5479107",
"0.54342437",
"0.53747666",
"0.5368387",
"0.53356916",
"0.5330443",
"0.53220665",
"0.532082",
"0.52951694",
"0.5269306",
"0.5266885",
"0.52651095",
"0.52512425",
"0.5247... | 0.66703874 | 0 |
Test parsing and streaming of DPTValue1Ucount 255. | def test_value_max(self):
self.assertEqual(DPTValue1Ucount().to_knx(255), (0xFF,))
self.assertEqual(DPTValue1Ucount().from_knx((0xFF,)), 255) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_value_50(self):\n self.assertEqual(DPTValue1Ucount().to_knx(50), (0x32,))\n self.assertEqual(DPTValue1Ucount().from_knx((0x32,)), 50)",
"def test_unit(self):\n self.assertEqual(DPTSignedRelativeValue.unit, \"\")\n self.assertEqual(DPTPercentV8.unit, \"%\")\n self.asser... | [
"0.67056155",
"0.631558",
"0.6267815",
"0.5858477",
"0.5822282",
"0.5758016",
"0.56248516",
"0.561795",
"0.5597454",
"0.55848616",
"0.5476851",
"0.53409237",
"0.530719",
"0.5269258",
"0.52683234",
"0.5258315",
"0.52361274",
"0.5220925",
"0.5200943",
"0.5164981",
"0.5155284",
... | 0.6720798 | 0 |
Test parsing and streaming of DPTValue1Ucount 0. | def test_value_min(self):
self.assertEqual(DPTValue1Ucount().to_knx(0), (0x00,))
self.assertEqual(DPTValue1Ucount().from_knx((0x00,)), 0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unit(self):\n self.assertEqual(DPTSignedRelativeValue.unit, \"\")\n self.assertEqual(DPTPercentV8.unit, \"%\")\n self.assertEqual(DPTValue1Count.unit, \"counter pulses\")",
"def test_value_50(self):\n self.assertEqual(DPTValue1Ucount().to_knx(50), (0x32,))\n self.asser... | [
"0.65742433",
"0.6063547",
"0.6014494",
"0.5983357",
"0.57647645",
"0.5689636",
"0.5639485",
"0.5594808",
"0.5583179",
"0.55746424",
"0.5439922",
"0.5422113",
"0.5407889",
"0.5406917",
"0.53917974",
"0.5373599",
"0.53290766",
"0.53238535",
"0.5318",
"0.52924883",
"0.5290578",... | 0.6662104 | 0 |
Test parsing of DPTValue1Ucount with wrong value (underflow). | def test_to_knx_min_exceeded(self):
with self.assertRaises(ConversionError):
DPTValue1Ucount().to_knx(DPTValue1Ucount.value_min - 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_value_min(self):\n self.assertEqual(DPTValue1Ucount().to_knx(0), (0x00,))\n self.assertEqual(DPTValue1Ucount().from_knx((0x00,)), 0)",
"def test_from_knx_wrong_value(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().from_knx((0x256,))",
"def test_fro... | [
"0.66430473",
"0.65788555",
"0.6345036",
"0.63011754",
"0.62446314",
"0.6172727",
"0.6139013",
"0.5989837",
"0.5946955",
"0.5930045",
"0.59022975",
"0.5796947",
"0.57517916",
"0.5694532",
"0.5599999",
"0.55728513",
"0.55712885",
"0.5526123",
"0.5521623",
"0.55063385",
"0.5474... | 0.57302237 | 13 |
Test parsing of DPTValue1Ucount with wrong value (overflow). | def test_to_knx_max_exceeded(self):
with self.assertRaises(ConversionError):
DPTValue1Ucount().to_knx(DPTValue1Ucount.value_max + 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_from_knx_wrong_value(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().from_knx((0x256,))",
"def test_value_min(self):\n self.assertEqual(DPTValue1Ucount().to_knx(0), (0x00,))\n self.assertEqual(DPTValue1Ucount().from_knx((0x00,)), 0)",
"def test_uni... | [
"0.6605722",
"0.65791065",
"0.64690846",
"0.63336855",
"0.62942255",
"0.6279501",
"0.62152576",
"0.6180856",
"0.6159583",
"0.61054754",
"0.6093372",
"0.6059035",
"0.59029233",
"0.58780617",
"0.58492506",
"0.57691437",
"0.574576",
"0.574576",
"0.56977135",
"0.56756204",
"0.566... | 0.57946146 | 15 |
Test parsing of DPTValue1Ucount with wrong value (string). | def test_to_knx_wrong_parameter(self):
with self.assertRaises(ConversionError):
DPTValue1Ucount().to_knx("fnord") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_uss_num_bad_values(self):\n for val in self.bad_values:\n self.assertRaises(line_format_errors.FieldParseError,\n lambda: self.line._parse_uss_num(val))",
"def test_unit(self):\n self.assertEqual(DPTSignedRelativeValue.unit, \"\")\n self.asser... | [
"0.6505707",
"0.6373843",
"0.6372432",
"0.6268583",
"0.62656677",
"0.6227337",
"0.6173566",
"0.61697394",
"0.6120558",
"0.60757333",
"0.606843",
"0.60362804",
"0.60135466",
"0.5993069",
"0.5965824",
"0.5962902",
"0.5954549",
"0.59497184",
"0.58848035",
"0.5879634",
"0.5850198... | 0.5491689 | 54 |
Test parsing of DPTValue1Ucount with wrong value (3 byte array). | def test_from_knx_wrong_parameter(self):
with self.assertRaises(ConversionError):
DPTValue1Ucount().from_knx((0x01, 0x02, 0x03)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_from_knx_wrong_value(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().from_knx((0x256,))",
"def test_from_knx_wrong_parameter2(self):\n with self.assertRaises(ConversionError):\n DPTValue1Ucount().from_knx(\"0x23\")",
"def test_value_min(self):\... | [
"0.6574174",
"0.64003175",
"0.63059187",
"0.6276057",
"0.6197245",
"0.6195625",
"0.61819005",
"0.6062769",
"0.600046",
"0.5978124",
"0.5972343",
"0.5937288",
"0.57631",
"0.5702879",
"0.566235",
"0.5638889",
"0.56113666",
"0.5604449",
"0.56010675",
"0.55782485",
"0.557578",
... | 0.6430515 | 1 |
Test parsing of DPTValue1Ucount with value which exceeds limits. | def test_from_knx_wrong_value(self):
with self.assertRaises(ConversionError):
DPTValue1Ucount().from_knx((0x256,)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_value_min(self):\n self.assertEqual(DPTValue1Ucount().to_knx(0), (0x00,))\n self.assertEqual(DPTValue1Ucount().from_knx((0x00,)), 0)",
"def test_value_max(self):\n self.assertEqual(DPTValue1Ucount().to_knx(255), (0xFF,))\n self.assertEqual(DPTValue1Ucount().from_knx((0xFF,)),... | [
"0.6418932",
"0.633995",
"0.60887456",
"0.60097504",
"0.5899993",
"0.58869195",
"0.5875206",
"0.577937",
"0.5753048",
"0.57470715",
"0.5724356",
"0.5703249",
"0.5686941",
"0.5644697",
"0.56209826",
"0.56093055",
"0.55792356",
"0.55781907",
"0.5557171",
"0.5544843",
"0.5543713... | 0.5518648 | 23 |
Test parsing of DPTValue1Ucount with wrong value (array containing string). | def test_from_knx_wrong_parameter2(self):
with self.assertRaises(ConversionError):
DPTValue1Ucount().from_knx("0x23") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_uss_num_bad_values(self):\n for val in self.bad_values:\n self.assertRaises(line_format_errors.FieldParseError,\n lambda: self.line._parse_uss_num(val))",
"def test_uss_num_good_values(self):\n for input_val, output_val in self.known_values:\n ... | [
"0.64697146",
"0.61905485",
"0.6125916",
"0.6093",
"0.60590595",
"0.60514253",
"0.60386145",
"0.6020416",
"0.59949565",
"0.59723514",
"0.5926353",
"0.58925855",
"0.5874658",
"0.5870202",
"0.5863102",
"0.5860344",
"0.5836023",
"0.582747",
"0.5825986",
"0.5784446",
"0.577219",
... | 0.5871998 | 13 |
Test parsing of DPTTariff with wrong value (overflow). | def test_from_knx_max_exceeded(self):
with self.assertRaises(ConversionError):
DPTTariff().from_knx((0xFF,)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_nonsense_decimal(self):\n test_passes = False\n try:\n self.parser.extract_zt(\"ZT.\")\n test_passes = False\n except Exception as e:\n test_passes = True\n self.assertTrue(test_passes)",
"def validate_tariff(self):\n\t\treturn True",
"def t... | [
"0.6723091",
"0.6319212",
"0.5926528",
"0.5925495",
"0.58749855",
"0.5870267",
"0.5810937",
"0.57904863",
"0.57482463",
"0.5747621",
"0.5714481",
"0.5709603",
"0.5658411",
"0.5625314",
"0.5606641",
"0.55434126",
"0.554246",
"0.55323154",
"0.5525947",
"0.55253166",
"0.5515092"... | 0.6114475 | 2 |
Returns the eopatch with the new grouping of the LPIS data. A column "GROUP_1_ID", is also added, with the ID associated to the groups. col_cropN_lpis is the name of the column of the crop type in the lpis dataframe. col_cropN_lpistogroup is the name of the column of the crop type in the csv file specified by self.lpis... | def execute(self, eopatch, col_cropN_lpis, col_cropN_lpistogroup):
# Group LPIS classes
lpis = eopatch.vector_timeless["LPIS_{}".format(self.year)]
mapping = pd.read_csv(self.lpis_to_group_file, sep=";")
result = pd.merge(lpis, mapping, how="left", left_on=[col_cropN_lpis], right_on=[col... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def putHaplotypeGroupIntoDB(self, session, input_fname, tg_ecotypeid2row, max_snp_typing_error_rate, snp_id_ls):\n\t\tsys.stderr.write(\"Constructing haplotype groups ...\\n\")\n\t\tpattern_ecotypeid = re.compile(r'(?<=\\))\\d+')\n\t\treader = csv.reader(open(input_fname), delimiter=figureOutDelimiter(input_fname)... | [
"0.54248655",
"0.52833027",
"0.52409554",
"0.51482445",
"0.5124294",
"0.50936604",
"0.5087704",
"0.5087017",
"0.5085758",
"0.50673145",
"0.5042352",
"0.50204813",
"0.5016356",
"0.49944848",
"0.4958095",
"0.49487063",
"0.49047828",
"0.49024466",
"0.48803094",
"0.48635092",
"0.... | 0.7963392 | 0 |
Split dataset into train and test data | def train_test_split_eopatches(patch_array, test_ratio, features_dict, labels_dict):
# define EOPatches for training and testing
trainIDs = list(range(len(patch_array)))
testIDs = trainIDs[0::test_ratio] # take every xth patch for testing
for elem in trainIDs:
if elem in testIDs:
t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __split_dataset(self):\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)",
"def split_data_into_train_and_test(raw_training_data):\n train_set, test_set = train_test_s... | [
"0.8715163",
"0.8671336",
"0.8420628",
"0.8248627",
"0.8183213",
"0.8146104",
"0.8093698",
"0.8087583",
"0.8075708",
"0.8037415",
"0.80204433",
"0.8016",
"0.8002609",
"0.79591835",
"0.79122245",
"0.78805375",
"0.7857199",
"0.78511673",
"0.78495",
"0.78276145",
"0.77810913",
... | 0.0 | -1 |
Split dataset into train and test data | def train_test_split_eopatch(patch_array, features_dict, labels_dict):
# Set the features and the labels for train and test sets
for eopatch in patch_array:
features = np.array([eopatch.data[features_dict]])
for eopatch in patch_array:
labels = np.array([eopatch.mask_timeless[labels_dict]])... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __split_dataset(self):\n self.train, self.valid, _, _ = train_test_split(self.data, self.data, test_size=0.2)\n self.valid, self.test, _, _ = train_test_split(self.valid, self.valid, test_size=0.5)",
"def split_data_into_train_and_test(raw_training_data):\n train_set, test_set = train_test_s... | [
"0.8715228",
"0.867129",
"0.8421134",
"0.8248853",
"0.8183687",
"0.8146796",
"0.8093657",
"0.8088005",
"0.8075957",
"0.80384034",
"0.80211496",
"0.80177146",
"0.80029935",
"0.79595435",
"0.7912857",
"0.7880697",
"0.7858649",
"0.78521097",
"0.7849592",
"0.78286815",
"0.7782076... | 0.0 | -1 |
mask out labels that are not in both train and test data and also mask out samples where features include NaN values | def masking(X_train, X_test, y_train, y_test):
# create mask to exclude NaN-values from train data
mask_train = np.zeros(X_train.shape[0], dtype=np.bool)
for i, subfeat in enumerate(X_train):
if True in np.isnan(subfeat):
mask_train[i] = True
else:
mask_train[i] = Fa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def omit_nans(self, data, label):\n maskarray=np.full(data.shape[0], True)\n masker=np.unique(np.argwhere(np.isnan(data))[:,0])\n maskarray[masker]=False\n traindata=data[maskarray,:,:,:]\n trainlabel=label[maskarray]\n return traindata, trainlabel",
"def filter_nan_samp... | [
"0.7626387",
"0.6600071",
"0.63293505",
"0.62641454",
"0.62288636",
"0.61516243",
"0.608271",
"0.6056829",
"0.6002692",
"0.599427",
"0.59860575",
"0.59836817",
"0.5916399",
"0.5898351",
"0.5887911",
"0.5840369",
"0.5840369",
"0.581876",
"0.58088595",
"0.5802163",
"0.5787612",... | 0.75027907 | 1 |
This function prints and plots the confusion matrix. Normalization can be applied by setting `normalize=True`. | def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues, ylabel='True label', xlabel='Predicted label', filename=None):
np.set_printoptions(precision=2, suppress=True)
if normalize:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_confusion_matrix(cm, classes=[0,1], normalize=False, title='Confusion matrix', print_matrix=False):\n\n if normalize:\n cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n print(\"Normalized confusion matrix\")\n else:\n print('Confusion matrix, without normalization')\n\n... | [
"0.8195649",
"0.8095532",
"0.803007",
"0.8019817",
"0.7994959",
"0.7991904",
"0.79818887",
"0.79766536",
"0.7961735",
"0.7957412",
"0.79385704",
"0.7935568",
"0.79352015",
"0.7932079",
"0.79270303",
"0.7925357",
"0.79243845",
"0.7923781",
"0.792341",
"0.79226786",
"0.7918532"... | 0.0 | -1 |
Returns mapping between Geopedia's crop index and crop id for Slovenia. | def get_slovenia_crop_geopedia_idx_to_crop_id_mapping():
gpd_session = GeopediaSession()
to_crop_id = list(GeopediaFeatureIterator(layer='2036', gpd_session=gpd_session))
to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]
to_crop_id = pd.DataFrame(to_crop_id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_austria_crop_geopedia_idx_to_crop_id_mapping():\n gpd_session = GeopediaSession()\n to_crop_id = list(GeopediaFeatureIterator(layer='2032', gpd_session=gpd_session))\n to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]\n to_crop_id = pd.DataFrame(to_cr... | [
"0.75980484",
"0.75025374",
"0.5695294",
"0.5330386",
"0.52470756",
"0.5175866",
"0.5105939",
"0.5084242",
"0.5022458",
"0.50011927",
"0.49794403",
"0.49425364",
"0.48705566",
"0.48659784",
"0.48595893",
"0.48556918",
"0.48154962",
"0.48137003",
"0.4780601",
"0.47703573",
"0.... | 0.8482437 | 0 |
Returns mapping between Geopedia's crop index and crop id for Austria. | def get_austria_crop_geopedia_idx_to_crop_id_mapping():
gpd_session = GeopediaSession()
to_crop_id = list(GeopediaFeatureIterator(layer='2032', gpd_session=gpd_session))
to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]
to_crop_id = pd.DataFrame(to_crop_id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_slovenia_crop_geopedia_idx_to_crop_id_mapping():\n gpd_session = GeopediaSession()\n to_crop_id = list(GeopediaFeatureIterator(layer='2036', gpd_session=gpd_session))\n to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]\n to_crop_id = pd.DataFrame(to_c... | [
"0.77784413",
"0.776725",
"0.5600029",
"0.54075384",
"0.5386751",
"0.52513653",
"0.521203",
"0.5181957",
"0.5152261",
"0.5145004",
"0.51417464",
"0.5124304",
"0.5023551",
"0.5006278",
"0.49717915",
"0.4945458",
"0.4932558",
"0.49104485",
"0.49027997",
"0.48968828",
"0.4886672... | 0.85902876 | 0 |
Returns mapping between Geopedia's crop index and crop id for Austria. | def get_danish_crop_geopedia_idx_to_crop_id_mapping():
gpd_session = GeopediaSession()
to_crop_id = list(GeopediaFeatureIterator(layer='2050', gpd_session=gpd_session))
to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]
to_crop_id = pd.DataFrame(to_crop_id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_austria_crop_geopedia_idx_to_crop_id_mapping():\n gpd_session = GeopediaSession()\n to_crop_id = list(GeopediaFeatureIterator(layer='2032', gpd_session=gpd_session))\n to_crop_id = [{'crop_geopedia_idx': code['id'], **code['properties']} for code in to_crop_id]\n to_crop_id = pd.DataFrame(to_cr... | [
"0.8590341",
"0.7777967",
"0.55995166",
"0.5406844",
"0.5386515",
"0.5250449",
"0.52115846",
"0.5181277",
"0.5151335",
"0.5144841",
"0.51434386",
"0.5124106",
"0.5024576",
"0.50069875",
"0.49709794",
"0.4945706",
"0.4932167",
"0.49089321",
"0.4904205",
"0.48967505",
"0.488521... | 0.77669185 | 2 |
See Task's docs for the explanation of what is done. | def _fix_slovenian_lpis(self, eopatch):
eopatch.vector_timeless[self.feature].rename(index=str, columns={"SIFRA_KMRS": "crop_geopedia_idx"},
inplace=True)
eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task_done(self) -> None:\n pass",
"def task():",
"def _work(self):\n return \"Task Done\"",
"def task():\n pass",
"def task():\n pass",
"def taskCompleted(self) -> None:\n ...",
"def taskCompleted(self) -> None:\n ...",
"def task_done(self):\n self.__data[... | [
"0.82386553",
"0.7563888",
"0.74738455",
"0.7442565",
"0.7442565",
"0.7423436",
"0.7423436",
"0.7390882",
"0.7277639",
"0.72640425",
"0.7255059",
"0.7245628",
"0.72235",
"0.72235",
"0.7144731",
"0.71438885",
"0.71137834",
"0.70728517",
"0.70728517",
"0.70479167",
"0.7043934",... | 0.0 | -1 |
See Task's docs for the explanation of what is done. | def _fix_austrian_lpis(self, eopatch):
eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],
self.mapping,
on='SNAR_BEZEI') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task_done(self) -> None:\n pass",
"def task():",
"def _work(self):\n return \"Task Done\"",
"def task():\n pass",
"def task():\n pass",
"def taskCompleted(self) -> None:\n ...",
"def taskCompleted(self) -> None:\n ...",
"def task_done(self):\n self.__data[... | [
"0.82387906",
"0.7566016",
"0.7473968",
"0.7443576",
"0.7443576",
"0.74233943",
"0.74233943",
"0.7391527",
"0.72773564",
"0.72633433",
"0.72552836",
"0.7246756",
"0.7225533",
"0.7225533",
"0.7146467",
"0.7144274",
"0.71132636",
"0.70735073",
"0.70735073",
"0.70464575",
"0.704... | 0.0 | -1 |
See Task's docs for the explanation of what is done. | def _fix_danish_lpis(self, eopatch):
eopatch.vector_timeless[self.feature].rename(index=str, columns={"CropName": "crop_geopedia_idx"}, inplace=True)
eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],
self.mapp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task_done(self) -> None:\n pass",
"def task():",
"def _work(self):\n return \"Task Done\"",
"def task():\n pass",
"def task():\n pass",
"def taskCompleted(self) -> None:\n ...",
"def taskCompleted(self) -> None:\n ...",
"def task_done(self):\n self.__data[... | [
"0.82381403",
"0.7564784",
"0.74732625",
"0.7443405",
"0.7443405",
"0.7422492",
"0.7422492",
"0.7391623",
"0.7276497",
"0.72642094",
"0.7255191",
"0.7246073",
"0.72239846",
"0.72239846",
"0.71451586",
"0.71425253",
"0.7114694",
"0.7072317",
"0.7072317",
"0.7047504",
"0.704338... | 0.0 | -1 |
Query oVirt for hosts and place them in env.hosts | def query(oquery='', sure='no', ovirt=None):
hosts = oVirtObjectType.all_types['host'].query(ovirt, oquery)
env.hosts = [host.address for host in hosts]
puts(yellow(
"Got %d hosts: \n\t" % len(env.hosts)
+ '\n\t'.join(env.hosts)
))
if sure != 'yes' and not env.parallel:
if pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_hosts(self):\n ...",
"def list_hosts():\n task_run(\"/bin/hostname -f\",RING_1_dev__allnodes)",
"def iter_hosts():\n environmentdef = _get_environmentdef()\n\n for host in environmentdef.hosts():\n # fabric needs the host if we're calling from main()\n with this_hostname(h... | [
"0.71519107",
"0.68191886",
"0.6781512",
"0.6779192",
"0.67747766",
"0.6615469",
"0.6611653",
"0.65831035",
"0.6563107",
"0.6526407",
"0.6524256",
"0.6518464",
"0.6516803",
"0.6516803",
"0.65129817",
"0.6509997",
"0.6502699",
"0.6498704",
"0.6484243",
"0.6476118",
"0.64731044... | 0.70534045 | 1 |
List walks, or create a new walks. | def walk_list_api(request):
if request.method == 'GET':
walks = Walk.objects.filter(user=request.user).order_by("-date")
serializer = WalkSerializer(walks, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = WalkSerializer(data=request.data)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def walk(self):\n pass",
"def _generate_walks(self):\n return parallel_generate_walks(\n self.d_graph,\n self.walk_length,\n self.num_walks,\n 'Single process!',\n self.sampling_strategy,\n self.NUM_WALKS_KEY,\n self.WALK_... | [
"0.5646791",
"0.5542716",
"0.55225664",
"0.5464238",
"0.54215646",
"0.528533",
"0.52653676",
"0.511849",
"0.5058529",
"0.5012877",
"0.4977857",
"0.49737927",
"0.4950848",
"0.4932711",
"0.4876913",
"0.48244464",
"0.48208708",
"0.4789596",
"0.4759153",
"0.47326207",
"0.47326207... | 0.56819975 | 0 |
Python script to read information from a public API returns employess an their completed tasks | def main():
number = sys.argv[1]
url_user = "https://jsonplaceholder.typicode.com/users/{}".format(number)
url_tasks = ("https://jsonplaceholder.typicode.com/users/{}/todos".
format(number))
response = requests.get(url_tasks)
tasks = response.json()
user_info = requests.get(url_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTasks(server, appId, maxNumberTasks, completedOnly, oper = 0, fileName = 'data/jsonTasksInfo.dat'):\n if oper == 0:\n if completedOnly == 1:\n JSONdata = urllib2.urlopen(url=server+\"/api/task?app_id=\"+ \\\n str(appId)+\"&state=completed&limit=\"+ \\\n str... | [
"0.6383334",
"0.6324897",
"0.60697365",
"0.60460687",
"0.6041132",
"0.6039913",
"0.6039841",
"0.6021158",
"0.59782183",
"0.594846",
"0.5938907",
"0.590392",
"0.58827335",
"0.58718795",
"0.5845513",
"0.58447444",
"0.5832608",
"0.5792506",
"0.5783988",
"0.57403696",
"0.5719636"... | 0.68217677 | 0 |
Return the first empty board space. | def ChooseAction(board, player):
# list of all possible initial actions
possible_actions = list(i for i in range(16) if board[i] == 0)
# default action
chosen_move = min(possible_actions)
# Dict to keep track of searched utilities and transposed/symmetric boards utilities
trans_map = {}
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_empty_space(board: list) -> tuple:\n board_length = len(board)\n for i in range(board_length):\n for j in range(board_length):\n if board[i][j] == 0:\n return (i,j)",
"def getBlank(self):\n return self.tiles[-1]",
"def firstEmptyCell(board):\r\n for i i... | [
"0.7228956",
"0.72194856",
"0.71157676",
"0.70752555",
"0.7033004",
"0.7023246",
"0.69070786",
"0.6800406",
"0.67626697",
"0.67131233",
"0.67107725",
"0.6703432",
"0.6672965",
"0.6548556",
"0.6537903",
"0.65232265",
"0.64945805",
"0.64092594",
"0.6404099",
"0.63550234",
"0.63... | 0.0 | -1 |
Given a state in a game, calculate the best move by searching forward all the way to the terminal states. | def min_max_dec(possible_actions, board, player):
max_move = None
max_u = None
alpha = None
beta = None
trans_map = {}
for a in possible_actions:
next_state, next_player = ApplyAction(a, copy.copy(board), player)
if str(next_state) not in trans_map:
u = best_utility(next_state, next_player, alpha, b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_best_move(state: GameState) -> None:",
"def find_best_move(state) -> None:\n C: float = 2 ** 0.5 # Start with sqrt(2)\n idx: int = -1\n win_ratio: float = 0\n\n # First create the root node for the game\n root = State(None, None, state)\n root = expand(root)\n root = run_each_move(r... | [
"0.86593556",
"0.7661473",
"0.7622619",
"0.75274277",
"0.75215596",
"0.73920614",
"0.73836887",
"0.7380424",
"0.7089991",
"0.70826083",
"0.70650315",
"0.70334923",
"0.702504",
"0.6907222",
"0.6841861",
"0.6832756",
"0.68116426",
"0.6809587",
"0.6802957",
"0.6794307",
"0.67721... | 0.0 | -1 |
Put one token in the appropriate space. | def ApplyAction(action, board, player):
# default next player
next_player = -player
# ensure move is an int not a string
action = int(action)
board[action] = player
# determine if adjacent squares to action are surrounded
check_pos = action+1
if is_surrounded(check_pos, board,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_token(self,token):\n\t\tif not token:\n\t\t\tlogging.error(\"Token cannot be empty!\")\n\t\t\texit()\n\n\t\tself.tokens.append(token.lower())\n\t\t#self.user_defined_token = token.lower()",
"def place_token(self, x, y, player):\n pass",
"def wrapspace(text, token):\n\n # Wildcards have no... | [
"0.6519636",
"0.64898586",
"0.6479388",
"0.64415634",
"0.63102734",
"0.6257991",
"0.6152137",
"0.6017201",
"0.6010566",
"0.59733546",
"0.59363115",
"0.59293514",
"0.5919438",
"0.5919438",
"0.59010226",
"0.5834218",
"0.5832736",
"0.57661647",
"0.5702237",
"0.5663479",
"0.56570... | 0.0 | -1 |
Pads episodes to all be the same length by repeating the last exp. | def pad(episodes):
max_len = max(len(episode) for episode in episodes)
mask = torch.zeros((len(episodes), max_len), dtype=torch.bool)
padded_episodes = []
for i, episode in enumerate(episodes):
padded = episode + [episode[-1]] * (max_len - len(episode))
padded_episodes.append(padded)
mask[i, :len(ep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pad(seq, n):\n return",
"def _add_target_n_step_q_to_episode(self, episode):\n horizon = len(episode)\n for t in range(horizon):\n end_idx = min(t + self.n, horizon)\n discount = self.gamma ** (end_idx - t)\n mask = episode[end_idx - 1][\"nonterminal\"]\n ... | [
"0.62974507",
"0.58488435",
"0.58399844",
"0.56710404",
"0.56123376",
"0.555278",
"0.55409425",
"0.55328083",
"0.54572415",
"0.5408101",
"0.5379053",
"0.53634495",
"0.5328769",
"0.5322512",
"0.53201896",
"0.5319856",
"0.5299281",
"0.52867496",
"0.52844036",
"0.5275552",
"0.52... | 0.6246594 | 1 |
Runs a single episode on the environment following the policy. | def run_episode(env, policy, experience_observers=None, test=False):
# Optimization: rendering takes a lot of time.
def maybe_render(env, action, reward, timestep):
if test:
render = env.render()
render.write_text("Action: {}".format(str(action)))
render.write_text("Reward: {}".format(reward))... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_episode(self, mode=0, eps=0.):\n if mode==0:\n eps = 0.\n done = False\n score = 0 \n \n while not done:\n state = self.env_info.vector_observations[0] # get the current state\n action = self.agent.act(state, eps=eps) ... | [
"0.76647586",
"0.75265527",
"0.7446451",
"0.7296921",
"0.7284399",
"0.72290254",
"0.71253014",
"0.7124329",
"0.7113471",
"0.711132",
"0.7066778",
"0.69308335",
"0.6915585",
"0.69102883",
"0.68798035",
"0.68423396",
"0.67618114",
"0.668217",
"0.66798794",
"0.6679265",
"0.66760... | 0.70803934 | 10 |
Returns the environment class specified by the type. | def get_env_class(environment_type):
if environment_type == "vanilla":
return city.CityGridEnv
elif environment_type == "distraction":
return city.DistractionGridEnv
elif environment_type == "map":
return city.MapGridEnv
elif environment_type == "cooking":
return cooking.CookingGridEnv
elif en... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_environment_class_by_name(environment_type):\n for cls in util.iter_subclasses(Environment):\n if cls.tool_name == environment_type:\n return cls\n raise EnvironmentUnavailable(\n f\"Unknown environment type '{environment_type}'\")",
"def get_environment_class(conf, python)... | [
"0.82389814",
"0.7236929",
"0.67771494",
"0.6746536",
"0.65948284",
"0.6437139",
"0.6344269",
"0.63292193",
"0.6256534",
"0.6174284",
"0.61565256",
"0.60773396",
"0.5924187",
"0.5919927",
"0.58619225",
"0.57948107",
"0.57791364",
"0.5763649",
"0.57397777",
"0.5733595",
"0.573... | 0.8176247 | 1 |
Add a value to the sketch. | def add(self, val):
key = self.get_key(val)
self.store.add(key)
# Keep track of summary stats
self._count += 1
self._sum += val
if val < self._min:
self._min = val
if val > self._max:
self._max = val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_value(self, value):\n self.value = value",
"def append_value(self, value):\n self.value += value",
"def add(self, value):\n pass",
"def add(self, value):",
"def add(self, value):\n self.arr.append(value)",
"def add(self, value):\n self._resolve_copies()\n ... | [
"0.77562946",
"0.7472587",
"0.7318282",
"0.72282714",
"0.71423835",
"0.695267",
"0.6935588",
"0.69271195",
"0.69076866",
"0.6858983",
"0.6736842",
"0.6711433",
"0.6589619",
"0.65422803",
"0.64677376",
"0.64545023",
"0.6430716",
"0.6359177",
"0.63571227",
"0.63571227",
"0.6344... | 0.5986063 | 57 |
Two sketches can be merged only if their gamma and min_values are equal. | def mergeable(self, other):
return self.gamma == other.gamma and self.min_value == other.min_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def canBeMergedWith(self, other):",
"def _merge_sanity_check(self, other):\n if self._fields is not None and (\n set(self.query.values_select) != set(other.query.values_select)\n or set(self.query.extra_select) != set(other.query.extra_select)\n or set(self.query.annotatio... | [
"0.561305",
"0.5554772",
"0.55113935",
"0.5468042",
"0.54112643",
"0.5404954",
"0.5348093",
"0.53448844",
"0.5326112",
"0.53066695",
"0.5288724",
"0.5269989",
"0.51783633",
"0.51139086",
"0.5101292",
"0.5095481",
"0.507951",
"0.50213623",
"0.5012159",
"0.4999083",
"0.4995614"... | 0.7373218 | 0 |
Takes a list of revision dicts and extracts globals, includes, and pages Expects revision dict to be sorted already Returns 3tuple | def extract_data(data, rev=0):
globs = {'_pages' : {}}
includes = []
pages = []
pages_list = []
for datum in data:
globs.update(datum.get('globals', {}))
includes += datum.get('includes', [])
datum_pages = datum.get('pages', [])
for page in datum_pages:
if... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_revision_pages(url_text):\n\trevision_links = []\n\tgrammar_indices = [m.start() for m in re.finditer(\"grammar\", url_text.lower())]\n\t# print(\"Grammar indices:\",grammar_indices)\n\n\tfor i in range(len(grammar_indices)):\n\t\tgrammar_index = grammar_indices[i] \n\t\tprev_index = url_text[:grammar_ind... | [
"0.58713603",
"0.5255621",
"0.5184779",
"0.5133159",
"0.5087633",
"0.50743926",
"0.5060516",
"0.50166947",
"0.49424127",
"0.49343994",
"0.49080712",
"0.48932",
"0.48899907",
"0.4886464",
"0.48854086",
"0.48630324",
"0.48628467",
"0.48229107",
"0.48138183",
"0.4796315",
"0.478... | 0.7212066 | 0 |
1 > spleen, 3 > left kidney, 4 > gallbladder, 5 > esophagus 6 > liver, 7 > stomach, 11 > pancreas, 14 > duodenum | def convert_tcia_labels(mask, keep_all_label=False):
mask[np.isin(mask, [14])] = 0 # Remove duodenum
label = [1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1] # no right kidney
if keep_all_label:
label += [0,0]
return mask, label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fo_shizzle_my_nizzle(n): \n if n < 0:\n n = \"fo\"\n elif n >= 1 and n < 50: \n n = \"shizzle\"\n elif n >= 50 and n <= 100:\n n = \"my\"\n elif n % 2 == 0 and n % 3 == 0 and n > 100:\n n = \"nizzle\"\n else:\n n = \"\"\n return n",
"def solution(self):\n ... | [
"0.5961289",
"0.57007194",
"0.5665112",
"0.56513536",
"0.56026876",
"0.55827665",
"0.55325526",
"0.552477",
"0.5503733",
"0.546128",
"0.5445984",
"0.54206806",
"0.5409947",
"0.5400704",
"0.53799486",
"0.5364139",
"0.5361406",
"0.53584707",
"0.5339072",
"0.5305817",
"0.5295436... | 0.0 | -1 |
1 spleen, 6 liver, 11 pancreas | def convert_medical_decathlon_labels(mask, cohort, keep_all_label=False):
label = 12*[0]
if keep_all_label:
label += [0,0]
if cohort == 'liver':
mask[mask == 2] = 6
mask[mask == 1] = 6
label[6] = 1
elif cohort == 'pancreas':
mask[mask == 2] = 11
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reemplaza_tildes(palabra):",
"def affiche_plateau(plateau):\n remplissage = ' ' * 30\n print(remplissage, end='')\n for i in range(1, 7, 2):\n print(\" \" + str(i), sep='', end='')\n print()\n for i in range(get_nb_lignes(plateau[0])):\n print(remplissage, end='')\n if i %... | [
"0.6889607",
"0.648981",
"0.61234885",
"0.6100312",
"0.59595793",
"0.5941458",
"0.5847579",
"0.5844933",
"0.58387846",
"0.58319885",
"0.5828353",
"0.5821314",
"0.5816315",
"0.5805892",
"0.5794173",
"0.5782808",
"0.5778222",
"0.57483304",
"0.57463837",
"0.57396597",
"0.5730707... | 0.0 | -1 |
1 spleen, 2 right kidney, 3 left kidney, 4 gall bladder, 5 esophagus 6 liver, 7 stomach, 8 aorta, 9 inferior vena cava, 10 portal and splenic vein, 11 pancreas, 12 left adrenal gland, 13 right adrenal gland. | def load_learn2reg(self, patient):
start = time.time()
ct_path = self.folder + 'img/' + patient + end
array = load_sitk(ct_path)[np.newaxis, ...].astype(float)# Add 1 dimension
array = array[:, ::-1, ::-1, :]
if self.load_mask:
if self.pseu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hangman_figure(attempt_left):\n if attempt_left == N_TURNS:\n print('___________')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|')\n print('|_____')\n if attempt_left == N_TURNS - 1:\n print('... | [
"0.53578615",
"0.53493005",
"0.5348243",
"0.5291687",
"0.528967",
"0.5280485",
"0.52631533",
"0.52626497",
"0.52135915",
"0.52076775",
"0.5184838",
"0.51696646",
"0.5135104",
"0.51240534",
"0.5113022",
"0.51092434",
"0.5107674",
"0.5095507",
"0.50915027",
"0.50757784",
"0.505... | 0.0 | -1 |
1 > spleen, 3 > left kidney, 4 > gallbladder, 5 > esophagus 6 > liver, 7 > stomach, 11 > pancreas, 14 > duodenum | def load_tcia_pancreas(self, patient):
start = time.time()
ct_path = self.folder + 'nifti/' + patient + end
array = load_sitk(ct_path)[np.newaxis, ...].astype(float)# Add 1 dimension
# Correction of the orientation
array = array[:, ::-1, ::-1, ::-1]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fo_shizzle_my_nizzle(n): \n if n < 0:\n n = \"fo\"\n elif n >= 1 and n < 50: \n n = \"shizzle\"\n elif n >= 50 and n <= 100:\n n = \"my\"\n elif n % 2 == 0 and n % 3 == 0 and n > 100:\n n = \"nizzle\"\n else:\n n = \"\"\n return n",
"def solution(self):\n ... | [
"0.596013",
"0.5699823",
"0.56656635",
"0.56514853",
"0.56017965",
"0.5583126",
"0.55336237",
"0.5523108",
"0.55034256",
"0.5462615",
"0.54474133",
"0.54238445",
"0.5409785",
"0.5402162",
"0.5380286",
"0.5365057",
"0.5361857",
"0.5359248",
"0.5339483",
"0.53059673",
"0.529754... | 0.0 | -1 |
1 kidney (left and right); 2 tumor | def load_kits(self, patient):
start = time.time()
ct_path = self.folder + patient + '/imaging' + end
array = load_sitk(ct_path)[np.newaxis, ...].astype(float)# Add 1 dimension
# Corection of orientation
array = array[:, ::-1, ::-1, ::-1]
if self.pseudo_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def right_child(self, pos): \n return (2 * pos) + 1",
"def boundary_op_n(v):\r\n h = list(v.dic.keys())[0]\r\n p = len(h) - 1\r\n s = P_chains([],[])\r\n if (p != 0) and (isinstance(h, str) != True) and (isinstance(h, frozenset) != True) and (isinstance(h, ImmutableMatrix) != True):\r\n ... | [
"0.5672551",
"0.56521153",
"0.5564578",
"0.5561289",
"0.5561289",
"0.55153245",
"0.54989326",
"0.5496743",
"0.54880667",
"0.54845977",
"0.5477298",
"0.54354954",
"0.5426299",
"0.54248595",
"0.54067",
"0.538001",
"0.5370772",
"0.5370066",
"0.5360813",
"0.5335627",
"0.53286135"... | 0.0 | -1 |
r"""Computes fingerprints of the input strings. | def _sdca_fprint(input, name=None):
result = _op_def_lib.apply_op("SdcaFprint", input=input, name=name)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fingerprint(self, algorithm):",
"def hash_all(strs, digest=None):\r\n digest = digest or hashlib.sha1()\r\n for s in strs:\r\n digest.update(s)\r\n return digest.hexdigest()",
"def compute_fingerprint(self):\n\t\t# initialize tensorflow session\n\t\tsess = tf.InteractiveSession()\n\t\tclf_image = wb_... | [
"0.670117",
"0.57371354",
"0.55651414",
"0.5493191",
"0.54896253",
"0.5443566",
"0.543582",
"0.5407759",
"0.5404549",
"0.53830826",
"0.5371627",
"0.53708583",
"0.5342098",
"0.5332482",
"0.53251714",
"0.5275193",
"0.5273674",
"0.5261942",
"0.52594906",
"0.52541286",
"0.524208"... | 0.0 | -1 |
r"""Distributed version of Stochastic Dual Coordinate Ascent (SDCA) optimizer for linear models with L1 + L2 regularization. As global optimization objective is stronglyconvex, the optimizer optimizes the dual objective at each step. The optimizer applies each update one example at a time. Examples are sampled uniforml... | def _sdca_optimizer(sparse_example_indices, sparse_feature_indices,
sparse_feature_values, dense_features, example_weights,
example_labels, sparse_indices, sparse_weights,
dense_weights, example_state_data, loss_type, l1, l2,
num_loss_parti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimize_sgd(beta, X, y, num_iterations, step_size):\n \n N = X.shape[0]\n P = X.shape[1]\n costs = []\n #variable step size\n if step_size == 'rm': #Robbins–Monro rule\n t0 = 2\n C = 1\n alpha = 0.5\n for i in range(num_iterations): \n j = random.ran... | [
"0.58430123",
"0.57700384",
"0.559415",
"0.55526096",
"0.5507653",
"0.5500585",
"0.54425055",
"0.5425867",
"0.5423508",
"0.5412528",
"0.54118615",
"0.5398304",
"0.53416395",
"0.534044",
"0.53132707",
"0.52848023",
"0.5283411",
"0.5282129",
"0.5275689",
"0.5273703",
"0.5230695... | 0.68696374 | 0 |
r"""Applies L1 regularization shrink step on the parameters. | def _sdca_shrink_l1(weights, l1, l2, name=None):
result = _op_def_lib.apply_op("SdcaShrinkL1", weights=weights, l1=l1, l2=l2,
name=name)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l1_regularizer(scale):\n if isinstance(scale, numbers.Integral):\n raise ValueError('scale cannot be an integer: %s' % scale)\n if isinstance(scale, numbers.Real):\n if scale < 0.:\n raise ValueError('Setting a scale less than 0 on a regularizer: %g' %\n ... | [
"0.6826777",
"0.61285764",
"0.6045434",
"0.59946656",
"0.59823173",
"0.5980362",
"0.59782636",
"0.5918527",
"0.58867913",
"0.57994086",
"0.57767415",
"0.57330287",
"0.57198095",
"0.56476456",
"0.55648047",
"0.5526961",
"0.5520416",
"0.5410303",
"0.5392533",
"0.5335324",
"0.53... | 0.61554843 | 1 |
Creates a new column called "state_name" which has the corresponding state name. | def convert_names(self):
names_map = {
"AL": "Alabama",
"CT": "Conn",
"CA": "Cali",
"CO": "Colo",
"DC": "District of Columbia"
}
self["state_name"] = self["abbrev"].map(names_map) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def state_name(self):\n return self.state.name if self.state else None",
"def _state_name(self):\n return '{}_{}'.format(self.function_name, self.STATE_CONFIG_SUFFIX)",
"def state_name(self):\n return task_states.to_str(self.state)",
"def test_state_name(self):\n state = State('te... | [
"0.59332365",
"0.5794769",
"0.57316923",
"0.56383705",
"0.56352866",
"0.5583133",
"0.55823433",
"0.5517401",
"0.5467954",
"0.5395791",
"0.5355729",
"0.53275317",
"0.5282603",
"0.52656084",
"0.5245819",
"0.5232131",
"0.5232131",
"0.52084243",
"0.51937133",
"0.514762",
"0.51289... | 0.57571137 | 2 |
This class holds the windows which shows the create experiment widget. | def __init__(self,currentExperiment):
super(AmoebaCreateExperimentWindow,self).__init__()
self.currentExperiment = currentExperiment
#Create the window
self.subWindow = QMdiSubWindow()
self.widget = AmoebaCreateExperiment(self.subWindow,self.currentExperiment)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createWidgets(self):\n raise NotImplementedError",
"def showUI(cls):\r\n win = cls()\r\n win.create()\r\n return win",
"def build_window(self):\n\n main_frame = tk.Frame(self.root)\n main_frame.pack(fill='both')\n\n self.open_machine_learner_window_button = ... | [
"0.73238564",
"0.70476335",
"0.7020338",
"0.69660527",
"0.6964482",
"0.695962",
"0.6924835",
"0.67237866",
"0.6702971",
"0.6695231",
"0.6694868",
"0.6665668",
"0.666019",
"0.6648684",
"0.6624867",
"0.6576935",
"0.6558816",
"0.6556843",
"0.6536284",
"0.65104073",
"0.6472229",
... | 0.7192625 | 1 |
This function shows the window which holds the widget. | def show(self):
if AMOEBA_CREATE_EXPERIMENT_DEBUG:
print "Show Window."
self.subWindow.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_window(self):\n self.show()",
"def show(self, window):\r\n\r\n return",
"def show(self):\n self.wid.show()",
"def show(self):\n self._window.show()",
"def show(self):\n self.Show()",
"def show(self):\n # * displays the window, after using either the icon... | [
"0.8502241",
"0.8415356",
"0.8357775",
"0.79170626",
"0.77707803",
"0.7727727",
"0.75549763",
"0.7479209",
"0.74743026",
"0.74242014",
"0.73494244",
"0.7291545",
"0.7291496",
"0.7277171",
"0.7250763",
"0.7220816",
"0.7209948",
"0.7197237",
"0.71558094",
"0.71508753",
"0.71490... | 0.71113247 | 21 |
This function is triggered when the user tries to close the window. I'm not sure it fully works. | def closeEvent(self, event):
print "Window closed"
event.ignore()
print "Hide window."
self.subWindow.hide() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __window_close(self):\n pass",
"def ev_windowclose(self, event: WindowEvent) -> None:",
"def __onclosing(self):\n self.window.destroy()",
"def onCloseWindow(self, event):\r\n\r\n self.Destroy()",
"def ev_windowclose(self, event: tcod.event.WindowEvent) -> T | None:",
"def closeEv... | [
"0.88118833",
"0.8732062",
"0.83870757",
"0.8189104",
"0.8009371",
"0.80067825",
"0.7978525",
"0.7954626",
"0.7857697",
"0.77236134",
"0.772265",
"0.7715848",
"0.76946735",
"0.76637465",
"0.7650199",
"0.7618164",
"0.75708306",
"0.7559188",
"0.75585526",
"0.7537625",
"0.753376... | 0.7644354 | 15 |
This class stores the sub UIs involved in creating experiments, it also provides the basic control and framework for the revealing and hiding the correct UIs. | def __init__(self,subWindow,currentExperiment):
super(AmoebaCreateExperiment,self).__init__()
self.stage = 0
self.currentExperiment = currentExperiment
#self.XMLWriter = ExperimentXMLWriter()
self.XMLWriter = Amoeba_experiment()
if AMOEBA_CREATE_EXPERIMENT_DEBUG:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_ui(self, parent):\n view = View(\n Item(name=\"text\",\n show_label=False,\n editor=ImageTraitEditor(\n image=ImageResource(self.obj.name,\n search_path=[self.obj.parent.absolute_path]) )),\n id=\"puddle... | [
"0.62471116",
"0.59212595",
"0.58168197",
"0.5744645",
"0.57158315",
"0.57158315",
"0.5714117",
"0.571169",
"0.56999123",
"0.56376207",
"0.56022507",
"0.5516006",
"0.5484253",
"0.5476682",
"0.5469117",
"0.5456683",
"0.54334265",
"0.5423621",
"0.54227364",
"0.5418681",
"0.5391... | 0.5426657 | 17 |
This function handles the showing and hiding of UIs when the program is being run. | def next_pressed(self):
if AMOEBA_CREATE_EXPERIMENT_DEBUG:
print "Next pressed."
#Check stage.
if self.stage==0:
self.ShowAllInstruments.retrieve_selected()
self.XMLWriter.instruments = self.ShowAllInstruments.retrieve_selected()
if len(self.XMLWr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hide_gui():\n pass",
"def show_gui():\n pass",
"def isUIused():\n return False",
"def showDisplay(self, type=\"DEFAULT\"):\n gd = mamba.getDisplayer() # <- trick to ensure the root windows is created and hidden\n if type==\"DEFAULT\":\n # First if there is any di... | [
"0.68529445",
"0.6712458",
"0.6654804",
"0.65738904",
"0.6489169",
"0.6392772",
"0.6144045",
"0.6099471",
"0.6089309",
"0.59926564",
"0.59250045",
"0.5883586",
"0.58749723",
"0.5853369",
"0.5846495",
"0.5838198",
"0.58305126",
"0.5829298",
"0.5809941",
"0.58038217",
"0.580006... | 0.0 | -1 |
Test prefix. Printed every test | def setUp(self):
print("New test by Nikolay Melnik") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_tests_results(self):\n\n for test in self.test_report:\n for detail in test:\n print detail + ': ', test[detail]",
"def test(got, expected):\r\n if got == expected:\r\n prefix = \" OK \"\r\n else:\r\n prefix = \" X \"\r\n print(\"%s got: %s expec... | [
"0.668197",
"0.6677865",
"0.6658674",
"0.65337527",
"0.63311327",
"0.62027156",
"0.61702615",
"0.6143053",
"0.6114684",
"0.61015594",
"0.60133135",
"0.6003737",
"0.5984142",
"0.59417367",
"0.5937343",
"0.59372973",
"0.592105",
"0.59095734",
"0.59049034",
"0.58890426",
"0.5883... | 0.0 | -1 |
Testing Tuna is not null | def test_Tuna(self):
tuna = Tuna("1", "2", "3", "4")
self.assertIsNotNone(tuna) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testIsNullTrueAgain(self):\n val = is_null('') \n self.assertTrue(val)",
"def test_non_thesis(non_thesis):\n assert non_thesis is None",
"def nulltest():",
"def testIsNullTrue(self):\n val = is_null(\"\") \n self.assertTrue(val)",
"def is_null(space, w_obj):\n ... | [
"0.66639656",
"0.6589096",
"0.6544759",
"0.6537418",
"0.65249217",
"0.6464309",
"0.6438317",
"0.6438317",
"0.6416694",
"0.6395729",
"0.6372581",
"0.6337188",
"0.63306767",
"0.6319348",
"0.6262661",
"0.62500733",
"0.61865604",
"0.6135527",
"0.6083987",
"0.6083987",
"0.6083662"... | 0.6774843 | 0 |
Testing Tuna's setTunasFeatures method works | def test_setTunaFeatures(self):
tuna = Tuna()
array = ["1", "2", "3", "4"]
tuna.setTunaFeatures(array)
self.assertEqual(tuna.getTunaFeatures(), array) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_getTunaFeatures(self):\n tuna = Tuna(\"1\", \"2\", \"3\", \"4\")\n array = [\"1\", \"2\", \"3\", \"4\"]\n self.assertEqual(tuna.getTunaFeatures(), array)",
"def _initialize_with_tune_context(self, context: \"TuneContext\") -> None:\n raise NotImplementedError",
"def prepare... | [
"0.6467389",
"0.6120855",
"0.5748472",
"0.5742488",
"0.5711489",
"0.56948525",
"0.56849676",
"0.5643649",
"0.5622461",
"0.5612863",
"0.5570076",
"0.5564452",
"0.5562412",
"0.5538345",
"0.5495508",
"0.5485487",
"0.54830647",
"0.5479651",
"0.5453535",
"0.54154104",
"0.5412377",... | 0.75750804 | 0 |
Testing Tuna's getTunasFeatures method works | def test_getTunaFeatures(self):
tuna = Tuna("1", "2", "3", "4")
array = ["1", "2", "3", "4"]
self.assertEqual(tuna.getTunaFeatures(), array) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_setTunaFeatures(self):\n tuna = Tuna()\n array = [\"1\", \"2\", \"3\", \"4\"]\n tuna.setTunaFeatures(array)\n self.assertEqual(tuna.getTunaFeatures(), array)",
"def findFeatures(self):\n\t\tpass",
"def test__extract_features(self):\n text_sample = \"I really really l... | [
"0.71556205",
"0.6340565",
"0.61837447",
"0.5806672",
"0.5796584",
"0.57937485",
"0.57770115",
"0.57497746",
"0.5737169",
"0.5710892",
"0.5675815",
"0.5668341",
"0.5659601",
"0.55376226",
"0.5520661",
"0.55035144",
"0.5499606",
"0.5498502",
"0.54887605",
"0.5487713",
"0.54858... | 0.7249121 | 0 |
Create "can_approve_estimated_completion_date" permission and add it to the "Admin" group. | def add_permissions(apps, schema_editor):
Permission = apps.get_model("auth", "Permission")
Group = apps.get_model("auth", "Group")
ContentType = apps.get_model("contenttypes", "ContentType")
permission, created = Permission.objects.get_or_create(
codename="can_approve_estimated_completion_dat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_authorize(cls, user, obj):\n if not obj.delivery.deadline.assignment_group.is_examiner(user):\n raise PermissionDenied()",
"def write_authorize(cls, user, obj):\n if not models.AssignmentGroup.published_where_is_examiner(user).filter(id=obj.deadline.assignment_group.id):\n ... | [
"0.61045885",
"0.5988743",
"0.5814144",
"0.5738462",
"0.5411797",
"0.5401533",
"0.5399722",
"0.5363404",
"0.53633904",
"0.53270596",
"0.52686125",
"0.523226",
"0.52310044",
"0.5126954",
"0.51135796",
"0.5107107",
"0.5074804",
"0.5071565",
"0.50627375",
"0.5031271",
"0.5008885... | 0.76646936 | 0 |
Remove "can_approve_estimated_completion_date" permission and remove it from the "Admin" group. | def remove_permissions(apps, schema_editor):
Permission = apps.get_model("auth", "Permission")
Group = apps.get_model("auth", "Group")
permission = Permission.objects.get(
codename="can_approve_estimated_completion_date",
)
admin_group = Group.objects.get(name="Administrator")
admin_g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delPermission(self,request):\n request.needAuthType(request.ADMIN)\n request.checkArgs(\"admin_username\",\"perm_name\")\n request.getAuthNameObj().canDo(\"CHANGE ADMIN PERMISSIONS\")\n perm_actions.getActionManager().deletePermission(request[\"admin_username\"],request[\"perm_name\... | [
"0.63204193",
"0.60559267",
"0.5868938",
"0.5853292",
"0.5768508",
"0.5714673",
"0.5648865",
"0.56440014",
"0.5544115",
"0.55229086",
"0.55072224",
"0.54663765",
"0.5419387",
"0.5413648",
"0.53388613",
"0.5335905",
"0.53285515",
"0.5316271",
"0.5315049",
"0.5301109",
"0.52911... | 0.81578374 | 0 |
Prevent values being changed. | def __setattr__(self, name, value):
raise AttributeError("You cannot modify attributes on a %s" % self.__class__.__name__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ignore_value_changes(self):\n return self._parent.ignore_value_changes",
"def ignore_value_changes(self, value):\n self._parent.ignore_value_changes = value",
"def allow_values_only(self, allow_values_only):\n\n self._allow_values_only = allow_values_only",
"def modifyNotValuableComp... | [
"0.72520024",
"0.7134793",
"0.6745022",
"0.6565378",
"0.6425409",
"0.63827246",
"0.6363821",
"0.62904686",
"0.62816423",
"0.62450707",
"0.6216821",
"0.61870974",
"0.6140225",
"0.60032874",
"0.5918717",
"0.5918717",
"0.5918717",
"0.5873133",
"0.585663",
"0.58394444",
"0.583944... | 0.0 | -1 |
export GPU for AD | def export_gpu(entity=None):
status = False
exportGrp = config.geoGrp
res = entity.task_res()
libPath = entity.libPath()
if res:
abcName = entity.libName(config.libName.get('gpu'), res, ext='abc')
# name without ext
basename = os.path.splitext(abcName)[0]
gpuName = '{0}/{1}'.format(libPath, abcNam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetGPU():\n return option['device_id']",
"def create_gpu_device_if_present():\n d = dpctl.SyclDevice(\"gpu,cpu\")\n print(\"Selected \" + (\"GPU\" if d.is_gpu else \"CPU\") + \" device\")",
"def add_gpu_and_mpi_marks():\n pass",
"def create_gpu_device():\n d1 = dpctl.SyclDevice(\"gpu\")\n ... | [
"0.62095964",
"0.6097989",
"0.59566474",
"0.5911981",
"0.585888",
"0.5828839",
"0.57508516",
"0.57136184",
"0.5679205",
"0.56655836",
"0.5627468",
"0.55777365",
"0.55777365",
"0.5537934",
"0.55370134",
"0.55342036",
"0.54773647",
"0.5465165",
"0.54110056",
"0.53959876",
"0.53... | 0.70596236 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.