int:\n return 0 if not L else L[0]+ssum(L[1:])","def add_list_numbers(incoming_list):\n if incoming_list: #if incoming_list is not None and len(incoming_list) > 0\n return_value = sum(incoming_list)\n else:\n return_value = 0\n return return_value","def sum_series(n, zeroth, oneth):\n\n if (n == 0):\n return zeroth\n elif (n == 1):\n return oneth\n else:\n return sum_series(n - 1, zeroth, oneth) + \\\n sum_series(n - 2, zeroth, oneth)","def fsum(items):\n return math.fsum(items)","def accumulate(combiner, base, n, term):\n total, k = base, 1\n while k <= n:\n total, k = combiner(total, term(k)), k + 1\n return total","def recursive_sum(lst):\n\n if lst == []:\n return 0\n\n else:\n\n return lst[0] + recursive_sum(lst[1:])","def roll_and_sum(array, sum_array, N):\n from_end = array.size - N\n idx = from_end\n for i in range(N):\n sum_array[i] += array[idx]\n idx += 1\n\n idx = N\n for i in range(from_end):\n sum_array[idx] += array[i]\n idx += 1\n return sum_array","def sumValues(aList):\r\n sum = 0\r\n for d in aList:\r\n sum += d\r\n return sum","def sum(*nums): \n s=0\n for num in nums:\n s += num\n return s","def sum_plus(t, init):\n total = init\n for x in t:\n total += x\n return total","def sum_series(n, first_val = 0, second_val = 1):\n if n == 0:\n return first_val\n elif n == 1:\n return second_val\n else:\n return (sum_series(n-1,first_val,second_val) +\n sum_series(n-2, first_val, second_val))","def task4_add_repeatedly(num):\n while len(str(num)) != 1:\n num = sum([int(i) for i in str(num)])\n return num","def inline_sum(summands, seed):\n for r in summands:\n seed += r\n return seed","def inline_sum(summands, seed):\n for r in summands:\n seed += r\n return seed","def sum_series(n, a=0, b=1):\n\tseq = []\n\tnth_term = 0\n\t\n\tfor i in range(0,n+1):\n\t\tif i == 0:\n\t\t\tseq.append(a)\n\t\tif i == 1:\n\t\t\tseq.append(b)\n\t\tif i > 1:\n\t\t\tnth_term = seq[-1] + seq[-2]\n\t\t\tseq.append(nth_term)\n\t\n\tprint(seq)\n\tprint(seq[n])\n\treturn(seq[n])","def rec_sum(user_n, sum_n=0, row_el=1):\n if user_n == 0:\n return sum_n\n else:\n sum_n += row_el\n row_el /= -2\n user_n -= 1\n return rec_sum(user_n, sum_n, row_el)","def sum_series(n, first_value=0, second_value=1):\n for i in range(n):\n first_value, second_value = second_value, first_value + second_value\n return first_value","def accumulate(values):\n # TODO: replace usage with numpy.cumsum(values) after adding numpy\n accumulation = 0\n for value in values:\n accumulation += value\n yield accumulation","def multiplication_total_of(num_list):","def total(n):\n if n < 0:\n return None\n else:\n result = 0\n for i in range(n + 1):\n result += i\n return result"],"string":"[\n \"def sum_of_numbers(numbers):\\r\\n return sum(numbers)\",\n \"def sum_list(numbers):\\n\\t\\n\\tif len(numbers) == 0:\\n\\t\\treturn 0 \\n\\n\\tsum = numbers[0] +sum_list(numbers[1:])\\n\\treturn sum\",\n \"def sum_numbers(sequence):\\r\\n\\r\\n total = 0\\r\\n seq = get_numbers(sequence)\\r\\n for element in seq:\\r\\n total += element\\r\\n\\r\\n return total\",\n \"def running_total(date_list):\\n return sum(d.price for d in date_list)\",\n \"def sum_numbers(numbers):\\n sum = 0\\n for number in numbers:\\n sum += number\\n\\n return sum\",\n \"def sum_list(num_list):\\n # return sum(num_list)\\n sum_list = 0\\n for number in num_list:\\n sum_list += number\\n print(sum_list)\\n \\n # code prints out the sum_list for each value, increasing by the value each time\\n # final output is the sum of numbers\\n # currently no output for '[]' as input \",\n \"def sum(inputList):\\n sum=0#the sum of the list starts from 0\\n for num in inputList:\\n sum=sum+num#add all number in the list\\n print(\\\"the sum is\\\",sum)\",\n \"def add_up(num):\\n aList = list(range(1, num + 1))\\n sum = 0\\n\\n for item in aList:\\n sum = add_together(sum, item)\\n# print(\\\"NOW SUM IS: \\\" + str(sum))\\n\\n return sum\",\n \"def total(num_list):\\n num_sum = 0.0\\n for item in num_list:\\n num_sum += item\\n return num_sum\",\n \"def recurrent_sum_of_elements_in_list(lst):\\n if len(lst) == 0:\\n return 0\\n elif len(lst) == 1:\\n return lst[0]\\n return lst[0] + recurrent_sum_of_elements_in_list(lst[1:])\",\n \"def sum_items(numbers):\\n total = 0\\n for item in numbers:\\n total += item\\n return total\",\n \"def sumTo(n):\\n \\n the_sum = 0 #current sum\\n a_number = 1 #where we are\\n while a_number <= n:\\n the_sum += a_number\\n a_number += 1\\n return the_sum\",\n \"def get_sum(lst):\\n _sum=0\\n for i in lst:\\n _sum+=i\\n return _sum\",\n \"def sum_numbers(numbers: list) -> int:\\n global num_hundreds\\n\\n total = sum(numbers)\\n num_hundreds += total // 100\\n\\n return total\",\n \"def cumulative_sum(x):\\n total = 0\\n sum = []\\n for num in x:\\n total += num\\n sum.append(total)\\n return sum\",\n \"def cumsum(L):\\n for i in range(1, len(L)):\\n L[i] += L[i-1]\\n return L\",\n \"def sum(iterable: typing.Iterable, start: float = 0) -> float:\\n return sum(iterable, start)\",\n \"def sum_numbers_one_to_ten():\\n sum=0\\n for num in range(1,11):\\n sum=sum+num\\n return sum\\n pass\",\n \"def add_list_numbers(incoming_list):\\n if incoming_list:\\n retval = sum(incoming_list)\\n else:\\n retval = 0\\n return retval\",\n \"def lsum (inlist):\\r\\n s = 0\\r\\n for item in inlist:\\r\\n s = s + item\\r\\n return s\",\n \"def sumTo(n):\\n\\n sum_all = (n * (n+1))/2\\n\\n return sum_all\",\n \"def add_list_numbers(incoming_list):\\n # summation=0\\n if incoming_list:\\n summation = sum(incoming_list)\\n else:\\n summation = 0\\n return summation\",\n \"def sum(lst):\\n total = 0\\n for i in lst:\\n total += i\\n return total\",\n \"def cum_sum(seq):\\n s = 0\\n cumult = [0]\\n for n in seq:\\n s += n\\n cumult.append(s)\\n return cumult\",\n \"def sum_to(n):\\n the_sum = 0\\n for counter in range(n+1):\\n the_sum = the_sum + counter\\n return the_sum\",\n \"def sumTotal(n):\\n\\n sum_total = 0\\n\\n for i in range(1, n+1):\\n sum_total = sum_total + i\\n\\n return sum_total\",\n \"def running_avg (mylist, N):\\n import numpy as np\\n \\n cumsum = np.cumsum(np.insert(mylist, 0, 0))\\n return (cumsum[N:] - cumsum[:-N]) / float(N)\",\n \"def summed(L):\\r\\n result = 0\\r\\n for e in L:\\r\\n result = result + e # or result += e\\r\\n return result\",\n \"def task_8_sum_of_ints(data: List[int]) -> int:\\n return sum(data)\",\n \"def cumsum(lst):\\n for i in range(1,len(lst)):\\n lst[i] = lst[i- 1 ] + lst[i]\\n return lst\",\n \"def __call__(self, i):\\n n = len(self.prompt_list)\\n if i <= 0:\\n return 0\\n elif i <= n:\\n return self.prompt_list[i - 1]\\n else:\\n running_list = self.prompt_list[:]\\n for j in range(n - 1, i):\\n running_sum = sum(running_list)\\n for k in range(n - 1):\\n running_list[k] = running_list[k + 1]\\n running_list[-1] = running_sum\\n return running_sum\",\n \"def sum_list(input_list: List[float]) -> float:\\n return sum(input_list)\",\n \"def sum_list(input_list: List[float]) -> float:\\n return sum(input_list)\",\n \"def test_running_sum_multi_positives(self):\\n\\n argument = [4,2,3,6]\\n expected = [4,6,9,15]\\n sums.running_sum(argument)\\n self.assertEqual(expected,argument,\\\"the list contains only positive values\\\")\",\n \"def sum_list(input_list: List[float]) -> float:\\n sum: float = 0\\n for i in input_list:\\n sum = sum + i\\n return sum\",\n \"def sum_f(f, xs):\\n sum_num = 0\\n for num in xs:\\n int_num = int(num)\\n fun_num = f(int_num)\\n sum_num = sum_num+fun_num\\n return sum_num\",\n \"def cumsum(ls):\\n\\t\\n\\tacc = 0\\n\\tr = [0 for v in ls]\\n\\tfor i,v in enumerate(ls):\\n\\t\\tacc += v\\n\\t\\tr[i] = acc\\n\\treturn r\",\n \"def cumulative_sum(self, lis):\\n new_list = []\\n for i in range(len(lis)):\\n if i == 0:\\n new_list.append(lis[i])\\n else:\\n new_list.append(new_list[i-1] + lis[i])\\n return new_list\",\n \"def sum_natural(n):\\n total, curr = 0 , 1\\n\\n while curr <= n:\\n total, curr = total + curr, curr + 1\\n return total\",\n \"def running_mean(sequence: list):\\n if not sequence:\\n return []\\n\\n mean = []\\n \\\"\\\"\\\"\\n [1] = 1 / 1\\n [1,2] = 3 / 2 \\n [1,2,3] = 6 / 3\\n \\\"\\\"\\\"\\n for idx, num in enumerate(sequence):\\n\\n sum_total = sum(sequence[:(idx + 1)])\\n result = sum_total / (idx + 1)\\n\\n mean.append(round(result, 2))\\n\\n return mean\",\n \"def sum_in_list_dyn(number_list, total_value):\\n memoization = [[False for i in range(total_value + 1)] for i in range(len(number_list) + 1)]\\n\\n for i in range(len(number_list) + 1):\\n # We can always make 0 with the empty set.\\n memoization[i][0] = True\\n\\n for i in range(1, len(number_list) + 1):\\n for j in range(1, total_value + 1):\\n if j < number_list[i - 1]:\\n memoization[i][j] = memoization[i - 1][j]\\n else:\\n memoization[i][j] = memoization[i - 1][j] or memoization[i - 1][j - number_list[i - 1]]\\n\\n return memoization[len(number_list)][total_value]\",\n \"def add(numbers):\\n counter = 0\\n for num in numbers:\\n counter += num\\n return counter\",\n \"def sum(*args):\\n result = 0\\n for i in args:\\n result += i\\n return result\",\n \"def sum1():\\n\\txs = []\\n\\tfor i in range(100000):\\n\\t\\tnum = joe.randrange(1000)\\n\\t\\txs.append(num)\\n\\n\\ttot = sum(xs)\\n\\treturn tot\",\n \"def add(numbers):\\n sum1 = 0\\n for i in numbers:\\n sum1 = sum1+i\\n\\n return sum1\",\n \"def test_running_sum_multi_mix(self):\\n argument = [4,0,2,-5,0]\\n expected = [4,4,6,1,1]\\n sums.running_sum(argument)\\n self.assertEqual(expected,argument, \\\"the list contains a mixture of negative\\\"\\n + \\\"and positive values. \\\")\",\n \"def sum(values):\\n total = 0\\n for i in values:\\n total += i\\n return total\",\n \"def sum_numbers(numbers=None):\\n if numbers is None:\\n return sum(range(1, 101))\\n else:\\n return sum(numbers)\",\n \"def task16_sum_up_until():\\n num = int(input('Enter how many numbers to sum up\\\\n'))\\n result = 0\\n for i in range(num + 1):\\n result += i\\n return result\",\n \"def summationLoop(lower, upper):\\r\\n sum = 0\\r\\n for i in range(lower, upper + 1):\\r\\n sum += i\\r\\n return sum\",\n \"def ll_sum(x):\\n xlist = []\\n for i in x:\\n for num in i:\\n xlist.append(num)\\n return sum(xlist)\",\n \"def sum_sum(t, init):\\n return sum(t, init)\",\n \"def cumulative_sum(some_list):\\n #This function will return new list that every element is the sum of the element before.\\n for i in range(len(some_list)):\\n new_list = some_list\\n if i > 0: #if it's not the first element in list so it can be sum by element before.\\n new_list[i] += new_list[i-1]\\n else:\\n pass #don't do anything with the first element of the list.\\n return new_list\",\n \"def fn(x):\\n if x <= 0: return int(x == 0)\\n return sum(fn(x - xx) for xx in nums)\",\n \"def lcumsum (inlist):\\r\\n newlist = copy.deepcopy(inlist)\\r\\n for i in range(1,len(newlist)):\\r\\n newlist[i] = newlist[i] + newlist[i-1]\\r\\n return newlist\",\n \"def sum_to_n(n):\\n total = 0\\n for i in range(1,n+1):\\n total += i\\n return total\",\n \"def fn(x):\\n ans = rsm = ii = 0 \\n for i in range(len(nums)): \\n rsm += nums[i]\\n while rsm > x: # sliding window \\n rsm -= nums[ii]\\n ii += 1\\n ans += i - ii + 1\\n return ans\",\n \"def question_26(list_num: int) -> int:\\n return sum(list_num)\",\n \"def test_running_sum_multi_zeros(self):\\n argument = [0,0,0,0]\\n expected = [0,0,0,0]\\n sums.running_sum(argument)\\n self.assertEqual(expected,argument,\\\"the list contains only zeros\\\")\",\n \"def main(n):\\n return sum(f(i) for i in xrange(n))\",\n \"def sum_multiples(num):\\n pass\",\n \"def _sum_sequence(seq):\\n\\n def _add(x, y): return x + y\\n\\n return reduce(_add, seq, 0)\",\n \"def find_sum( *my_list):\\n # a = len(my_list)- 2\\n # i = 0\\n # suma=0\\n # for i in my_list :\\n # suma += my_list[i]\\n # i+=1\\n # return suma\\n return sum(my_list)\",\n \"def sumDivisor(inputList):\\n result = 0\\n for i in inputList:\\n result += i\\n return result\",\n \"def add_list_numbers(incoming_list: list):\\n return sum(incoming_list)\",\n \"def cumulative_sum(array):\\n res = []\\n val = 0\\n for elem in array:\\n val += elem\\n res.append(val)\\n return res\",\n \"def summationReduce(lower, upper):\\r\\n if lower > upper:\\r\\n return 0\\r\\n else:\\r\\n return reduce(lambda x, y: x + y, range(lower, upper + 1))\",\n \"def method2():\\n n = 1000\\n s = 0\\n multiples = [3,5]\\n total = []\\n\\n for m in multiples:\\n total.append(0)\\n\\n minValue = 0\\n while(minValue < 1000):\\n minValue = 1000\\n minPosition = 0\\n for i, v in enumerate(total):\\n if v < minValue:\\n minValue = v\\n minPosition = i\\n\\n temp = total[minPosition] + multiples[minPosition]\\n\\n if(temp < 1000) and (temp not in total):\\n s += temp\\n\\n total[minPosition] = temp\\n\\n return s\",\n \"def summation(self):\\n return sum(self.read_ints())\",\n \"def _cumulative_sum(xs):\\r\\n cumsum = 0\\r\\n for x in xs:\\r\\n cumsum += x\\r\\n yield cumsum\",\n \"def sum_all_element(my_list):\\n result = 0\\n for i in range(len(my_list)):\\n result = result + int(my_list[i])\\n return result\",\n \"def sum_f(f, xs):\\n sum = 0\\n for x in xs:\\n sum += f(x)\\n return sum\",\n \"def sum_n_numbers():\\n n=int(input(\\\"Enter a number:\\\"))\\n s=0\\n for i in range(n+1):\\n s+=i\\n print(\\\"sum=\\\",s)\",\n \"def sum(n):\\n if n == 0:\\n return 0\\n return sum(n - 1) + n\",\n \"def for_loop_sum_to_end(end):\\n final_number = 0\\n for numbers in range(0, int(end+1)):\\n final_number += numbers\\n\\n print(final_number)\",\n \"def make_accumulator():\\n sum = []\\n def accumulator(x):\\n sum.append(x)\\n total = 0\\n for elem in sum:\\n total += elem\\n return total\\n return accumulator\",\n \"def square(original_number):\\n running_total = 0\\n for counter in range(original_number):\\n running_total = running_total + original_number\\n return running_total\",\n \"def sum_elements(arr):\\n return sum(arr)\",\n \"def add(numbers):\\n \\n result = numbers[0]\\n for n in numbers[1:]:\\n result = n + result\\n return result\",\n \"def sum_list(lst):\\n\\n if lst == []:\\n return 0\\n else:\\n return lst[0] + sum_list(lst[1:])\",\n \"def ssum(L: list) -> int:\\n return 0 if not L else L[0]+ssum(L[1:])\",\n \"def add_list_numbers(incoming_list):\\n if incoming_list: #if incoming_list is not None and len(incoming_list) > 0\\n return_value = sum(incoming_list)\\n else:\\n return_value = 0\\n return return_value\",\n \"def sum_series(n, zeroth, oneth):\\n\\n if (n == 0):\\n return zeroth\\n elif (n == 1):\\n return oneth\\n else:\\n return sum_series(n - 1, zeroth, oneth) + \\\\\\n sum_series(n - 2, zeroth, oneth)\",\n \"def fsum(items):\\n return math.fsum(items)\",\n \"def accumulate(combiner, base, n, term):\\n total, k = base, 1\\n while k <= n:\\n total, k = combiner(total, term(k)), k + 1\\n return total\",\n \"def recursive_sum(lst):\\n\\n if lst == []:\\n return 0\\n\\n else:\\n\\n return lst[0] + recursive_sum(lst[1:])\",\n \"def roll_and_sum(array, sum_array, N):\\n from_end = array.size - N\\n idx = from_end\\n for i in range(N):\\n sum_array[i] += array[idx]\\n idx += 1\\n\\n idx = N\\n for i in range(from_end):\\n sum_array[idx] += array[i]\\n idx += 1\\n return sum_array\",\n \"def sumValues(aList):\\r\\n sum = 0\\r\\n for d in aList:\\r\\n sum += d\\r\\n return sum\",\n \"def sum(*nums): \\n s=0\\n for num in nums:\\n s += num\\n return s\",\n \"def sum_plus(t, init):\\n total = init\\n for x in t:\\n total += x\\n return total\",\n \"def sum_series(n, first_val = 0, second_val = 1):\\n if n == 0:\\n return first_val\\n elif n == 1:\\n return second_val\\n else:\\n return (sum_series(n-1,first_val,second_val) +\\n sum_series(n-2, first_val, second_val))\",\n \"def task4_add_repeatedly(num):\\n while len(str(num)) != 1:\\n num = sum([int(i) for i in str(num)])\\n return num\",\n \"def inline_sum(summands, seed):\\n for r in summands:\\n seed += r\\n return seed\",\n \"def inline_sum(summands, seed):\\n for r in summands:\\n seed += r\\n return seed\",\n \"def sum_series(n, a=0, b=1):\\n\\tseq = []\\n\\tnth_term = 0\\n\\t\\n\\tfor i in range(0,n+1):\\n\\t\\tif i == 0:\\n\\t\\t\\tseq.append(a)\\n\\t\\tif i == 1:\\n\\t\\t\\tseq.append(b)\\n\\t\\tif i > 1:\\n\\t\\t\\tnth_term = seq[-1] + seq[-2]\\n\\t\\t\\tseq.append(nth_term)\\n\\t\\n\\tprint(seq)\\n\\tprint(seq[n])\\n\\treturn(seq[n])\",\n \"def rec_sum(user_n, sum_n=0, row_el=1):\\n if user_n == 0:\\n return sum_n\\n else:\\n sum_n += row_el\\n row_el /= -2\\n user_n -= 1\\n return rec_sum(user_n, sum_n, row_el)\",\n \"def sum_series(n, first_value=0, second_value=1):\\n for i in range(n):\\n first_value, second_value = second_value, first_value + second_value\\n return first_value\",\n \"def accumulate(values):\\n # TODO: replace usage with numpy.cumsum(values) after adding numpy\\n accumulation = 0\\n for value in values:\\n accumulation += value\\n yield accumulation\",\n \"def multiplication_total_of(num_list):\",\n \"def total(n):\\n if n < 0:\\n return None\\n else:\\n result = 0\\n for i in range(n + 1):\\n result += i\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71576524","0.69815713","0.6841886","0.6837456","0.6800794","0.6772406","0.67528427","0.67181194","0.6673988","0.65260226","0.65095073","0.64830434","0.64651746","0.6440968","0.6426239","0.6422132","0.6415855","0.64094716","0.63918203","0.63566345","0.63403064","0.6335576","0.630845","0.629218","0.62911224","0.6284487","0.62749356","0.62685746","0.6267026","0.62655836","0.6259211","0.6254339","0.6254339","0.62539226","0.6253186","0.62501425","0.6222645","0.6214502","0.620238","0.6201233","0.6195757","0.61906904","0.618011","0.61704046","0.6158947","0.6150538","0.61371535","0.6118303","0.60865027","0.60863864","0.60804856","0.6079798","0.6040214","0.6035942","0.60330147","0.6014705","0.60146046","0.6009947","0.600729","0.59977204","0.598749","0.59848493","0.5977266","0.59759855","0.59748435","0.59715915","0.5966598","0.5955087","0.59517854","0.5939102","0.59385145","0.59330875","0.59313613","0.592226","0.59143263","0.5908306","0.59064025","0.58962095","0.5893355","0.5882217","0.58735317","0.58577853","0.58404434","0.5831435","0.5829158","0.5828598","0.582384","0.58072615","0.5805138","0.57894695","0.5784668","0.57833225","0.57769823","0.57769823","0.57750976","0.57705164","0.5767385","0.5766822","0.5758301","0.57470113"],"string":"[\n \"0.71576524\",\n \"0.69815713\",\n \"0.6841886\",\n \"0.6837456\",\n \"0.6800794\",\n \"0.6772406\",\n \"0.67528427\",\n \"0.67181194\",\n \"0.6673988\",\n \"0.65260226\",\n \"0.65095073\",\n \"0.64830434\",\n \"0.64651746\",\n \"0.6440968\",\n \"0.6426239\",\n \"0.6422132\",\n \"0.6415855\",\n \"0.64094716\",\n \"0.63918203\",\n \"0.63566345\",\n \"0.63403064\",\n \"0.6335576\",\n \"0.630845\",\n \"0.629218\",\n \"0.62911224\",\n \"0.6284487\",\n \"0.62749356\",\n \"0.62685746\",\n \"0.6267026\",\n \"0.62655836\",\n \"0.6259211\",\n \"0.6254339\",\n \"0.6254339\",\n \"0.62539226\",\n \"0.6253186\",\n \"0.62501425\",\n \"0.6222645\",\n \"0.6214502\",\n \"0.620238\",\n \"0.6201233\",\n \"0.6195757\",\n \"0.61906904\",\n \"0.618011\",\n \"0.61704046\",\n \"0.6158947\",\n \"0.6150538\",\n \"0.61371535\",\n \"0.6118303\",\n \"0.60865027\",\n \"0.60863864\",\n \"0.60804856\",\n \"0.6079798\",\n \"0.6040214\",\n \"0.6035942\",\n \"0.60330147\",\n \"0.6014705\",\n \"0.60146046\",\n \"0.6009947\",\n \"0.600729\",\n \"0.59977204\",\n \"0.598749\",\n \"0.59848493\",\n \"0.5977266\",\n \"0.59759855\",\n \"0.59748435\",\n \"0.59715915\",\n \"0.5966598\",\n \"0.5955087\",\n \"0.59517854\",\n \"0.5939102\",\n \"0.59385145\",\n \"0.59330875\",\n \"0.59313613\",\n \"0.592226\",\n \"0.59143263\",\n \"0.5908306\",\n \"0.59064025\",\n \"0.58962095\",\n \"0.5893355\",\n \"0.5882217\",\n \"0.58735317\",\n \"0.58577853\",\n \"0.58404434\",\n \"0.5831435\",\n \"0.5829158\",\n \"0.5828598\",\n \"0.582384\",\n \"0.58072615\",\n \"0.5805138\",\n \"0.57894695\",\n \"0.5784668\",\n \"0.57833225\",\n \"0.57769823\",\n \"0.57769823\",\n \"0.57750976\",\n \"0.57705164\",\n \"0.5767385\",\n \"0.5766822\",\n \"0.5758301\",\n \"0.57470113\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83650804"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":75093,"cells":{"query":{"kind":"string","value":"Add poisson noise to the sinogram."},"document":{"kind":"string","value":"def add_poisson_noise_deprecated(self, snr=5):\n flag = False\n temp = np.copy(self.sinogram)\n if np.isclose(temp.max(), 1):\n snr += 3\n temp = temp * 10000.\n flag = True\n x_ref_norm_sq = np.linalg.norm(temp) ** 2\n lam = x_ref_norm_sq / pow(10., snr/10.) / temp.size\n noise = np.random.poisson(lam=lam, size=temp.shape) - lam\n self.sinogram = temp + noise\n if flag:\n self.sinogram = self.sinogram / 10000."},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_poisson_noise(self, sinogram, max_count=1000):\n\n temp = np.copy(sinogram)\n temp = temp * max_count\n temp = np.random.poisson(temp).astype('float')\n return temp / max_count","def add_poisson_noise(self):\n\n # Can be done without loops, but this reduces memory requirements.\n for i in range(self.nintegs):\n\n ramp = deepcopy(self.data[i])\n\n # Convert up the ramp samples, to flux between reads.\n ramp[1:] = np.diff(ramp, axis=0)\n\n # Add the poisson noise.\n ramp = np.where(ramp < 0, 0, ramp) # Sanity check.\n ramp = rdm.poisson(ramp)\n\n # Convert back to up the ramp samples.\n ramp = np.cumsum(ramp, axis=0)\n\n self.data[i] = deepcopy(ramp)\n\n self.modif_str = self.modif_str + '_poisson_noise'","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\n self.im += self.noise\n return","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\n self.image += self.noise\n return","def add_noise(self, noise):\n if noise > 0.0:\n for key in self.counts:\n self.counts[key] *= 1.0 + noise * np.random.random_sample()","def noise_poisson(img):\n imgtype = img.dtype\n img = img.astype(np.float32)/255.0\n\n vals = len(np.unique(img))\n vals = 2 ** np.ceil(np.log2(vals))\n noisy = 255 * np.clip(np.random.poisson(img.astype(np.float32) * vals) / float(vals), 0, 1)\n return noisy.astype(imgtype)","def apply_poisson_noise(data, seed=None):\n data = np.asanyarray(data)\n if np.any(data < 0):\n raise ValueError('data must not contain any negative values')\n\n rng = np.random.default_rng(seed)\n\n return rng.poisson(data)","def inhomogenous_poisson_gen():\n pass","def add_noise(self, data):","def poisson_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.16, channel_wise=1):\n if stddev is None:\n stddev = torch.rand(channel_wise) * sigma_max\n stddev = torch.tensor(stddev, device=inputs.device)\n if DATA_FORMAT == 'channels_first':\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\n else:\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\n sigma_map = (1 - inputs) * stddev\n return torch.randn_like(inputs) * sigma_map","def noise(self, freq: int, /) -> None:","def homogenous_poisson_gen():\n pass","def poisson_example(en, small2):\n from scipy.stats import poisson\n\n B = 1 << small2\n z = np.zeros(B); z[1] = 1\n wrap = irfft(np.exp(en * (rfft(z) - 1)))\n k = en // B + 1\n xs = k * B - (B >> 1) + np.arange(B)\n pmf = roll(wrap, B >> 1)\n df = pd.DataFrame({'x': xs, 'FFT pmf': pmf})\n po = poisson(en)\n df['Exact pmf'] = po.pmf(df.x)\n df = df.set_index('x', drop=True)\n fig, [ax0, ax1] = plt.subplots(1, 2, figsize=(FIG_W * 2, FIG_H + 0.3), constrained_layout=True)\n ax0.plot(wrap);\n ax0.set(title=f'Raw FFT-based output, wrapped to [0, {B}]',\n xlabel=f'Wrapped outcome, n mod {B}',\n ylabel='Probability mass, Pr(N=n)');\n df[['FFT pmf', 'Exact pmf']].plot(style=['-', ':'], ax=ax1, logy=True,\n title='Shifted FFT vs exact Poisson probabilities\\n(log scale)',\n xlabel='Outcome, n', ylabel='Probability mass, Pr(N=n)');\n ax1.set(ylim=[1e-17, 2 * df['FFT pmf'].max()])\n ax1.yaxis.set_minor_locator(ticker.LogLocator(subs='all'))","def addNoise(self, sigma=1.0):\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\n self.image += noise\n return","def add_imageNoise(img):\n if not np.all(img >= 0):\n print 'make sure the image pixel values are positive definite'\n sys.exit()\n noise = st.poisson.rvs(1.,loc = -1.,scale=1.,size=img.shape)*np.sqrt(img)\n return noise","def noise(self, noise):\n\n self._noise = noise","def noise(self, stddev):\n #add noise to weights\n pass","def addNoise(x,y,noise):\n n = len(x)\n theta = np.random.random(n)*(2*np.pi) # random angle in [0,2*pi[\n d = np.random.random(n)*noise # random amplitude in [0,noise[\n x += np.cos(theta)*d\n y += np.sin(theta)*d","def add_noise(arr, sigma):\n dims = arr.shape\n arr += sigma * noise(*dims)","def add_noise(self,fing):\r\n\t\tfingerprint = copy.deepcopy(fing)\r\n\t\tl = len(fingerprint)\r\n\t\tnp.random.seed()\t\r\n\t\tif self.noise_type == 'SNR':\r\n\t\t\tnoise = np.random.normal(0, 1, l)\r\n\t\t\tsignal_Power = np.linalg.norm(fingerprint)\r\n\t\t\tnoise_Power = np.linalg.norm(noise)\r\n\t\t\tcst = signal_Power / (noise_Power * self.noise_level)\r\n\t\t\tnoise = noise * cst\r\n\t\telif self.noise_type == 'Standard':\r\n\t\t\tnoise = np.random.normal(0, self.noise_level, l)\r\n\t\tfingerprint += noise\r\n\t\tif self.trparas.normalization == 'Noisy_input':\r\n\t\t\treturn fingerprint / np.linalg.norm(fingerprint)\r\n\t\telse:\r\n\t\t\treturn fingerprint","def addNoise(pure,snr):\r\n watts = pure**2\r\n # Calculate signal power and convert to dB \r\n sig_avg_watts = np.mean(watts)\r\n sig_avg_db = 10 * np.log10(sig_avg_watts)\r\n # Calculate noise according to [2] then convert to watts\r\n noise_avg_db = sig_avg_db - snr\r\n noise_avg_watts = 10 ** (noise_avg_db / 10)\r\n # Generate an sample of white noise\r\n mean_noise = 0\r\n noise = np.random.normal(mean_noise, np.sqrt(noise_avg_watts), len(watts))\r\n \r\n return pure+noise","def poisson(gp_link=None):\r\n if gp_link is None:\r\n gp_link = noise_models.gp_transformations.Log_ex_1()\r\n #else:\r\n # assert isinstance(gp_link,noise_models.gp_transformations.GPTransformation), 'gp_link function is not valid.'\r\n analytical_mean = False\r\n analytical_variance = False\r\n return noise_models.poisson_noise.Poisson(gp_link,analytical_mean,analytical_variance)","def addNoise_amp(array,counts):\r\n if array.dtype == 'complex' :\r\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\r\n else :\r\n if np.float64(counts) == 0.0e0 :\r\n arrayout = np.copy(array)\r\n elif np.float64(counts) < 0.0e0 :\r\n print 'bg.addNoise : warning counts < 0'\r\n else :\r\n arrayout = np.zeros(array.shape)\r\n arrayout = np.square(normalise(array))\r\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\r\n arrayout = np.sqrt(arrayout)\r\n tot = np.sum(np.abs(array)**2)\r\n arrayout = normalise(arrayout,tot)\r\n return arrayout","def addNoise(array,counts):\r\n if array.dtype == 'complex' :\r\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\r\n else :\r\n if np.float64(counts) == 0.0e0 :\r\n arrayout = np.zeros(array.shape, dtype=arrayout.dtype)\r\n elif np.float64(counts) < 0.0e0 :\r\n print 'bg.addNoise : warning counts < 0'\r\n elif np.float64(counts) > 1.0e9 :\r\n arrayout = np.zeros(array.shape)\r\n arrayout = normaliseInt(array)\r\n arrayout = np.random.normal(arrayout*np.float64(counts),np.sqrt(arrayout*np.float64(counts)))/np.float64(counts)\r\n tot = np.sum(array)\r\n arrayout = normaliseInt(arrayout,tot)\r\n else :\r\n arrayout = np.zeros(array.shape)\r\n arrayout = normaliseInt(array)\r\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\r\n tot = np.sum(array)\r\n arrayout = normaliseInt(arrayout,tot)\r\n return arrayout","def poisson_sd(data: DataSeries) -> DataSeries:\n return data.pow(0.5)","def add_noise(self):\n self.segments = deepcopy(self.segments)\n # Iterate through each of the first three Segments in the WordForm.\n for i in range(3):\n # Add noise to each Segment.\n self.segments[i].add_noise()","def noiseAtten(atten) :\n s.noiseAtten(atten)","def add_noise(spectrum,rms):\n noise = np.random.randn(spectrum.data.shape[0])*rms\n noisy_data = spectrum.data + noise\n noisy_spec = pyspeckit.Spectrum(xarr=spectrum.xarr,data=noisy_data)\n return noisy_spec","def add_noise_at_snr(channel_in, snr):\n\n rms_channel = np.sqrt(np.mean(channel_in ** 2.0))\n noise_std = rms_channel / np.sqrt(10.0 ** (snr/10.0))\n\n return channel_in + np.random.normal(size=channel_in.shape, scale=noise_std)","def add_noise(self):\n self.noise = torch.normal(0.5, .2, self.state.shape).double()\n self.noise *= torch.sqrt(2 *\n self.vars['T']*torch.tensor(self.vars['dt']))","def add_noise(self, snr, unit=None):\n return self.from_time(self.fs, noisify(self.in_time, snr, unit=unit))","def make_noisy_images(image):\r\n return apply_poisson_noise(image, random_state=12345)","def noise(self, xs, ys):\n raise NotImplementedError","def add_noise(image):\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\n \n return image","def convert_to_poisson(dp):\n return np.random.poisson(dp)","def _addNoise(self):\n self.dispNoise = self.dispRaw.copy()\n self.dispNoise[:, 0] += self.sigmaEast * numpy.random.randn(self.numStations)\n self.dispNoise[:, 1] += self.sigmaNorth * numpy.random.randn(self.numStations)\n self.dispNoise[:, 2] += self.sigmaUp * numpy.random.randn(self.numStations)\n return","def writeNoise(self):\n\n if (self.noise_file == None or self.noise_file == \"\"):\n return\n ofname = self.noise_file\n ofh = open(ofname,'w')\n\n # these have to be there as long as we've read the FAST file already\n ## not true: we don't store these in the dict.\n have_data = False\n if (\"TipRad\" in self.fstDict and 'TowerHt' in self.fstDict and 'Twr2Shft' in self.fstDict):\n tiprad = self.fstDict['TipRad']\n towerht = self.fstDict['TowerHt']\n twr2shft = self.fstDict['Twr2Shft']\n have_data = True\n\n for line in self.lines_noise:\n if (have_data and line.find('Observer location') >= 0):\n xdist = -1.0 * (tiprad + (towerht + twr2shft))\n ofh.write('{:.1f} 0.0 0.0'.format(xdist))\n ofh.write(' (x,y,z) Observer location in tower-base coordinate system. Use -(RotRad+HubHt)\\n')\n else:\n ofh.write(line)\n ofh.close()","def noiseReduction(self):\n pass","def add_noise(Y, sigma):\r\n return Y + np.random.normal(0, sigma, Y.shape)","def poisson_significance(s,b):\n return np.sqrt(2*((s+b)*np.log(1+s/b)-s))","def add_noise(spectra: np.ndarray, maxLevel: float = 0.1, seed: int = 42) -> np.ndarray:\n np.random.seed(seed)\n spectra = spectra.copy()\n spectra[:, 1:] *= (1-maxLevel/2) + np.random.rand(spectra.shape[0], spectra.shape[1]-1) * maxLevel\n return spectra","def plot_noise_distribution(self, ax, mask=None, **kwargs):\r\n trs = self.rec_smooth_pos\r\n ivalid = np.where(np.isfinite(trs.noise))[0]\r\n sigma = np.std(trs.noise[ivalid])\r\n mu = np.average(trs.noise[ivalid])\r\n\r\n kwargs['linestyle']='-'\r\n kwargs['linewidth']=1.0\r\n # fit lognormal\r\n if len(ivalid) > 10:\r\n try:\r\n x = np.linspace(-4.*sigma+mu, 4*sigma+mu, 200)\r\n params = stats.lognorm.fit(trs.noise[ivalid], loc=0.2)\r\n pdf_fit = stats.lognorm.pdf(x, params[0], loc=params[1], \r\n scale=params[2])\r\n ax.plot(x, pdf_fit, color='k', **kwargs)\r\n except:\r\n print(\"lognormal fit failed for \",self.ID)\r\n # fit normal\r\n ax.plot(x, mlab.normpdf(x, mu, sigma), color='b', **kwargs)\r\n\r\n plt.hist(trs.noise[ivalid], bins=50, normed=True, facecolor='g')\r\n ax.set_xlabel('position error (m)')\r\n ax.set_xlim([0, 10])\r\n ax.set_ylim([0, 1.0])\r\n ax.set_ylabel('frequency')\r\n\r\n return","def add_noise(image, noise, rate=0.05):\n\n if noise == \"gaussian\":\n row, col = image.shape\n var = ndimage.laplace(image).var()\n sigma = (var*rate) ** 0.5\n print(var, sigma)\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\n noisy = image + gauss\n # noisy = image + gauss\n return noisy\n\n elif noise == \"salt_pepper\":\n output = image.copy()\n black = 0\n white = 255\n probs = np.random.random(image.shape[:2])\n output[probs < (rate / 2)] = black\n output[probs > 1 - (rate / 2)] = white\n\n return output\n\n else:\n return image","def _apply_observation_noise(self, state: RobotState,\n config: RobotGroupConfig):\n if config.sim_observation_noise is None or self.random_state is None:\n return\n\n # Define the noise calculation.\n def noise(value_range: np.ndarray):\n amplitude = config.sim_observation_noise * np.ptp(\n value_range, axis=1)\n return amplitude * self.random_state.uniform(\n low=-0.5, high=0.5, size=value_range.shape[0])\n\n if config.qpos_range is not None:\n state.qpos += noise(config.qpos_range)\n if config.qvel_range is not None:\n state.qvel += noise(config.qvel_range)","def excess_noise_PDF(y,base_noise,Poisson=False):\n \n y, base_noise = array(y), array(base_noise)\n ymn = mean(y)\n yvar = var(y)\n base_var = base_noise**2\n x_guess = sqrt(yvar - mean(base_var)) if yvar > mean(base_var) else 0.0\n \n def log_like(mn,x_noise,log_norm_fac):\n x_var = x_noise**2\n var = x_var + base_var\n terms = -log(2*pi*var)/2 - (y - mn)**2/2/var\n return sum(terms) + log_norm_fac\n \n #initial pass at a normalization factor - use peak value\n def neg_like(x):\n mn,x_noise= x\n return -log_like(mn,x_noise,0.0)\n result = minimize(neg_like, [ymn,x_guess], method='Nelder-Mead')\n log_norm_fac = result.fun\n mn_pk, x_noise_pk = result.x\n \n def like(mn,x_noise):\n return exp(log_like(mn, x_noise, log_norm_fac))\n \n def xmn_like(xnorm):\n constrained_like = lambda mn: like(mn, xnorm*mn)\n result = quad(constrained_like, mn_pk, inf)[0]\n result += -quad(constrained_like, mn_pk, 0.0)[0]\n return result\n \n xmn_pk = x_noise_pk/mn_pk\n result = minimize(lambda x: -xmn_like(x), xmn_pk, method='Nelder-Mead')\n xmn_pk = result.x[0]\n# f_pk = -result.fun\n if xmn_pk < 0.0: xmn_pk = 0.0\n# width = 1.0/f_pk\n# area = pu.gauss_integrate(xmn_like, xmn_pk, 0.0, inf, sigma_guess=width)\n area = quad(xmn_like, xmn_pk, inf)[0]\n area += -quad(xmn_like, xmn_pk, 0.0)[0]\n pdf = lambda x: xmn_like(x)/area if x >= 0.0 else 0.0\n# if pdf(xmn_pk) <= 0.0: pdb.set_trace()\n return pdf, xmn_pk","def apply_noise(self, input):\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \n noisy_input = mask * input\n \n return noisy_input","def addNoise (image,noise_type=\"gauss\",var = .01):\n row,col,ch= image.shape\n if noise_type == \"gauss\": \n mean = 0.0\n #var = 0.001\n sigma = var**0.5\n gauss = np.array(image.shape)\n gauss = np.random.normal(mean,sigma,(row,col,ch))\n gauss = gauss.reshape(row,col,ch)\n #print(gauss)\n noisy = image + gauss*255\n return noisy.astype('uint8')\n elif noise_type == \"s&p\":\n s_vs_p = 0.5\n amount = 0.09\n out = image\n # Generate Salt '1' noise\n num_salt = np.ceil(amount * image.size * s_vs_p)\n coords = [np.random.randint(0, i - 1, int(num_salt))\n for i in image.shape]\n out[coords] = 255\n # Generate Pepper '0' noise\n num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))\n coords = [np.random.randint(0, i - 1, int(num_pepper))\n for i in image.shape]\n out[coords] = 0\n return out\n elif noise_type == \"poisson\":\n vals = len(np.unique(image))\n vals = 2 ** np.ceil(np.log2(vals))\n noisy = np.random.poisson(image * vals) / float(vals)\n return noisy\n elif noise_type ==\"speckle\":\n gauss = np.random.randn(row,col,ch)\n gauss = gauss.reshape(row,col,ch) \n noisy = image + image * gauss\n return noisy\n else:\n return image","def make_noise(self, signal_only):\n\n #print >> sys.stdout, \"generating noise...\"\n\n if signal_only:\n\n # the noise is just a time series of zeros\n \n self.td_noise = pycbc.types.timeseries.TimeSeries(\n initial_array=np.zeros(self.duration/self.delta_t),\n delta_t=self.delta_t, epoch=self.epoch)\n\n else:\n # Generate noise \n self.assign_noise_curve()\n\n # Generate time-domain noise\n # XXX: minimum duration seems to be 1 second. I'll hack around this by\n # reducing the 1 second to the desired duration\n tmplen=max(self.duration,1.0)/self.delta_t\n self.td_noise = pycbc.noise.noise_from_psd(int(tmplen), self.delta_t,\n self.psd, seed=self.seed)\n\n self.td_noise = \\\n pycbc.types.TimeSeries(self.td_noise.data[:self.duration/self.delta_t],\n delta_t=self.delta_t)\n\n # XXX not sure if this is a good idea...\n self.td_noise.start_time = float(self.epoch)\n\n self.fd_noise = self.td_noise.to_frequencyseries()","def std_poisson(world_seed, world_rate):\n return SimOpts(src_id=1,\n other_sources=[('Poisson2',\n {'src_id': 2,\n 'seed': world_seed,\n 'rate': world_rate})],\n end_time=1.0,\n sink_ids=[1001],\n s=np.asarray([1.0]),\n q=1.0,\n edge_list=[(1, 1001), (2, 1001)])","def addWhiteNoise(map,rmsArcmin):\n noisyMap = map.copy()\n if rmsArcmin == 0.0:\n pass\n else:\n radToMin = 180/numpy.pi*60\n pixArea = radToMin**2 * map.pixScaleX*map.pixScaleY\n rms = rmsArcmin/numpy.sqrt(pixArea)\n \n noise = numpy.random.normal( scale = rms, size = map.data.shape )\n \n noisyMap.data[:] += noise[:]\n\n \n return noisyMap","def pink_noise():\n global curr_tick\n octave = octave_lookup[curr_tick]\n curr_noise[octave] = int(white_noise() / (5-octave))\n curr_tick += 1\n if curr_tick >= len(octave_lookup):\n curr_tick = 0\n return sum(curr_noise)","def add_noise(self, u):\n noise = torch.randn_like(u)\n noise[:, :, :3] = noise[:, :, :3] * self.imu_std[0]\n noise[:, :, 3:6] = noise[:, :, 3:6] * self.imu_std[1]\n\n # bias repeatability (without in run bias stability)\n b0 = self.uni.sample(u[:, 0].shape).cuda()\n b0[:, :, :3] = b0[:, :, :3] * self.imu_b0[0]\n b0[:, :, 3:6] = b0[:, :, 3:6] * self.imu_b0[1]\n u = u + noise + b0.transpose(1, 2)\n return u","def _add_noise(signal: np.array, noise_power: float) -> np.array:\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\n return signal + noise","def _add_noise(signal: np.array, noise_power: float) -> np.array:\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\n return signal + noise","def add_noise(a: np.ndarray, noise: float) -> np.ndarray:\n return np.clip(a + np.random.normal(0, noise, len(a)), -1, 1)","def noise(self) -> Sequence:\n\n return self._noise","def addNoise( bmp, noise, savefile = '' ):\n w_count = 0 # count number of non-black pixels\n non_signal = [] # holds coordinates of w_counts\n for h in range(bmp.height):\n for w in range(bmp.width):\n # Add coordinates to non_signal\n if( intensity(bmp.pixels[h][w]) != 0 ):\n w_count += 1\n non_signal.append((h,w))\n\n #print(\"> Counted\", w_count, \"non-signal pixels; length signal\",len(non_signal))\n\n # If noise is greater than number of white pixels, then set noise ceiling\n if( noise > w_count ):\n noise = w_count\n\n # Now add noise\n noise_index = [] # holds random indicies for non_signal manipulation\n \n # we will fill up noise_index with random indicies\n while( len(noise_index) < noise ):\n # randomize based on size of non-black pixels\n add = int(random()*w_count)\n if( add not in noise_index ):\n noise_index.append(add)\n\n for n in noise_index:\n # --------- pixel height ---- pixel width ------------\n bmp.pixels[non_signal[n][0]][non_signal[n][1]] = (0,0,0)\n\n # Save image to a new file if prompted\n if( savefile != '' ):\n bmp.save(savefile)\n \n return bmp","def add_gaussian_noise(x, std):\n noise = x.new_zeros(x.size()).normal_(std=std)\n return x + noise","def get_image_with_poisson_noise(image):\r\n img = tf_norm_crop_resize_image(image, resize_dim=(64,64))\r\n noisy_img = np.clip(make_noisy_images(img*255.)/255., 0., 1.)\r\n return noisy_img","def add_image_noise(\n self, mu=0, sigma=0.005, only_positive=False, random_seed=None):\n if random_seed is not None:\n np.random.seed(random_seed)\n shape = self.signal.axes_manager.shape\n noise = normal(mu, sigma, shape)\n if only_positive:\n self._image_noise = np.absolute(noise)\n else:\n self._image_noise = noise","def nu_poisson(self) -> float:\n return self._nu_poisson","def _filter_sinogram(self, sino):\n # pad sinogram to reduce periodicity artefacts\n target_size = max(\n 64, int(2 ** np.ceil(np.log2(2 * self.m[-1].item())))\n )\n pad = target_size - self.m[-1]\n sino_pad = torch.nn.functional.pad(sino, (pad // 2, pad - pad // 2))\n\n # fft along detector direction\n sino_complex = torch.stack(\n [sino_pad, torch.zeros_like(sino_pad)], dim=-1\n )\n sino_fft = fft1(sino_complex)\n\n # apply frequency filter\n f = self._get_fourier_filter().unsqueeze(-1).to(sino.device)\n filtered_sino_fft = sino_fft * f\n\n # ifft along detector direction\n filtered_sino_pad = ifft1(filtered_sino_fft)[..., 0]\n\n # remove padding and rescale\n filtered_sino = filtered_sino_pad[..., pad // 2 : -(pad - pad // 2)]\n\n return filtered_sino","def test_self_consistency_noise(self):\n # test with SNR = 100\n SNR = self.p_gt[0] / 9\n noisy_data = self.data + SNR * RNG.normal(size=self.data.shape)\n popt, pcov = sine_fit(noisy_data, self.periods)\n assert_allclose(*fixed_signs(self.p_gt, popt), 5e-1)","def prob_3_6(self):\n \n ###### START CODE HERE ######\n\n\n ###### END CODE HERE ######\n pass\n \n ###### return addNoiseImg ######","def noisePreset() :\n s.noisePreset()","def make_noise(self, num):\n return np.random.randn(num, self.seq_length, self.noise_dim)","def poisson(self, size=None, lam=None, ndim=None, dtype='int64'):\r\n return self.gen(poisson, size, lam, ndim=ndim, dtype=dtype)","def add_noise(self, portion, amplitude):\n # TODO: Implement the add_noise function. Remember to record the\n # boolean value is_add_noise. You can try uniform noise or Gaussian\n # noise or others ones that you think appropriate.\n self.is_add_noise = True\n noise = np.random.normal(0, 1, size = self.x.shape)\n noNoiseIndices = np.random.choice(self.x.shape[0], size = int(np.round(self.x.shape[0]*(1 - portion))), replace = False)\n noise = (noise*amplitude).astype(np.uint8)\n noise[noNoiseIndices,:] = 0\n self.x += noise\n self.x = np.clip(self.x, 0, 255, out=self.x)\n \n \n \n \n # raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def noise_generator(n, mean, std, fractindex):\n if fractindex not in VALID_FRACT:\n raise ValueError(\"results: status must be one of %r.\" % VALID_FRACT)\n \n stdev = std\n \n b = 2*fractindex-1\n print('beta: ', b)\n \n bdis = np.zeros(n)\n\n bdis[0] = 1\n for i in range(1,n):\n bdis[i] = bdis[i-1] * (0.5 * b + (i-1))/i # note that b is the shape parementer (b)\n\n plt.plot(bdis)\n plt.show\n\n wnt = np.random.normal(mean, stdev, size = n)\n print('WhiteNoise Stdev: ', np.std(wnt))\n plt.plot(wnt)\n plt.show()\n\n bdis_freq = np.fft.fft(bdis)\n wnt_freq = np.fft.fft(wnt)\n\n bdis_freq = bdis_freq[1:n+1]\n wnt_freq = wnt_freq[1:n+1]\n\n freq_total = bdis_freq * wnt_freq\n \n NumUniquePts = n/2 + 1\n NumUniquePts = int(NumUniquePts)\n j = np.arange(1, NumUniquePts)\n \n if fractindex > 1.0:\n j = j\n elif fractindex <= 1.0:\n j = j**0.5\n \n ft_half1 = freq_total[1:NumUniquePts]/j\n\n real = np.real(freq_total[1:NumUniquePts+1])\n real = np.flip(real, axis=0)\n\n imaginary = np.imag(freq_total[1:NumUniquePts+1])\n imaginary = np.flip(imaginary, axis=0)\n imaginary = 1j * imaginary\n\n ft_half2 = real - imaginary\n\n ft = np.hstack((ft_half1, ft_half2))\n \n x = np.fft.ifft(ft)\n x = np.real(x[:n])\n\n mean_diff = mean - np.mean(x)\n x = mean_diff + x\n print(np.mean(x))\n print(np.std(x))\n plt.plot(x)\n plt.show()\n \n return x","def noisy_seismogram(t, seismogram, noise_amp=5):\n\n # Noise\n signoise = 2 * np.sqrt(3)\n\n # Create filter to take out high frequency noise\n filtgauss = gaussian(t, 75, signoise, 1.)\n filtgauss = filtgauss / sum(filtgauss)\n\n # Amplitude for the noise\n amp = noise_amp\n noise = 2 * (np.random.uniform(size=t.shape) - 0.5) * amp\n\n # Compute filtered noise\n filtnoise = np.real(ifft(fft(noise) * fft(filtgauss)))\n\n # Add noise to original seismogram\n noisemogram = seismogram + filtnoise\n\n return noisemogram","def noise(self):\n # Extract parameters\n pzs = self.params[0]\n # retrieve number of galaxies in each bins\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\n if isinstance(self.config[\"sigma_e\"], list):\n sigma_e = np.array([s for s in self.config[\"sigma_e\"]])\n else:\n sigma_e = self.config[\"sigma_e\"]\n return sigma_e ** 2 / ngals","def _add_noise(X, n_noise, random_state=None):\n np.random.seed(random_state)\n noise = np.random.randn(X.shape[0], n_noise)\n return np.hstack((X, noise))","def make_noise(self, num):\n return np.random.randn(num, self.seq_length + 2 * self.seq_pad,\n self.noise_dim)","def noise(self):\n # Extract parameters\n pzs = self.params[0]\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\n return 1.0 / ngals","def noise(self):\r\n if self.buffer_offset + self.frames_per_buffer - 1 > self.x_max:\r\n #relleno con ceros al final si es necesario\r\n xs = np.arange(self.buffer_offset, self.x_max)\r\n tmp = np.random.random_sample(len(xs)) #ruido\r\n out = np.append(tmp, np.zeros(self.frames_per_buffer-len(tmp)))\r\n else:\r\n xs = np.arange(self.buffer_offset,\r\n self.buffer_offset + self.frames_per_buffer)\r\n out = np.random.random_sample(len(xs))\r\n self.buffer_offset += self.frames_per_buffer\r\n return out","def noise_generator(self, power=None, SNR=None, size=None):\r\n alpha = self.db2power(SNR)\r\n sigma = np.sqrt(power / alpha) # 计算噪声标准差\r\n # 产生噪声\r\n noise_data = np.sqrt(0.5) * (np.random.normal(0, sigma, size=size) + np.random.normal(0, sigma, size=size) * 1j)\r\n noise_data = noise_data.astype(np.complex64)\r\n return noise_data","def add_noise_batch(self,fingerprints):\r\n\t\tif self.trparas.complex:\r\n\t\t\tn,l,r = fingerprints.shape\r\n\t\t\tnp.random.seed()\r\n\r\n\t\t\t# noise_level = 0.002\r\n\t\t\tnoise_level = self.noise_level\r\n\t\t\t# add noise to real and imag part seperately with different noise level\r\n\t\t\tnoise_real = np.random.normal(0, noise_level, (n, l))\r\n\t\t\tnoise_imag = np.random.normal(0, noise_level, (n, l))\r\n\t\t\tnoise = np.stack([noise_real,noise_imag],axis=2) # n,l,r 4000,666,2\r\n\t\t\tfingerprints += noise\r\n\t\t\treturn fingerprints\r\n\r\n\t\telse:\t\r\n\t\t\tn,l = fingerprints.shape\r\n\t\t\tnp.random.seed()\r\n\t\t\tif self.noise_type == 'SNR':\r\n\t\t\t\tnoise = np.random.normal(0, 1, (n,l))\r\n\t\t\t\tsignal_Power = np.linalg.norm(fingerprints, axis=1)\r\n\t\t\t\tnoise_Power = np.linalg.norm(noise,axis=1)\r\n\t\t\t\tcst = signal_Power / (noise_Power * self.noise_level)\r\n\t\t\t\tnoise = noise * np.tile(cst.reshape(-1,1),(1,l))\r\n\t\t\telif self.noise_type == 'Standard':\r\n\t\t\t\tnoise = np.random.normal(0, self.noise_level, (n,l))\r\n\t\t\tfingerprints += noise\r\n\t\t\tif self.trparas.normalization == 'Noisy_input':\r\n\t\t\t\treturn fingerprints / np.tile(np.linalg.norm(fingerprints,axis=1).reshape(-1,1), (1,l))\r\n\t\t\telse:\r\n\t\t\t\treturn fingerprints","def noisysphere(self, x, noise=4.0, cond=1.0):\r\n return self.elli(x, cond=cond) * (1 + noise * np.random.randn() / len(x))","def generate_noise_vector(self, ):\n self.noise.resize_(\n self.batch_size, int(self.opt.nz), 1, 1).normal_(0, 1)\n self.noisev = Variable(self.noise) # TODO: Add volatile=True???","def noise_data(self, x):\n return x + np.random.normal(size=x.shape)","def rfd_poisson(ps,n):\n lam = sum(ps)\n G = len(ps)\n sample_q = lambda:nprandom.poisson(lam) # chromosomal occupancy approximately poisson.\n sampler = make_sampler(ps)\n return [direct_sampling_ps(ps,sample_q(),sampler) for i in xrange(n)]","def __init__(self, *args, **kwargs):\n\n # ...\n\n poisson.__init__(self, *args, **kwargs)\n\n # ...","def applyChannelNoise(self, signal):\n \n # If noise not applieable\n if self.rx_SNR == None:\n return signal\n \n # Average power for the convolved signal\n signal_power = np.mean(abs(signal**2))\n \n # Calculate the std for given signal power, based on rx_SNR\n sigma2 = signal_power * 10**( -self.rx_SNR/10)\n \n # Generate noise given std\n noise = np.sqrt(sigma2/2) * (np.random.randn(*signal.shape)+1j*np.random.randn(*signal.shape))\n \n # TODO -- IS THAT CORRECT? APPLY CIR AND THEN ABS\n if Global.IM_DD:\n noise = np.abs(noise)\n \n return noise + signal","def add_readout_noise(self, PSF_images, RMS_READ, sigma_offset=5.0):\n\n N_samples, pix, N_chan = PSF_images.shape[0], PSF_images.shape[1], PSF_images.shape[-1]\n PSF_images_noisy = np.zeros_like(PSF_images)\n print(\"Adding Readout Noise with RMS: %.4f | SNR: %.1f\" % (RMS_READ, 1./RMS_READ))\n for k in range(N_samples):\n for j in range(N_chan):\n read_out = np.random.normal(loc=0, scale=RMS_READ, size=(pix, pix))\n PSF_images_noisy[k, :, :, j] = PSF_images[k, :, :, j] + read_out\n\n # Add a X Sigma offset to avoid having negative values\n PSF_images_noisy += sigma_offset * RMS_READ\n\n return PSF_images_noisy","def addNoise(img, sigma=2.0, mean=0):\n img2 = np.random.normal(mean, sigma, size=img.shape)\n\n img2 += img\n img2 = np.uint8(img2.clip(0, 255))\n return img2","def _make_noisy(x, the_noise):\n noise_sample = the_noise[np.random.choice(the_noise.shape[0],\n x.shape[0],\n replace=False)]\n return x + noise_sample","def noise(self):\n return self._noise","def sample(self,noise,s):\n rhs=self.prior.sqrtM*noise\n self.prior.Msolver.solve(s,rhs)","def add_noise(emg):\n MAX_AMPLITUDE = 32767\n\n # Sampling\n # 1 second of data requires 600 frames. And 600 fps is 600 Hz, sampling rate of EMG.\n Ts = 1/EMG_F_SAMPLE\n\n # Time vector\n t = np.arange(0, len(emg)/EMG_F_SAMPLE, Ts) # each unit of t is a second\n\n # Noise\n randAmplitudeScale = np.random.random()*0.1\n randOffset = np.random.random() * 2*np.pi\n \n fNoise = 50; # Frequency [Hz]\n aNoise = randAmplitudeScale*MAX_AMPLITUDE # Amplitude\n noise = aNoise * np.sin(2 * np.pi * t * fNoise + randOffset)\n\n # Add noise to signal\n for channel in [\"emg1\", \"emg2\", \"emg3\", \"emg4\", \"emg5\", \"emg6\"]:\n emg[channel] += noise\n return emg","def toy_poisson_1d(seed=default_seed):\n\n X = np.arange(0,100,5)[:,None]\n F = np.round(np.sin(X/18.) + .1*X) + np.arange(5,25)[:,None]\n E = np.random.randint(-5,5,20)[:,None]\n Y = F + E\n\n kernel = GPy.kern.rbf(1)\n distribution = GPy.likelihoods.likelihood_functions.Poisson()\n likelihood = GPy.likelihoods.EP(Y,distribution)\n\n m = GPy.models.GP(X,likelihood,kernel)\n m.ensure_default_constraints()\n\n # Approximate likelihood\n m.update_likelihood_approximation()\n\n # Optimize and plot\n m.optimize()\n #m.EPEM FIXME\n print m\n\n # Plot\n pb.subplot(211)\n m.plot_f() #GP plot\n pb.subplot(212)\n m.plot() #Output plot\n\n return m","def add_noise(np_image, amount):\n noise = np.random.randn(np_image.shape[0],np_image.shape[1])\n norm_noise = abs(noise/np.max(noise))\n np_image = np_image + norm_noise*np.max(np_image)*amount\n \n return np_image","def add_noise_m(self, data):\n return self.range_to_m(self.add_noise(self.m_to_range(data)))","def add_noise(pointcloud, stddev=0.01):\n result = pointcloud\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\n return result","def plot5a(nSamples):\n rv = stats.poisson(2.0)\n expectations, variances = simulate(nSamples, rv)\n plot(nSamples, expectations, variances, 2.0, 2.0, \"Poisson distribution\")","def add_weight_noise(self, std):\n with torch.no_grad():\n param_vector = parameters_to_vector(self.parameters())\n normal_dist = torch.distributions.Normal(loc=torch.tensor([0.0]), scale=torch.tensor([std]))\n noise = normal_dist.sample(param_vector.size())\n if self.device_id >= 0:\n noise = noise\n param_vector.add_(noise[0])\n vector_to_parameters(param_vector, self.parameters())","def Poisson(ni, f, x, v, n):\n ne = DECSKS.lib.density.single_integration(f[n,:,:], of = x, wrt = v)\n\n xi = np.zeros(x.N)\n E_hat = np.zeros(x.N, dtype = complex) # container\n\n\n # define wave indices\n for r in range(x.N):\n if r <= x.N/2 :\n xi[r] = 2*np.pi*r / x.L\n else:\n xi[r] = 2*np.pi*(r - x.N) / x.L\n\n # total charge density, n(x), len(n) = Nx\n\n n = ni - ne\n\n N = np.fft.fft(n)\n A = max(N)\n eps = 2.0e-15\n xi_min = A*eps\n for r in range(x.N):\n if np.abs(N[r]) < xi_min:\n N[r] = 0\n\n # E_hat[0] = 0 from periodic BCs, i.e. because N[0] = 0, quasineutrality\n # equivalently, E_hat[0] is the DC field, of which there is none in\n # a quasineutral system of charged particles, only flucutations are present\n # E_hat[0] = 0 already from E_hat vector initialization\n\n for each in range(1,len(xi)):\n\n E_hat[each] = 1 / (1j*xi[each]) * N[each] # Electric field in Fourier space\n\n\n E = np.real(np.fft.ifft(E_hat)) # Electric field in configurational space\n\n\n return E","def add_noise(self, data):\n noise = self._get_noise(data.shape, data.dtype)\n return np.clip(data + noise, self._clipping_lower_bound,\n self._clipping_upper_bound)","def add_noise(self, data):\n noise = self._get_noise(data.shape, data.dtype)\n return np.clip(data + noise, self._clipping_lower_bound,\n self._clipping_upper_bound)","def add_signal_to_noise(self):\n\n # noise\n noise = lal.CreateREAL8TimeSeries('blah', self.epoch, 0,\n self.td_noise.delta_t, lal.StrainUnit, \n int(self.td_noise.duration / self.td_noise.delta_t))\n noise.data.data = self.td_noise.data\n\n # signal\n signal = lal.CreateREAL8TimeSeries('blah',\n self.ext_params.geocent_peak_time, 0, self.td_signal.delta_t,\n lal.StrainUnit, int(self.td_signal.duration /\n self.td_signal.delta_t))\n signal.data.data = self.td_signal.data\n\n win = lal.CreateTukeyREAL8Window(len(signal.data.data),0.1)\n win.data.data[len(signal.data.data):] = 1.0\n #signal.data.data *= win.data.data\n\n # --- Scale to a target snr\n print '---'\n if self.target_snr is not None:\n\n tmp_sig = pycbc.types.TimeSeries(signal.data.data,\n delta_t=self.td_signal.delta_t)\n\n current_snr = pycbc.filter.sigma(tmp_sig, psd=self.psd,\n low_frequency_cutoff=self.f_low,\n high_frequency_cutoff=0.5/self.delta_t)\n\n signal.data.data *= self.target_snr / current_snr\n # ----\n\n # sum\n noise_plus_signal = lal.AddREAL8TimeSeries(noise, signal)\n\n self.td_response = \\\n pycbc.types.timeseries.TimeSeries(\\\n initial_array=np.copy(noise_plus_signal.data.data),\n delta_t=noise_plus_signal.deltaT,\n epoch=noise_plus_signal.epoch)\n\n # Finally, zero-pad the signal vector to have the same length as the actual data\n # vector\n no_noise = lal.CreateREAL8TimeSeries('blah', self.epoch, 0,\n self.td_noise.delta_t, lal.StrainUnit, \n int(self.td_noise.duration / self.td_noise.delta_t))\n\n no_noise.data.data = np.zeros(\\\n int(self.td_noise.duration / self.td_noise.delta_t))\n\n signal = lal.AddREAL8TimeSeries(no_noise, signal)\n\n self.td_signal = \\\n pycbc.types.timeseries.TimeSeries(initial_array=np.copy(signal.data.data),\n delta_t=signal.deltaT, epoch=noise_plus_signal.epoch)\n\n del noise, signal, noise_plus_signal","def copyCounterWithNoise(self, counter, prob):\n \"\"\"\n counter = deepcopy(counter)\n for i in range(self.nObjectTypes):\n noise = np.random.randint(1,5)\n if np.random.random() < prob:\n if np.random.random() > 0.5:\n counter[i] += noise # false detections\n else:\n counter[i] -= noise # missed detections\n if counter[i] < 0:\n counter[i]=0\n return counter\n \"\"\"\n counter = deepcopy(counter)\n for i in range(self.nObjectTypes):\n noise = np.random.randint(1,5)\n if np.random.random() > prob:\n continue\n if counter[i] == 0:\n # Noise could only be +1\n counter[i] = noise\n else:\n # Noise could be either +1 or -1\n if np.random.random() > 0.5:\n counter[i] += noise\n else:\n counter[i] -= noise\n if counter[i] < 0:\n counter[i]=0\n return counter"],"string":"[\n \"def add_poisson_noise(self, sinogram, max_count=1000):\\n\\n temp = np.copy(sinogram)\\n temp = temp * max_count\\n temp = np.random.poisson(temp).astype('float')\\n return temp / max_count\",\n \"def add_poisson_noise(self):\\n\\n # Can be done without loops, but this reduces memory requirements.\\n for i in range(self.nintegs):\\n\\n ramp = deepcopy(self.data[i])\\n\\n # Convert up the ramp samples, to flux between reads.\\n ramp[1:] = np.diff(ramp, axis=0)\\n\\n # Add the poisson noise.\\n ramp = np.where(ramp < 0, 0, ramp) # Sanity check.\\n ramp = rdm.poisson(ramp)\\n\\n # Convert back to up the ramp samples.\\n ramp = np.cumsum(ramp, axis=0)\\n\\n self.data[i] = deepcopy(ramp)\\n\\n self.modif_str = self.modif_str + '_poisson_noise'\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\\n self.im += self.noise\\n return\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\\n self.image += self.noise\\n return\",\n \"def add_noise(self, noise):\\n if noise > 0.0:\\n for key in self.counts:\\n self.counts[key] *= 1.0 + noise * np.random.random_sample()\",\n \"def noise_poisson(img):\\n imgtype = img.dtype\\n img = img.astype(np.float32)/255.0\\n\\n vals = len(np.unique(img))\\n vals = 2 ** np.ceil(np.log2(vals))\\n noisy = 255 * np.clip(np.random.poisson(img.astype(np.float32) * vals) / float(vals), 0, 1)\\n return noisy.astype(imgtype)\",\n \"def apply_poisson_noise(data, seed=None):\\n data = np.asanyarray(data)\\n if np.any(data < 0):\\n raise ValueError('data must not contain any negative values')\\n\\n rng = np.random.default_rng(seed)\\n\\n return rng.poisson(data)\",\n \"def inhomogenous_poisson_gen():\\n pass\",\n \"def add_noise(self, data):\",\n \"def poisson_noise(inputs: torch.Tensor, stddev=None, sigma_max=0.16, channel_wise=1):\\n if stddev is None:\\n stddev = torch.rand(channel_wise) * sigma_max\\n stddev = torch.tensor(stddev, device=inputs.device)\\n if DATA_FORMAT == 'channels_first':\\n stddev = stddev.reshape([1, -1] + [1] * (inputs.ndim - 2))\\n else:\\n stddev = stddev.reshape([1] * (inputs.ndim - 1) + [-1])\\n sigma_map = (1 - inputs) * stddev\\n return torch.randn_like(inputs) * sigma_map\",\n \"def noise(self, freq: int, /) -> None:\",\n \"def homogenous_poisson_gen():\\n pass\",\n \"def poisson_example(en, small2):\\n from scipy.stats import poisson\\n\\n B = 1 << small2\\n z = np.zeros(B); z[1] = 1\\n wrap = irfft(np.exp(en * (rfft(z) - 1)))\\n k = en // B + 1\\n xs = k * B - (B >> 1) + np.arange(B)\\n pmf = roll(wrap, B >> 1)\\n df = pd.DataFrame({'x': xs, 'FFT pmf': pmf})\\n po = poisson(en)\\n df['Exact pmf'] = po.pmf(df.x)\\n df = df.set_index('x', drop=True)\\n fig, [ax0, ax1] = plt.subplots(1, 2, figsize=(FIG_W * 2, FIG_H + 0.3), constrained_layout=True)\\n ax0.plot(wrap);\\n ax0.set(title=f'Raw FFT-based output, wrapped to [0, {B}]',\\n xlabel=f'Wrapped outcome, n mod {B}',\\n ylabel='Probability mass, Pr(N=n)');\\n df[['FFT pmf', 'Exact pmf']].plot(style=['-', ':'], ax=ax1, logy=True,\\n title='Shifted FFT vs exact Poisson probabilities\\\\n(log scale)',\\n xlabel='Outcome, n', ylabel='Probability mass, Pr(N=n)');\\n ax1.set(ylim=[1e-17, 2 * df['FFT pmf'].max()])\\n ax1.yaxis.set_minor_locator(ticker.LogLocator(subs='all'))\",\n \"def addNoise(self, sigma=1.0):\\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\\n self.image += noise\\n return\",\n \"def add_imageNoise(img):\\n if not np.all(img >= 0):\\n print 'make sure the image pixel values are positive definite'\\n sys.exit()\\n noise = st.poisson.rvs(1.,loc = -1.,scale=1.,size=img.shape)*np.sqrt(img)\\n return noise\",\n \"def noise(self, noise):\\n\\n self._noise = noise\",\n \"def noise(self, stddev):\\n #add noise to weights\\n pass\",\n \"def addNoise(x,y,noise):\\n n = len(x)\\n theta = np.random.random(n)*(2*np.pi) # random angle in [0,2*pi[\\n d = np.random.random(n)*noise # random amplitude in [0,noise[\\n x += np.cos(theta)*d\\n y += np.sin(theta)*d\",\n \"def add_noise(arr, sigma):\\n dims = arr.shape\\n arr += sigma * noise(*dims)\",\n \"def add_noise(self,fing):\\r\\n\\t\\tfingerprint = copy.deepcopy(fing)\\r\\n\\t\\tl = len(fingerprint)\\r\\n\\t\\tnp.random.seed()\\t\\r\\n\\t\\tif self.noise_type == 'SNR':\\r\\n\\t\\t\\tnoise = np.random.normal(0, 1, l)\\r\\n\\t\\t\\tsignal_Power = np.linalg.norm(fingerprint)\\r\\n\\t\\t\\tnoise_Power = np.linalg.norm(noise)\\r\\n\\t\\t\\tcst = signal_Power / (noise_Power * self.noise_level)\\r\\n\\t\\t\\tnoise = noise * cst\\r\\n\\t\\telif self.noise_type == 'Standard':\\r\\n\\t\\t\\tnoise = np.random.normal(0, self.noise_level, l)\\r\\n\\t\\tfingerprint += noise\\r\\n\\t\\tif self.trparas.normalization == 'Noisy_input':\\r\\n\\t\\t\\treturn fingerprint / np.linalg.norm(fingerprint)\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn fingerprint\",\n \"def addNoise(pure,snr):\\r\\n watts = pure**2\\r\\n # Calculate signal power and convert to dB \\r\\n sig_avg_watts = np.mean(watts)\\r\\n sig_avg_db = 10 * np.log10(sig_avg_watts)\\r\\n # Calculate noise according to [2] then convert to watts\\r\\n noise_avg_db = sig_avg_db - snr\\r\\n noise_avg_watts = 10 ** (noise_avg_db / 10)\\r\\n # Generate an sample of white noise\\r\\n mean_noise = 0\\r\\n noise = np.random.normal(mean_noise, np.sqrt(noise_avg_watts), len(watts))\\r\\n \\r\\n return pure+noise\",\n \"def poisson(gp_link=None):\\r\\n if gp_link is None:\\r\\n gp_link = noise_models.gp_transformations.Log_ex_1()\\r\\n #else:\\r\\n # assert isinstance(gp_link,noise_models.gp_transformations.GPTransformation), 'gp_link function is not valid.'\\r\\n analytical_mean = False\\r\\n analytical_variance = False\\r\\n return noise_models.poisson_noise.Poisson(gp_link,analytical_mean,analytical_variance)\",\n \"def addNoise_amp(array,counts):\\r\\n if array.dtype == 'complex' :\\r\\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\\r\\n else :\\r\\n if np.float64(counts) == 0.0e0 :\\r\\n arrayout = np.copy(array)\\r\\n elif np.float64(counts) < 0.0e0 :\\r\\n print 'bg.addNoise : warning counts < 0'\\r\\n else :\\r\\n arrayout = np.zeros(array.shape)\\r\\n arrayout = np.square(normalise(array))\\r\\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\\r\\n arrayout = np.sqrt(arrayout)\\r\\n tot = np.sum(np.abs(array)**2)\\r\\n arrayout = normalise(arrayout,tot)\\r\\n return arrayout\",\n \"def addNoise(array,counts):\\r\\n if array.dtype == 'complex' :\\r\\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\\r\\n else :\\r\\n if np.float64(counts) == 0.0e0 :\\r\\n arrayout = np.zeros(array.shape, dtype=arrayout.dtype)\\r\\n elif np.float64(counts) < 0.0e0 :\\r\\n print 'bg.addNoise : warning counts < 0'\\r\\n elif np.float64(counts) > 1.0e9 :\\r\\n arrayout = np.zeros(array.shape)\\r\\n arrayout = normaliseInt(array)\\r\\n arrayout = np.random.normal(arrayout*np.float64(counts),np.sqrt(arrayout*np.float64(counts)))/np.float64(counts)\\r\\n tot = np.sum(array)\\r\\n arrayout = normaliseInt(arrayout,tot)\\r\\n else :\\r\\n arrayout = np.zeros(array.shape)\\r\\n arrayout = normaliseInt(array)\\r\\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\\r\\n tot = np.sum(array)\\r\\n arrayout = normaliseInt(arrayout,tot)\\r\\n return arrayout\",\n \"def poisson_sd(data: DataSeries) -> DataSeries:\\n return data.pow(0.5)\",\n \"def add_noise(self):\\n self.segments = deepcopy(self.segments)\\n # Iterate through each of the first three Segments in the WordForm.\\n for i in range(3):\\n # Add noise to each Segment.\\n self.segments[i].add_noise()\",\n \"def noiseAtten(atten) :\\n s.noiseAtten(atten)\",\n \"def add_noise(spectrum,rms):\\n noise = np.random.randn(spectrum.data.shape[0])*rms\\n noisy_data = spectrum.data + noise\\n noisy_spec = pyspeckit.Spectrum(xarr=spectrum.xarr,data=noisy_data)\\n return noisy_spec\",\n \"def add_noise_at_snr(channel_in, snr):\\n\\n rms_channel = np.sqrt(np.mean(channel_in ** 2.0))\\n noise_std = rms_channel / np.sqrt(10.0 ** (snr/10.0))\\n\\n return channel_in + np.random.normal(size=channel_in.shape, scale=noise_std)\",\n \"def add_noise(self):\\n self.noise = torch.normal(0.5, .2, self.state.shape).double()\\n self.noise *= torch.sqrt(2 *\\n self.vars['T']*torch.tensor(self.vars['dt']))\",\n \"def add_noise(self, snr, unit=None):\\n return self.from_time(self.fs, noisify(self.in_time, snr, unit=unit))\",\n \"def make_noisy_images(image):\\r\\n return apply_poisson_noise(image, random_state=12345)\",\n \"def noise(self, xs, ys):\\n raise NotImplementedError\",\n \"def add_noise(image):\\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\\n \\n return image\",\n \"def convert_to_poisson(dp):\\n return np.random.poisson(dp)\",\n \"def _addNoise(self):\\n self.dispNoise = self.dispRaw.copy()\\n self.dispNoise[:, 0] += self.sigmaEast * numpy.random.randn(self.numStations)\\n self.dispNoise[:, 1] += self.sigmaNorth * numpy.random.randn(self.numStations)\\n self.dispNoise[:, 2] += self.sigmaUp * numpy.random.randn(self.numStations)\\n return\",\n \"def writeNoise(self):\\n\\n if (self.noise_file == None or self.noise_file == \\\"\\\"):\\n return\\n ofname = self.noise_file\\n ofh = open(ofname,'w')\\n\\n # these have to be there as long as we've read the FAST file already\\n ## not true: we don't store these in the dict.\\n have_data = False\\n if (\\\"TipRad\\\" in self.fstDict and 'TowerHt' in self.fstDict and 'Twr2Shft' in self.fstDict):\\n tiprad = self.fstDict['TipRad']\\n towerht = self.fstDict['TowerHt']\\n twr2shft = self.fstDict['Twr2Shft']\\n have_data = True\\n\\n for line in self.lines_noise:\\n if (have_data and line.find('Observer location') >= 0):\\n xdist = -1.0 * (tiprad + (towerht + twr2shft))\\n ofh.write('{:.1f} 0.0 0.0'.format(xdist))\\n ofh.write(' (x,y,z) Observer location in tower-base coordinate system. Use -(RotRad+HubHt)\\\\n')\\n else:\\n ofh.write(line)\\n ofh.close()\",\n \"def noiseReduction(self):\\n pass\",\n \"def add_noise(Y, sigma):\\r\\n return Y + np.random.normal(0, sigma, Y.shape)\",\n \"def poisson_significance(s,b):\\n return np.sqrt(2*((s+b)*np.log(1+s/b)-s))\",\n \"def add_noise(spectra: np.ndarray, maxLevel: float = 0.1, seed: int = 42) -> np.ndarray:\\n np.random.seed(seed)\\n spectra = spectra.copy()\\n spectra[:, 1:] *= (1-maxLevel/2) + np.random.rand(spectra.shape[0], spectra.shape[1]-1) * maxLevel\\n return spectra\",\n \"def plot_noise_distribution(self, ax, mask=None, **kwargs):\\r\\n trs = self.rec_smooth_pos\\r\\n ivalid = np.where(np.isfinite(trs.noise))[0]\\r\\n sigma = np.std(trs.noise[ivalid])\\r\\n mu = np.average(trs.noise[ivalid])\\r\\n\\r\\n kwargs['linestyle']='-'\\r\\n kwargs['linewidth']=1.0\\r\\n # fit lognormal\\r\\n if len(ivalid) > 10:\\r\\n try:\\r\\n x = np.linspace(-4.*sigma+mu, 4*sigma+mu, 200)\\r\\n params = stats.lognorm.fit(trs.noise[ivalid], loc=0.2)\\r\\n pdf_fit = stats.lognorm.pdf(x, params[0], loc=params[1], \\r\\n scale=params[2])\\r\\n ax.plot(x, pdf_fit, color='k', **kwargs)\\r\\n except:\\r\\n print(\\\"lognormal fit failed for \\\",self.ID)\\r\\n # fit normal\\r\\n ax.plot(x, mlab.normpdf(x, mu, sigma), color='b', **kwargs)\\r\\n\\r\\n plt.hist(trs.noise[ivalid], bins=50, normed=True, facecolor='g')\\r\\n ax.set_xlabel('position error (m)')\\r\\n ax.set_xlim([0, 10])\\r\\n ax.set_ylim([0, 1.0])\\r\\n ax.set_ylabel('frequency')\\r\\n\\r\\n return\",\n \"def add_noise(image, noise, rate=0.05):\\n\\n if noise == \\\"gaussian\\\":\\n row, col = image.shape\\n var = ndimage.laplace(image).var()\\n sigma = (var*rate) ** 0.5\\n print(var, sigma)\\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\\n noisy = image + gauss\\n # noisy = image + gauss\\n return noisy\\n\\n elif noise == \\\"salt_pepper\\\":\\n output = image.copy()\\n black = 0\\n white = 255\\n probs = np.random.random(image.shape[:2])\\n output[probs < (rate / 2)] = black\\n output[probs > 1 - (rate / 2)] = white\\n\\n return output\\n\\n else:\\n return image\",\n \"def _apply_observation_noise(self, state: RobotState,\\n config: RobotGroupConfig):\\n if config.sim_observation_noise is None or self.random_state is None:\\n return\\n\\n # Define the noise calculation.\\n def noise(value_range: np.ndarray):\\n amplitude = config.sim_observation_noise * np.ptp(\\n value_range, axis=1)\\n return amplitude * self.random_state.uniform(\\n low=-0.5, high=0.5, size=value_range.shape[0])\\n\\n if config.qpos_range is not None:\\n state.qpos += noise(config.qpos_range)\\n if config.qvel_range is not None:\\n state.qvel += noise(config.qvel_range)\",\n \"def excess_noise_PDF(y,base_noise,Poisson=False):\\n \\n y, base_noise = array(y), array(base_noise)\\n ymn = mean(y)\\n yvar = var(y)\\n base_var = base_noise**2\\n x_guess = sqrt(yvar - mean(base_var)) if yvar > mean(base_var) else 0.0\\n \\n def log_like(mn,x_noise,log_norm_fac):\\n x_var = x_noise**2\\n var = x_var + base_var\\n terms = -log(2*pi*var)/2 - (y - mn)**2/2/var\\n return sum(terms) + log_norm_fac\\n \\n #initial pass at a normalization factor - use peak value\\n def neg_like(x):\\n mn,x_noise= x\\n return -log_like(mn,x_noise,0.0)\\n result = minimize(neg_like, [ymn,x_guess], method='Nelder-Mead')\\n log_norm_fac = result.fun\\n mn_pk, x_noise_pk = result.x\\n \\n def like(mn,x_noise):\\n return exp(log_like(mn, x_noise, log_norm_fac))\\n \\n def xmn_like(xnorm):\\n constrained_like = lambda mn: like(mn, xnorm*mn)\\n result = quad(constrained_like, mn_pk, inf)[0]\\n result += -quad(constrained_like, mn_pk, 0.0)[0]\\n return result\\n \\n xmn_pk = x_noise_pk/mn_pk\\n result = minimize(lambda x: -xmn_like(x), xmn_pk, method='Nelder-Mead')\\n xmn_pk = result.x[0]\\n# f_pk = -result.fun\\n if xmn_pk < 0.0: xmn_pk = 0.0\\n# width = 1.0/f_pk\\n# area = pu.gauss_integrate(xmn_like, xmn_pk, 0.0, inf, sigma_guess=width)\\n area = quad(xmn_like, xmn_pk, inf)[0]\\n area += -quad(xmn_like, xmn_pk, 0.0)[0]\\n pdf = lambda x: xmn_like(x)/area if x >= 0.0 else 0.0\\n# if pdf(xmn_pk) <= 0.0: pdb.set_trace()\\n return pdf, xmn_pk\",\n \"def apply_noise(self, input):\\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \\n noisy_input = mask * input\\n \\n return noisy_input\",\n \"def addNoise (image,noise_type=\\\"gauss\\\",var = .01):\\n row,col,ch= image.shape\\n if noise_type == \\\"gauss\\\": \\n mean = 0.0\\n #var = 0.001\\n sigma = var**0.5\\n gauss = np.array(image.shape)\\n gauss = np.random.normal(mean,sigma,(row,col,ch))\\n gauss = gauss.reshape(row,col,ch)\\n #print(gauss)\\n noisy = image + gauss*255\\n return noisy.astype('uint8')\\n elif noise_type == \\\"s&p\\\":\\n s_vs_p = 0.5\\n amount = 0.09\\n out = image\\n # Generate Salt '1' noise\\n num_salt = np.ceil(amount * image.size * s_vs_p)\\n coords = [np.random.randint(0, i - 1, int(num_salt))\\n for i in image.shape]\\n out[coords] = 255\\n # Generate Pepper '0' noise\\n num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))\\n coords = [np.random.randint(0, i - 1, int(num_pepper))\\n for i in image.shape]\\n out[coords] = 0\\n return out\\n elif noise_type == \\\"poisson\\\":\\n vals = len(np.unique(image))\\n vals = 2 ** np.ceil(np.log2(vals))\\n noisy = np.random.poisson(image * vals) / float(vals)\\n return noisy\\n elif noise_type ==\\\"speckle\\\":\\n gauss = np.random.randn(row,col,ch)\\n gauss = gauss.reshape(row,col,ch) \\n noisy = image + image * gauss\\n return noisy\\n else:\\n return image\",\n \"def make_noise(self, signal_only):\\n\\n #print >> sys.stdout, \\\"generating noise...\\\"\\n\\n if signal_only:\\n\\n # the noise is just a time series of zeros\\n \\n self.td_noise = pycbc.types.timeseries.TimeSeries(\\n initial_array=np.zeros(self.duration/self.delta_t),\\n delta_t=self.delta_t, epoch=self.epoch)\\n\\n else:\\n # Generate noise \\n self.assign_noise_curve()\\n\\n # Generate time-domain noise\\n # XXX: minimum duration seems to be 1 second. I'll hack around this by\\n # reducing the 1 second to the desired duration\\n tmplen=max(self.duration,1.0)/self.delta_t\\n self.td_noise = pycbc.noise.noise_from_psd(int(tmplen), self.delta_t,\\n self.psd, seed=self.seed)\\n\\n self.td_noise = \\\\\\n pycbc.types.TimeSeries(self.td_noise.data[:self.duration/self.delta_t],\\n delta_t=self.delta_t)\\n\\n # XXX not sure if this is a good idea...\\n self.td_noise.start_time = float(self.epoch)\\n\\n self.fd_noise = self.td_noise.to_frequencyseries()\",\n \"def std_poisson(world_seed, world_rate):\\n return SimOpts(src_id=1,\\n other_sources=[('Poisson2',\\n {'src_id': 2,\\n 'seed': world_seed,\\n 'rate': world_rate})],\\n end_time=1.0,\\n sink_ids=[1001],\\n s=np.asarray([1.0]),\\n q=1.0,\\n edge_list=[(1, 1001), (2, 1001)])\",\n \"def addWhiteNoise(map,rmsArcmin):\\n noisyMap = map.copy()\\n if rmsArcmin == 0.0:\\n pass\\n else:\\n radToMin = 180/numpy.pi*60\\n pixArea = radToMin**2 * map.pixScaleX*map.pixScaleY\\n rms = rmsArcmin/numpy.sqrt(pixArea)\\n \\n noise = numpy.random.normal( scale = rms, size = map.data.shape )\\n \\n noisyMap.data[:] += noise[:]\\n\\n \\n return noisyMap\",\n \"def pink_noise():\\n global curr_tick\\n octave = octave_lookup[curr_tick]\\n curr_noise[octave] = int(white_noise() / (5-octave))\\n curr_tick += 1\\n if curr_tick >= len(octave_lookup):\\n curr_tick = 0\\n return sum(curr_noise)\",\n \"def add_noise(self, u):\\n noise = torch.randn_like(u)\\n noise[:, :, :3] = noise[:, :, :3] * self.imu_std[0]\\n noise[:, :, 3:6] = noise[:, :, 3:6] * self.imu_std[1]\\n\\n # bias repeatability (without in run bias stability)\\n b0 = self.uni.sample(u[:, 0].shape).cuda()\\n b0[:, :, :3] = b0[:, :, :3] * self.imu_b0[0]\\n b0[:, :, 3:6] = b0[:, :, 3:6] * self.imu_b0[1]\\n u = u + noise + b0.transpose(1, 2)\\n return u\",\n \"def _add_noise(signal: np.array, noise_power: float) -> np.array:\\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\\n return signal + noise\",\n \"def _add_noise(signal: np.array, noise_power: float) -> np.array:\\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\\n return signal + noise\",\n \"def add_noise(a: np.ndarray, noise: float) -> np.ndarray:\\n return np.clip(a + np.random.normal(0, noise, len(a)), -1, 1)\",\n \"def noise(self) -> Sequence:\\n\\n return self._noise\",\n \"def addNoise( bmp, noise, savefile = '' ):\\n w_count = 0 # count number of non-black pixels\\n non_signal = [] # holds coordinates of w_counts\\n for h in range(bmp.height):\\n for w in range(bmp.width):\\n # Add coordinates to non_signal\\n if( intensity(bmp.pixels[h][w]) != 0 ):\\n w_count += 1\\n non_signal.append((h,w))\\n\\n #print(\\\"> Counted\\\", w_count, \\\"non-signal pixels; length signal\\\",len(non_signal))\\n\\n # If noise is greater than number of white pixels, then set noise ceiling\\n if( noise > w_count ):\\n noise = w_count\\n\\n # Now add noise\\n noise_index = [] # holds random indicies for non_signal manipulation\\n \\n # we will fill up noise_index with random indicies\\n while( len(noise_index) < noise ):\\n # randomize based on size of non-black pixels\\n add = int(random()*w_count)\\n if( add not in noise_index ):\\n noise_index.append(add)\\n\\n for n in noise_index:\\n # --------- pixel height ---- pixel width ------------\\n bmp.pixels[non_signal[n][0]][non_signal[n][1]] = (0,0,0)\\n\\n # Save image to a new file if prompted\\n if( savefile != '' ):\\n bmp.save(savefile)\\n \\n return bmp\",\n \"def add_gaussian_noise(x, std):\\n noise = x.new_zeros(x.size()).normal_(std=std)\\n return x + noise\",\n \"def get_image_with_poisson_noise(image):\\r\\n img = tf_norm_crop_resize_image(image, resize_dim=(64,64))\\r\\n noisy_img = np.clip(make_noisy_images(img*255.)/255., 0., 1.)\\r\\n return noisy_img\",\n \"def add_image_noise(\\n self, mu=0, sigma=0.005, only_positive=False, random_seed=None):\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n shape = self.signal.axes_manager.shape\\n noise = normal(mu, sigma, shape)\\n if only_positive:\\n self._image_noise = np.absolute(noise)\\n else:\\n self._image_noise = noise\",\n \"def nu_poisson(self) -> float:\\n return self._nu_poisson\",\n \"def _filter_sinogram(self, sino):\\n # pad sinogram to reduce periodicity artefacts\\n target_size = max(\\n 64, int(2 ** np.ceil(np.log2(2 * self.m[-1].item())))\\n )\\n pad = target_size - self.m[-1]\\n sino_pad = torch.nn.functional.pad(sino, (pad // 2, pad - pad // 2))\\n\\n # fft along detector direction\\n sino_complex = torch.stack(\\n [sino_pad, torch.zeros_like(sino_pad)], dim=-1\\n )\\n sino_fft = fft1(sino_complex)\\n\\n # apply frequency filter\\n f = self._get_fourier_filter().unsqueeze(-1).to(sino.device)\\n filtered_sino_fft = sino_fft * f\\n\\n # ifft along detector direction\\n filtered_sino_pad = ifft1(filtered_sino_fft)[..., 0]\\n\\n # remove padding and rescale\\n filtered_sino = filtered_sino_pad[..., pad // 2 : -(pad - pad // 2)]\\n\\n return filtered_sino\",\n \"def test_self_consistency_noise(self):\\n # test with SNR = 100\\n SNR = self.p_gt[0] / 9\\n noisy_data = self.data + SNR * RNG.normal(size=self.data.shape)\\n popt, pcov = sine_fit(noisy_data, self.periods)\\n assert_allclose(*fixed_signs(self.p_gt, popt), 5e-1)\",\n \"def prob_3_6(self):\\n \\n ###### START CODE HERE ######\\n\\n\\n ###### END CODE HERE ######\\n pass\\n \\n ###### return addNoiseImg ######\",\n \"def noisePreset() :\\n s.noisePreset()\",\n \"def make_noise(self, num):\\n return np.random.randn(num, self.seq_length, self.noise_dim)\",\n \"def poisson(self, size=None, lam=None, ndim=None, dtype='int64'):\\r\\n return self.gen(poisson, size, lam, ndim=ndim, dtype=dtype)\",\n \"def add_noise(self, portion, amplitude):\\n # TODO: Implement the add_noise function. Remember to record the\\n # boolean value is_add_noise. You can try uniform noise or Gaussian\\n # noise or others ones that you think appropriate.\\n self.is_add_noise = True\\n noise = np.random.normal(0, 1, size = self.x.shape)\\n noNoiseIndices = np.random.choice(self.x.shape[0], size = int(np.round(self.x.shape[0]*(1 - portion))), replace = False)\\n noise = (noise*amplitude).astype(np.uint8)\\n noise[noNoiseIndices,:] = 0\\n self.x += noise\\n self.x = np.clip(self.x, 0, 255, out=self.x)\\n \\n \\n \\n \\n # raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def noise_generator(n, mean, std, fractindex):\\n if fractindex not in VALID_FRACT:\\n raise ValueError(\\\"results: status must be one of %r.\\\" % VALID_FRACT)\\n \\n stdev = std\\n \\n b = 2*fractindex-1\\n print('beta: ', b)\\n \\n bdis = np.zeros(n)\\n\\n bdis[0] = 1\\n for i in range(1,n):\\n bdis[i] = bdis[i-1] * (0.5 * b + (i-1))/i # note that b is the shape parementer (b)\\n\\n plt.plot(bdis)\\n plt.show\\n\\n wnt = np.random.normal(mean, stdev, size = n)\\n print('WhiteNoise Stdev: ', np.std(wnt))\\n plt.plot(wnt)\\n plt.show()\\n\\n bdis_freq = np.fft.fft(bdis)\\n wnt_freq = np.fft.fft(wnt)\\n\\n bdis_freq = bdis_freq[1:n+1]\\n wnt_freq = wnt_freq[1:n+1]\\n\\n freq_total = bdis_freq * wnt_freq\\n \\n NumUniquePts = n/2 + 1\\n NumUniquePts = int(NumUniquePts)\\n j = np.arange(1, NumUniquePts)\\n \\n if fractindex > 1.0:\\n j = j\\n elif fractindex <= 1.0:\\n j = j**0.5\\n \\n ft_half1 = freq_total[1:NumUniquePts]/j\\n\\n real = np.real(freq_total[1:NumUniquePts+1])\\n real = np.flip(real, axis=0)\\n\\n imaginary = np.imag(freq_total[1:NumUniquePts+1])\\n imaginary = np.flip(imaginary, axis=0)\\n imaginary = 1j * imaginary\\n\\n ft_half2 = real - imaginary\\n\\n ft = np.hstack((ft_half1, ft_half2))\\n \\n x = np.fft.ifft(ft)\\n x = np.real(x[:n])\\n\\n mean_diff = mean - np.mean(x)\\n x = mean_diff + x\\n print(np.mean(x))\\n print(np.std(x))\\n plt.plot(x)\\n plt.show()\\n \\n return x\",\n \"def noisy_seismogram(t, seismogram, noise_amp=5):\\n\\n # Noise\\n signoise = 2 * np.sqrt(3)\\n\\n # Create filter to take out high frequency noise\\n filtgauss = gaussian(t, 75, signoise, 1.)\\n filtgauss = filtgauss / sum(filtgauss)\\n\\n # Amplitude for the noise\\n amp = noise_amp\\n noise = 2 * (np.random.uniform(size=t.shape) - 0.5) * amp\\n\\n # Compute filtered noise\\n filtnoise = np.real(ifft(fft(noise) * fft(filtgauss)))\\n\\n # Add noise to original seismogram\\n noisemogram = seismogram + filtnoise\\n\\n return noisemogram\",\n \"def noise(self):\\n # Extract parameters\\n pzs = self.params[0]\\n # retrieve number of galaxies in each bins\\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\\n if isinstance(self.config[\\\"sigma_e\\\"], list):\\n sigma_e = np.array([s for s in self.config[\\\"sigma_e\\\"]])\\n else:\\n sigma_e = self.config[\\\"sigma_e\\\"]\\n return sigma_e ** 2 / ngals\",\n \"def _add_noise(X, n_noise, random_state=None):\\n np.random.seed(random_state)\\n noise = np.random.randn(X.shape[0], n_noise)\\n return np.hstack((X, noise))\",\n \"def make_noise(self, num):\\n return np.random.randn(num, self.seq_length + 2 * self.seq_pad,\\n self.noise_dim)\",\n \"def noise(self):\\n # Extract parameters\\n pzs = self.params[0]\\n ngals = np.array([pz.gals_per_steradian for pz in pzs])\\n return 1.0 / ngals\",\n \"def noise(self):\\r\\n if self.buffer_offset + self.frames_per_buffer - 1 > self.x_max:\\r\\n #relleno con ceros al final si es necesario\\r\\n xs = np.arange(self.buffer_offset, self.x_max)\\r\\n tmp = np.random.random_sample(len(xs)) #ruido\\r\\n out = np.append(tmp, np.zeros(self.frames_per_buffer-len(tmp)))\\r\\n else:\\r\\n xs = np.arange(self.buffer_offset,\\r\\n self.buffer_offset + self.frames_per_buffer)\\r\\n out = np.random.random_sample(len(xs))\\r\\n self.buffer_offset += self.frames_per_buffer\\r\\n return out\",\n \"def noise_generator(self, power=None, SNR=None, size=None):\\r\\n alpha = self.db2power(SNR)\\r\\n sigma = np.sqrt(power / alpha) # 计算噪声标准差\\r\\n # 产生噪声\\r\\n noise_data = np.sqrt(0.5) * (np.random.normal(0, sigma, size=size) + np.random.normal(0, sigma, size=size) * 1j)\\r\\n noise_data = noise_data.astype(np.complex64)\\r\\n return noise_data\",\n \"def add_noise_batch(self,fingerprints):\\r\\n\\t\\tif self.trparas.complex:\\r\\n\\t\\t\\tn,l,r = fingerprints.shape\\r\\n\\t\\t\\tnp.random.seed()\\r\\n\\r\\n\\t\\t\\t# noise_level = 0.002\\r\\n\\t\\t\\tnoise_level = self.noise_level\\r\\n\\t\\t\\t# add noise to real and imag part seperately with different noise level\\r\\n\\t\\t\\tnoise_real = np.random.normal(0, noise_level, (n, l))\\r\\n\\t\\t\\tnoise_imag = np.random.normal(0, noise_level, (n, l))\\r\\n\\t\\t\\tnoise = np.stack([noise_real,noise_imag],axis=2) # n,l,r 4000,666,2\\r\\n\\t\\t\\tfingerprints += noise\\r\\n\\t\\t\\treturn fingerprints\\r\\n\\r\\n\\t\\telse:\\t\\r\\n\\t\\t\\tn,l = fingerprints.shape\\r\\n\\t\\t\\tnp.random.seed()\\r\\n\\t\\t\\tif self.noise_type == 'SNR':\\r\\n\\t\\t\\t\\tnoise = np.random.normal(0, 1, (n,l))\\r\\n\\t\\t\\t\\tsignal_Power = np.linalg.norm(fingerprints, axis=1)\\r\\n\\t\\t\\t\\tnoise_Power = np.linalg.norm(noise,axis=1)\\r\\n\\t\\t\\t\\tcst = signal_Power / (noise_Power * self.noise_level)\\r\\n\\t\\t\\t\\tnoise = noise * np.tile(cst.reshape(-1,1),(1,l))\\r\\n\\t\\t\\telif self.noise_type == 'Standard':\\r\\n\\t\\t\\t\\tnoise = np.random.normal(0, self.noise_level, (n,l))\\r\\n\\t\\t\\tfingerprints += noise\\r\\n\\t\\t\\tif self.trparas.normalization == 'Noisy_input':\\r\\n\\t\\t\\t\\treturn fingerprints / np.tile(np.linalg.norm(fingerprints,axis=1).reshape(-1,1), (1,l))\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\treturn fingerprints\",\n \"def noisysphere(self, x, noise=4.0, cond=1.0):\\r\\n return self.elli(x, cond=cond) * (1 + noise * np.random.randn() / len(x))\",\n \"def generate_noise_vector(self, ):\\n self.noise.resize_(\\n self.batch_size, int(self.opt.nz), 1, 1).normal_(0, 1)\\n self.noisev = Variable(self.noise) # TODO: Add volatile=True???\",\n \"def noise_data(self, x):\\n return x + np.random.normal(size=x.shape)\",\n \"def rfd_poisson(ps,n):\\n lam = sum(ps)\\n G = len(ps)\\n sample_q = lambda:nprandom.poisson(lam) # chromosomal occupancy approximately poisson.\\n sampler = make_sampler(ps)\\n return [direct_sampling_ps(ps,sample_q(),sampler) for i in xrange(n)]\",\n \"def __init__(self, *args, **kwargs):\\n\\n # ...\\n\\n poisson.__init__(self, *args, **kwargs)\\n\\n # ...\",\n \"def applyChannelNoise(self, signal):\\n \\n # If noise not applieable\\n if self.rx_SNR == None:\\n return signal\\n \\n # Average power for the convolved signal\\n signal_power = np.mean(abs(signal**2))\\n \\n # Calculate the std for given signal power, based on rx_SNR\\n sigma2 = signal_power * 10**( -self.rx_SNR/10)\\n \\n # Generate noise given std\\n noise = np.sqrt(sigma2/2) * (np.random.randn(*signal.shape)+1j*np.random.randn(*signal.shape))\\n \\n # TODO -- IS THAT CORRECT? APPLY CIR AND THEN ABS\\n if Global.IM_DD:\\n noise = np.abs(noise)\\n \\n return noise + signal\",\n \"def add_readout_noise(self, PSF_images, RMS_READ, sigma_offset=5.0):\\n\\n N_samples, pix, N_chan = PSF_images.shape[0], PSF_images.shape[1], PSF_images.shape[-1]\\n PSF_images_noisy = np.zeros_like(PSF_images)\\n print(\\\"Adding Readout Noise with RMS: %.4f | SNR: %.1f\\\" % (RMS_READ, 1./RMS_READ))\\n for k in range(N_samples):\\n for j in range(N_chan):\\n read_out = np.random.normal(loc=0, scale=RMS_READ, size=(pix, pix))\\n PSF_images_noisy[k, :, :, j] = PSF_images[k, :, :, j] + read_out\\n\\n # Add a X Sigma offset to avoid having negative values\\n PSF_images_noisy += sigma_offset * RMS_READ\\n\\n return PSF_images_noisy\",\n \"def addNoise(img, sigma=2.0, mean=0):\\n img2 = np.random.normal(mean, sigma, size=img.shape)\\n\\n img2 += img\\n img2 = np.uint8(img2.clip(0, 255))\\n return img2\",\n \"def _make_noisy(x, the_noise):\\n noise_sample = the_noise[np.random.choice(the_noise.shape[0],\\n x.shape[0],\\n replace=False)]\\n return x + noise_sample\",\n \"def noise(self):\\n return self._noise\",\n \"def sample(self,noise,s):\\n rhs=self.prior.sqrtM*noise\\n self.prior.Msolver.solve(s,rhs)\",\n \"def add_noise(emg):\\n MAX_AMPLITUDE = 32767\\n\\n # Sampling\\n # 1 second of data requires 600 frames. And 600 fps is 600 Hz, sampling rate of EMG.\\n Ts = 1/EMG_F_SAMPLE\\n\\n # Time vector\\n t = np.arange(0, len(emg)/EMG_F_SAMPLE, Ts) # each unit of t is a second\\n\\n # Noise\\n randAmplitudeScale = np.random.random()*0.1\\n randOffset = np.random.random() * 2*np.pi\\n \\n fNoise = 50; # Frequency [Hz]\\n aNoise = randAmplitudeScale*MAX_AMPLITUDE # Amplitude\\n noise = aNoise * np.sin(2 * np.pi * t * fNoise + randOffset)\\n\\n # Add noise to signal\\n for channel in [\\\"emg1\\\", \\\"emg2\\\", \\\"emg3\\\", \\\"emg4\\\", \\\"emg5\\\", \\\"emg6\\\"]:\\n emg[channel] += noise\\n return emg\",\n \"def toy_poisson_1d(seed=default_seed):\\n\\n X = np.arange(0,100,5)[:,None]\\n F = np.round(np.sin(X/18.) + .1*X) + np.arange(5,25)[:,None]\\n E = np.random.randint(-5,5,20)[:,None]\\n Y = F + E\\n\\n kernel = GPy.kern.rbf(1)\\n distribution = GPy.likelihoods.likelihood_functions.Poisson()\\n likelihood = GPy.likelihoods.EP(Y,distribution)\\n\\n m = GPy.models.GP(X,likelihood,kernel)\\n m.ensure_default_constraints()\\n\\n # Approximate likelihood\\n m.update_likelihood_approximation()\\n\\n # Optimize and plot\\n m.optimize()\\n #m.EPEM FIXME\\n print m\\n\\n # Plot\\n pb.subplot(211)\\n m.plot_f() #GP plot\\n pb.subplot(212)\\n m.plot() #Output plot\\n\\n return m\",\n \"def add_noise(np_image, amount):\\n noise = np.random.randn(np_image.shape[0],np_image.shape[1])\\n norm_noise = abs(noise/np.max(noise))\\n np_image = np_image + norm_noise*np.max(np_image)*amount\\n \\n return np_image\",\n \"def add_noise_m(self, data):\\n return self.range_to_m(self.add_noise(self.m_to_range(data)))\",\n \"def add_noise(pointcloud, stddev=0.01):\\n result = pointcloud\\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\\n return result\",\n \"def plot5a(nSamples):\\n rv = stats.poisson(2.0)\\n expectations, variances = simulate(nSamples, rv)\\n plot(nSamples, expectations, variances, 2.0, 2.0, \\\"Poisson distribution\\\")\",\n \"def add_weight_noise(self, std):\\n with torch.no_grad():\\n param_vector = parameters_to_vector(self.parameters())\\n normal_dist = torch.distributions.Normal(loc=torch.tensor([0.0]), scale=torch.tensor([std]))\\n noise = normal_dist.sample(param_vector.size())\\n if self.device_id >= 0:\\n noise = noise\\n param_vector.add_(noise[0])\\n vector_to_parameters(param_vector, self.parameters())\",\n \"def Poisson(ni, f, x, v, n):\\n ne = DECSKS.lib.density.single_integration(f[n,:,:], of = x, wrt = v)\\n\\n xi = np.zeros(x.N)\\n E_hat = np.zeros(x.N, dtype = complex) # container\\n\\n\\n # define wave indices\\n for r in range(x.N):\\n if r <= x.N/2 :\\n xi[r] = 2*np.pi*r / x.L\\n else:\\n xi[r] = 2*np.pi*(r - x.N) / x.L\\n\\n # total charge density, n(x), len(n) = Nx\\n\\n n = ni - ne\\n\\n N = np.fft.fft(n)\\n A = max(N)\\n eps = 2.0e-15\\n xi_min = A*eps\\n for r in range(x.N):\\n if np.abs(N[r]) < xi_min:\\n N[r] = 0\\n\\n # E_hat[0] = 0 from periodic BCs, i.e. because N[0] = 0, quasineutrality\\n # equivalently, E_hat[0] is the DC field, of which there is none in\\n # a quasineutral system of charged particles, only flucutations are present\\n # E_hat[0] = 0 already from E_hat vector initialization\\n\\n for each in range(1,len(xi)):\\n\\n E_hat[each] = 1 / (1j*xi[each]) * N[each] # Electric field in Fourier space\\n\\n\\n E = np.real(np.fft.ifft(E_hat)) # Electric field in configurational space\\n\\n\\n return E\",\n \"def add_noise(self, data):\\n noise = self._get_noise(data.shape, data.dtype)\\n return np.clip(data + noise, self._clipping_lower_bound,\\n self._clipping_upper_bound)\",\n \"def add_noise(self, data):\\n noise = self._get_noise(data.shape, data.dtype)\\n return np.clip(data + noise, self._clipping_lower_bound,\\n self._clipping_upper_bound)\",\n \"def add_signal_to_noise(self):\\n\\n # noise\\n noise = lal.CreateREAL8TimeSeries('blah', self.epoch, 0,\\n self.td_noise.delta_t, lal.StrainUnit, \\n int(self.td_noise.duration / self.td_noise.delta_t))\\n noise.data.data = self.td_noise.data\\n\\n # signal\\n signal = lal.CreateREAL8TimeSeries('blah',\\n self.ext_params.geocent_peak_time, 0, self.td_signal.delta_t,\\n lal.StrainUnit, int(self.td_signal.duration /\\n self.td_signal.delta_t))\\n signal.data.data = self.td_signal.data\\n\\n win = lal.CreateTukeyREAL8Window(len(signal.data.data),0.1)\\n win.data.data[len(signal.data.data):] = 1.0\\n #signal.data.data *= win.data.data\\n\\n # --- Scale to a target snr\\n print '---'\\n if self.target_snr is not None:\\n\\n tmp_sig = pycbc.types.TimeSeries(signal.data.data,\\n delta_t=self.td_signal.delta_t)\\n\\n current_snr = pycbc.filter.sigma(tmp_sig, psd=self.psd,\\n low_frequency_cutoff=self.f_low,\\n high_frequency_cutoff=0.5/self.delta_t)\\n\\n signal.data.data *= self.target_snr / current_snr\\n # ----\\n\\n # sum\\n noise_plus_signal = lal.AddREAL8TimeSeries(noise, signal)\\n\\n self.td_response = \\\\\\n pycbc.types.timeseries.TimeSeries(\\\\\\n initial_array=np.copy(noise_plus_signal.data.data),\\n delta_t=noise_plus_signal.deltaT,\\n epoch=noise_plus_signal.epoch)\\n\\n # Finally, zero-pad the signal vector to have the same length as the actual data\\n # vector\\n no_noise = lal.CreateREAL8TimeSeries('blah', self.epoch, 0,\\n self.td_noise.delta_t, lal.StrainUnit, \\n int(self.td_noise.duration / self.td_noise.delta_t))\\n\\n no_noise.data.data = np.zeros(\\\\\\n int(self.td_noise.duration / self.td_noise.delta_t))\\n\\n signal = lal.AddREAL8TimeSeries(no_noise, signal)\\n\\n self.td_signal = \\\\\\n pycbc.types.timeseries.TimeSeries(initial_array=np.copy(signal.data.data),\\n delta_t=signal.deltaT, epoch=noise_plus_signal.epoch)\\n\\n del noise, signal, noise_plus_signal\",\n \"def copyCounterWithNoise(self, counter, prob):\\n \\\"\\\"\\\"\\n counter = deepcopy(counter)\\n for i in range(self.nObjectTypes):\\n noise = np.random.randint(1,5)\\n if np.random.random() < prob:\\n if np.random.random() > 0.5:\\n counter[i] += noise # false detections\\n else:\\n counter[i] -= noise # missed detections\\n if counter[i] < 0:\\n counter[i]=0\\n return counter\\n \\\"\\\"\\\"\\n counter = deepcopy(counter)\\n for i in range(self.nObjectTypes):\\n noise = np.random.randint(1,5)\\n if np.random.random() > prob:\\n continue\\n if counter[i] == 0:\\n # Noise could only be +1\\n counter[i] = noise\\n else:\\n # Noise could be either +1 or -1\\n if np.random.random() > 0.5:\\n counter[i] += noise\\n else:\\n counter[i] -= noise\\n if counter[i] < 0:\\n counter[i]=0\\n return counter\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8177312","0.79445064","0.76086766","0.74834347","0.670996","0.66914463","0.65419954","0.6426317","0.6410218","0.63080287","0.62796485","0.62407404","0.62318236","0.61993545","0.61238045","0.6062723","0.603536","0.6005666","0.5956273","0.59545517","0.5942513","0.5929696","0.5924307","0.5809637","0.57662445","0.57532156","0.57406986","0.57319736","0.57289696","0.5709521","0.5706742","0.57038057","0.57013935","0.56912744","0.56810397","0.5659182","0.5648597","0.5616444","0.55893284","0.5585681","0.5580336","0.55799586","0.5570834","0.5562775","0.5554049","0.55511916","0.5544756","0.55414635","0.54990613","0.54584396","0.5429325","0.54257226","0.5416981","0.5416981","0.5406612","0.5388797","0.5381735","0.5379847","0.5369442","0.5367309","0.5348285","0.5326642","0.5321074","0.5320748","0.53147817","0.53092563","0.53064203","0.53026044","0.5297706","0.5291785","0.5288644","0.527917","0.5272284","0.52542305","0.5244315","0.52360976","0.52197254","0.5202845","0.520122","0.51980174","0.5156586","0.5155714","0.5154922","0.5154492","0.5150553","0.5147506","0.5141061","0.513951","0.5138698","0.51331383","0.5132796","0.5132218","0.5122095","0.5111935","0.5107903","0.5104923","0.5091111","0.5091111","0.50845796","0.5075081"],"string":"[\n \"0.8177312\",\n \"0.79445064\",\n \"0.76086766\",\n \"0.74834347\",\n \"0.670996\",\n \"0.66914463\",\n \"0.65419954\",\n \"0.6426317\",\n \"0.6410218\",\n \"0.63080287\",\n \"0.62796485\",\n \"0.62407404\",\n \"0.62318236\",\n \"0.61993545\",\n \"0.61238045\",\n \"0.6062723\",\n \"0.603536\",\n \"0.6005666\",\n \"0.5956273\",\n \"0.59545517\",\n \"0.5942513\",\n \"0.5929696\",\n \"0.5924307\",\n \"0.5809637\",\n \"0.57662445\",\n \"0.57532156\",\n \"0.57406986\",\n \"0.57319736\",\n \"0.57289696\",\n \"0.5709521\",\n \"0.5706742\",\n \"0.57038057\",\n \"0.57013935\",\n \"0.56912744\",\n \"0.56810397\",\n \"0.5659182\",\n \"0.5648597\",\n \"0.5616444\",\n \"0.55893284\",\n \"0.5585681\",\n \"0.5580336\",\n \"0.55799586\",\n \"0.5570834\",\n \"0.5562775\",\n \"0.5554049\",\n \"0.55511916\",\n \"0.5544756\",\n \"0.55414635\",\n \"0.54990613\",\n \"0.54584396\",\n \"0.5429325\",\n \"0.54257226\",\n \"0.5416981\",\n \"0.5416981\",\n \"0.5406612\",\n \"0.5388797\",\n \"0.5381735\",\n \"0.5379847\",\n \"0.5369442\",\n \"0.5367309\",\n \"0.5348285\",\n \"0.5326642\",\n \"0.5321074\",\n \"0.5320748\",\n \"0.53147817\",\n \"0.53092563\",\n \"0.53064203\",\n \"0.53026044\",\n \"0.5297706\",\n \"0.5291785\",\n \"0.5288644\",\n \"0.527917\",\n \"0.5272284\",\n \"0.52542305\",\n \"0.5244315\",\n \"0.52360976\",\n \"0.52197254\",\n \"0.5202845\",\n \"0.520122\",\n \"0.51980174\",\n \"0.5156586\",\n \"0.5155714\",\n \"0.5154922\",\n \"0.5154492\",\n \"0.5150553\",\n \"0.5147506\",\n \"0.5141061\",\n \"0.513951\",\n \"0.5138698\",\n \"0.51331383\",\n \"0.5132796\",\n \"0.5132218\",\n \"0.5122095\",\n \"0.5111935\",\n \"0.5107903\",\n \"0.5104923\",\n \"0.5091111\",\n \"0.5091111\",\n \"0.50845796\",\n \"0.5075081\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7924378"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":75094,"cells":{"query":{"kind":"string","value":"Feed raw (not minuslogged) sinogram."},"document":{"kind":"string","value":"def add_poisson_noise(self, sinogram, max_count=1000):\n\n temp = np.copy(sinogram)\n temp = temp * max_count\n temp = np.random.poisson(temp).astype('float')\n return temp / max_count"},"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 spew_fake_data(self, ideal_datapoint=None):\n if not ideal_datapoint:\n ideal_datapoint = 0\n for chan, wsock in self._chan_to_wsocket.items():\n if chan.stream_type == \"Integrated\":\n length = 1\n data = 0.5 + 0.1*(np.random.random(length).astype(chan.dtype) + 1j*np.random.random(length).astype(chan.dtype)) + ideal_datapoint\n elif chan.stream_type == \"Demodulated\":\n length = int(self._lib.record_length/32)\n data = np.zeros(length, dtype=chan.dtype)\n data[int(length/4):int(3*length/4)] = 1.0\n data += 0.1*(np.random.random(length) + 1j*np.random.random(length))\n else: #Raw\n length = int(self._lib.record_length/4)\n signal = np.sin(np.linspace(0,10.0*np.pi,int(length/2)))\n data = np.zeros(length, dtype=chan.dtype)\n data[int(length/4):int(length/4)+len(signal)] = signal\n data += 0.1*np.random.random(length)\n wsock.send(struct.pack('n', length*data.dtype.itemsize) + data.tostring())","def run(self, stream):\n pass","def sndData(self, dat):\r\n\t\t# comando da inviare\r\n\t\tstrCmd=\"\"\r\n\t\tfor byt in dat:\r\n\t\t\tstrCmd+=(\"%c\" %byt)\r\n\t\t# Non uso sndByte per evitare il ritardo self.dlTx\r\n\t\tself.ser.write(strCmd)\r\n\t\tif self.deb:\r\n\t\t\tfor ele in dat:\r\n\t\t\t\tprint \"\\\\x%02X\" %ele,\r\n\t\t\tprint\r\n\t\tsleep(0.001)","def process(self, data):\n if self.__head:\n self.__head.send(Element(\n stream_id=self.id,\n data=data))","def request_realtime_info(self):\n self.socket_datastream.sendto(b\"!r\", self.ip_port_arduino_datastream)\n self.socket_datastream.sendto(b\"!s\", self.ip_port_arduino_datastream)","def data_received(self, data):\n self.log.debug('data_received: {!r}'.format(data))\n self._last_received = datetime.datetime.now()\n for byte in (bytes([value]) for value in data):\n\n try:\n self.stream.feed_byte(byte)\n except (ValueError, AssertionError):\n e_type, e_value, _ = sys.exc_info()\n map(self.log.warn,\n traceback.format_exception_only(e_type, e_value))\n continue\n\n if self.stream.is_oob:\n continue\n\n # self.reader.feed_byte()\n self.shell.feed_byte(byte)","def raw(self,msg):\n self.unhang()\n print (msg,flush=True, file=self.fp)\n self.hanging=False","def flush(handIn):","def stream_call(self):\n pass","def feed() -> None:\n ...","def add_noise(self, data):","def stream():\n while True:\n yield random_point()","def got_data(self, data):\n if self.get_current_state() == SBE37ProtocolState.DIRECT_ACCESS:\n # direct access mode\n if len(data) > 0:\n mi_logger.debug(\"SBE37Protocol._got_data(): <\" + data + \">\") \n if self._driver_event:\n self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data)\n # TODO: what about logging this as an event?\n return\n \n if len(data)>0:\n # Call the superclass to update line and prompt buffers.\n CommandResponseInstrumentProtocol.got_data(self, data)\n \n # If in streaming mode, process the buffer for samples to publish.\n cur_state = self.get_current_state()\n if cur_state == SBE37ProtocolState.AUTOSAMPLE:\n if SBE37_NEWLINE in self._linebuf:\n lines = self._linebuf.split(SBE37_NEWLINE)\n self._linebuf = lines[-1]\n for line in lines:\n self._extract_sample(line)","def req_stream_bin(self):\n meassage = b'SUP 23 1' + self.end_mess_bytes\n print('Requesting binary stream...')\n self.sock.sendall(meassage)","def send(self, payload):\n self.emitter.input(payload)","def _filter_sinogram(self, sino):\n # pad sinogram to reduce periodicity artefacts\n target_size = max(\n 64, int(2 ** np.ceil(np.log2(2 * self.m[-1].item())))\n )\n pad = target_size - self.m[-1]\n sino_pad = torch.nn.functional.pad(sino, (pad // 2, pad - pad // 2))\n\n # fft along detector direction\n sino_complex = torch.stack(\n [sino_pad, torch.zeros_like(sino_pad)], dim=-1\n )\n sino_fft = fft1(sino_complex)\n\n # apply frequency filter\n f = self._get_fourier_filter().unsqueeze(-1).to(sino.device)\n filtered_sino_fft = sino_fft * f\n\n # ifft along detector direction\n filtered_sino_pad = ifft1(filtered_sino_fft)[..., 0]\n\n # remove padding and rescale\n filtered_sino = filtered_sino_pad[..., pad // 2 : -(pad - pad // 2)]\n\n return filtered_sino","async def snoop(self, ctx):\n await self.bot.send_file(ctx.message.channel,\n \"{}snoop.jpg\".format(self.base))","def process_stream(self, sid, f):\n http_response = wavehttp.get(\"/wave/wfe/channel?VER=6&RID=rpc&SID=\"+sid+\n \"&CI=0&AID=0&TYPE=xmlhttp&zx=\"+self.zx()+\"&t=1\")\n http_data = http_response.read(120)\n print http_data\n exit()\n connection.close()","def flush(self, data):","def _raw(self, txt):\n\n if not txt:\n return\n\n rlog(2, self.name + '.sending', txt)\n\n try:\n self.lastoutput = time.time()\n itxt = toenc(outputmorphs.do(txt), self.encoding)\n if self.ssl:\n self.sock.write(itxt + '\\n')\n else:\n self.sock.send(itxt[:500] + '\\n')\n except Exception, ex:\n # check for broken pipe error .. if so ignore \n # used for nonblocking sockets\n try:\n (errno, errstr) = ex\n if errno != 32 and errno != 9:\n raise\n else:\n rlog(10, self.name, 'broken pipe/bad socket error .. ignoring')\n except:\n rlog(10, self.name, \"ERROR: can't send %s\" % str(ex))\n self.reconnect()","def execute(self, stream):\n pass","def run_snuffler(stream, events, markers, inventory, ntracks=12):\n if isinstance(events, obspy.core.event.Event):\n catalog = obspy.Catalog(events=[event])\n else:\n catalog = events\n if inventory:\n return_tag, markers_out = stream.snuffle(catalog=catalog, inventory=inventory, markers=markers, ntracks=ntracks)\n else:\n return_tag, markers_out = stream.snuffle(catalog=catalog, markers=markers, ntracks=ntracks)\n return return_tag, markers_out","def feed(self) -> None:","async def onSend(self, stream, stanza):\n pass","def recieve_data_request(self,stefan_index):\n self.signal_status_message.emit('Recieved data request for STEFAN {}'.format(stefan_index))\n data = self.get_analyser_data()\n self.signal_data_for_stefan.emit(data,stefan_index)\n self.signal_status_message.emit('Forwarded all data for STEFAN {} to SIMON'.format(stefan_index))","def read_raw_data_from_server():\n s = connect_to_eeg_server(enable_raw_output=True)\n loop = 50\n while loop > 0:\n buf = s.recv(1024)\n raw = str(buf).strip()\n print(raw)\n loop -= 1\n s.close()","def sendBuffer():\n dislin.sendbf()","def emit(data):","def send(self, data):","def onRecv(self, data):\n self.stream += data\n while self.handleStream(): pass","def skim(lines, file):\n for line in skim_generator(lines, file):\n sys.stdout.write(line)","def feed(self):\n # or intelligence discard\n pass","def start_stream_to_queue(self, q, with_header=True):\n # Start Streaming\n self.send_command_bytes_usb(chr(0x55), response_header=with_header)\n # Drain any residual bytes\n self.port.read(128)\n while True:\n header, data = self.get_IMU_data()\n timestamp = header[1]\n \"\"\"\n DO STUFF\n \"\"\"\n #print(\"imu data: \", data)\n #print(\"%f,%d,% 9f,% 9f,% 9f,% 9f,% 9f,% 9f,% 9f\" % tuple(data1) )\n #print(\"% 9f,% 9f,% 9f,% 9f,% 9f,% 9f,% 9f\" % tuple(data) )\n q.put((header, data))","def send_data(self, fp, dest: PathLike, force: bool = False):","def sample(self):\n self.dev.write(1, 'S')","def server_do(self,input, connstream):\r\n pass","def _sample_indication(self, buf, addr):\n #print 'Buffer, Address:', buf, addr\n try:\n #We may be (or may not be!) in need of translating our data with: hexlify or unhexlify. \n data = hexlify(str(buf))\n print 'RAW data: ', buf\n print 'heXlify data: ', data\n except:\n traceback.print_exc()\n self.property_set('data_channel', Sample(0, str(data), 'hex'))","def sendraw(self, st):\n\n st = self.as_str(st)\n\n if '\\n' in st or '\\r\\n' in st:\n raise ValueError('cannot send strings with newline characters')\n _python_print_function(st, file=self.stdout or sys.stdout)","def publish_line(self, stream, line):\n pass","def send_fft_osc(self):\n self.client.send_message(\"/fft_train\", list(self.fft_bins_y))","def add_raw_signal(self, signal):\n assert int(signal[0]) == signal[0], \"Raw signal are always integers\"\n assert len(signal) == len(self.scaled_signal) and len(signal) == self.signal_length, \\\n \"Raw signal must be same size as scaled signal input:{} != scale:{}\".format(signal, self.scaled_signal)\n self.raw_signal = signal","def process_data(data):\n bio = BytesIO()\n bio.write(data)\n bio.seek(0)\n process(bio)","def _slurp(self):\n self.parser.parse(self.stream)\n self.getEvent = self._emit\n return self._emit()","def draw(data):\n global TIE\n print(str(data))\n TIE.append(str(data['Draw']))\n #print(TIE)\n SOCKETIO.emit('Draw', data, broadcast=True, include_self=True)\n return data","def note(freq):\n data = np.sin(2.0 * np.pi * freq * t) * amp\n return data","def sse(self, pattern, handler):\n pass","def tempsRaw(self, cmd):\n\n cmd_txt = cmd.cmd.keywords['raw'].values[0]\n\n ret = self.actor.controllers['ltemps'].tempsCmd(cmd_txt, cmd=cmd)\n cmd.finish('text=\"returned %s\"' % (qstr(ret)))","def sendraw(self, txt):\n\n if self.stopped:\n return\n rlog(2, self.name + '.sending', txt)\n self._raw(txt)","def synthetic_seismogram(green, wavelet):\n return np.real(ifft(fft(wavelet) * fft(green)))","def collect_incoming_data(self, data):\n self.__input.append(data)","def notch_filter_raw_plot(data, fs, fc):\n b, a = sp.iirnotch(w0=fc / fs * 2, Q=100)\n w, h = sp.freqz(b, a)\n f = w / np.pi * fs / 2\n plt.figure()\n plt.plot(f, 10 * np.log10(abs(h)))\n plt.xlabel('frequency (Hz)')\n plt.ylabel('Magnitude (dB)')\n plt.title('frequency response of notch filter at 50Hz')\n plt.grid()\n\n data1 = sp.filtfilt(b, a, data)\n return data1","def SendPayload(s, payload):\n for line in payload:\n s.send(line)\n RecvAndSleep(s)","def push_write(self, s):\n ...","def SimpsonsPic(sc, event):\n sc.api_call('chat.postMessage', as_user='true', channel=event['channel'],\n text='Something is broken and @alex has not fixed it yet. Blame him.')\n return\n search_text = event['text'][10:]\n if search_text:\n meme_url = make_meme(search_text)\n sc.api_call('chat.postMessage', as_user='true',\n channel=event['channel'], text=meme_url)","def process(self, stream):\n\n # Extract data and weight arrays, averaging over beams\n data = np.mean(stream.hfb[:], axis=2)\n weight = np.mean(stream.weight[:], axis=2)\n\n # Number of samples per data point in the HFB data:\n # n_samp = delta_nu * delta_t * (1 - frac_lost), where\n # delta_nu is the frequency resolution (390.625 kHz / 128),\n # delta_t the integration time (~10.066 s), and\n # frac_lost is the fraction of integration that was lost upstream\n freq_width = stream._data[\"index_map/freq/width\"][0] * 1e6\n nsubfreq = len(stream._data[\"index_map/subfreq\"])\n delta_nu = freq_width / nsubfreq\n delta_t = np.median(np.diff(stream._data[\"index_map/time/ctime\"]))\n frac_lost = stream[\"flags/frac_lost\"][0]\n n_samp = delta_nu * delta_t * (1.0 - frac_lost)\n\n # Ideal radiometer equation\n radiometer = data**2 * tools.invert_no_zero(n_samp)\n\n # Radiometer noise test: the sensitivity metric would be unity for\n # an ideal radiometer, it would be higher for data with RFI\n sensitivity_metric = 2.0 * tools.invert_no_zero(radiometer * weight)\n\n # Boolean mask indicating data that are contaminated by RFI\n mask = sensitivity_metric > self.threshold\n\n # Create container to hold output\n out = HFBRFIMask(axes_from=stream, attrs_from=stream)\n\n if self.keep_sens:\n out.add_dataset(\"sens\")\n out.sens[:] = sensitivity_metric\n\n # Save mask to output container\n out.mask[:] = mask\n\n # Add beam selection to RFI mask attributes\n out.attrs[\"beam\"] = stream._data[\"index_map\"][\"beam\"][:]\n\n # Return output container\n return out","def __raw(self, lines):\n os.sys.stdout.write(u\"\\n\".join(lines).encode('utf-8', 'ignore'))\n os.sys.stdout.flush()","def dump_data(ser, meta, args):\n ser.reset_input_buffer()\n ser.reset_output_buffer()\n\n command = b\"TEXT.DUMP\\r\"\n rx = \"\"\n ntry = 0\n while not rx or (rx.split()[-1] != \"data?\"):\n rx = send_cmd(ser, command, args.debug)\n # sys.stderr.write(rx)\n ntry += 1\n if ntry > 3:\n LOGGER.warning(\"Wrong response to dump command ({})\".format(command))\n return 0\n\n command = b\"Y\"\n rx = \"\"\n ntry = 0\n while not rx or (rx.split()[-1] != \"ready\"):\n rx = send_cmd(ser, command, args.debug)\n # sys.stderr.write(rx)\n ntry += 1\n if ntry > 3:\n LOGGER.warning(\"Wrong response to dump command ({})\".format(command))\n return 0\n\n b = b\"\\r\"\n n = ser.write(b)\n if args.debug:\n LOGGER.debug(\"{} byte ({}) written to port\\n\".format(n, repr(b)))\n time.sleep(0.05)\n\n dumpst = time.time()\n suff = \"\"\n if meta.badclock:\n suff = \"-badclock\"\n\n fname = \"{}/{}sb.{}{}\".format(args.path, meta.modserial, args.calday, suff)\n fh = open(fname, \"w\")\n\n fraw = \"\"\n rxline = 1\n try:\n while rxline:\n rxline = ser.readline()\n if rxline:\n sys.stdout.write(rxline.decode(errors=\"replace\"))\n fout = crlfpat.sub(linend, rxline.decode(errors=\"replace\"))\n if cafepat.search(fout):\n meta.cafe = True\n fh.write(fout)\n except KeyboardInterrupt:\n interrupt = b\"\\x03\"\n send_cmd(ser, interrupt, args.debug)\n # time.sleep(1.0)\n # rxline = 1\n # while rxline:\n # rxline = ser.readline()\n # if rxline:\n # sys.stdout.write(rxline.decode(errors='replace'))\n # fout = crlfpat.sub(linend, rxline.decode(errors='replace'))\n # fh.write(fout)\n ser.reset_input_buffer()\n fh.close()\n fsize = os.stat(fname).st_size\n frename = fname + \"-abort\"\n os.rename(fname, frename)\n sys.stderr.write(\"\\n\\n\")\n LOGGER.warning(\"Download aborted: wrote {} bytes to {}\".format(fsize, frename))\n return 0\n\n fh.close()\n\n if meta.cafe:\n frename = fname + \"-cafe\"\n os.rename(fname, frename)\n fname = frename\n\n dumpend = time.time()\n etsec = dumpend - dumpst\n dtet = datetime(1900, 1, 1, 0, 0, 0) + timedelta(seconds=etsec)\n\n fsize = os.stat(fname).st_size\n sys.stderr.write(\"\\n\\n\")\n if meta.badclock or meta.cafe:\n LOGGER.warning(\"Wrote {} bytes to {}\".format(fsize, fname))\n else:\n LOGGER.info(\"Wrote {} bytes to {}\".format(fsize, fname))\n LOGGER.info(\n \"Dumped {} records in {} (hh:mm:ss)\".format(meta.ndumprec, dtet.strftime(etfmt))\n )\n\n FLOGGER.info(\"Wrote {} bytes to {}\".format(fsize, fname))\n FLOGGER.info(\n \"Dumped {} records in {} (hh:mm:ss)\".format(meta.ndumprec, dtet.strftime(etfmt))\n )\n\n return fsize","def test_process_mono(self):\n self.encoder = StreamEncoder(**self.default_kwargs)\n test_samples = np.random.rand(DEFAULT_BLOCKSIZE, 1).astype('int16')\n self.encoder.process(test_samples)\n self.encoder.finish()\n self.assertTrue(self.write_callback_called)","def process(self, packet):\n pass","def write( data ):","def run(self) -> None:\n self._running = True\n while self._running:\n self._ist_mut.acquire()\n self.buff = np.zeros(params.BUF)\n for i in self.ist:\n self.buff += np.asarray(struct.unpack('f'*params.BUF, i.read(params.BUF)))\n self.buff /= len(self.ist)\n self._ist_mut.release()\n self.buff = self.transf.apply_all(self.buff)\n self._sou_mut.acquire()\n dels = []\n for i, s in enumerate(self.sounds):\n so_raw = s.read(params.BUF)\n if so_raw == b'':\n dels.append(i)\n continue\n so = np.asarray(struct.unpack(s.format*(len(so_raw)//s.f_size), so_raw)).astype(np.float32)\n so /= 2**(8*s.f_size-1)\n so = np.hstack((so, np.zeros(params.BUF-len(so))))*s.amp\n self.buff = np.average([self.buff, so], axis=0, weights=[.8,.2])\n for d in reversed(dels):\n del self.sounds[d]\n self._sou_mut.release()\n raw = struct.pack('f'*len(self.buff), *self.buff)\n self._ost_mut.acquire()\n for o in self.ost:\n o.write(raw)\n self._ost_mut.release()","def main():\n #follow_line()\n #data, samplerate = sf.read('youtube_8660.wav')\n #sf.write('new_file.ogg', data, samplerate)\n beep_for_color()","def snip(filename,s,e,wout=True):\n n, data, data_dB,sr,ch=inputwav(filename)\n st=int(s*44100)\n en=int(e*44100)\n data_s=data[st:en,:]\n if wout==True:\n print('Exporting...')\n sf.write(filename[0:len(filename)-4]+'_snipped.wav',data_s,sr,'PCM_16')\n print('Done!')\n return data_s","def _send(self, data, newline=\"\\r\\n\", sock=None):\n self.outbuff.append(data+newline)\n for msg in self.outbuff:\n if self.print_raw:\n logger.debug(msg.strip())\n self.sock.sendall((msg+newline).encode(\"utf-8\"))","def slurp(self, op_type, points):\n\t\t#self.conn.write_points(op_type, points, batch_size=50)\n\t\tpass","def forward_dummy(self, img):\n output = self.generator(img)\n return output","def add_data(self, sample, data_id):\n sample = np.array(sample)\n if len(sample.shape) == 1:\n sample = sample.reshape(1, -1)\n self.feat_in_pipe_in.send(sample)","def _send(self, msg):\n try:\n if msg != self.eof_msg:\n if not self.open_as_binary:\n msg = backwards.as_unicode(msg)\n self.fd.write(msg)\n if self.append == 'ow':\n self.fd.truncate()\n self.fd.flush()\n except (AttributeError, ValueError): # pragma: debug\n if self.is_open:\n raise\n return False\n if msg != self.eof_msg and self.is_series:\n self.advance_in_series()\n self.debug(\"Advanced to %d\", self._series_index)\n return True","def write(self, args, gen, out=sys.stdout):\n seqsum = sniff(gen)\n\n out.write(str(seqsum))","def run(self):\n write_chunk(self.chunk, self.token)","def act_like_hub (self, packet, packet_in):\n # We want to output to all ports -- we do that using the special\n # OFPP_ALL port as the output port. (We could have also used\n # OFPP_FLOOD.)\n self.resend_packet(packet_in, of.OFPP_ALL)\n\n # Note that if we didn't get arp_req valid buffer_id, arp_req slightly better\n # implementation would check that we got the full data before\n # sending it (len(packet_in.data) should be == packet_in.total_len)).","def write_data(self, packet):\n # TODO: check frequency instead of just doing one and two - could only be 2\n if not packet.satellites:\n return # No satellites\n t = dt.datetime(1980, 1, 6) + \\\n dt.timedelta(days=7*packet.week, seconds=int(packet.rcvTow),\n microseconds=(packet.rcvTow - int(packet.rcvTow))*10**6) - \\\n dt.timedelta(seconds=packet.leapS)\n epoch = f'> {t.year:4d} {t.month:02d} {t.day:02d} {t.hour:2d} {t.minute:2d} ' \\\n f'{t.second + t.microsecond*10**-6:11.7f} 0{len(packet.satellites):>3d}{\" \":<44}\\n'\n line = ''\n for s in packet.satellites:\n snr0 = s[0].cno\n if s[0].key == '':\n pass\n elif s[0].sigId in [0, 1]:\n line = line + f'{s[0].key:3s}{s[0].prMeas:>14.3f} {snr0:>1d}{s[0].cpMeas:>14.3f} {snr0:>1d}' \\\n f'{s[0].doMeas:>14.3f} {snr0:>1d}{s[0].cno:>14.3f} {snr0:>1d}'\n if len(s) == 2: # If L1 and L2 Frequencies\n snr1 = s[1].cno\n line = line + f'{s[1].prMeas:>14.3f} {snr1:>1d}{s[1].cpMeas:>14.3f} {snr1:>1d}{s[1].doMeas:>14.3f} ' \\\n f'{snr1:>1d}{s[1].cno:>14.3f} {snr1:>1d}\\n'\n\n else:\n line = line + f'{0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} \\n'\n elif len(s) < 2:\n line = line + f'{0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} ' \\\n f'{s[0].key:3s}{s[0].prMeas:>14.3f} {snr0:>1d}{s[0].cpMeas:>14.3f} {snr0:>1d}' \\\n f'{s[0].doMeas:>14.3f} {snr0:>1d}{s[0].cno:>14.3f} {snr0:>1d}\\n'\n elif len(s) == 2:\n line = line + f'{s[1].prMeas:>14.3f} {snr1:>1d}{s[1].cpMeas:>14.3f} {snr1:>1d}{s[1].doMeas:>14.3f} ' \\\n f'{snr1:>1d}{s[1].cno:>14.3f} {snr1:>1d}' \\\n f'{s[0].key:3s}{s[0].prMeas:>14.3f} {snr0:>1d}{s[0].cpMeas:>14.3f} {snr0:>1d}' \\\n f'{s[0].doMeas:>14.3f} {snr0:>1d}{s[0].cno:>14.3f} {snr0:>1d}\\n'\n \n try:\n with open(self.fname, 'a') as f:\n f.write(epoch + line)\n except FileNotFoundError:\n print('Bad data directory. Try again.')\n sys.exit(0)","def push_data(self, data):\n self.incoming.write(data)","def apply():\r\n result = dataSampling(str, \"hhhhhhahhhhhahhahahahahhahahha\", 5)\r\n final_res = dataScreening(result, \"ha\")\r\n print(final_res)","def tell(self):\n ...","def sendInstruction(self, instruction):\n # instruction = '!'\n print(f'Sending: {instruction}')\n self.ser.write(instruction.encode(\"ascii\"))\n self.ser.write('\\n'.encode(\"ascii\"))\n\n self.ser.reset_input_buffer()\n\n ser_bytes = self.ser.read(1)\n print(f'Receiving\\nraw data: {ser_bytes}')\n\n # decoded_bytes = (ser_bytes.decode(\"ascii\"))\n # print(f'Ascii Value: {decoded_bytes}', flush=True)","def _add_to_buffer(self, data):\n for byte in data:\n self.next_fn(byte) \n self._parse_cmds()","def raw_signal_odd():\n signal_x = np.linspace(0, 2 * np.pi, 1001)\n signal_y = np.sin(10 * signal_x) + np.sin(50 * signal_x) + 2\n return signal_y","def main(event, context):\n\n logger.info(f\"Event data is: {event}\")\n try:\n # Incoming event is already byte encoded\n client.append_message(stream_name=\"LocalDataStream\", data=event)\n except Exception as e:\n logger.error(f\"Error appending: {e}\")\n return","def record_chunk(self):\n data = self.stream.read(nFFT)\n data_array = bytearray(data)\n self.cur_input = []\n for i in range(nFFT):\n amp = struct.unpack('H', data_array[:2])\n for _ in range(2):\n data_array.pop(0)\n self.cur_input.append(amp)","def plugin_send(raw_data, stream_id):\n\n global _recreate_omf_objects\n\n data_to_send = []\n data_sent = False\n\n config_category_name = _CONFIG_CATEGORY_NAME + \"_\" + str(stream_id)\n type_id = _config_omf_types['type-id']['value']\n\n try:\n data_available, new_position, num_sent = _transform_in_memory_data(data_to_send, raw_data)\n\n if data_available:\n _create_omf_objects(raw_data, config_category_name, type_id)\n\n try:\n _send_in_memory_data_to_picromf(\"Data\", data_to_send)\n\n except Exception as ex:\n # Forces the recreation of PIServer's objects on the first error occurred\n if _recreate_omf_objects:\n\n _logger.debug(\"{0} - Forces objects recreation \".format(\"plugin_send\"))\n\n _deleted_omf_types_already_created(config_category_name, type_id)\n _recreate_omf_objects = False\n\n raise ex\n else:\n data_sent = True\n\n except Exception as ex:\n _message = plugin_common.MESSAGES_LIST[\"e000031\"].format(ex)\n\n _logger.exception(_message)\n raise\n\n return data_sent, new_position, num_sent","def normal(self, *args):\n\n if self.is_on(_Log.NORMAL):\n self._write(self._out, *args)","def run(self) -> Any:\n self.prepare()\n for step in self.stream:\n self.output = step\n return self.output","def _send_data(self):\n pass","async def send_raw(self, data: bytes) -> None:\n await self.socket.sendall(data)","def _send_raw_data(self, data_dict: dict) -> None:\n data = np.array(([point[\"secs\"] for point in data_dict[0][\"data\"]],\n [point[\"val\"] for point in data_dict[0][\"data\"]]))\n self.new_value_signal[np.ndarray].emit(data)","def signal_process( Qin, source, stop_flag, log, pos_ref, FIX_1BIT_ERRORS=False ):\n\n\trow_size = 16 + 112*2 #240 bits\n\t\n\twhile( not stop_flag.is_set() ):\n\t\tcurr_time = time.strftime('%d/%b/%Y %H:%M:%S', time.localtime())\n\t\t\n\t\t# Get streaming chunk from sdr_read thread\n\t\ty = Qin.get();\n\t\t\t\n\t\tpacket_diff = len(packets)\n\t\tidx_preamble, noise_floor = asp.detectPreamble(y)\t\t\n\t\tfor n in idx_preamble:\n\t\t\tsignal = abs(y[int(n) : int(n) + row_size])\n\t\t\tmsg = asp.decode_ADSB( signal, FIX_1BIT_ERRORS )\n\t\t\tif msg != None:\n\t\t\t\tsnr = asp.SNR(signal, noise_floor)\n\t\t\t\tpkt = ao.Packet(msg, time.time(), snr)\n\t\t\t\tpackets.append( pkt )\n\t\t\t\tprint( '!' , end='', flush=True )\n\t\t\t\t\n\t\t\t\tif len(packets) > PACKET_BUFF_SIZE:\n\t\t\t\t\tpackets.pop(0)\n\t\t\t\t\n\t\t\t\tif log != None:\n\t\t\t\t\ttry:\n\t\t\t\t\t\twith open(log, 'a') as f:\n\t\t\t\t\t\t\tf.write(f\"[{curr_time}] {msg}\\n\")\n\t\t\t\t\texcept:\n\t\t\t\t\t\tprint(f\"Error writing to {log}!\")\n\t\t\t\t\n\t\t\t\tif pkt.icao in planes:\n\t\t\t\t\tplanes[pkt.icao].process_packet( pkt )\n\t\t\t\telif pkt.icao != None:\n\t\t\t\t\tplanes[pkt.icao] = ao.Plane( pkt, pos_ref )\n\t\t\n\t\tif packet_diff == len(packets):\n\t\t\t# packets.append(f\"[{curr_time}] None received...\")\n\t\t\tprint( '.' , end='', flush=True )\n\t\t\n\t\t# Remove excess objects\n\t\tto_delete = []\n\t\tfor p in planes.keys():\n\t\t\tif (time.time() - planes[p].last_update) >= TTL:\n\t\t\t\tto_delete.append(p)\n\t\t\n\t\tfor p in to_delete:\n\t\t\tplanes.pop(p)\n\t\t\n\t\tQin.queue.clear()","def process_say(data):\n logger.info(f\"Said: {data}\")","def send(self, data):\n pass","def stream_callback(self, in_data, frame_count, time_info, status_flags):\n time_delta = time.time() - self.last_frame_timestamp\n if time_delta == 0:\n time_delta = sys.float_info.min\n fps = int(1.0 / time_delta)\n self.last_frame_timestamp = time.time()\n if DEBUG:\n self.fps_deque.append(fps)\n avg_fps = 0\n for frame_fps in self.fps_deque:\n avg_fps += frame_fps\n avg_fps /= len(self.fps_deque)\n self.log_fps(self.last_frame_timestamp, fps)\n sys.stdout.write(\"\\r{} FPS\".format(avg_fps))\n sys.stdout.flush()\n self.data = np.frombuffer(in_data, dtype=np.float32)\n if self.binned:\n self.binned_fft()\n self.fft_callback(self.fft_bins_y)\n else:\n self.fft()\n self.fft_callback(self.spec_y)\n if self.send_osc:\n self.send_fft_osc()\n return (None, pyaudio.paContinue)","def emit(self, tweet):\n raise NotImplementedError","def read_incoming(self):\r\n buf = ''\r\n debug_prompt = re.compile(r'\\A[\\w]+>>? ')\r\n while 1:\r\n try:\r\n buf += os.read(self.fid, 100).decode('utf8')\r\n except:\r\n self.queue.put(None)\r\n return\r\n lines = buf.splitlines()\r\n for line in lines[:-1]:\r\n self.queue.put(line)\r\n if buf.endswith('\\n'):\r\n self.queue.put(lines[-1])\r\n buf = ''\r\n elif re.match(debug_prompt, lines[-1]):\r\n self.queue.put(lines[-1])\r\n buf = ''\r\n else:\r\n buf = lines[-1]","def run(self, quiet=False):\n self.write_input()\n util.execute(self._bins[0], quiet)","def run(self):\n self.socket.connect()\n with open('src/inputs/output.file', 'rb') as f:\n self.sent_bytes = f.read()\n self.socket.send(self.sent_bytes)\n self.socket.disconnect()\n self.socket.close()","def run(self, data):\n\t\t# no processing here\n\t\treturn data","def __stream_triggered(self):\n # Call this every time period\n thread = Timer(self.stream_time, self.__stream_triggered)\n thread.start()\n self.__threads.append(thread)\n\n if len(self.__spike_buffer) > 2:\n speed = self.__get_speed()\n print(speed)\n self.__stream_send(speed)","def run(self, stream: np.ndarray) -> None:\n for index, event in enumerate(stream):\n self.event_index = index\n case_id, activity_name, activity_timestamp = (event[0], event[1], event[2])\n if index == 0:\n self.check_point = activity_timestamp\n self.process_event(case_id, activity_name, activity_timestamp)\n\n self.drift_indexes = list(np.unique(self.drift_indexes))\n print(\"Total number of drifts:\", len(self.drift_indexes))\n print(\"Drift points:\", self.drift_indexes)\n cumulative_stream_drifts(len(stream), self.drift_indexes, f'visualization/drifts/{self.name}.pdf')","def squares_streaming_get():\n \n return 'do some magic!'","def example_data(fs, Ts):\n\n # Number of points\n N = Ts * fs\n\n # random signals\n phi = np.pi / 2\n ax = [np.sin(2 * np.pi * 2 * (i / fs)) for i in range(N)]\n ay = [np.sin(2 * np.pi * 2 * (i / fs) + phi) for i in range(N)]\n Rx = [a * 0.01 + 0.5 for a in ax]\n Ry = [a * 0.01 + 0.3 for a in ay]\n\n # Make some noise!\n noise1 = np.random.normal(0, 0.1, N)\n noise2 = np.random.normal(0, 0.1, N)\n noise3 = np.random.normal(0, 0.1, N)\n noise4 = np.random.normal(0, 0.1, N)\n\n ax = ax + noise1\n ay = ay + noise2\n Rx = Rx + noise3\n Ry = Ry + noise4\n\n return ax, ay, Rx, Ry","def send(self, data: bytes):","def create_stream(phrase, queue):\n local = SocketIO(message_queue=queue)\n stream = Twitter().stream(phrase, timeout=30)\n\n for i in range(60):\n stream.update()\n for tweet in reversed(stream):\n sentiment = classify_tweet(tweet)\n x, y = vectorize_tweet(tweet)\n local.emit('tweet', {'id': str(i),\n 'text': str(tweet.text.encode('ascii', 'ignore')),\n 'sentiment': sentiment,\n 'x': x,\n 'y': y})\n stream.clear()\n time.sleep(1)\n\n return queue"],"string":"[\n \"def spew_fake_data(self, ideal_datapoint=None):\\n if not ideal_datapoint:\\n ideal_datapoint = 0\\n for chan, wsock in self._chan_to_wsocket.items():\\n if chan.stream_type == \\\"Integrated\\\":\\n length = 1\\n data = 0.5 + 0.1*(np.random.random(length).astype(chan.dtype) + 1j*np.random.random(length).astype(chan.dtype)) + ideal_datapoint\\n elif chan.stream_type == \\\"Demodulated\\\":\\n length = int(self._lib.record_length/32)\\n data = np.zeros(length, dtype=chan.dtype)\\n data[int(length/4):int(3*length/4)] = 1.0\\n data += 0.1*(np.random.random(length) + 1j*np.random.random(length))\\n else: #Raw\\n length = int(self._lib.record_length/4)\\n signal = np.sin(np.linspace(0,10.0*np.pi,int(length/2)))\\n data = np.zeros(length, dtype=chan.dtype)\\n data[int(length/4):int(length/4)+len(signal)] = signal\\n data += 0.1*np.random.random(length)\\n wsock.send(struct.pack('n', length*data.dtype.itemsize) + data.tostring())\",\n \"def run(self, stream):\\n pass\",\n \"def sndData(self, dat):\\r\\n\\t\\t# comando da inviare\\r\\n\\t\\tstrCmd=\\\"\\\"\\r\\n\\t\\tfor byt in dat:\\r\\n\\t\\t\\tstrCmd+=(\\\"%c\\\" %byt)\\r\\n\\t\\t# Non uso sndByte per evitare il ritardo self.dlTx\\r\\n\\t\\tself.ser.write(strCmd)\\r\\n\\t\\tif self.deb:\\r\\n\\t\\t\\tfor ele in dat:\\r\\n\\t\\t\\t\\tprint \\\"\\\\\\\\x%02X\\\" %ele,\\r\\n\\t\\t\\tprint\\r\\n\\t\\tsleep(0.001)\",\n \"def process(self, data):\\n if self.__head:\\n self.__head.send(Element(\\n stream_id=self.id,\\n data=data))\",\n \"def request_realtime_info(self):\\n self.socket_datastream.sendto(b\\\"!r\\\", self.ip_port_arduino_datastream)\\n self.socket_datastream.sendto(b\\\"!s\\\", self.ip_port_arduino_datastream)\",\n \"def data_received(self, data):\\n self.log.debug('data_received: {!r}'.format(data))\\n self._last_received = datetime.datetime.now()\\n for byte in (bytes([value]) for value in data):\\n\\n try:\\n self.stream.feed_byte(byte)\\n except (ValueError, AssertionError):\\n e_type, e_value, _ = sys.exc_info()\\n map(self.log.warn,\\n traceback.format_exception_only(e_type, e_value))\\n continue\\n\\n if self.stream.is_oob:\\n continue\\n\\n # self.reader.feed_byte()\\n self.shell.feed_byte(byte)\",\n \"def raw(self,msg):\\n self.unhang()\\n print (msg,flush=True, file=self.fp)\\n self.hanging=False\",\n \"def flush(handIn):\",\n \"def stream_call(self):\\n pass\",\n \"def feed() -> None:\\n ...\",\n \"def add_noise(self, data):\",\n \"def stream():\\n while True:\\n yield random_point()\",\n \"def got_data(self, data):\\n if self.get_current_state() == SBE37ProtocolState.DIRECT_ACCESS:\\n # direct access mode\\n if len(data) > 0:\\n mi_logger.debug(\\\"SBE37Protocol._got_data(): <\\\" + data + \\\">\\\") \\n if self._driver_event:\\n self._driver_event(DriverAsyncEvent.DIRECT_ACCESS, data)\\n # TODO: what about logging this as an event?\\n return\\n \\n if len(data)>0:\\n # Call the superclass to update line and prompt buffers.\\n CommandResponseInstrumentProtocol.got_data(self, data)\\n \\n # If in streaming mode, process the buffer for samples to publish.\\n cur_state = self.get_current_state()\\n if cur_state == SBE37ProtocolState.AUTOSAMPLE:\\n if SBE37_NEWLINE in self._linebuf:\\n lines = self._linebuf.split(SBE37_NEWLINE)\\n self._linebuf = lines[-1]\\n for line in lines:\\n self._extract_sample(line)\",\n \"def req_stream_bin(self):\\n meassage = b'SUP 23 1' + self.end_mess_bytes\\n print('Requesting binary stream...')\\n self.sock.sendall(meassage)\",\n \"def send(self, payload):\\n self.emitter.input(payload)\",\n \"def _filter_sinogram(self, sino):\\n # pad sinogram to reduce periodicity artefacts\\n target_size = max(\\n 64, int(2 ** np.ceil(np.log2(2 * self.m[-1].item())))\\n )\\n pad = target_size - self.m[-1]\\n sino_pad = torch.nn.functional.pad(sino, (pad // 2, pad - pad // 2))\\n\\n # fft along detector direction\\n sino_complex = torch.stack(\\n [sino_pad, torch.zeros_like(sino_pad)], dim=-1\\n )\\n sino_fft = fft1(sino_complex)\\n\\n # apply frequency filter\\n f = self._get_fourier_filter().unsqueeze(-1).to(sino.device)\\n filtered_sino_fft = sino_fft * f\\n\\n # ifft along detector direction\\n filtered_sino_pad = ifft1(filtered_sino_fft)[..., 0]\\n\\n # remove padding and rescale\\n filtered_sino = filtered_sino_pad[..., pad // 2 : -(pad - pad // 2)]\\n\\n return filtered_sino\",\n \"async def snoop(self, ctx):\\n await self.bot.send_file(ctx.message.channel,\\n \\\"{}snoop.jpg\\\".format(self.base))\",\n \"def process_stream(self, sid, f):\\n http_response = wavehttp.get(\\\"/wave/wfe/channel?VER=6&RID=rpc&SID=\\\"+sid+\\n \\\"&CI=0&AID=0&TYPE=xmlhttp&zx=\\\"+self.zx()+\\\"&t=1\\\")\\n http_data = http_response.read(120)\\n print http_data\\n exit()\\n connection.close()\",\n \"def flush(self, data):\",\n \"def _raw(self, txt):\\n\\n if not txt:\\n return\\n\\n rlog(2, self.name + '.sending', txt)\\n\\n try:\\n self.lastoutput = time.time()\\n itxt = toenc(outputmorphs.do(txt), self.encoding)\\n if self.ssl:\\n self.sock.write(itxt + '\\\\n')\\n else:\\n self.sock.send(itxt[:500] + '\\\\n')\\n except Exception, ex:\\n # check for broken pipe error .. if so ignore \\n # used for nonblocking sockets\\n try:\\n (errno, errstr) = ex\\n if errno != 32 and errno != 9:\\n raise\\n else:\\n rlog(10, self.name, 'broken pipe/bad socket error .. ignoring')\\n except:\\n rlog(10, self.name, \\\"ERROR: can't send %s\\\" % str(ex))\\n self.reconnect()\",\n \"def execute(self, stream):\\n pass\",\n \"def run_snuffler(stream, events, markers, inventory, ntracks=12):\\n if isinstance(events, obspy.core.event.Event):\\n catalog = obspy.Catalog(events=[event])\\n else:\\n catalog = events\\n if inventory:\\n return_tag, markers_out = stream.snuffle(catalog=catalog, inventory=inventory, markers=markers, ntracks=ntracks)\\n else:\\n return_tag, markers_out = stream.snuffle(catalog=catalog, markers=markers, ntracks=ntracks)\\n return return_tag, markers_out\",\n \"def feed(self) -> None:\",\n \"async def onSend(self, stream, stanza):\\n pass\",\n \"def recieve_data_request(self,stefan_index):\\n self.signal_status_message.emit('Recieved data request for STEFAN {}'.format(stefan_index))\\n data = self.get_analyser_data()\\n self.signal_data_for_stefan.emit(data,stefan_index)\\n self.signal_status_message.emit('Forwarded all data for STEFAN {} to SIMON'.format(stefan_index))\",\n \"def read_raw_data_from_server():\\n s = connect_to_eeg_server(enable_raw_output=True)\\n loop = 50\\n while loop > 0:\\n buf = s.recv(1024)\\n raw = str(buf).strip()\\n print(raw)\\n loop -= 1\\n s.close()\",\n \"def sendBuffer():\\n dislin.sendbf()\",\n \"def emit(data):\",\n \"def send(self, data):\",\n \"def onRecv(self, data):\\n self.stream += data\\n while self.handleStream(): pass\",\n \"def skim(lines, file):\\n for line in skim_generator(lines, file):\\n sys.stdout.write(line)\",\n \"def feed(self):\\n # or intelligence discard\\n pass\",\n \"def start_stream_to_queue(self, q, with_header=True):\\n # Start Streaming\\n self.send_command_bytes_usb(chr(0x55), response_header=with_header)\\n # Drain any residual bytes\\n self.port.read(128)\\n while True:\\n header, data = self.get_IMU_data()\\n timestamp = header[1]\\n \\\"\\\"\\\"\\n DO STUFF\\n \\\"\\\"\\\"\\n #print(\\\"imu data: \\\", data)\\n #print(\\\"%f,%d,% 9f,% 9f,% 9f,% 9f,% 9f,% 9f,% 9f\\\" % tuple(data1) )\\n #print(\\\"% 9f,% 9f,% 9f,% 9f,% 9f,% 9f,% 9f\\\" % tuple(data) )\\n q.put((header, data))\",\n \"def send_data(self, fp, dest: PathLike, force: bool = False):\",\n \"def sample(self):\\n self.dev.write(1, 'S')\",\n \"def server_do(self,input, connstream):\\r\\n pass\",\n \"def _sample_indication(self, buf, addr):\\n #print 'Buffer, Address:', buf, addr\\n try:\\n #We may be (or may not be!) in need of translating our data with: hexlify or unhexlify. \\n data = hexlify(str(buf))\\n print 'RAW data: ', buf\\n print 'heXlify data: ', data\\n except:\\n traceback.print_exc()\\n self.property_set('data_channel', Sample(0, str(data), 'hex'))\",\n \"def sendraw(self, st):\\n\\n st = self.as_str(st)\\n\\n if '\\\\n' in st or '\\\\r\\\\n' in st:\\n raise ValueError('cannot send strings with newline characters')\\n _python_print_function(st, file=self.stdout or sys.stdout)\",\n \"def publish_line(self, stream, line):\\n pass\",\n \"def send_fft_osc(self):\\n self.client.send_message(\\\"/fft_train\\\", list(self.fft_bins_y))\",\n \"def add_raw_signal(self, signal):\\n assert int(signal[0]) == signal[0], \\\"Raw signal are always integers\\\"\\n assert len(signal) == len(self.scaled_signal) and len(signal) == self.signal_length, \\\\\\n \\\"Raw signal must be same size as scaled signal input:{} != scale:{}\\\".format(signal, self.scaled_signal)\\n self.raw_signal = signal\",\n \"def process_data(data):\\n bio = BytesIO()\\n bio.write(data)\\n bio.seek(0)\\n process(bio)\",\n \"def _slurp(self):\\n self.parser.parse(self.stream)\\n self.getEvent = self._emit\\n return self._emit()\",\n \"def draw(data):\\n global TIE\\n print(str(data))\\n TIE.append(str(data['Draw']))\\n #print(TIE)\\n SOCKETIO.emit('Draw', data, broadcast=True, include_self=True)\\n return data\",\n \"def note(freq):\\n data = np.sin(2.0 * np.pi * freq * t) * amp\\n return data\",\n \"def sse(self, pattern, handler):\\n pass\",\n \"def tempsRaw(self, cmd):\\n\\n cmd_txt = cmd.cmd.keywords['raw'].values[0]\\n\\n ret = self.actor.controllers['ltemps'].tempsCmd(cmd_txt, cmd=cmd)\\n cmd.finish('text=\\\"returned %s\\\"' % (qstr(ret)))\",\n \"def sendraw(self, txt):\\n\\n if self.stopped:\\n return\\n rlog(2, self.name + '.sending', txt)\\n self._raw(txt)\",\n \"def synthetic_seismogram(green, wavelet):\\n return np.real(ifft(fft(wavelet) * fft(green)))\",\n \"def collect_incoming_data(self, data):\\n self.__input.append(data)\",\n \"def notch_filter_raw_plot(data, fs, fc):\\n b, a = sp.iirnotch(w0=fc / fs * 2, Q=100)\\n w, h = sp.freqz(b, a)\\n f = w / np.pi * fs / 2\\n plt.figure()\\n plt.plot(f, 10 * np.log10(abs(h)))\\n plt.xlabel('frequency (Hz)')\\n plt.ylabel('Magnitude (dB)')\\n plt.title('frequency response of notch filter at 50Hz')\\n plt.grid()\\n\\n data1 = sp.filtfilt(b, a, data)\\n return data1\",\n \"def SendPayload(s, payload):\\n for line in payload:\\n s.send(line)\\n RecvAndSleep(s)\",\n \"def push_write(self, s):\\n ...\",\n \"def SimpsonsPic(sc, event):\\n sc.api_call('chat.postMessage', as_user='true', channel=event['channel'],\\n text='Something is broken and @alex has not fixed it yet. Blame him.')\\n return\\n search_text = event['text'][10:]\\n if search_text:\\n meme_url = make_meme(search_text)\\n sc.api_call('chat.postMessage', as_user='true',\\n channel=event['channel'], text=meme_url)\",\n \"def process(self, stream):\\n\\n # Extract data and weight arrays, averaging over beams\\n data = np.mean(stream.hfb[:], axis=2)\\n weight = np.mean(stream.weight[:], axis=2)\\n\\n # Number of samples per data point in the HFB data:\\n # n_samp = delta_nu * delta_t * (1 - frac_lost), where\\n # delta_nu is the frequency resolution (390.625 kHz / 128),\\n # delta_t the integration time (~10.066 s), and\\n # frac_lost is the fraction of integration that was lost upstream\\n freq_width = stream._data[\\\"index_map/freq/width\\\"][0] * 1e6\\n nsubfreq = len(stream._data[\\\"index_map/subfreq\\\"])\\n delta_nu = freq_width / nsubfreq\\n delta_t = np.median(np.diff(stream._data[\\\"index_map/time/ctime\\\"]))\\n frac_lost = stream[\\\"flags/frac_lost\\\"][0]\\n n_samp = delta_nu * delta_t * (1.0 - frac_lost)\\n\\n # Ideal radiometer equation\\n radiometer = data**2 * tools.invert_no_zero(n_samp)\\n\\n # Radiometer noise test: the sensitivity metric would be unity for\\n # an ideal radiometer, it would be higher for data with RFI\\n sensitivity_metric = 2.0 * tools.invert_no_zero(radiometer * weight)\\n\\n # Boolean mask indicating data that are contaminated by RFI\\n mask = sensitivity_metric > self.threshold\\n\\n # Create container to hold output\\n out = HFBRFIMask(axes_from=stream, attrs_from=stream)\\n\\n if self.keep_sens:\\n out.add_dataset(\\\"sens\\\")\\n out.sens[:] = sensitivity_metric\\n\\n # Save mask to output container\\n out.mask[:] = mask\\n\\n # Add beam selection to RFI mask attributes\\n out.attrs[\\\"beam\\\"] = stream._data[\\\"index_map\\\"][\\\"beam\\\"][:]\\n\\n # Return output container\\n return out\",\n \"def __raw(self, lines):\\n os.sys.stdout.write(u\\\"\\\\n\\\".join(lines).encode('utf-8', 'ignore'))\\n os.sys.stdout.flush()\",\n \"def dump_data(ser, meta, args):\\n ser.reset_input_buffer()\\n ser.reset_output_buffer()\\n\\n command = b\\\"TEXT.DUMP\\\\r\\\"\\n rx = \\\"\\\"\\n ntry = 0\\n while not rx or (rx.split()[-1] != \\\"data?\\\"):\\n rx = send_cmd(ser, command, args.debug)\\n # sys.stderr.write(rx)\\n ntry += 1\\n if ntry > 3:\\n LOGGER.warning(\\\"Wrong response to dump command ({})\\\".format(command))\\n return 0\\n\\n command = b\\\"Y\\\"\\n rx = \\\"\\\"\\n ntry = 0\\n while not rx or (rx.split()[-1] != \\\"ready\\\"):\\n rx = send_cmd(ser, command, args.debug)\\n # sys.stderr.write(rx)\\n ntry += 1\\n if ntry > 3:\\n LOGGER.warning(\\\"Wrong response to dump command ({})\\\".format(command))\\n return 0\\n\\n b = b\\\"\\\\r\\\"\\n n = ser.write(b)\\n if args.debug:\\n LOGGER.debug(\\\"{} byte ({}) written to port\\\\n\\\".format(n, repr(b)))\\n time.sleep(0.05)\\n\\n dumpst = time.time()\\n suff = \\\"\\\"\\n if meta.badclock:\\n suff = \\\"-badclock\\\"\\n\\n fname = \\\"{}/{}sb.{}{}\\\".format(args.path, meta.modserial, args.calday, suff)\\n fh = open(fname, \\\"w\\\")\\n\\n fraw = \\\"\\\"\\n rxline = 1\\n try:\\n while rxline:\\n rxline = ser.readline()\\n if rxline:\\n sys.stdout.write(rxline.decode(errors=\\\"replace\\\"))\\n fout = crlfpat.sub(linend, rxline.decode(errors=\\\"replace\\\"))\\n if cafepat.search(fout):\\n meta.cafe = True\\n fh.write(fout)\\n except KeyboardInterrupt:\\n interrupt = b\\\"\\\\x03\\\"\\n send_cmd(ser, interrupt, args.debug)\\n # time.sleep(1.0)\\n # rxline = 1\\n # while rxline:\\n # rxline = ser.readline()\\n # if rxline:\\n # sys.stdout.write(rxline.decode(errors='replace'))\\n # fout = crlfpat.sub(linend, rxline.decode(errors='replace'))\\n # fh.write(fout)\\n ser.reset_input_buffer()\\n fh.close()\\n fsize = os.stat(fname).st_size\\n frename = fname + \\\"-abort\\\"\\n os.rename(fname, frename)\\n sys.stderr.write(\\\"\\\\n\\\\n\\\")\\n LOGGER.warning(\\\"Download aborted: wrote {} bytes to {}\\\".format(fsize, frename))\\n return 0\\n\\n fh.close()\\n\\n if meta.cafe:\\n frename = fname + \\\"-cafe\\\"\\n os.rename(fname, frename)\\n fname = frename\\n\\n dumpend = time.time()\\n etsec = dumpend - dumpst\\n dtet = datetime(1900, 1, 1, 0, 0, 0) + timedelta(seconds=etsec)\\n\\n fsize = os.stat(fname).st_size\\n sys.stderr.write(\\\"\\\\n\\\\n\\\")\\n if meta.badclock or meta.cafe:\\n LOGGER.warning(\\\"Wrote {} bytes to {}\\\".format(fsize, fname))\\n else:\\n LOGGER.info(\\\"Wrote {} bytes to {}\\\".format(fsize, fname))\\n LOGGER.info(\\n \\\"Dumped {} records in {} (hh:mm:ss)\\\".format(meta.ndumprec, dtet.strftime(etfmt))\\n )\\n\\n FLOGGER.info(\\\"Wrote {} bytes to {}\\\".format(fsize, fname))\\n FLOGGER.info(\\n \\\"Dumped {} records in {} (hh:mm:ss)\\\".format(meta.ndumprec, dtet.strftime(etfmt))\\n )\\n\\n return fsize\",\n \"def test_process_mono(self):\\n self.encoder = StreamEncoder(**self.default_kwargs)\\n test_samples = np.random.rand(DEFAULT_BLOCKSIZE, 1).astype('int16')\\n self.encoder.process(test_samples)\\n self.encoder.finish()\\n self.assertTrue(self.write_callback_called)\",\n \"def process(self, packet):\\n pass\",\n \"def write( data ):\",\n \"def run(self) -> None:\\n self._running = True\\n while self._running:\\n self._ist_mut.acquire()\\n self.buff = np.zeros(params.BUF)\\n for i in self.ist:\\n self.buff += np.asarray(struct.unpack('f'*params.BUF, i.read(params.BUF)))\\n self.buff /= len(self.ist)\\n self._ist_mut.release()\\n self.buff = self.transf.apply_all(self.buff)\\n self._sou_mut.acquire()\\n dels = []\\n for i, s in enumerate(self.sounds):\\n so_raw = s.read(params.BUF)\\n if so_raw == b'':\\n dels.append(i)\\n continue\\n so = np.asarray(struct.unpack(s.format*(len(so_raw)//s.f_size), so_raw)).astype(np.float32)\\n so /= 2**(8*s.f_size-1)\\n so = np.hstack((so, np.zeros(params.BUF-len(so))))*s.amp\\n self.buff = np.average([self.buff, so], axis=0, weights=[.8,.2])\\n for d in reversed(dels):\\n del self.sounds[d]\\n self._sou_mut.release()\\n raw = struct.pack('f'*len(self.buff), *self.buff)\\n self._ost_mut.acquire()\\n for o in self.ost:\\n o.write(raw)\\n self._ost_mut.release()\",\n \"def main():\\n #follow_line()\\n #data, samplerate = sf.read('youtube_8660.wav')\\n #sf.write('new_file.ogg', data, samplerate)\\n beep_for_color()\",\n \"def snip(filename,s,e,wout=True):\\n n, data, data_dB,sr,ch=inputwav(filename)\\n st=int(s*44100)\\n en=int(e*44100)\\n data_s=data[st:en,:]\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_snipped.wav',data_s,sr,'PCM_16')\\n print('Done!')\\n return data_s\",\n \"def _send(self, data, newline=\\\"\\\\r\\\\n\\\", sock=None):\\n self.outbuff.append(data+newline)\\n for msg in self.outbuff:\\n if self.print_raw:\\n logger.debug(msg.strip())\\n self.sock.sendall((msg+newline).encode(\\\"utf-8\\\"))\",\n \"def slurp(self, op_type, points):\\n\\t\\t#self.conn.write_points(op_type, points, batch_size=50)\\n\\t\\tpass\",\n \"def forward_dummy(self, img):\\n output = self.generator(img)\\n return output\",\n \"def add_data(self, sample, data_id):\\n sample = np.array(sample)\\n if len(sample.shape) == 1:\\n sample = sample.reshape(1, -1)\\n self.feat_in_pipe_in.send(sample)\",\n \"def _send(self, msg):\\n try:\\n if msg != self.eof_msg:\\n if not self.open_as_binary:\\n msg = backwards.as_unicode(msg)\\n self.fd.write(msg)\\n if self.append == 'ow':\\n self.fd.truncate()\\n self.fd.flush()\\n except (AttributeError, ValueError): # pragma: debug\\n if self.is_open:\\n raise\\n return False\\n if msg != self.eof_msg and self.is_series:\\n self.advance_in_series()\\n self.debug(\\\"Advanced to %d\\\", self._series_index)\\n return True\",\n \"def write(self, args, gen, out=sys.stdout):\\n seqsum = sniff(gen)\\n\\n out.write(str(seqsum))\",\n \"def run(self):\\n write_chunk(self.chunk, self.token)\",\n \"def act_like_hub (self, packet, packet_in):\\n # We want to output to all ports -- we do that using the special\\n # OFPP_ALL port as the output port. (We could have also used\\n # OFPP_FLOOD.)\\n self.resend_packet(packet_in, of.OFPP_ALL)\\n\\n # Note that if we didn't get arp_req valid buffer_id, arp_req slightly better\\n # implementation would check that we got the full data before\\n # sending it (len(packet_in.data) should be == packet_in.total_len)).\",\n \"def write_data(self, packet):\\n # TODO: check frequency instead of just doing one and two - could only be 2\\n if not packet.satellites:\\n return # No satellites\\n t = dt.datetime(1980, 1, 6) + \\\\\\n dt.timedelta(days=7*packet.week, seconds=int(packet.rcvTow),\\n microseconds=(packet.rcvTow - int(packet.rcvTow))*10**6) - \\\\\\n dt.timedelta(seconds=packet.leapS)\\n epoch = f'> {t.year:4d} {t.month:02d} {t.day:02d} {t.hour:2d} {t.minute:2d} ' \\\\\\n f'{t.second + t.microsecond*10**-6:11.7f} 0{len(packet.satellites):>3d}{\\\" \\\":<44}\\\\n'\\n line = ''\\n for s in packet.satellites:\\n snr0 = s[0].cno\\n if s[0].key == '':\\n pass\\n elif s[0].sigId in [0, 1]:\\n line = line + f'{s[0].key:3s}{s[0].prMeas:>14.3f} {snr0:>1d}{s[0].cpMeas:>14.3f} {snr0:>1d}' \\\\\\n f'{s[0].doMeas:>14.3f} {snr0:>1d}{s[0].cno:>14.3f} {snr0:>1d}'\\n if len(s) == 2: # If L1 and L2 Frequencies\\n snr1 = s[1].cno\\n line = line + f'{s[1].prMeas:>14.3f} {snr1:>1d}{s[1].cpMeas:>14.3f} {snr1:>1d}{s[1].doMeas:>14.3f} ' \\\\\\n f'{snr1:>1d}{s[1].cno:>14.3f} {snr1:>1d}\\\\n'\\n\\n else:\\n line = line + f'{0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} \\\\n'\\n elif len(s) < 2:\\n line = line + f'{0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} {0.0:>14.3f} ' \\\\\\n f'{s[0].key:3s}{s[0].prMeas:>14.3f} {snr0:>1d}{s[0].cpMeas:>14.3f} {snr0:>1d}' \\\\\\n f'{s[0].doMeas:>14.3f} {snr0:>1d}{s[0].cno:>14.3f} {snr0:>1d}\\\\n'\\n elif len(s) == 2:\\n line = line + f'{s[1].prMeas:>14.3f} {snr1:>1d}{s[1].cpMeas:>14.3f} {snr1:>1d}{s[1].doMeas:>14.3f} ' \\\\\\n f'{snr1:>1d}{s[1].cno:>14.3f} {snr1:>1d}' \\\\\\n f'{s[0].key:3s}{s[0].prMeas:>14.3f} {snr0:>1d}{s[0].cpMeas:>14.3f} {snr0:>1d}' \\\\\\n f'{s[0].doMeas:>14.3f} {snr0:>1d}{s[0].cno:>14.3f} {snr0:>1d}\\\\n'\\n \\n try:\\n with open(self.fname, 'a') as f:\\n f.write(epoch + line)\\n except FileNotFoundError:\\n print('Bad data directory. Try again.')\\n sys.exit(0)\",\n \"def push_data(self, data):\\n self.incoming.write(data)\",\n \"def apply():\\r\\n result = dataSampling(str, \\\"hhhhhhahhhhhahhahahahahhahahha\\\", 5)\\r\\n final_res = dataScreening(result, \\\"ha\\\")\\r\\n print(final_res)\",\n \"def tell(self):\\n ...\",\n \"def sendInstruction(self, instruction):\\n # instruction = '!'\\n print(f'Sending: {instruction}')\\n self.ser.write(instruction.encode(\\\"ascii\\\"))\\n self.ser.write('\\\\n'.encode(\\\"ascii\\\"))\\n\\n self.ser.reset_input_buffer()\\n\\n ser_bytes = self.ser.read(1)\\n print(f'Receiving\\\\nraw data: {ser_bytes}')\\n\\n # decoded_bytes = (ser_bytes.decode(\\\"ascii\\\"))\\n # print(f'Ascii Value: {decoded_bytes}', flush=True)\",\n \"def _add_to_buffer(self, data):\\n for byte in data:\\n self.next_fn(byte) \\n self._parse_cmds()\",\n \"def raw_signal_odd():\\n signal_x = np.linspace(0, 2 * np.pi, 1001)\\n signal_y = np.sin(10 * signal_x) + np.sin(50 * signal_x) + 2\\n return signal_y\",\n \"def main(event, context):\\n\\n logger.info(f\\\"Event data is: {event}\\\")\\n try:\\n # Incoming event is already byte encoded\\n client.append_message(stream_name=\\\"LocalDataStream\\\", data=event)\\n except Exception as e:\\n logger.error(f\\\"Error appending: {e}\\\")\\n return\",\n \"def record_chunk(self):\\n data = self.stream.read(nFFT)\\n data_array = bytearray(data)\\n self.cur_input = []\\n for i in range(nFFT):\\n amp = struct.unpack('H', data_array[:2])\\n for _ in range(2):\\n data_array.pop(0)\\n self.cur_input.append(amp)\",\n \"def plugin_send(raw_data, stream_id):\\n\\n global _recreate_omf_objects\\n\\n data_to_send = []\\n data_sent = False\\n\\n config_category_name = _CONFIG_CATEGORY_NAME + \\\"_\\\" + str(stream_id)\\n type_id = _config_omf_types['type-id']['value']\\n\\n try:\\n data_available, new_position, num_sent = _transform_in_memory_data(data_to_send, raw_data)\\n\\n if data_available:\\n _create_omf_objects(raw_data, config_category_name, type_id)\\n\\n try:\\n _send_in_memory_data_to_picromf(\\\"Data\\\", data_to_send)\\n\\n except Exception as ex:\\n # Forces the recreation of PIServer's objects on the first error occurred\\n if _recreate_omf_objects:\\n\\n _logger.debug(\\\"{0} - Forces objects recreation \\\".format(\\\"plugin_send\\\"))\\n\\n _deleted_omf_types_already_created(config_category_name, type_id)\\n _recreate_omf_objects = False\\n\\n raise ex\\n else:\\n data_sent = True\\n\\n except Exception as ex:\\n _message = plugin_common.MESSAGES_LIST[\\\"e000031\\\"].format(ex)\\n\\n _logger.exception(_message)\\n raise\\n\\n return data_sent, new_position, num_sent\",\n \"def normal(self, *args):\\n\\n if self.is_on(_Log.NORMAL):\\n self._write(self._out, *args)\",\n \"def run(self) -> Any:\\n self.prepare()\\n for step in self.stream:\\n self.output = step\\n return self.output\",\n \"def _send_data(self):\\n pass\",\n \"async def send_raw(self, data: bytes) -> None:\\n await self.socket.sendall(data)\",\n \"def _send_raw_data(self, data_dict: dict) -> None:\\n data = np.array(([point[\\\"secs\\\"] for point in data_dict[0][\\\"data\\\"]],\\n [point[\\\"val\\\"] for point in data_dict[0][\\\"data\\\"]]))\\n self.new_value_signal[np.ndarray].emit(data)\",\n \"def signal_process( Qin, source, stop_flag, log, pos_ref, FIX_1BIT_ERRORS=False ):\\n\\n\\trow_size = 16 + 112*2 #240 bits\\n\\t\\n\\twhile( not stop_flag.is_set() ):\\n\\t\\tcurr_time = time.strftime('%d/%b/%Y %H:%M:%S', time.localtime())\\n\\t\\t\\n\\t\\t# Get streaming chunk from sdr_read thread\\n\\t\\ty = Qin.get();\\n\\t\\t\\t\\n\\t\\tpacket_diff = len(packets)\\n\\t\\tidx_preamble, noise_floor = asp.detectPreamble(y)\\t\\t\\n\\t\\tfor n in idx_preamble:\\n\\t\\t\\tsignal = abs(y[int(n) : int(n) + row_size])\\n\\t\\t\\tmsg = asp.decode_ADSB( signal, FIX_1BIT_ERRORS )\\n\\t\\t\\tif msg != None:\\n\\t\\t\\t\\tsnr = asp.SNR(signal, noise_floor)\\n\\t\\t\\t\\tpkt = ao.Packet(msg, time.time(), snr)\\n\\t\\t\\t\\tpackets.append( pkt )\\n\\t\\t\\t\\tprint( '!' , end='', flush=True )\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif len(packets) > PACKET_BUFF_SIZE:\\n\\t\\t\\t\\t\\tpackets.pop(0)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif log != None:\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\twith open(log, 'a') as f:\\n\\t\\t\\t\\t\\t\\t\\tf.write(f\\\"[{curr_time}] {msg}\\\\n\\\")\\n\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\tprint(f\\\"Error writing to {log}!\\\")\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif pkt.icao in planes:\\n\\t\\t\\t\\t\\tplanes[pkt.icao].process_packet( pkt )\\n\\t\\t\\t\\telif pkt.icao != None:\\n\\t\\t\\t\\t\\tplanes[pkt.icao] = ao.Plane( pkt, pos_ref )\\n\\t\\t\\n\\t\\tif packet_diff == len(packets):\\n\\t\\t\\t# packets.append(f\\\"[{curr_time}] None received...\\\")\\n\\t\\t\\tprint( '.' , end='', flush=True )\\n\\t\\t\\n\\t\\t# Remove excess objects\\n\\t\\tto_delete = []\\n\\t\\tfor p in planes.keys():\\n\\t\\t\\tif (time.time() - planes[p].last_update) >= TTL:\\n\\t\\t\\t\\tto_delete.append(p)\\n\\t\\t\\n\\t\\tfor p in to_delete:\\n\\t\\t\\tplanes.pop(p)\\n\\t\\t\\n\\t\\tQin.queue.clear()\",\n \"def process_say(data):\\n logger.info(f\\\"Said: {data}\\\")\",\n \"def send(self, data):\\n pass\",\n \"def stream_callback(self, in_data, frame_count, time_info, status_flags):\\n time_delta = time.time() - self.last_frame_timestamp\\n if time_delta == 0:\\n time_delta = sys.float_info.min\\n fps = int(1.0 / time_delta)\\n self.last_frame_timestamp = time.time()\\n if DEBUG:\\n self.fps_deque.append(fps)\\n avg_fps = 0\\n for frame_fps in self.fps_deque:\\n avg_fps += frame_fps\\n avg_fps /= len(self.fps_deque)\\n self.log_fps(self.last_frame_timestamp, fps)\\n sys.stdout.write(\\\"\\\\r{} FPS\\\".format(avg_fps))\\n sys.stdout.flush()\\n self.data = np.frombuffer(in_data, dtype=np.float32)\\n if self.binned:\\n self.binned_fft()\\n self.fft_callback(self.fft_bins_y)\\n else:\\n self.fft()\\n self.fft_callback(self.spec_y)\\n if self.send_osc:\\n self.send_fft_osc()\\n return (None, pyaudio.paContinue)\",\n \"def emit(self, tweet):\\n raise NotImplementedError\",\n \"def read_incoming(self):\\r\\n buf = ''\\r\\n debug_prompt = re.compile(r'\\\\A[\\\\w]+>>? ')\\r\\n while 1:\\r\\n try:\\r\\n buf += os.read(self.fid, 100).decode('utf8')\\r\\n except:\\r\\n self.queue.put(None)\\r\\n return\\r\\n lines = buf.splitlines()\\r\\n for line in lines[:-1]:\\r\\n self.queue.put(line)\\r\\n if buf.endswith('\\\\n'):\\r\\n self.queue.put(lines[-1])\\r\\n buf = ''\\r\\n elif re.match(debug_prompt, lines[-1]):\\r\\n self.queue.put(lines[-1])\\r\\n buf = ''\\r\\n else:\\r\\n buf = lines[-1]\",\n \"def run(self, quiet=False):\\n self.write_input()\\n util.execute(self._bins[0], quiet)\",\n \"def run(self):\\n self.socket.connect()\\n with open('src/inputs/output.file', 'rb') as f:\\n self.sent_bytes = f.read()\\n self.socket.send(self.sent_bytes)\\n self.socket.disconnect()\\n self.socket.close()\",\n \"def run(self, data):\\n\\t\\t# no processing here\\n\\t\\treturn data\",\n \"def __stream_triggered(self):\\n # Call this every time period\\n thread = Timer(self.stream_time, self.__stream_triggered)\\n thread.start()\\n self.__threads.append(thread)\\n\\n if len(self.__spike_buffer) > 2:\\n speed = self.__get_speed()\\n print(speed)\\n self.__stream_send(speed)\",\n \"def run(self, stream: np.ndarray) -> None:\\n for index, event in enumerate(stream):\\n self.event_index = index\\n case_id, activity_name, activity_timestamp = (event[0], event[1], event[2])\\n if index == 0:\\n self.check_point = activity_timestamp\\n self.process_event(case_id, activity_name, activity_timestamp)\\n\\n self.drift_indexes = list(np.unique(self.drift_indexes))\\n print(\\\"Total number of drifts:\\\", len(self.drift_indexes))\\n print(\\\"Drift points:\\\", self.drift_indexes)\\n cumulative_stream_drifts(len(stream), self.drift_indexes, f'visualization/drifts/{self.name}.pdf')\",\n \"def squares_streaming_get():\\n \\n return 'do some magic!'\",\n \"def example_data(fs, Ts):\\n\\n # Number of points\\n N = Ts * fs\\n\\n # random signals\\n phi = np.pi / 2\\n ax = [np.sin(2 * np.pi * 2 * (i / fs)) for i in range(N)]\\n ay = [np.sin(2 * np.pi * 2 * (i / fs) + phi) for i in range(N)]\\n Rx = [a * 0.01 + 0.5 for a in ax]\\n Ry = [a * 0.01 + 0.3 for a in ay]\\n\\n # Make some noise!\\n noise1 = np.random.normal(0, 0.1, N)\\n noise2 = np.random.normal(0, 0.1, N)\\n noise3 = np.random.normal(0, 0.1, N)\\n noise4 = np.random.normal(0, 0.1, N)\\n\\n ax = ax + noise1\\n ay = ay + noise2\\n Rx = Rx + noise3\\n Ry = Ry + noise4\\n\\n return ax, ay, Rx, Ry\",\n \"def send(self, data: bytes):\",\n \"def create_stream(phrase, queue):\\n local = SocketIO(message_queue=queue)\\n stream = Twitter().stream(phrase, timeout=30)\\n\\n for i in range(60):\\n stream.update()\\n for tweet in reversed(stream):\\n sentiment = classify_tweet(tweet)\\n x, y = vectorize_tweet(tweet)\\n local.emit('tweet', {'id': str(i),\\n 'text': str(tweet.text.encode('ascii', 'ignore')),\\n 'sentiment': sentiment,\\n 'x': x,\\n 'y': y})\\n stream.clear()\\n time.sleep(1)\\n\\n return queue\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56662464","0.56494576","0.5452499","0.5403465","0.5392977","0.5359452","0.5254567","0.52149475","0.5201187","0.51998246","0.51904345","0.5170478","0.5113757","0.5108657","0.50941855","0.5092163","0.5084607","0.5078546","0.50472206","0.5040828","0.50347483","0.5025204","0.5023635","0.5010168","0.5005093","0.5004414","0.500146","0.49753603","0.4965314","0.4963896","0.49471143","0.49412972","0.4933091","0.49227607","0.4904131","0.48864523","0.488019","0.48754114","0.48678958","0.48653555","0.4861919","0.4852183","0.4844166","0.4835963","0.48357588","0.4834491","0.48180264","0.48117056","0.48050866","0.4799472","0.47916064","0.47778526","0.47707132","0.475739","0.4754765","0.47538337","0.47407526","0.47403252","0.47401997","0.47356492","0.47351378","0.473371","0.47330043","0.47216222","0.47203657","0.47154707","0.47142985","0.4710661","0.46925315","0.46907443","0.4687329","0.46869746","0.46811703","0.4676124","0.46755558","0.46749794","0.467098","0.4665908","0.46596974","0.46592757","0.4658712","0.46587068","0.46583286","0.46543226","0.46503997","0.4643061","0.46306723","0.46296364","0.46280873","0.46250725","0.46233383","0.4613664","0.4611973","0.46059138","0.4605434","0.4602416","0.46019605","0.45997614","0.459934","0.459876","0.45890242"],"string":"[\n \"0.56662464\",\n \"0.56494576\",\n \"0.5452499\",\n \"0.5403465\",\n \"0.5392977\",\n \"0.5359452\",\n \"0.5254567\",\n \"0.52149475\",\n \"0.5201187\",\n \"0.51998246\",\n \"0.51904345\",\n \"0.5170478\",\n \"0.5113757\",\n \"0.5108657\",\n \"0.50941855\",\n \"0.5092163\",\n \"0.5084607\",\n \"0.5078546\",\n \"0.50472206\",\n \"0.5040828\",\n \"0.50347483\",\n \"0.5025204\",\n \"0.5023635\",\n \"0.5010168\",\n \"0.5005093\",\n \"0.5004414\",\n \"0.500146\",\n \"0.49753603\",\n \"0.4965314\",\n \"0.4963896\",\n \"0.49471143\",\n \"0.49412972\",\n \"0.4933091\",\n \"0.49227607\",\n \"0.4904131\",\n \"0.48864523\",\n \"0.488019\",\n \"0.48754114\",\n \"0.48678958\",\n \"0.48653555\",\n \"0.4861919\",\n \"0.4852183\",\n \"0.4844166\",\n \"0.4835963\",\n \"0.48357588\",\n \"0.4834491\",\n \"0.48180264\",\n \"0.48117056\",\n \"0.48050866\",\n \"0.4799472\",\n \"0.47916064\",\n \"0.47778526\",\n \"0.47707132\",\n \"0.475739\",\n \"0.4754765\",\n \"0.47538337\",\n \"0.47407526\",\n \"0.47403252\",\n \"0.47401997\",\n \"0.47356492\",\n \"0.47351378\",\n \"0.473371\",\n \"0.47330043\",\n \"0.47216222\",\n \"0.47203657\",\n \"0.47154707\",\n \"0.47142985\",\n \"0.4710661\",\n \"0.46925315\",\n \"0.46907443\",\n \"0.4687329\",\n \"0.46869746\",\n \"0.46811703\",\n \"0.4676124\",\n \"0.46755558\",\n \"0.46749794\",\n \"0.467098\",\n \"0.4665908\",\n \"0.46596974\",\n \"0.46592757\",\n \"0.4658712\",\n \"0.46587068\",\n \"0.46583286\",\n \"0.46543226\",\n \"0.46503997\",\n \"0.4643061\",\n \"0.46306723\",\n \"0.46296364\",\n \"0.46280873\",\n \"0.46250725\",\n \"0.46233383\",\n \"0.4613664\",\n \"0.4611973\",\n \"0.46059138\",\n \"0.4605434\",\n \"0.4602416\",\n \"0.46019605\",\n \"0.45997614\",\n \"0.459934\",\n \"0.459876\",\n \"0.45890242\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":75095,"cells":{"query":{"kind":"string","value":"Create a block with the given ID and return it."},"document":{"kind":"string","value":"def CreateBlock(self, props):\n # Set some default properties\n\n # blk / cfg | name | name+inst\n # -----------------------------\n # name | n==n | False\n # name+inst | n==n | n==n&&i==i\n if 'ordinal' not in props and 'name' in props:\n for ordinal, ni in self.config.get('ordinals', {}).items():\n if isinstance(ni, str):\n # Config only has name, don't care about block\n if props['name'] == ni:\n props['ordinal'] = ordinal\n break\n elif 'instance' not in props:\n # Config has name+instance, block only has name\n continue\n else:\n # Config has name+instance, block has name+instance\n if props['name'] == ni[0] and props['instance'] == ni[1]:\n props['ordinal'] = ordinal\n break\n\n # Compute a block ID\n if 'name' in props:\n bid = props['name'].replace('-', '')\n else:\n bid = \"block\"\n\n if bid in self.blocks:\n i = 1\n while bid+str(i) in self.blocks:\n i += 1\n bid = bid+str(i)\n\n # Actually create block\n self.blocks[bid] = blk = Block(bid, props)\n blk.changed.handler(lambda: self.blockchanged(blk))\n\n self.blockadded(blk)\n\n return blk"},"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_block(world: World, block_id: str, x: int, y: int, *args):\n block_id = BLOCKS[block_id]\n if block_id == \"mystery_empty\":\n block = MysteryBlock()\n elif block_id == \"mystery_coin\":\n block = MysteryBlock(drop=\"coin\", drop_range=(3, 6))\n elif block_id == \"bounce_block\":\n block = BounceBlock()\n elif block_id == \"flag\":\n block = Flagpole()\n elif block_id == \"tunnel\":\n block = Tunnel()\n elif block_id == \"switch\":\n block = Switch()\n else:\n block = Block(block_id)\n\n world.add_block(block, x * BLOCK_SIZE, y * BLOCK_SIZE)","def gen_new_block(self):\n block = BasicBlock()\n self.blocks.append(block)\n return block","def createBlock(self, block: ghidra.program.model.mem.MemoryBlock, name: unicode, start: ghidra.program.model.address.Address, length: long) -> ghidra.program.model.mem.MemoryBlock:\n ...","def create_block(self):\n return poet_transaction_block.PoetTransactionBlock()","def FindOrCreateBlock(self, name, instance):\n try:\n return self.FindBlock(name, instance)\n except KeyError:\n return self.CreateBlock({'name': name, 'instance': instance})","def create_block(self, complete_hash, nonce):\n print(\"Creating block with hash: '%s'\" % complete_hash)\n block = Block(complete_hash, nonce)\n for transaction in self.transactions:\n block.add_transaction(transaction)\n return block","def get_a_block(self, usage_id=None):\r\n scope_ids = Mock()\r\n if usage_id is None:\r\n usage_id = \"_auto%d\" % len(self.all_blocks)\r\n scope_ids.usage_id = usage_id\r\n block = self.system.construct_xblock_from_class(\r\n self.TestableInheritingXBlock,\r\n field_data=self.field_data,\r\n scope_ids=scope_ids,\r\n )\r\n self.all_blocks[usage_id] = block\r\n return block","def _new_block(self, user_id, category, block_fields, definition_id, new_id, raw=False,\n asides=None, block_defaults=None):\n if not raw:\n block_fields = self._serialize_fields(category, block_fields)\n if not asides:\n asides = {}\n document = {\n 'block_type': category,\n 'definition': definition_id,\n 'fields': block_fields,\n 'asides': asides,\n 'edit_info': {\n 'edited_on': datetime.datetime.now(UTC),\n 'edited_by': user_id,\n 'previous_version': None,\n 'update_version': new_id\n }\n }\n if block_defaults:\n document['defaults'] = block_defaults\n return BlockData(**document)","def create_block(self, prev_hash=None):\n # Update blockchain and balance state (thread safe)\n if prev_hash is not None and prev_hash not in self._blockchain.hash_block_map.keys():\n print(prev_hash, self._blockchain.hash_block_map)\n prev_blk = None if prev_hash is None else \\\n self._blockchain.hash_block_map[prev_hash]\n last_blk = self._update(prev_blk)\n pending_tx = self._get_tx_pool()\n gathered_tx = self._gather_transactions(pending_tx)\n block = self._mine_new_block(last_blk.header, gathered_tx)\n if block is not None:\n blk_json = block.to_json()\n # Add block to blockchain (thread safe)\n self.add_block(blk_json)\n print(f\"{self.__class__.__name__} {self.name} created a block.\")\n # Broadcast block and the header.\n self._broadcast_block(block)\n # Remove gathered transactions from pool and them to added pile\n with self.added_tx_lock:\n self._added_transactions |= set(gathered_tx)\n self._update()\n return block","def _new_block(self, user_id, category, block_fields, definition_id, new_id, raw=False):\r\n if not raw:\r\n block_fields = self._serialize_fields(category, block_fields)\r\n return {\r\n 'category': category,\r\n 'definition': definition_id,\r\n 'fields': block_fields,\r\n 'edit_info': {\r\n 'edited_on': datetime.datetime.now(UTC),\r\n 'edited_by': user_id,\r\n 'previous_version': None,\r\n 'update_version': new_id\r\n }\r\n }","def new_block(self):\n child = Block(self, py3_wrapper=self.py3_wrapper)\n self.add(child)\n return child","def get_block(self, usage_id, for_parent=None):\n def_id = self.id_reader.get_definition_id(usage_id)\n try:\n block_type = self.id_reader.get_block_type(def_id)\n except NoSuchDefinition:\n raise NoSuchUsage(repr(usage_id)) # pylint: disable= raise-missing-from\n keys = ScopeIds(self.user_id, block_type, def_id, usage_id)\n block = self.construct_xblock(block_type, keys, for_parent=for_parent)\n return block","def createNewBlock(self, nonce, previousBlockHash, hash):\n newBlock = Block(len(self.chain), self.pendingTransactions, nonce, hash, previousBlockHash)\n self.pendingTransactions = []\n self.chain.append(newBlock)\n return newBlock","def createFirstBlock(self):\n firstBlock = Block(0, self.__currentTransactionsList, 0, '00')\n self.__chain.append(firstBlock)","def newBlock(preBlock, remitter, number, payee):\r\n index = preBlock.index + 1\r\n timestamp = int(round(time.time() * 1000))\r\n data = (remitter, number, payee).__str__()\r\n previousHash = preBlock.hash\r\n nounce = 0\r\n return Blockchain(index, data, timestamp, nounce, previousHash)","def create_block_from_xml(xml_data, system, id_generator):\r\n node = etree.fromstring(xml_data)\r\n raw_class = system.load_block_type(node.tag)\r\n xblock_class = system.mixologist.mix(raw_class)\r\n\r\n # leave next line commented out - useful for low-level debugging\r\n # log.debug('[create_block_from_xml] tag=%s, class=%s' % (node.tag, xblock_class))\r\n\r\n block_type = node.tag\r\n url_name = node.get('url_name')\r\n def_id = id_generator.create_definition(block_type, url_name)\r\n usage_id = id_generator.create_usage(def_id)\r\n\r\n scope_ids = ScopeIds(None, block_type, def_id, usage_id)\r\n xblock = xblock_class.parse_xml(node, system, scope_ids, id_generator)\r\n\r\n _convert_reference_fields_to_keys(xblock)\r\n\r\n return xblock","def build_new_block(cls, data='', previous_block=None):\n if previous_block:\n new_index = previous_block.index+1\n previous_hash = previous_block.hash\n else:\n new_index = 0\n previous_hash = ''\n timestamp = int(time.time())\n block_hash = cls.build_block_hash(\n index=new_index,\n timestamp=timestamp,\n data=data,\n previous_hash=previous_hash\n )\n block = cls(\n index=new_index,\n previous_hash=previous_hash,\n data=data,\n timestamp=timestamp,\n block_hash=block_hash\n )\n\n return block","def get_block_obj(self, vault_id, block_id):\n path = self._get_block_path(vault_id, block_id)\n\n if not os.path.exists(path):\n return None\n\n return open(path, 'rb')","def new_block(self, proof, previous_hash=None):\n\n # Create the block\n my_block = Block(proof=proof,\n previous_hash=previous_hash or self.hash(self.last_block))\n my_block.save()\n\n # Update current_transactions with this new block.\n my_block_trans = self.current_transactions_obj\n\n for trans in Transaction.objects.filter(block__isnull=True):\n trans.block = my_block\n trans.save()\n\n block = {\n 'index': my_block.id,\n 'timestamp': my_block.timestamp,\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\n 'proof': my_block.proof,\n 'previous_hash': my_block.previous_hash,\n }\n\n return block","def get_block(block_id: Optional[bytes] = None) -> Optional[Block]:\n if block_id is not None and not isinstance(block_id, bytes):\n raise TypeError\n if block_id is None:\n logging.debug(\"Last block requested\")\n else:\n logging.debug(\"Block %s requested\", util.bintos(block_id))\n\n r = util.get_db()\n if block_id is None:\n block_id = r.get(\"blockchain:last_block\")\n if block_id is None:\n # The blockchain is empty\n logging.debug(\"Blockchain is empty\")\n return None\n\n blockb = r.hget(\"blockchain:blocks\", block_id)\n if blockb is None:\n # Requested block not found\n logging.debug(\"Block %s not found\", util.bintos(block_id))\n return None\n\n logging.debug(\"Block %s retrieved\", util.bintos(block_id))\n return Block.loadb(blockb)","def get(block_id):\n _url = get_root_url()\n try:\n block = DB.get_block_details([block_id]).__next__()\n response = block\n\n response['links'] = {\n 'self': '{}'.format(request.url),\n 'list': '{}/processing-blocks'.format(_url),\n 'home': '{}'.format(_url)\n }\n return block\n except IndexError as error:\n response = dict(message='Unable to GET Processing Block',\n id='{}'.format(block_id),\n error=error.__str__())\n response['links'] = {\n 'list': '{}/processing-blocks'.format(_url),\n 'home': '{}'.format(_url)\n }\n return response, HTTPStatus.NOT_FOUND","def _get_block_from_structure(self, structure, block_id):\r\n return structure['blocks'].get(LocMapperStore.encode_key_for_mongo(block_id))","def create_block(self, nonce, previous_hash):\n block = {'block_number': transaction_blocks.count() + 1,\n 'timestamp': ctime(t),\n 'transactions': self.transactions,\n 'nonce': nonce,\n 'previous_hash': previous_hash}\n\n # Reset the current list of transactions\n self.transactions = []\n self.chain.append(block)\n return block","def NewBlock(self):\n for i in self.matrix:\n if 2 in i:\n return()\n blockType = self.bag.Choose()\n subtractor = {\"I\" : 4, \"J\" : 3, \"L\" : 3, \"O\" : 2, \"S\" : 3, \"T\" : 3, \"Z\": 3}\n x = random.randint(0, self.width - subtractor.get(blockType))\n coords = []\n if blockType == \"I\":\n coords = [(x + i, 0) for i in range(4)]\n elif blockType == \"J\":\n coords = [(x + i, 0) for i in range(3)]\n coords.append((x, 1))\n elif blockType == \"L\":\n coords = [(x + i, 0) for i in range(3)]\n coords.append((x + 2, 1))\n elif blockType == \"O\":\n coords = [(x, 0), (x + 1, 0), (x, 1), (x + 1, 1)]\n elif blockType == \"Z\":\n coords = [(x, 0), (x + 1, 0), (x + 1, 1), (x + 2, 1)]\n elif blockType == \"S\":\n coords = [(x + 1, 0), (x + 2, 0), (x, 1), (x + 1, 1)]\n elif blockType == \"T\":\n coords = [(x, 0), (x + 1, 0), (x + 2, 0), (x + 1, 1)]\n self.coords = coords\n return(coords)","def create_genesis_block(self):\r\n genesis_block = Block(0, [], time.time(), \"0\")\r\n genesis_block.hash = genesis_block.compute_hash()\r\n self.chain.append(genesis_block)","def create_block(type: str, color_key, position):\n if type not in BlockCreator.types.keys():\n raise BlockCreator.IncorrectBlockType\n image_name = BlockCreator.types[type]\n return Block(image_name, color_key, position)","def create_block(self, previous_hash):\r\n if len(self.transaction_pool) < 1:\r\n return None, None\r\n\r\n # Create A Temporary Block\r\n block = {'index': None, # before mining set index to None\r\n 'timestamp': None, # before mining set timestamp to None\r\n 'nonce': 0, # before mining set nonce to 0\r\n 'transactions': self.transaction_pool, # Fill in all the transactions\r\n 'previous_hash': previous_hash, # Set the previous hash\r\n 'current_hash': ''} # Current hash is yet to be calculated\r\n\r\n # Empty Transaction Pool\r\n self.transaction_pool = [] # Once transactions have been placed in a block\r\n # they can be removed from the pool\r\n\r\n # Calculate Proof Of Work (Nonce)\r\n block['nonce'], block['current_hash'] = self.proof_of_work(block, previous_hash) # Validate the block by calculating the nonce\r\n block['index'] = len(self.chain) + 1 # Set the block index\r\n block['timestamp'] = str(datetime.datetime.now()) # Set the timestamp to the time when the block was validated\r\n\r\n # Add Block To DistrictNode's Own Chain\r\n self.chain.append(block) # Append the block to the list of blocks in the blockchain\r\n print(\"BLOCK ADDED TO 90\")\r\n for block in self.chain:\r\n for key, value in block.items():\r\n print(key, value)\r\n print('\\n')\r\n\r\n return self.chain, self.transaction_pool # Return the new chain and the new transaction_pool\r","def save_block(self, drip_campaign_id, start_time, nodes_id):\n new_block = Block(\n drip_campaign_id=drip_campaign_id,\n start_time=start_time,\n nodes_id=nodes_id\n )\n new_block.save()","def create_genesis_block(self):\n genesis_block = Block(0, [], time.time(), \"0\")\n genesis_block.hash = genesis_block.compute_hash()\n self.chain.append(genesis_block)","def makeBlock(tag):\n return {\"t\":\"RawBlock\",\"c\":[\"html\",tag]}","def new_block(self, proof, previous_hash = None):\n #create a new Block & adds it to the chain.\n \n block = {\n 'index' : len(self.chain) + 1,\n 'timestamp' : time(),\n 'transactions' : self.pending_transactions,\n 'proof' : proof,\n 'previous_hash' : previous_hash or self.hash(self.chain[-1])\n }\n\n # Reset the current list of transactions\n self.pending_transactions = []\n\n self.chain.append(block)\n return block\n #pass","def get_random_block(a=0, b=269400):\n height = random.randint(a, b)\n return get_block(get_block_hash(height))","def newblock(self, parent=None):\n block = ControlBlock()\n self.blocks.add(block)\n if parent:\n parent.add_child(block)\n return block","def create_block(data: str, leading_zeros: int) -> Block:\n MAX_NONCE_VALUE = 2 ** 32\n\n nonce = 0\n created_block = None\n\n potential_block = Block(data, nonce)\n\n while potential_block.nonce != MAX_NONCE_VALUE:\n potential_block_hash = potential_block.get_hash()\n binary_block_hash = get_binary_sha256_hash(potential_block_hash)\n\n if binary_block_hash[:leading_zeros] == \"0\" * leading_zeros:\n potential_block.hash = potential_block_hash\n potential_block.store()\n created_block = potential_block\n\n break\n else:\n potential_block.nonce += 1\n\n return created_block","def get_block(blockhash):\n return requests.get(BASE+f'/api/block/{blockhash}').json()","def add_block(self, env):\n block_size = (0.04, 0.04, 0.04)\n block_pose = self.random_pose(env, block_size)\n block_urdf = 'assets/stacking/block.urdf'\n block_id = env.add_object(block_urdf, block_pose)\n self.object_points[block_id] = np.float32((0, 0, 0)).reshape(3, 1)\n self._IDs[block_id] = 'block'\n return block_id","def create_genesis_block(self):\n genesis_block = Block(0, [], 0, \"0\")\n genesis_block.hash = genesis_block.compute_hash()\n self.chain.append(genesis_block)","def create_genesis_block(self):\n genesis_block = Block(0, [], 0, \"0\")\n genesis_block.hash = genesis_block.compute_hash()\n self.chain.append(genesis_block)","def addBlock(self, data):\n #get the hashVal of last block in blockchain\n lastHash = self.chain[len(self.chain) - 1].hashVal\n timestamp = time()\n hashVal = Block.hashSHA(timestamp, lastHash, data, NONCE, DIFFICULTY)\n adding_block = Block(timestamp, lastHash, hashVal, data, NONCE, DIFFICULTY)\n \n self.chain.append(adding_block)\n return adding_block","def get_block_id(self):\n return self._block_id","def make_genesis_block():\n block = Block(index=0,\n timestamp=datetime.now(),\n data=\"Genesis Block\",\n previous_hash=\"0\")\n return block","async def new_block(request: Request) -> dict:\n block: dict = await request.json()\n block = await chain.add_block(block)\n response_block = Block(**block).to_dict()\n\n miner_ip = f\"{request.client.host}:{request.client.port}\"\n for node in chain.peers:\n async with httpx.AsyncClient() as client:\n _ = await client.get(f\"{node}/\")\n temp_chain = {f\"Block-{height}\": data.to_dict()\n for height, data in enumerate(chain.serialized)}\n return {\"miner_address\": miner_ip,\n \"latest_block\": response_block.dict(),\n \"new_chain\": temp_chain, }","def newblock(self, parent=None, **kwargs):\n block = ControlBlock(len(self.blocks), **kwargs)\n self.blocks.append(block)\n if parent:\n parent.add_child(block)\n\n return block","def create_block(self, nonce, previous_hash) -> None:\n block = {\n 'block_number': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions': self.transactions,\n 'nonce': nonce,\n 'previous_hash': previous_hash\n }\n\n self.transactions = []\n self.chain.append(block)","def build_block(self, format_string):\n first_block = Block(None, py3_wrapper=self.py3_wrapper)\n block = first_block\n\n # Tokenize the format string and process them\n for token in self.tokens(format_string):\n value = token.group(0)\n if token.group(\"block_start\"):\n # Create new block\n block = block.new_block()\n elif token.group(\"block_end\"):\n # Close block setting any valid state as needed\n # and return to parent block to continue\n if not block.parent:\n raise Exception(\"Too many `]`\")\n block = block.parent\n elif token.group(\"switch\"):\n # a new option has been created\n block = block.switch()\n elif token.group(\"placeholder\"):\n # Found a {placeholder}\n key = token.group(\"key\")\n format = token.group(\"format\")\n block.add(Placeholder(key, format))\n elif token.group(\"literal\"):\n block.add(Literal(value))\n elif token.group(\"lost_brace\"):\n # due to how parsing happens we can get a lonesome }\n # eg in format_string '{{something}' this fixes that issue\n block.add(Literal(value))\n elif token.group(\"command\"):\n # a block command has been found\n block.set_commands(token.group(\"command\"))\n elif token.group(\"escaped\"):\n # escaped characters add unescaped values\n if value[0] in [\"\\\\\", \"{\", \"}\"]:\n value = value[1:]\n block.add(Literal(value))\n\n if block.parent:\n raise Exception(\"Block not closed\")\n # add to the cache\n self.block_cache[format_string] = first_block","def createMemoryBlock(self, name: unicode, start: ghidra.program.model.address.Address, bytes: List[int], overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\n ...","def block(self):\n if self._block is None:\n bunchdt, block, data, commdct, idd_index, versiontuple = idfreader1(\n self.idfname, self.iddname, self, commdct=None, block=None\n )\n self._block = block\n self._idd_info = commdct\n self._idd_index = idd_index\n self._idfobjects = bunchdt\n self._model = data\n self._idd_version = versiontuple\n return self._block","def getBlock(self, blockName: unicode) -> ghidra.program.model.mem.MemoryBlock:\n ...","def new_block(self, proof, previous_hash=None):\n servers = [\n \"1.us.pool.ntp.org\",\n \"2.us.pool.ntp.org\",\n \"3.us.pool.ntp.org\"\n ]\n\n response = {}\n\n try:\n response = self.c.request('0.us.pool.ntp.org')\n except Exception:\n for server in servers:\n try:\n response = self.c.request(server)\n\n if response:\n break\n\n except Exception:\n print('\\n //// alternate ntp server didnt work')\n\n block = {\n 'message': 'New Block Forged',\n 'index': len(self.chain) + 1,\n 'timestamp': response.tx_time or time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.chain[-1]['hash'],\n }\n\n # Calculate the hash of this new Block\n block['hash'] = self.hash(block)\n\n # Reset the current list of transactions\n self.current_transactions = []\n\n self.chain.append(block)\n return block","async def refresh(self):\n block = await self.blockchain.rpc.get_block(self.identifier)\n if not block:\n raise BlockDoesNotExistsException\n await super(Block, self).__init__(\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\n )","def show_block_by_id(plugin, block_id):\n import alltheitems.item_page\n return alltheitems.item_page.item_page(plugin + ':' + block_id, block=True)","def create_block(self, x, y, block_type):\n sprite_stack = self.get_sprite(x, y)\n if sprite_stack:\n sprite = sprite_stack[-1]\n sprite.image = block_type\n return\n\n # no existing block, so create a new one\n block_x = x * self.block_x + self.offset_x + self.menu_x\n block_y = y * self.block_y + self.offset_y\n\n bar = Sprite(\"\", image_data=block_type, x=block_x, y=block_y)\n if (x, y) in self.sprites:\n self.sprites[(x, y)].append(bar)\n else:\n self.sprites[(x, y)] = [bar]","def create():\n config = request.data\n return add_scheduling_block(config)","async def create_block_type(self, block_type: BlockTypeCreate) -> BlockType:\n try:\n response = await self._client.post(\n \"/block_types/\",\n json=block_type.dict(\n json_compatible=True, exclude_unset=True, exclude={\"id\"}\n ),\n )\n except httpx.HTTPStatusError as e:\n if e.response.status_code == status.HTTP_409_CONFLICT:\n raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e\n else:\n raise\n return BlockType.parse_obj(response.json())","def create_block(self, proof, previous_hash=None):\n\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash,\n }\n\n # Reset current list of transactions\n self.current_transactions = []\n\n self.chain.append(block)\n return block","def create_genesis_block(self):\n index = 0\n transactions = []\n timestamp = 0.0\n previous_hash = \"0\"*64\n block = Block(index=index, transactions=transactions, timestamp=timestamp,previous_hash=previous_hash)\n block.hash = block.compute_hash()\n self.chain.append(block)","def define_block(identifier, block_tag, block_data, std_block_tag = None,\n std_tag = None):\n diff = INDENT - len(identifier)\n assert diff > 0, diff\n \n # if no std_tag info is defined, just make std_tag a no-op function\n if std_tag is None:\n def do_nothing(martel_info):\n return martel_info\n std_tag = do_nothing\n\n identifier_and_text = Martel.Str(identifier) + \\\n Martel.Rep(Martel.Str(\" \")) + \\\n std_tag(Martel.UntilEol(block_data)) + \\\n Martel.AnyEol()\n indented_text = Martel.Str(\" \"*INDENT) + \\\n std_tag(Martel.UntilEol(block_data)) + \\\n Martel.AnyEol()\n block_info = Martel.Group(\n block_tag,\n identifier_and_text +\n Martel.Rep(Martel.Alt(Martel.AnyEol(), indented_text))\n )\n # tag the info as some standard Martel element if specified\n if std_block_tag is not None:\n block_info = std_block_tag(block_info)\n\n return block_info","def _check_for_new_block() -> None:\n logging.debug(\"Checking for new block\")\n CAPACITY = block.get_capacity()\n\n r = util.get_db()\n with r.lock(\"blockchain:last_block:lock\"), \\\n r.lock(\"blockchain:miner_pid:lock\"), \\\n r.lock(\"blockchain:tx_pool:lock\"), \\\n r.lock(\"blockchain:utxo-block:lock\"):\n # NOTE: If a miner is running, we expect it to add a new block, so we\n # abort. If mining succeeds, this function will be called again by\n # new_recv_block(). If it fails (another valid block is received) this\n # will again be called by new_recv_block()\n miner_pidb = r.get(\"blockchain:miner_pid\")\n if miner_pidb is not None:\n logging.debug(\"Miner already running with PID %d\", util.btoui(miner_pidb))\n return\n\n tx_pool = {Transaction.loadb(tb) for tb in r.hvals(\"blockchain:tx_pool\")}\n if len(tx_pool) < CAPACITY:\n logging.debug(\"Cannot create new block yet (not enough transactions)\")\n return\n\n last_block = get_block()\n utxo_block = {TransactionInput.loadb(i): TransactionOutput.loadb(o) for i, o \\\n in r.hgetall(\"blockchain:utxo-block:\".encode() + last_block.current_hash).items()}\n new_block_tx: List[Transaction] = []\n # NOTE: Since there are >= CAPACITY transactions in the pool, and we\n # don't mind transaction inter-dependence in the same block, a new\n # block can be created, so this loop will terminate\n while True:\n for t in tx_pool:\n # Search for t.inputs in UTXO-block[last_block] as well as in new_block_tx\n if all(i in utxo_block or \\\n any(nt.id == i.transaction_id for nt in new_block_tx) for i in t.inputs):\n new_block_tx.append(t)\n if len(new_block_tx) == CAPACITY:\n new_block = Block(index=last_block.index + 1,\n previous_hash=last_block.current_hash,\n transactions=new_block_tx)\n # NOTE: We don't delete the new block_tx from the pool, because\n # mining might fail. They will be deleted eventually when they\n # enter the main branch.\n miner_pid = new_block.finalize()\n r.set(\"blockchain:miner_pid\", util.uitob(miner_pid))\n logging.debug(\"Miner started with PID %d\", miner_pid)\n return\n tx_pool.difference_update(new_block_tx)","def getBlock(self) -> ghidra.program.model.correlate.Block:\n ...","def MakeBlock(self, *args):\n return _BRepAlgo.BRepAlgo_EdgeConnector_MakeBlock(self, *args)","def block(self, cid):\n with self.block_cache.get_or_lock(cid) as (in_cache, value):\n if in_cache:\n return value\n\n if self._is_object(cid):\n # object\n object_data = self._load_object(cid)\n return object_data.Data\n\n elif self._is_raw_block(cid):\n # raw block\n block = self.client.block.get(cid, **self.client_request_kwargs)\n self.block_cache[cid] = block\n return block\n\n else:\n # unknown object type\n raise InvalidIPFSPathException()","def get_block(self, crypto, block_height='', block_number='', latest=False):\n raise NotImplementedError(\n \"This service does not support getting getting block data. \"\n \"Or rather it has no defined 'get_block' method.\"\n )","def add_block(self, env, block_color, width, height):\n\n block_size = (0.04, 0.04, 0.04)\n block_urdf = \"stacking/block.urdf\"\n block_pose = self.get_random_pose(env, block_size)\n block_id = env.add_object(block_urdf, block_pose)\n pb.changeVisualShape(\n block_id, -1, rgbaColor=utils.COLORS[block_color] + [1])\n # (0, None): 0 means that the block is symmetric.\n # TODO(hagrawal): Not sure what None means. Update. This is kept\n # for CLIPort compatibility. We don't use it.\n self.blocks.append((block_id, (0, None)))\n block_pix = utils.xyz_to_pix(block_pose[0], self.bounds, self.pix_size)\n block_obj_info = {\n \"obj_id\": block_id,\n \"pose\": block_pose,\n \"size\": block_size,\n \"urdf\": block_urdf,\n \"color\": block_color,\n \"unknown_color\": block_color in utils.EVAL_COLORS,\n \"pix\": block_pix,\n \"region\": determine_region(block_pix[0], block_pix[1], width, height),\n }\n return block_obj_info","def createBitMappedBlock(self, name: unicode, start: ghidra.program.model.address.Address, mappedAddress: ghidra.program.model.address.Address, length: long, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\n ...","def get_block_id(zone_id: int, position: CommonVector3, surface_level: int) -> int:\n return build_buy.get_block_id(zone_id, position, surface_level)","def genesisBlock():\n return Block(0, \"0\", 1465154705, \"my genesis block!!\",\n \"816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7\");","def add_block(block_id):\n if not g.user or g.user.id == block_id:\n flash(\"Access unauthorized.\", \"danger\")\n return redirect(\"/\")\n\n blocked_user = User.query.get_or_404(block_id)\n g.user.blocked_users.append(blocked_user)\n\n if g.user.is_following(blocked_user):\n g.user.following.remove(blocked_user)\n \n if blocked_user.is_following(g.user):\n blocked_user.following.remove(g.user)\n\n\n db.session.commit()\n\n return redirect(f\"/users/{g.user.id}/blocked-users\")","def new_block(self, proof, previous_hash=None):\n \n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n\n # Reset the current list of transactions\n self.current_transactions = []\n # Add block to existing chain\n self.chain.append(block)\n return block","def block_eid(self, block_id):\n ...","def nextblock(self, parent=None, **kwargs):\n block = self.newblock(parent, **kwargs)\n if not parent and self.block:\n self.block.add_child(block)\n\n self.block = block\n return block","def createInitializedBlock(self, name: unicode, start: ghidra.program.model.address.Address, fileBytes: ghidra.program.database.mem.FileBytes, offset: long, size: long, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\n ...","def get_ipblock(self, ipblock_id):\n response = self._perform_request('/ipblocks/%s' % ipblock_id)\n return response","def block_by_id(self, uid: int) -> None:\n self.api.block(uid)","def get_block(self, chunk, coords):\n\n return chunk.get_block(coords)","def createMemoryBlock(self, name: unicode, start: ghidra.program.model.address.Address, input: java.io.InputStream, length: long, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\n ...","def _do_add_block(self, args):\r\n bus_type = args[1]\r\n slave_id = int(args[2])\r\n name = args[3]\r\n block_type = int(args[4])\r\n starting_address = int(args[5])\r\n length = int(args[6])\r\n if bus_type == 'rtu':\r\n slave = self.server._servers[0].get_slave(slave_id)\r\n elif bus_type == 'tcp':\r\n slave = self.server._servers[1].get_slave(slave_id)\r\n slave.add_block(name, block_type, starting_address, length)\r\n return name","def new_block(self, proof, previous_hash=None):\n\n\t\tblock = {\n\t\t\t'index': len(self.chain) + 1,\n\t\t\t'timestamp': time(),\n\t\t\t'transactions': self.current_transactions,\n\t\t\t'proof': proof,\n\t\t\t'previous_hash': previous_hash or self.hash(self.chain[-1]),\t\t\n\t\t}\n\n\t\t#Reset current list of transactions\n\t\tself.current_transactions = []\n\n\t\tself.chain.append(block)\n\t\treturn block","def GetBlock(self):\n return self._block","def stringToBlock(strBlock):\r\n blocksplit = strBlock.split(';')\r\n block = Blockchain(int(blocksplit[0]), blocksplit[1], int(blocksplit[2]), int(blocksplit[3]) ,blocksplit[4])\r\n return block","def createGenesisBlock(self):\n return Block(\"Genesis Block\")","def get_best_block(self, node):\n block_height = node.getblockcount()\n blockhash = node.getblockhash(block_height)\n block = FromHex(CBlock(), node.getblock(blockhash, 0))\n block.calc_sha256()\n self.block_heights[block.sha256] = block_height\n return block","def create_hard_block_at(self, x, y):\n cell_size = self.map.get_cell_size()\n obj = HardBlock(\n parent=self.map,\n style={\n 'width': cell_size, \n 'height': cell_size * 2, \n 'z-index': layers['object'] }\n )\n # I am a hard block, I can stop the fire without being destroyed\n fireblocking(block(obj))\n\n self.map.add_node(obj, x, y, 0, -cell_size)\n return obj","def get_block_from_node(node):\n coords = node.name.split(\",\") # name format is '(row,col)'\n col = int((coords[1])[:-1])\n row = int((coords[0])[1:])\n return Block(row, col)","def create_block():\n global BLOCK\n posx = SEG_SIZE * random.randint(1, (WIDTH-SEG_SIZE) / SEG_SIZE)\n posy = SEG_SIZE * random.randint(1, (HEIGHT-SEG_SIZE) / SEG_SIZE)\n BLOCK = c.create_oval(posx, posy,\n posx+SEG_SIZE, posy+SEG_SIZE,\n fill=\"red\")\n # print(posx, posy)\n return posx, posy","def new_block(self, previous_hash):\n\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'information': self.current_information,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n\n # Reset the current list of transactions\n self.current_information = []\n\n self.chain.append(block)\n return block","def seed(cls, block: Expr) -> Expr:\n return cls(BlockField.block_seed, block)","def get_building_block(self, vertex_id):\n\n return self._graph_state.get_building_block(vertex_id)","async def get_block(self, api_params: dict) -> Optional[str]:\n\n height: int = api_params['height']\n transform_id: str = api_params['transform_id']\n\n db = self.transform_storage_dbs[transform_id]\n key = str(height).encode()\n value = db.get(key)\n value = value.decode() if value else value\n\n return value","def get_label_block(self, name):\n if name in self.labeled_blocks:\n block = self.labeled_blocks[name]\n else:\n block = self.builder.new_block()\n self.labeled_blocks[name] = block # TODO: use name\n return block","def getMemoryBlock(self, name: unicode) -> ghidra.program.model.mem.MemoryBlock:\n ...","def createInitializedBlock(self, name: unicode, start: ghidra.program.model.address.Address, is_: java.io.InputStream, length: long, monitor: ghidra.util.task.TaskMonitor, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\n ...","def new_block(self, proof, previous_hash=None):\n block = {\n 'index': len( self.chain ) + 1,\n 'timestamp': time(),\n 'transactions': self.current_transactions,\n 'merkle': self.hash(self.current_transactions),\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1])\n }\n\n # Reset the current list of transactions\n self.current_transactions = []\n\n # Add the block to the chain\n self.chain.append( block )\n self._write_chain()\n\n return block","def getblock(self, hash):\n return self.proxy.getblock(hash)","def new_block(self, proof, previous_hash=None):\n block = {\n 'index': len(self.chain) + 1,\n 'timestamp': time(),\n 'transactions':self.current_transactions,\n 'proof': proof,\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\n }\n self.current_transactions = []\n self.chain.append(block)\n return block","def add_blocks(self, block_id, positions, rotations=None, offset=None):\n # check if block_id is known\n assert block_id in block_config, \"Unknown block id: {}\".format(block_id)\n for idx_position, position in enumerate(positions):\n if rotations:\n rotation = rotations[idx_position]\n assert rotation < 32, \"Invalid rotation: {}\".format(rotation) # (1 << 5)\n # the rotations correspond to the last 5 bits of the state (int_24)\n block_id += (rotation << 19)\n new_block = block_pool(block_id)\n if offset:\n self.smd3.add_block(new_block, (position[0]+offset[0], position[1]+offset[1], position[2]+offset[2]))\n else:\n self.smd3.add_block(new_block, tuple(position))\n self.logic.update(self.smd3)\n self.header.update(self.smd3)","def mine():\n last_block = blockchain.get_last_block\n print(last_block)\n last_proof = last_block['proof']\n proof = blockchain.proof_of_work(last_proof)\n\n blockchain.add_transaction(sender=0, recipient=node_identifier, amount=1)\n block = blockchain.add_block(proof)\n block['message'] = 'New block added'\n\n return jsonify(block), 200","def create_origin_block(self):\n # creating a new hash object and finding new hash with empty string.\n hash = hashlib.sha256()\n hash.update(''.encode('utf-8'))\n # Instantiating a new block with data 'Origin', and for previous hash we'll give the hash generated by empty string\n origin_block = Block('Origin', hash)\n # Mine the block with the difficulty level of the chain\n origin_block.mine(self.difficulty)\n # Appending it to the mined block list\n self.blocks.append(origin_block)","def create_block_message(self, block):\n msg = poet_transaction_block.PoetTransactionBlockMessage()\n msg.TransactionBlock = block\n return msg","def create_genesis(self):\n return Block(0, 0, b'0', b'0', b'')","def _get_block(self, pos):\n return _get_mc().getBlock(pos)"],"string":"[\n \"def create_block(world: World, block_id: str, x: int, y: int, *args):\\n block_id = BLOCKS[block_id]\\n if block_id == \\\"mystery_empty\\\":\\n block = MysteryBlock()\\n elif block_id == \\\"mystery_coin\\\":\\n block = MysteryBlock(drop=\\\"coin\\\", drop_range=(3, 6))\\n elif block_id == \\\"bounce_block\\\":\\n block = BounceBlock()\\n elif block_id == \\\"flag\\\":\\n block = Flagpole()\\n elif block_id == \\\"tunnel\\\":\\n block = Tunnel()\\n elif block_id == \\\"switch\\\":\\n block = Switch()\\n else:\\n block = Block(block_id)\\n\\n world.add_block(block, x * BLOCK_SIZE, y * BLOCK_SIZE)\",\n \"def gen_new_block(self):\\n block = BasicBlock()\\n self.blocks.append(block)\\n return block\",\n \"def createBlock(self, block: ghidra.program.model.mem.MemoryBlock, name: unicode, start: ghidra.program.model.address.Address, length: long) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def create_block(self):\\n return poet_transaction_block.PoetTransactionBlock()\",\n \"def FindOrCreateBlock(self, name, instance):\\n try:\\n return self.FindBlock(name, instance)\\n except KeyError:\\n return self.CreateBlock({'name': name, 'instance': instance})\",\n \"def create_block(self, complete_hash, nonce):\\n print(\\\"Creating block with hash: '%s'\\\" % complete_hash)\\n block = Block(complete_hash, nonce)\\n for transaction in self.transactions:\\n block.add_transaction(transaction)\\n return block\",\n \"def get_a_block(self, usage_id=None):\\r\\n scope_ids = Mock()\\r\\n if usage_id is None:\\r\\n usage_id = \\\"_auto%d\\\" % len(self.all_blocks)\\r\\n scope_ids.usage_id = usage_id\\r\\n block = self.system.construct_xblock_from_class(\\r\\n self.TestableInheritingXBlock,\\r\\n field_data=self.field_data,\\r\\n scope_ids=scope_ids,\\r\\n )\\r\\n self.all_blocks[usage_id] = block\\r\\n return block\",\n \"def _new_block(self, user_id, category, block_fields, definition_id, new_id, raw=False,\\n asides=None, block_defaults=None):\\n if not raw:\\n block_fields = self._serialize_fields(category, block_fields)\\n if not asides:\\n asides = {}\\n document = {\\n 'block_type': category,\\n 'definition': definition_id,\\n 'fields': block_fields,\\n 'asides': asides,\\n 'edit_info': {\\n 'edited_on': datetime.datetime.now(UTC),\\n 'edited_by': user_id,\\n 'previous_version': None,\\n 'update_version': new_id\\n }\\n }\\n if block_defaults:\\n document['defaults'] = block_defaults\\n return BlockData(**document)\",\n \"def create_block(self, prev_hash=None):\\n # Update blockchain and balance state (thread safe)\\n if prev_hash is not None and prev_hash not in self._blockchain.hash_block_map.keys():\\n print(prev_hash, self._blockchain.hash_block_map)\\n prev_blk = None if prev_hash is None else \\\\\\n self._blockchain.hash_block_map[prev_hash]\\n last_blk = self._update(prev_blk)\\n pending_tx = self._get_tx_pool()\\n gathered_tx = self._gather_transactions(pending_tx)\\n block = self._mine_new_block(last_blk.header, gathered_tx)\\n if block is not None:\\n blk_json = block.to_json()\\n # Add block to blockchain (thread safe)\\n self.add_block(blk_json)\\n print(f\\\"{self.__class__.__name__} {self.name} created a block.\\\")\\n # Broadcast block and the header.\\n self._broadcast_block(block)\\n # Remove gathered transactions from pool and them to added pile\\n with self.added_tx_lock:\\n self._added_transactions |= set(gathered_tx)\\n self._update()\\n return block\",\n \"def _new_block(self, user_id, category, block_fields, definition_id, new_id, raw=False):\\r\\n if not raw:\\r\\n block_fields = self._serialize_fields(category, block_fields)\\r\\n return {\\r\\n 'category': category,\\r\\n 'definition': definition_id,\\r\\n 'fields': block_fields,\\r\\n 'edit_info': {\\r\\n 'edited_on': datetime.datetime.now(UTC),\\r\\n 'edited_by': user_id,\\r\\n 'previous_version': None,\\r\\n 'update_version': new_id\\r\\n }\\r\\n }\",\n \"def new_block(self):\\n child = Block(self, py3_wrapper=self.py3_wrapper)\\n self.add(child)\\n return child\",\n \"def get_block(self, usage_id, for_parent=None):\\n def_id = self.id_reader.get_definition_id(usage_id)\\n try:\\n block_type = self.id_reader.get_block_type(def_id)\\n except NoSuchDefinition:\\n raise NoSuchUsage(repr(usage_id)) # pylint: disable= raise-missing-from\\n keys = ScopeIds(self.user_id, block_type, def_id, usage_id)\\n block = self.construct_xblock(block_type, keys, for_parent=for_parent)\\n return block\",\n \"def createNewBlock(self, nonce, previousBlockHash, hash):\\n newBlock = Block(len(self.chain), self.pendingTransactions, nonce, hash, previousBlockHash)\\n self.pendingTransactions = []\\n self.chain.append(newBlock)\\n return newBlock\",\n \"def createFirstBlock(self):\\n firstBlock = Block(0, self.__currentTransactionsList, 0, '00')\\n self.__chain.append(firstBlock)\",\n \"def newBlock(preBlock, remitter, number, payee):\\r\\n index = preBlock.index + 1\\r\\n timestamp = int(round(time.time() * 1000))\\r\\n data = (remitter, number, payee).__str__()\\r\\n previousHash = preBlock.hash\\r\\n nounce = 0\\r\\n return Blockchain(index, data, timestamp, nounce, previousHash)\",\n \"def create_block_from_xml(xml_data, system, id_generator):\\r\\n node = etree.fromstring(xml_data)\\r\\n raw_class = system.load_block_type(node.tag)\\r\\n xblock_class = system.mixologist.mix(raw_class)\\r\\n\\r\\n # leave next line commented out - useful for low-level debugging\\r\\n # log.debug('[create_block_from_xml] tag=%s, class=%s' % (node.tag, xblock_class))\\r\\n\\r\\n block_type = node.tag\\r\\n url_name = node.get('url_name')\\r\\n def_id = id_generator.create_definition(block_type, url_name)\\r\\n usage_id = id_generator.create_usage(def_id)\\r\\n\\r\\n scope_ids = ScopeIds(None, block_type, def_id, usage_id)\\r\\n xblock = xblock_class.parse_xml(node, system, scope_ids, id_generator)\\r\\n\\r\\n _convert_reference_fields_to_keys(xblock)\\r\\n\\r\\n return xblock\",\n \"def build_new_block(cls, data='', previous_block=None):\\n if previous_block:\\n new_index = previous_block.index+1\\n previous_hash = previous_block.hash\\n else:\\n new_index = 0\\n previous_hash = ''\\n timestamp = int(time.time())\\n block_hash = cls.build_block_hash(\\n index=new_index,\\n timestamp=timestamp,\\n data=data,\\n previous_hash=previous_hash\\n )\\n block = cls(\\n index=new_index,\\n previous_hash=previous_hash,\\n data=data,\\n timestamp=timestamp,\\n block_hash=block_hash\\n )\\n\\n return block\",\n \"def get_block_obj(self, vault_id, block_id):\\n path = self._get_block_path(vault_id, block_id)\\n\\n if not os.path.exists(path):\\n return None\\n\\n return open(path, 'rb')\",\n \"def new_block(self, proof, previous_hash=None):\\n\\n # Create the block\\n my_block = Block(proof=proof,\\n previous_hash=previous_hash or self.hash(self.last_block))\\n my_block.save()\\n\\n # Update current_transactions with this new block.\\n my_block_trans = self.current_transactions_obj\\n\\n for trans in Transaction.objects.filter(block__isnull=True):\\n trans.block = my_block\\n trans.save()\\n\\n block = {\\n 'index': my_block.id,\\n 'timestamp': my_block.timestamp,\\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\\n 'proof': my_block.proof,\\n 'previous_hash': my_block.previous_hash,\\n }\\n\\n return block\",\n \"def get_block(block_id: Optional[bytes] = None) -> Optional[Block]:\\n if block_id is not None and not isinstance(block_id, bytes):\\n raise TypeError\\n if block_id is None:\\n logging.debug(\\\"Last block requested\\\")\\n else:\\n logging.debug(\\\"Block %s requested\\\", util.bintos(block_id))\\n\\n r = util.get_db()\\n if block_id is None:\\n block_id = r.get(\\\"blockchain:last_block\\\")\\n if block_id is None:\\n # The blockchain is empty\\n logging.debug(\\\"Blockchain is empty\\\")\\n return None\\n\\n blockb = r.hget(\\\"blockchain:blocks\\\", block_id)\\n if blockb is None:\\n # Requested block not found\\n logging.debug(\\\"Block %s not found\\\", util.bintos(block_id))\\n return None\\n\\n logging.debug(\\\"Block %s retrieved\\\", util.bintos(block_id))\\n return Block.loadb(blockb)\",\n \"def get(block_id):\\n _url = get_root_url()\\n try:\\n block = DB.get_block_details([block_id]).__next__()\\n response = block\\n\\n response['links'] = {\\n 'self': '{}'.format(request.url),\\n 'list': '{}/processing-blocks'.format(_url),\\n 'home': '{}'.format(_url)\\n }\\n return block\\n except IndexError as error:\\n response = dict(message='Unable to GET Processing Block',\\n id='{}'.format(block_id),\\n error=error.__str__())\\n response['links'] = {\\n 'list': '{}/processing-blocks'.format(_url),\\n 'home': '{}'.format(_url)\\n }\\n return response, HTTPStatus.NOT_FOUND\",\n \"def _get_block_from_structure(self, structure, block_id):\\r\\n return structure['blocks'].get(LocMapperStore.encode_key_for_mongo(block_id))\",\n \"def create_block(self, nonce, previous_hash):\\n block = {'block_number': transaction_blocks.count() + 1,\\n 'timestamp': ctime(t),\\n 'transactions': self.transactions,\\n 'nonce': nonce,\\n 'previous_hash': previous_hash}\\n\\n # Reset the current list of transactions\\n self.transactions = []\\n self.chain.append(block)\\n return block\",\n \"def NewBlock(self):\\n for i in self.matrix:\\n if 2 in i:\\n return()\\n blockType = self.bag.Choose()\\n subtractor = {\\\"I\\\" : 4, \\\"J\\\" : 3, \\\"L\\\" : 3, \\\"O\\\" : 2, \\\"S\\\" : 3, \\\"T\\\" : 3, \\\"Z\\\": 3}\\n x = random.randint(0, self.width - subtractor.get(blockType))\\n coords = []\\n if blockType == \\\"I\\\":\\n coords = [(x + i, 0) for i in range(4)]\\n elif blockType == \\\"J\\\":\\n coords = [(x + i, 0) for i in range(3)]\\n coords.append((x, 1))\\n elif blockType == \\\"L\\\":\\n coords = [(x + i, 0) for i in range(3)]\\n coords.append((x + 2, 1))\\n elif blockType == \\\"O\\\":\\n coords = [(x, 0), (x + 1, 0), (x, 1), (x + 1, 1)]\\n elif blockType == \\\"Z\\\":\\n coords = [(x, 0), (x + 1, 0), (x + 1, 1), (x + 2, 1)]\\n elif blockType == \\\"S\\\":\\n coords = [(x + 1, 0), (x + 2, 0), (x, 1), (x + 1, 1)]\\n elif blockType == \\\"T\\\":\\n coords = [(x, 0), (x + 1, 0), (x + 2, 0), (x + 1, 1)]\\n self.coords = coords\\n return(coords)\",\n \"def create_genesis_block(self):\\r\\n genesis_block = Block(0, [], time.time(), \\\"0\\\")\\r\\n genesis_block.hash = genesis_block.compute_hash()\\r\\n self.chain.append(genesis_block)\",\n \"def create_block(type: str, color_key, position):\\n if type not in BlockCreator.types.keys():\\n raise BlockCreator.IncorrectBlockType\\n image_name = BlockCreator.types[type]\\n return Block(image_name, color_key, position)\",\n \"def create_block(self, previous_hash):\\r\\n if len(self.transaction_pool) < 1:\\r\\n return None, None\\r\\n\\r\\n # Create A Temporary Block\\r\\n block = {'index': None, # before mining set index to None\\r\\n 'timestamp': None, # before mining set timestamp to None\\r\\n 'nonce': 0, # before mining set nonce to 0\\r\\n 'transactions': self.transaction_pool, # Fill in all the transactions\\r\\n 'previous_hash': previous_hash, # Set the previous hash\\r\\n 'current_hash': ''} # Current hash is yet to be calculated\\r\\n\\r\\n # Empty Transaction Pool\\r\\n self.transaction_pool = [] # Once transactions have been placed in a block\\r\\n # they can be removed from the pool\\r\\n\\r\\n # Calculate Proof Of Work (Nonce)\\r\\n block['nonce'], block['current_hash'] = self.proof_of_work(block, previous_hash) # Validate the block by calculating the nonce\\r\\n block['index'] = len(self.chain) + 1 # Set the block index\\r\\n block['timestamp'] = str(datetime.datetime.now()) # Set the timestamp to the time when the block was validated\\r\\n\\r\\n # Add Block To DistrictNode's Own Chain\\r\\n self.chain.append(block) # Append the block to the list of blocks in the blockchain\\r\\n print(\\\"BLOCK ADDED TO 90\\\")\\r\\n for block in self.chain:\\r\\n for key, value in block.items():\\r\\n print(key, value)\\r\\n print('\\\\n')\\r\\n\\r\\n return self.chain, self.transaction_pool # Return the new chain and the new transaction_pool\\r\",\n \"def save_block(self, drip_campaign_id, start_time, nodes_id):\\n new_block = Block(\\n drip_campaign_id=drip_campaign_id,\\n start_time=start_time,\\n nodes_id=nodes_id\\n )\\n new_block.save()\",\n \"def create_genesis_block(self):\\n genesis_block = Block(0, [], time.time(), \\\"0\\\")\\n genesis_block.hash = genesis_block.compute_hash()\\n self.chain.append(genesis_block)\",\n \"def makeBlock(tag):\\n return {\\\"t\\\":\\\"RawBlock\\\",\\\"c\\\":[\\\"html\\\",tag]}\",\n \"def new_block(self, proof, previous_hash = None):\\n #create a new Block & adds it to the chain.\\n \\n block = {\\n 'index' : len(self.chain) + 1,\\n 'timestamp' : time(),\\n 'transactions' : self.pending_transactions,\\n 'proof' : proof,\\n 'previous_hash' : previous_hash or self.hash(self.chain[-1])\\n }\\n\\n # Reset the current list of transactions\\n self.pending_transactions = []\\n\\n self.chain.append(block)\\n return block\\n #pass\",\n \"def get_random_block(a=0, b=269400):\\n height = random.randint(a, b)\\n return get_block(get_block_hash(height))\",\n \"def newblock(self, parent=None):\\n block = ControlBlock()\\n self.blocks.add(block)\\n if parent:\\n parent.add_child(block)\\n return block\",\n \"def create_block(data: str, leading_zeros: int) -> Block:\\n MAX_NONCE_VALUE = 2 ** 32\\n\\n nonce = 0\\n created_block = None\\n\\n potential_block = Block(data, nonce)\\n\\n while potential_block.nonce != MAX_NONCE_VALUE:\\n potential_block_hash = potential_block.get_hash()\\n binary_block_hash = get_binary_sha256_hash(potential_block_hash)\\n\\n if binary_block_hash[:leading_zeros] == \\\"0\\\" * leading_zeros:\\n potential_block.hash = potential_block_hash\\n potential_block.store()\\n created_block = potential_block\\n\\n break\\n else:\\n potential_block.nonce += 1\\n\\n return created_block\",\n \"def get_block(blockhash):\\n return requests.get(BASE+f'/api/block/{blockhash}').json()\",\n \"def add_block(self, env):\\n block_size = (0.04, 0.04, 0.04)\\n block_pose = self.random_pose(env, block_size)\\n block_urdf = 'assets/stacking/block.urdf'\\n block_id = env.add_object(block_urdf, block_pose)\\n self.object_points[block_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n self._IDs[block_id] = 'block'\\n return block_id\",\n \"def create_genesis_block(self):\\n genesis_block = Block(0, [], 0, \\\"0\\\")\\n genesis_block.hash = genesis_block.compute_hash()\\n self.chain.append(genesis_block)\",\n \"def create_genesis_block(self):\\n genesis_block = Block(0, [], 0, \\\"0\\\")\\n genesis_block.hash = genesis_block.compute_hash()\\n self.chain.append(genesis_block)\",\n \"def addBlock(self, data):\\n #get the hashVal of last block in blockchain\\n lastHash = self.chain[len(self.chain) - 1].hashVal\\n timestamp = time()\\n hashVal = Block.hashSHA(timestamp, lastHash, data, NONCE, DIFFICULTY)\\n adding_block = Block(timestamp, lastHash, hashVal, data, NONCE, DIFFICULTY)\\n \\n self.chain.append(adding_block)\\n return adding_block\",\n \"def get_block_id(self):\\n return self._block_id\",\n \"def make_genesis_block():\\n block = Block(index=0,\\n timestamp=datetime.now(),\\n data=\\\"Genesis Block\\\",\\n previous_hash=\\\"0\\\")\\n return block\",\n \"async def new_block(request: Request) -> dict:\\n block: dict = await request.json()\\n block = await chain.add_block(block)\\n response_block = Block(**block).to_dict()\\n\\n miner_ip = f\\\"{request.client.host}:{request.client.port}\\\"\\n for node in chain.peers:\\n async with httpx.AsyncClient() as client:\\n _ = await client.get(f\\\"{node}/\\\")\\n temp_chain = {f\\\"Block-{height}\\\": data.to_dict()\\n for height, data in enumerate(chain.serialized)}\\n return {\\\"miner_address\\\": miner_ip,\\n \\\"latest_block\\\": response_block.dict(),\\n \\\"new_chain\\\": temp_chain, }\",\n \"def newblock(self, parent=None, **kwargs):\\n block = ControlBlock(len(self.blocks), **kwargs)\\n self.blocks.append(block)\\n if parent:\\n parent.add_child(block)\\n\\n return block\",\n \"def create_block(self, nonce, previous_hash) -> None:\\n block = {\\n 'block_number': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions': self.transactions,\\n 'nonce': nonce,\\n 'previous_hash': previous_hash\\n }\\n\\n self.transactions = []\\n self.chain.append(block)\",\n \"def build_block(self, format_string):\\n first_block = Block(None, py3_wrapper=self.py3_wrapper)\\n block = first_block\\n\\n # Tokenize the format string and process them\\n for token in self.tokens(format_string):\\n value = token.group(0)\\n if token.group(\\\"block_start\\\"):\\n # Create new block\\n block = block.new_block()\\n elif token.group(\\\"block_end\\\"):\\n # Close block setting any valid state as needed\\n # and return to parent block to continue\\n if not block.parent:\\n raise Exception(\\\"Too many `]`\\\")\\n block = block.parent\\n elif token.group(\\\"switch\\\"):\\n # a new option has been created\\n block = block.switch()\\n elif token.group(\\\"placeholder\\\"):\\n # Found a {placeholder}\\n key = token.group(\\\"key\\\")\\n format = token.group(\\\"format\\\")\\n block.add(Placeholder(key, format))\\n elif token.group(\\\"literal\\\"):\\n block.add(Literal(value))\\n elif token.group(\\\"lost_brace\\\"):\\n # due to how parsing happens we can get a lonesome }\\n # eg in format_string '{{something}' this fixes that issue\\n block.add(Literal(value))\\n elif token.group(\\\"command\\\"):\\n # a block command has been found\\n block.set_commands(token.group(\\\"command\\\"))\\n elif token.group(\\\"escaped\\\"):\\n # escaped characters add unescaped values\\n if value[0] in [\\\"\\\\\\\\\\\", \\\"{\\\", \\\"}\\\"]:\\n value = value[1:]\\n block.add(Literal(value))\\n\\n if block.parent:\\n raise Exception(\\\"Block not closed\\\")\\n # add to the cache\\n self.block_cache[format_string] = first_block\",\n \"def createMemoryBlock(self, name: unicode, start: ghidra.program.model.address.Address, bytes: List[int], overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def block(self):\\n if self._block is None:\\n bunchdt, block, data, commdct, idd_index, versiontuple = idfreader1(\\n self.idfname, self.iddname, self, commdct=None, block=None\\n )\\n self._block = block\\n self._idd_info = commdct\\n self._idd_index = idd_index\\n self._idfobjects = bunchdt\\n self._model = data\\n self._idd_version = versiontuple\\n return self._block\",\n \"def getBlock(self, blockName: unicode) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def new_block(self, proof, previous_hash=None):\\n servers = [\\n \\\"1.us.pool.ntp.org\\\",\\n \\\"2.us.pool.ntp.org\\\",\\n \\\"3.us.pool.ntp.org\\\"\\n ]\\n\\n response = {}\\n\\n try:\\n response = self.c.request('0.us.pool.ntp.org')\\n except Exception:\\n for server in servers:\\n try:\\n response = self.c.request(server)\\n\\n if response:\\n break\\n\\n except Exception:\\n print('\\\\n //// alternate ntp server didnt work')\\n\\n block = {\\n 'message': 'New Block Forged',\\n 'index': len(self.chain) + 1,\\n 'timestamp': response.tx_time or time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.chain[-1]['hash'],\\n }\\n\\n # Calculate the hash of this new Block\\n block['hash'] = self.hash(block)\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n\\n self.chain.append(block)\\n return block\",\n \"async def refresh(self):\\n block = await self.blockchain.rpc.get_block(self.identifier)\\n if not block:\\n raise BlockDoesNotExistsException\\n await super(Block, self).__init__(\\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\\n )\",\n \"def show_block_by_id(plugin, block_id):\\n import alltheitems.item_page\\n return alltheitems.item_page.item_page(plugin + ':' + block_id, block=True)\",\n \"def create_block(self, x, y, block_type):\\n sprite_stack = self.get_sprite(x, y)\\n if sprite_stack:\\n sprite = sprite_stack[-1]\\n sprite.image = block_type\\n return\\n\\n # no existing block, so create a new one\\n block_x = x * self.block_x + self.offset_x + self.menu_x\\n block_y = y * self.block_y + self.offset_y\\n\\n bar = Sprite(\\\"\\\", image_data=block_type, x=block_x, y=block_y)\\n if (x, y) in self.sprites:\\n self.sprites[(x, y)].append(bar)\\n else:\\n self.sprites[(x, y)] = [bar]\",\n \"def create():\\n config = request.data\\n return add_scheduling_block(config)\",\n \"async def create_block_type(self, block_type: BlockTypeCreate) -> BlockType:\\n try:\\n response = await self._client.post(\\n \\\"/block_types/\\\",\\n json=block_type.dict(\\n json_compatible=True, exclude_unset=True, exclude={\\\"id\\\"}\\n ),\\n )\\n except httpx.HTTPStatusError as e:\\n if e.response.status_code == status.HTTP_409_CONFLICT:\\n raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e\\n else:\\n raise\\n return BlockType.parse_obj(response.json())\",\n \"def create_block(self, proof, previous_hash=None):\\n\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash,\\n }\\n\\n # Reset current list of transactions\\n self.current_transactions = []\\n\\n self.chain.append(block)\\n return block\",\n \"def create_genesis_block(self):\\n index = 0\\n transactions = []\\n timestamp = 0.0\\n previous_hash = \\\"0\\\"*64\\n block = Block(index=index, transactions=transactions, timestamp=timestamp,previous_hash=previous_hash)\\n block.hash = block.compute_hash()\\n self.chain.append(block)\",\n \"def define_block(identifier, block_tag, block_data, std_block_tag = None,\\n std_tag = None):\\n diff = INDENT - len(identifier)\\n assert diff > 0, diff\\n \\n # if no std_tag info is defined, just make std_tag a no-op function\\n if std_tag is None:\\n def do_nothing(martel_info):\\n return martel_info\\n std_tag = do_nothing\\n\\n identifier_and_text = Martel.Str(identifier) + \\\\\\n Martel.Rep(Martel.Str(\\\" \\\")) + \\\\\\n std_tag(Martel.UntilEol(block_data)) + \\\\\\n Martel.AnyEol()\\n indented_text = Martel.Str(\\\" \\\"*INDENT) + \\\\\\n std_tag(Martel.UntilEol(block_data)) + \\\\\\n Martel.AnyEol()\\n block_info = Martel.Group(\\n block_tag,\\n identifier_and_text +\\n Martel.Rep(Martel.Alt(Martel.AnyEol(), indented_text))\\n )\\n # tag the info as some standard Martel element if specified\\n if std_block_tag is not None:\\n block_info = std_block_tag(block_info)\\n\\n return block_info\",\n \"def _check_for_new_block() -> None:\\n logging.debug(\\\"Checking for new block\\\")\\n CAPACITY = block.get_capacity()\\n\\n r = util.get_db()\\n with r.lock(\\\"blockchain:last_block:lock\\\"), \\\\\\n r.lock(\\\"blockchain:miner_pid:lock\\\"), \\\\\\n r.lock(\\\"blockchain:tx_pool:lock\\\"), \\\\\\n r.lock(\\\"blockchain:utxo-block:lock\\\"):\\n # NOTE: If a miner is running, we expect it to add a new block, so we\\n # abort. If mining succeeds, this function will be called again by\\n # new_recv_block(). If it fails (another valid block is received) this\\n # will again be called by new_recv_block()\\n miner_pidb = r.get(\\\"blockchain:miner_pid\\\")\\n if miner_pidb is not None:\\n logging.debug(\\\"Miner already running with PID %d\\\", util.btoui(miner_pidb))\\n return\\n\\n tx_pool = {Transaction.loadb(tb) for tb in r.hvals(\\\"blockchain:tx_pool\\\")}\\n if len(tx_pool) < CAPACITY:\\n logging.debug(\\\"Cannot create new block yet (not enough transactions)\\\")\\n return\\n\\n last_block = get_block()\\n utxo_block = {TransactionInput.loadb(i): TransactionOutput.loadb(o) for i, o \\\\\\n in r.hgetall(\\\"blockchain:utxo-block:\\\".encode() + last_block.current_hash).items()}\\n new_block_tx: List[Transaction] = []\\n # NOTE: Since there are >= CAPACITY transactions in the pool, and we\\n # don't mind transaction inter-dependence in the same block, a new\\n # block can be created, so this loop will terminate\\n while True:\\n for t in tx_pool:\\n # Search for t.inputs in UTXO-block[last_block] as well as in new_block_tx\\n if all(i in utxo_block or \\\\\\n any(nt.id == i.transaction_id for nt in new_block_tx) for i in t.inputs):\\n new_block_tx.append(t)\\n if len(new_block_tx) == CAPACITY:\\n new_block = Block(index=last_block.index + 1,\\n previous_hash=last_block.current_hash,\\n transactions=new_block_tx)\\n # NOTE: We don't delete the new block_tx from the pool, because\\n # mining might fail. They will be deleted eventually when they\\n # enter the main branch.\\n miner_pid = new_block.finalize()\\n r.set(\\\"blockchain:miner_pid\\\", util.uitob(miner_pid))\\n logging.debug(\\\"Miner started with PID %d\\\", miner_pid)\\n return\\n tx_pool.difference_update(new_block_tx)\",\n \"def getBlock(self) -> ghidra.program.model.correlate.Block:\\n ...\",\n \"def MakeBlock(self, *args):\\n return _BRepAlgo.BRepAlgo_EdgeConnector_MakeBlock(self, *args)\",\n \"def block(self, cid):\\n with self.block_cache.get_or_lock(cid) as (in_cache, value):\\n if in_cache:\\n return value\\n\\n if self._is_object(cid):\\n # object\\n object_data = self._load_object(cid)\\n return object_data.Data\\n\\n elif self._is_raw_block(cid):\\n # raw block\\n block = self.client.block.get(cid, **self.client_request_kwargs)\\n self.block_cache[cid] = block\\n return block\\n\\n else:\\n # unknown object type\\n raise InvalidIPFSPathException()\",\n \"def get_block(self, crypto, block_height='', block_number='', latest=False):\\n raise NotImplementedError(\\n \\\"This service does not support getting getting block data. \\\"\\n \\\"Or rather it has no defined 'get_block' method.\\\"\\n )\",\n \"def add_block(self, env, block_color, width, height):\\n\\n block_size = (0.04, 0.04, 0.04)\\n block_urdf = \\\"stacking/block.urdf\\\"\\n block_pose = self.get_random_pose(env, block_size)\\n block_id = env.add_object(block_urdf, block_pose)\\n pb.changeVisualShape(\\n block_id, -1, rgbaColor=utils.COLORS[block_color] + [1])\\n # (0, None): 0 means that the block is symmetric.\\n # TODO(hagrawal): Not sure what None means. Update. This is kept\\n # for CLIPort compatibility. We don't use it.\\n self.blocks.append((block_id, (0, None)))\\n block_pix = utils.xyz_to_pix(block_pose[0], self.bounds, self.pix_size)\\n block_obj_info = {\\n \\\"obj_id\\\": block_id,\\n \\\"pose\\\": block_pose,\\n \\\"size\\\": block_size,\\n \\\"urdf\\\": block_urdf,\\n \\\"color\\\": block_color,\\n \\\"unknown_color\\\": block_color in utils.EVAL_COLORS,\\n \\\"pix\\\": block_pix,\\n \\\"region\\\": determine_region(block_pix[0], block_pix[1], width, height),\\n }\\n return block_obj_info\",\n \"def createBitMappedBlock(self, name: unicode, start: ghidra.program.model.address.Address, mappedAddress: ghidra.program.model.address.Address, length: long, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def get_block_id(zone_id: int, position: CommonVector3, surface_level: int) -> int:\\n return build_buy.get_block_id(zone_id, position, surface_level)\",\n \"def genesisBlock():\\n return Block(0, \\\"0\\\", 1465154705, \\\"my genesis block!!\\\",\\n \\\"816534932c2b7154836da6afc367695e6337db8a921823784c14378abed4f7d7\\\");\",\n \"def add_block(block_id):\\n if not g.user or g.user.id == block_id:\\n flash(\\\"Access unauthorized.\\\", \\\"danger\\\")\\n return redirect(\\\"/\\\")\\n\\n blocked_user = User.query.get_or_404(block_id)\\n g.user.blocked_users.append(blocked_user)\\n\\n if g.user.is_following(blocked_user):\\n g.user.following.remove(blocked_user)\\n \\n if blocked_user.is_following(g.user):\\n blocked_user.following.remove(g.user)\\n\\n\\n db.session.commit()\\n\\n return redirect(f\\\"/users/{g.user.id}/blocked-users\\\")\",\n \"def new_block(self, proof, previous_hash=None):\\n \\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n # Add block to existing chain\\n self.chain.append(block)\\n return block\",\n \"def block_eid(self, block_id):\\n ...\",\n \"def nextblock(self, parent=None, **kwargs):\\n block = self.newblock(parent, **kwargs)\\n if not parent and self.block:\\n self.block.add_child(block)\\n\\n self.block = block\\n return block\",\n \"def createInitializedBlock(self, name: unicode, start: ghidra.program.model.address.Address, fileBytes: ghidra.program.database.mem.FileBytes, offset: long, size: long, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def get_ipblock(self, ipblock_id):\\n response = self._perform_request('/ipblocks/%s' % ipblock_id)\\n return response\",\n \"def block_by_id(self, uid: int) -> None:\\n self.api.block(uid)\",\n \"def get_block(self, chunk, coords):\\n\\n return chunk.get_block(coords)\",\n \"def createMemoryBlock(self, name: unicode, start: ghidra.program.model.address.Address, input: java.io.InputStream, length: long, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def _do_add_block(self, args):\\r\\n bus_type = args[1]\\r\\n slave_id = int(args[2])\\r\\n name = args[3]\\r\\n block_type = int(args[4])\\r\\n starting_address = int(args[5])\\r\\n length = int(args[6])\\r\\n if bus_type == 'rtu':\\r\\n slave = self.server._servers[0].get_slave(slave_id)\\r\\n elif bus_type == 'tcp':\\r\\n slave = self.server._servers[1].get_slave(slave_id)\\r\\n slave.add_block(name, block_type, starting_address, length)\\r\\n return name\",\n \"def new_block(self, proof, previous_hash=None):\\n\\n\\t\\tblock = {\\n\\t\\t\\t'index': len(self.chain) + 1,\\n\\t\\t\\t'timestamp': time(),\\n\\t\\t\\t'transactions': self.current_transactions,\\n\\t\\t\\t'proof': proof,\\n\\t\\t\\t'previous_hash': previous_hash or self.hash(self.chain[-1]),\\t\\t\\n\\t\\t}\\n\\n\\t\\t#Reset current list of transactions\\n\\t\\tself.current_transactions = []\\n\\n\\t\\tself.chain.append(block)\\n\\t\\treturn block\",\n \"def GetBlock(self):\\n return self._block\",\n \"def stringToBlock(strBlock):\\r\\n blocksplit = strBlock.split(';')\\r\\n block = Blockchain(int(blocksplit[0]), blocksplit[1], int(blocksplit[2]), int(blocksplit[3]) ,blocksplit[4])\\r\\n return block\",\n \"def createGenesisBlock(self):\\n return Block(\\\"Genesis Block\\\")\",\n \"def get_best_block(self, node):\\n block_height = node.getblockcount()\\n blockhash = node.getblockhash(block_height)\\n block = FromHex(CBlock(), node.getblock(blockhash, 0))\\n block.calc_sha256()\\n self.block_heights[block.sha256] = block_height\\n return block\",\n \"def create_hard_block_at(self, x, y):\\n cell_size = self.map.get_cell_size()\\n obj = HardBlock(\\n parent=self.map,\\n style={\\n 'width': cell_size, \\n 'height': cell_size * 2, \\n 'z-index': layers['object'] }\\n )\\n # I am a hard block, I can stop the fire without being destroyed\\n fireblocking(block(obj))\\n\\n self.map.add_node(obj, x, y, 0, -cell_size)\\n return obj\",\n \"def get_block_from_node(node):\\n coords = node.name.split(\\\",\\\") # name format is '(row,col)'\\n col = int((coords[1])[:-1])\\n row = int((coords[0])[1:])\\n return Block(row, col)\",\n \"def create_block():\\n global BLOCK\\n posx = SEG_SIZE * random.randint(1, (WIDTH-SEG_SIZE) / SEG_SIZE)\\n posy = SEG_SIZE * random.randint(1, (HEIGHT-SEG_SIZE) / SEG_SIZE)\\n BLOCK = c.create_oval(posx, posy,\\n posx+SEG_SIZE, posy+SEG_SIZE,\\n fill=\\\"red\\\")\\n # print(posx, posy)\\n return posx, posy\",\n \"def new_block(self, previous_hash):\\n\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'information': self.current_information,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n\\n # Reset the current list of transactions\\n self.current_information = []\\n\\n self.chain.append(block)\\n return block\",\n \"def seed(cls, block: Expr) -> Expr:\\n return cls(BlockField.block_seed, block)\",\n \"def get_building_block(self, vertex_id):\\n\\n return self._graph_state.get_building_block(vertex_id)\",\n \"async def get_block(self, api_params: dict) -> Optional[str]:\\n\\n height: int = api_params['height']\\n transform_id: str = api_params['transform_id']\\n\\n db = self.transform_storage_dbs[transform_id]\\n key = str(height).encode()\\n value = db.get(key)\\n value = value.decode() if value else value\\n\\n return value\",\n \"def get_label_block(self, name):\\n if name in self.labeled_blocks:\\n block = self.labeled_blocks[name]\\n else:\\n block = self.builder.new_block()\\n self.labeled_blocks[name] = block # TODO: use name\\n return block\",\n \"def getMemoryBlock(self, name: unicode) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def createInitializedBlock(self, name: unicode, start: ghidra.program.model.address.Address, is_: java.io.InputStream, length: long, monitor: ghidra.util.task.TaskMonitor, overlay: bool) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def new_block(self, proof, previous_hash=None):\\n block = {\\n 'index': len( self.chain ) + 1,\\n 'timestamp': time(),\\n 'transactions': self.current_transactions,\\n 'merkle': self.hash(self.current_transactions),\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1])\\n }\\n\\n # Reset the current list of transactions\\n self.current_transactions = []\\n\\n # Add the block to the chain\\n self.chain.append( block )\\n self._write_chain()\\n\\n return block\",\n \"def getblock(self, hash):\\n return self.proxy.getblock(hash)\",\n \"def new_block(self, proof, previous_hash=None):\\n block = {\\n 'index': len(self.chain) + 1,\\n 'timestamp': time(),\\n 'transactions':self.current_transactions,\\n 'proof': proof,\\n 'previous_hash': previous_hash or self.hash(self.chain[-1]),\\n }\\n self.current_transactions = []\\n self.chain.append(block)\\n return block\",\n \"def add_blocks(self, block_id, positions, rotations=None, offset=None):\\n # check if block_id is known\\n assert block_id in block_config, \\\"Unknown block id: {}\\\".format(block_id)\\n for idx_position, position in enumerate(positions):\\n if rotations:\\n rotation = rotations[idx_position]\\n assert rotation < 32, \\\"Invalid rotation: {}\\\".format(rotation) # (1 << 5)\\n # the rotations correspond to the last 5 bits of the state (int_24)\\n block_id += (rotation << 19)\\n new_block = block_pool(block_id)\\n if offset:\\n self.smd3.add_block(new_block, (position[0]+offset[0], position[1]+offset[1], position[2]+offset[2]))\\n else:\\n self.smd3.add_block(new_block, tuple(position))\\n self.logic.update(self.smd3)\\n self.header.update(self.smd3)\",\n \"def mine():\\n last_block = blockchain.get_last_block\\n print(last_block)\\n last_proof = last_block['proof']\\n proof = blockchain.proof_of_work(last_proof)\\n\\n blockchain.add_transaction(sender=0, recipient=node_identifier, amount=1)\\n block = blockchain.add_block(proof)\\n block['message'] = 'New block added'\\n\\n return jsonify(block), 200\",\n \"def create_origin_block(self):\\n # creating a new hash object and finding new hash with empty string.\\n hash = hashlib.sha256()\\n hash.update(''.encode('utf-8'))\\n # Instantiating a new block with data 'Origin', and for previous hash we'll give the hash generated by empty string\\n origin_block = Block('Origin', hash)\\n # Mine the block with the difficulty level of the chain\\n origin_block.mine(self.difficulty)\\n # Appending it to the mined block list\\n self.blocks.append(origin_block)\",\n \"def create_block_message(self, block):\\n msg = poet_transaction_block.PoetTransactionBlockMessage()\\n msg.TransactionBlock = block\\n return msg\",\n \"def create_genesis(self):\\n return Block(0, 0, b'0', b'0', b'')\",\n \"def _get_block(self, pos):\\n return _get_mc().getBlock(pos)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70892054","0.6922745","0.6734681","0.67146844","0.6691439","0.66598445","0.6569314","0.6507948","0.6451737","0.6438023","0.64173955","0.631916","0.6271522","0.6259364","0.6188753","0.61676276","0.6142407","0.61034083","0.60966974","0.60704386","0.60684276","0.6029692","0.6009155","0.59929794","0.5969436","0.5961704","0.5954037","0.5953773","0.5932083","0.5918317","0.59000754","0.5887087","0.58756274","0.58583283","0.5857568","0.58550173","0.58484","0.58484","0.5846258","0.5820258","0.58125526","0.5808692","0.58064795","0.57831186","0.57699585","0.5765646","0.5763049","0.57554835","0.57446647","0.57337743","0.5715362","0.5713845","0.56963813","0.56906295","0.5690263","0.5677034","0.56511456","0.56509525","0.5643036","0.5636894","0.561841","0.56147105","0.560218","0.5598404","0.559728","0.5592777","0.5584862","0.55807287","0.5576038","0.55748904","0.5571572","0.5571337","0.5567872","0.5562196","0.55556285","0.5553788","0.55505043","0.5545386","0.5544667","0.5535774","0.55320966","0.5529952","0.55218536","0.55124736","0.5502758","0.5502419","0.55002046","0.5498015","0.54925656","0.54905677","0.5478652","0.54696953","0.54625154","0.54528797","0.54503626","0.54455084","0.54434294","0.54387194","0.5423669","0.5411888"],"string":"[\n \"0.70892054\",\n \"0.6922745\",\n \"0.6734681\",\n \"0.67146844\",\n \"0.6691439\",\n \"0.66598445\",\n \"0.6569314\",\n \"0.6507948\",\n \"0.6451737\",\n \"0.6438023\",\n \"0.64173955\",\n \"0.631916\",\n \"0.6271522\",\n \"0.6259364\",\n \"0.6188753\",\n \"0.61676276\",\n \"0.6142407\",\n \"0.61034083\",\n \"0.60966974\",\n \"0.60704386\",\n \"0.60684276\",\n \"0.6029692\",\n \"0.6009155\",\n \"0.59929794\",\n \"0.5969436\",\n \"0.5961704\",\n \"0.5954037\",\n \"0.5953773\",\n \"0.5932083\",\n \"0.5918317\",\n \"0.59000754\",\n \"0.5887087\",\n \"0.58756274\",\n \"0.58583283\",\n \"0.5857568\",\n \"0.58550173\",\n \"0.58484\",\n \"0.58484\",\n \"0.5846258\",\n \"0.5820258\",\n \"0.58125526\",\n \"0.5808692\",\n \"0.58064795\",\n \"0.57831186\",\n \"0.57699585\",\n \"0.5765646\",\n \"0.5763049\",\n \"0.57554835\",\n \"0.57446647\",\n \"0.57337743\",\n \"0.5715362\",\n \"0.5713845\",\n \"0.56963813\",\n \"0.56906295\",\n \"0.5690263\",\n \"0.5677034\",\n \"0.56511456\",\n \"0.56509525\",\n \"0.5643036\",\n \"0.5636894\",\n \"0.561841\",\n \"0.56147105\",\n \"0.560218\",\n \"0.5598404\",\n \"0.559728\",\n \"0.5592777\",\n \"0.5584862\",\n \"0.55807287\",\n \"0.5576038\",\n \"0.55748904\",\n \"0.5571572\",\n \"0.5571337\",\n \"0.5567872\",\n \"0.5562196\",\n \"0.55556285\",\n \"0.5553788\",\n \"0.55505043\",\n \"0.5545386\",\n \"0.5544667\",\n \"0.5535774\",\n \"0.55320966\",\n \"0.5529952\",\n \"0.55218536\",\n \"0.55124736\",\n \"0.5502758\",\n \"0.5502419\",\n \"0.55002046\",\n \"0.5498015\",\n \"0.54925656\",\n \"0.54905677\",\n \"0.5478652\",\n \"0.54696953\",\n \"0.54625154\",\n \"0.54528797\",\n \"0.54503626\",\n \"0.54455084\",\n \"0.54434294\",\n \"0.54387194\",\n \"0.5423669\",\n \"0.5411888\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6633076"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":75096,"cells":{"query":{"kind":"string","value":"Find a block, or create it if it doesn't exist."},"document":{"kind":"string","value":"def FindOrCreateBlock(self, name, instance):\n try:\n return self.FindBlock(name, instance)\n except KeyError:\n return self.CreateBlock({'name': name, 'instance': instance})"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _load_block(self, addr):\n ret_block = None\n\n tag, set_index, offset = self._decompose(addr)\n\n if set_index not in self._d:\n self._d[set_index] = []\n block_list = self._d[set_index]\n for tag_, block in block_list:\n if tag == tag_:\n self._track(addr, read=True, hit=True)\n return block\n\n # block not explicitly present, so might be a miss\n if self.implicit and len(block_list) <= self.num_blocks_per_set:\n # even though the addr hasn't been explicitly added to the store\n # yet, this store is implicity known to have been zerod out\n # so we just create a new block and store it explicitly, and\n # pretend it was a hit\n self._track(addr, read=True, hit=True)\n base = addr - offset\n block = Block(self.block_size, base)\n block_list.append((tag, block))\n return block\n\n # definite miss\n self._track(addr, read=True, hit=False)\n\n # ...and load from the next level of the store\n block_base = addr - offset\n block = self._read_block_from_next(block_base)\n\n # and add it to the store\n self._write_block(addr, block, direct=False)\n\n return block","def get_block_by_hash(self, block_hash):\n if block_hash in self.block_cache:\n return self.block_cache[block_hash]\n\n mongo_block = self.blocks.find_one({\"hash\": block_hash})\n\n if not mongo_block:\n raise KeyError(\"[get_block_by_hash] Block with hash %s not found.\" % block_hash)\n\n mongo_block_transactions = self.transactions.find({\"blockhash\": mongo_block['hash']})\n return MongoBlockFactory.from_mongo(mongo_block, mongo_block_transactions)","def get_block_with_name(self, block_name: str) -> BasicBlock:\n block: BasicBlock\n all_blocks: Dict[str, BasicBlock] = self.get_all_blocks()\n if block_name in all_blocks:\n return all_blocks[block_name]\n raise Exception(ERROR_BLOCK_DOESNT_EXIST % block_name)","async def add_block(\n self,\n position: typing.Tuple[int, int, int],\n block_name: typing.Union[str, typing.Any],\n immediate=True,\n block_update=True,\n block_update_self=True,\n lazy_setup: typing.Callable[[typing.Any], None] = None,\n check_build_range=True,\n block_state=None,\n network_sync=True,\n ) -> typing.Optional[typing.Any]:\n raise NotImplementedError","def _check_for_new_block() -> None:\n logging.debug(\"Checking for new block\")\n CAPACITY = block.get_capacity()\n\n r = util.get_db()\n with r.lock(\"blockchain:last_block:lock\"), \\\n r.lock(\"blockchain:miner_pid:lock\"), \\\n r.lock(\"blockchain:tx_pool:lock\"), \\\n r.lock(\"blockchain:utxo-block:lock\"):\n # NOTE: If a miner is running, we expect it to add a new block, so we\n # abort. If mining succeeds, this function will be called again by\n # new_recv_block(). If it fails (another valid block is received) this\n # will again be called by new_recv_block()\n miner_pidb = r.get(\"blockchain:miner_pid\")\n if miner_pidb is not None:\n logging.debug(\"Miner already running with PID %d\", util.btoui(miner_pidb))\n return\n\n tx_pool = {Transaction.loadb(tb) for tb in r.hvals(\"blockchain:tx_pool\")}\n if len(tx_pool) < CAPACITY:\n logging.debug(\"Cannot create new block yet (not enough transactions)\")\n return\n\n last_block = get_block()\n utxo_block = {TransactionInput.loadb(i): TransactionOutput.loadb(o) for i, o \\\n in r.hgetall(\"blockchain:utxo-block:\".encode() + last_block.current_hash).items()}\n new_block_tx: List[Transaction] = []\n # NOTE: Since there are >= CAPACITY transactions in the pool, and we\n # don't mind transaction inter-dependence in the same block, a new\n # block can be created, so this loop will terminate\n while True:\n for t in tx_pool:\n # Search for t.inputs in UTXO-block[last_block] as well as in new_block_tx\n if all(i in utxo_block or \\\n any(nt.id == i.transaction_id for nt in new_block_tx) for i in t.inputs):\n new_block_tx.append(t)\n if len(new_block_tx) == CAPACITY:\n new_block = Block(index=last_block.index + 1,\n previous_hash=last_block.current_hash,\n transactions=new_block_tx)\n # NOTE: We don't delete the new block_tx from the pool, because\n # mining might fail. They will be deleted eventually when they\n # enter the main branch.\n miner_pid = new_block.finalize()\n r.set(\"blockchain:miner_pid\", util.uitob(miner_pid))\n logging.debug(\"Miner started with PID %d\", miner_pid)\n return\n tx_pool.difference_update(new_block_tx)","def find_blk_below(blk, name):\n if blk == None or len(blk.connections) == 0:\n return\n _group = find_group(blk)\n for _gblk in _group:\n if _gblk.name == name:\n return _gblk\n return None","def get_block(block_id: Optional[bytes] = None) -> Optional[Block]:\n if block_id is not None and not isinstance(block_id, bytes):\n raise TypeError\n if block_id is None:\n logging.debug(\"Last block requested\")\n else:\n logging.debug(\"Block %s requested\", util.bintos(block_id))\n\n r = util.get_db()\n if block_id is None:\n block_id = r.get(\"blockchain:last_block\")\n if block_id is None:\n # The blockchain is empty\n logging.debug(\"Blockchain is empty\")\n return None\n\n blockb = r.hget(\"blockchain:blocks\", block_id)\n if blockb is None:\n # Requested block not found\n logging.debug(\"Block %s not found\", util.bintos(block_id))\n return None\n\n logging.debug(\"Block %s retrieved\", util.bintos(block_id))\n return Block.loadb(blockb)","async def refresh(self):\n block = await self.blockchain.rpc.get_block(self.identifier)\n if not block:\n raise BlockDoesNotExistsException\n await super(Block, self).__init__(\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\n )","def _get_block_from_structure(self, structure, block_id):\r\n return structure['blocks'].get(LocMapperStore.encode_key_for_mongo(block_id))","def refresh(self):\n block = self.graphene.rpc.get_block(self.block)\n if not block:\n raise BlockDoesNotExistsException\n super(Block, self).__init__(block)\n self.cached = True","def _get_block_from_structure(self, structure, block_key):\n return structure['blocks'].get(block_key)","def get_best_block(self) -> Block:\n assert self.indexes is not None\n block_hash = self.indexes.height.get_tip()\n block = self.get_transaction(block_hash)\n assert isinstance(block, Block)\n assert block.get_metadata().validation.is_fully_connected()\n return block","def createBlock(self, block: ghidra.program.model.mem.MemoryBlock, name: unicode, start: ghidra.program.model.address.Address, length: long) -> ghidra.program.model.mem.MemoryBlock:\n ...","def _get_block(self, pos):\n raise NotImplementedError","def get_best_block(self, node):\n block_height = node.getblockcount()\n blockhash = node.getblockhash(block_height)\n block = FromHex(CBlock(), node.getblock(blockhash, 0))\n block.calc_sha256()\n self.block_heights[block.sha256] = block_height\n return block","def getBlockByName(self, name):\n try:\n return self.blocksByName[name]\n except AttributeError:\n self._genBlocksByName()\n return self.blocksByName[name]","def get_block_obj(self, vault_id, block_id):\n path = self._get_block_path(vault_id, block_id)\n\n if not os.path.exists(path):\n return None\n\n return open(path, 'rb')","def add(self, block):\n\n try:\n self.blocks[block.height]\n except:\n\n self.blocks[block.height] = [block]\n if self.current_height < block.height:\n self.current_height = block.height\n return\n\n if not block.hash() in [b.hash() for b in self.blocks[block.height]]:\n self.blocks[block.height].append(block)\n loggerutil.debug(\"fork detected for height:\" + str(block.height) +\n \"block candidats:\" + str(self.blocks[block.height]))\n if self.current_height < block.height:\n self.current_height = block.height","def get_block_by_path(self, path):\n\n def walk(block, parts):\n # Check if instance matches\n instance = \"{}[{}]\".format(parts[0].name, parts[0].index)\n if block.instance != instance:\n return None\n\n # Check if operating mode matches\n if parts[0].mode is not None:\n if block.mode != parts[0].mode:\n return None\n\n # Next\n parts = parts[1:]\n\n # No more path parts, this is the block\n if not parts:\n return block\n\n # Find child block by its instance and recurse\n instance = \"{}[{}]\".format(parts[0].name, parts[0].index)\n if instance in block.blocks:\n return walk(block.blocks[instance], parts)\n\n return None\n\n # Prepend self to the path\n path = \"{}[{}]\".format(self.instance, self.mode) + \".\" + path\n\n # Split and parse the path\n path = path.split(\".\")\n path = [PathNode.from_string(p) for p in path]\n\n # Find the child\n return walk(self, path)","def _get_block(self, pos):\n if pos in self._changes:\n return self._changes[pos]\n else:\n return _get_mc().getBlock(pos)","def get_block(self, blockhash):\n\n return self._blocks.get(blockhash)","def find_next_block(chunks, pos):\n\n\twhile pos < len(chunks):\n\n\t\tpos, chunk = find_next_chunk(chunks, pos, [0x100, 0x102])\n\n#\t\tif chunks[pos][0] == 0x100 or chunks[pos][0] == 0x102:\n\n#\t\t\tif len(chunks[pos][1]) > 1:\n\n\t\tif pos == None:\n\n\t\t\treturn None\n\t\telse:\n\t\t\tif len(chunk[1]) > 1:\n\n\t\t\t\t# Found a block, return this position\n\t\t\t\treturn pos\n\n\t\t# Otherwise continue looking\n\t\tpos = pos + 1\n\n\treturn None","def get_block(blockhash):\n return requests.get(BASE+f'/api/block/{blockhash}').json()","def add_block(self, name):\n\n if not self.RE_NAME.match(name):\n raise ValueError(u\"Invalid block name '{0}'\"\n .format(common.from_utf8(name)))\n\n if name in self._block_map:\n raise ValueError(u\"Block '{0}' already exists\"\n .format(common.from_utf8(name)))\n\n # add new block and index mapping\n self._block_map[name] = len(self._ast[2]) # must come first\n option_list = []\n block = [name, option_list]\n self._ast[2].append(block)","def get_cached_block(self, course_key, version_guid, block_id):\n bulk_write_record = self._get_bulk_ops_record(course_key)\n if bulk_write_record.active:\n return bulk_write_record.modules[version_guid].get(block_id, None)\n else:\n return None","def find_block_to_run(blk):\n _top = find_top_block(blk)\n if blk == _top and blk.name[0:3] is not 'def':\n return True\n else:\n return False","def find_node(self, name, create=False):\n\n name = self._validate_name(name)\n node = self.nodes.get(name)\n if node is None:\n if not create:\n raise KeyError\n node = self.node_factory()\n self.nodes[name] = node\n return node","def find_top_block(blk):\n if blk is None:\n return None\n if len(blk.connections) == 0:\n return blk\n while blk.connections[0] is not None:\n blk = blk.connections[0]\n return blk","def getBlock(self, blockName: unicode) -> ghidra.program.model.mem.MemoryBlock:\n ...","def pick_block(self):\n current_block = self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]]\n if current_block in self.available_block_types:\n self.current_block_type = self.available_block_types.index(current_block)","def add_block(self, block, save=True):\n if block.hash in self.blocks:\n return False\n if not block.is_valid()[0]:\n return False\n if not block.height in self.chain:\n self.chain[block.height] = []\n if not block.hash in self.chain[block.height]:\n # add newer blocks to front so they show up first in UI\n self.chain[block.height] = [block.hash] + self.chain[block.height]\n if not block.hash in self.blocks:\n self.blocks[block.hash] = block\n for tx in block.transactions:\n self.all_transactions[tx.hash] = tx\n if not tx.hash in self.blocks_containing_tx:\n self.blocks_containing_tx[tx.hash] = []\n self.blocks_containing_tx[tx.hash].append(block.hash)\n for input_ref in tx.input_refs:\n if not input_ref in self.blocks_spending_input:\n self.blocks_spending_input[input_ref] = []\n self.blocks_spending_input[input_ref].append(block.hash)\n self._p_changed = True # Marked object as changed so changes get saved to ZODB.\n if save:\n transaction.commit() # If we're going to save the block, commit the transaction.\n return True","async def create_block_type(self, block_type: BlockTypeCreate) -> BlockType:\n try:\n response = await self._client.post(\n \"/block_types/\",\n json=block_type.dict(\n json_compatible=True, exclude_unset=True, exclude={\"id\"}\n ),\n )\n except httpx.HTTPStatusError as e:\n if e.response.status_code == status.HTTP_409_CONFLICT:\n raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e\n else:\n raise\n return BlockType.parse_obj(response.json())","def add_block(self, block):\n # checks for errors in new block's position\n if block.index != 0 and len(self.chain) == 0:\n raise Exception('Chain was not initiated. Insert Genesis block first')\n elif len(self.chain) < block.index:\n raise Exception(\"New block's position doesn't fit chain's order\")\n elif block.index == 0 and len(self.chain) == 1:\n raise Exception(\"Genesis block is already exist\")\n elif block.index == 0:\n self.chain.append(block)\n return True\n # validates the block and verifies the chain with the new block\n elif block.is_valid() and self.verify_chain(block):\n self.chain.append(block)\n return True\n else:\n return False","def locate_block(mm, header, trailer, force_head=False, force_tail=False,\n skip_header=True, skip_trailer=None):\n if skip_trailer is None:\n skip_trailer = not force_tail\n begin_idx = mm.find(header.encode())\n if begin_idx == -1:\n if force_head:\n begin_idx = 0\n else:\n raise RuntimeError('failed to find \"%s\"' % header)\n if skip_header:\n mm.seek(begin_idx)\n mm.readline()\n begin_idx = mm.tell()\n end_idx = mm.find(trailer.encode())\n whence = 1 # seek from current location by default\n if end_idx == -1:\n if force_tail:\n whence = 2 # seek from end of file\n else:\n raise RuntimeError('failed to find \"%s\"' % trailer)\n if not skip_trailer:\n mm.seek(end_idx, whence)\n mm.readline()\n end_idx = mm.tell()\n return begin_idx, end_idx","def add_block(self, block_pf):\n\n # test si il s'agit du bloc genesis\n if len(self.blocks) != 0:\n # check si previous H est coherent avant ajout a chaine\n if self.check_previousBlockH(block_pf.header['prevBlockH']):\n self.blocks.append(block_pf)\n else:\n print \"== Probleme de parent\"\n print \"= %s\" % block_pf.header['prevBlockH']\n print \"= %s\" % getHashBlock(self.get_topBlock())\n else:\n self.blocks.append(block_pf)","async def add_block(\n self,\n block: FullBlock,\n peer: Optional[WSChiaConnection] = None,\n raise_on_disconnected: bool = False,\n ) -> Optional[Message]:\n if self.sync_store.get_sync_mode():\n return None\n\n # Adds the block to seen, and check if it's seen before (which means header is in memory)\n header_hash = block.header_hash\n if self.blockchain.contains_block(header_hash):\n return None\n\n pre_validation_result: Optional[PreValidationResult] = None\n if (\n block.is_transaction_block()\n and block.transactions_info is not None\n and block.transactions_info.generator_root != bytes([0] * 32)\n and block.transactions_generator is None\n ):\n # This is the case where we already had the unfinished block, and asked for this block without\n # the transactions (since we already had them). Therefore, here we add the transactions.\n unfinished_rh: bytes32 = block.reward_chain_block.get_unfinished().get_hash()\n unf_block: Optional[UnfinishedBlock] = self.full_node_store.get_unfinished_block(unfinished_rh)\n if (\n unf_block is not None\n and unf_block.transactions_generator is not None\n and unf_block.foliage_transaction_block == block.foliage_transaction_block\n ):\n # We checked that the transaction block is the same, therefore all transactions and the signature\n # must be identical in the unfinished and finished blocks. We can therefore use the cache.\n pre_validation_result = self.full_node_store.get_unfinished_block_result(unfinished_rh)\n assert pre_validation_result is not None\n block = dataclasses.replace(\n block,\n transactions_generator=unf_block.transactions_generator,\n transactions_generator_ref_list=unf_block.transactions_generator_ref_list,\n )\n else:\n # We still do not have the correct information for this block, perhaps there is a duplicate block\n # with the same unfinished block hash in the cache, so we need to fetch the correct one\n if peer is None:\n return None\n\n block_response: Optional[Any] = await peer.call_api(\n FullNodeAPI.request_block, full_node_protocol.RequestBlock(block.height, True)\n )\n if block_response is None or not isinstance(block_response, full_node_protocol.RespondBlock):\n self.log.warning(\n f\"Was not able to fetch the correct block for height {block.height} {block_response}\"\n )\n return None\n new_block: FullBlock = block_response.block\n if new_block.foliage_transaction_block != block.foliage_transaction_block:\n self.log.warning(f\"Received the wrong block for height {block.height} {new_block.header_hash}\")\n return None\n assert new_block.transactions_generator is not None\n\n self.log.debug(\n f\"Wrong info in the cache for bh {new_block.header_hash}, there might be multiple blocks from the \"\n f\"same farmer with the same pospace.\"\n )\n # This recursion ends here, we cannot recurse again because transactions_generator is not None\n return await self.add_block(new_block, peer)\n state_change_summary: Optional[StateChangeSummary] = None\n ppp_result: Optional[PeakPostProcessingResult] = None\n async with self.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):\n # After acquiring the lock, check again, because another asyncio thread might have added it\n if self.blockchain.contains_block(header_hash):\n return None\n validation_start = time.time()\n # Tries to add the block to the blockchain, if we already validated transactions, don't do it again\n npc_results = {}\n if pre_validation_result is not None and pre_validation_result.npc_result is not None:\n npc_results[block.height] = pre_validation_result.npc_result\n\n # Don't validate signatures because we want to validate them in the main thread later, since we have a\n # cache available\n pre_validation_results = await self.blockchain.pre_validate_blocks_multiprocessing(\n [block], npc_results, validate_signatures=False\n )\n added: Optional[AddBlockResult] = None\n pre_validation_time = time.time() - validation_start\n try:\n if len(pre_validation_results) < 1:\n raise ValueError(f\"Failed to validate block {header_hash} height {block.height}\")\n if pre_validation_results[0].error is not None:\n if Err(pre_validation_results[0].error) == Err.INVALID_PREV_BLOCK_HASH:\n added = AddBlockResult.DISCONNECTED_BLOCK\n error_code: Optional[Err] = Err.INVALID_PREV_BLOCK_HASH\n elif Err(pre_validation_results[0].error) == Err.TIMESTAMP_TOO_FAR_IN_FUTURE:\n raise TimestampError()\n else:\n raise ValueError(\n f\"Failed to validate block {header_hash} height \"\n f\"{block.height}: {Err(pre_validation_results[0].error).name}\"\n )\n else:\n result_to_validate = (\n pre_validation_results[0] if pre_validation_result is None else pre_validation_result\n )\n assert result_to_validate.required_iters == pre_validation_results[0].required_iters\n (added, error_code, state_change_summary) = await self.blockchain.add_block(\n block, result_to_validate, None\n )\n if added == AddBlockResult.ALREADY_HAVE_BLOCK:\n return None\n elif added == AddBlockResult.INVALID_BLOCK:\n assert error_code is not None\n self.log.error(f\"Block {header_hash} at height {block.height} is invalid with code {error_code}.\")\n raise ConsensusError(error_code, [header_hash])\n elif added == AddBlockResult.DISCONNECTED_BLOCK:\n self.log.info(f\"Disconnected block {header_hash} at height {block.height}\")\n if raise_on_disconnected:\n raise RuntimeError(\"Expected block to be added, received disconnected block.\")\n return None\n elif added == AddBlockResult.NEW_PEAK:\n # Only propagate blocks which extend the blockchain (becomes one of the heads)\n assert state_change_summary is not None\n ppp_result = await self.peak_post_processing(block, state_change_summary, peer)\n\n elif added == AddBlockResult.ADDED_AS_ORPHAN:\n self.log.info(\n f\"Received orphan block of height {block.height} rh {block.reward_chain_block.get_hash()}\"\n )\n else:\n # Should never reach here, all the cases are covered\n raise RuntimeError(f\"Invalid result from add_block {added}\")\n except asyncio.CancelledError:\n # We need to make sure to always call this method even when we get a cancel exception, to make sure\n # the node stays in sync\n if added == AddBlockResult.NEW_PEAK:\n assert state_change_summary is not None\n await self.peak_post_processing(block, state_change_summary, peer)\n raise\n\n validation_time = time.time() - validation_start\n\n if ppp_result is not None:\n assert state_change_summary is not None\n await self.peak_post_processing_2(block, peer, state_change_summary, ppp_result)\n\n percent_full_str = (\n (\n \", percent full: \"\n + str(round(100.0 * float(block.transactions_info.cost) / self.constants.MAX_BLOCK_COST_CLVM, 3))\n + \"%\"\n )\n if block.transactions_info is not None\n else \"\"\n )\n self.log.log(\n logging.WARNING if validation_time > 2 else logging.DEBUG,\n f\"Block validation time: {validation_time:0.2f} seconds, \"\n f\"pre_validation time: {pre_validation_time:0.2f} seconds, \"\n f\"cost: {block.transactions_info.cost if block.transactions_info is not None else 'None'}\"\n f\"{percent_full_str} header_hash: {header_hash} height: {block.height}\",\n )\n\n # This code path is reached if added == ADDED_AS_ORPHAN or NEW_TIP\n peak = self.blockchain.get_peak()\n assert peak is not None\n\n # Removes all temporary data for old blocks\n clear_height = uint32(max(0, peak.height - 50))\n self.full_node_store.clear_candidate_blocks_below(clear_height)\n self.full_node_store.clear_unfinished_blocks_below(clear_height)\n if peak.height % 1000 == 0 and not self.sync_store.get_sync_mode():\n await self.sync_store.clear_sync_info() # Occasionally clear sync peer info\n\n state_changed_data: Dict[str, Any] = {\n \"transaction_block\": False,\n \"k_size\": block.reward_chain_block.proof_of_space.size,\n \"header_hash\": block.header_hash,\n \"height\": block.height,\n \"validation_time\": validation_time,\n \"pre_validation_time\": pre_validation_time,\n }\n\n if block.transactions_info is not None:\n state_changed_data[\"transaction_block\"] = True\n state_changed_data[\"block_cost\"] = block.transactions_info.cost\n state_changed_data[\"block_fees\"] = block.transactions_info.fees\n\n if block.foliage_transaction_block is not None:\n state_changed_data[\"timestamp\"] = block.foliage_transaction_block.timestamp\n\n if block.transactions_generator is not None:\n state_changed_data[\"transaction_generator_size_bytes\"] = len(bytes(block.transactions_generator))\n\n state_changed_data[\"transaction_generator_ref_list\"] = block.transactions_generator_ref_list\n if added is not None:\n state_changed_data[\"receive_block_result\"] = added.value\n\n self._state_changed(\"block\", state_changed_data)\n\n record = self.blockchain.block_record(block.header_hash)\n if self.weight_proof_handler is not None and record.sub_epoch_summary_included is not None:\n if self._segment_task is None or self._segment_task.done():\n self._segment_task = asyncio.create_task(self.weight_proof_handler.create_prev_sub_epoch_segments())\n return None","def CreateBlock(self, props):\n # Set some default properties\n\n # blk / cfg | name | name+inst\n # -----------------------------\n # name | n==n | False\n # name+inst | n==n | n==n&&i==i\n if 'ordinal' not in props and 'name' in props:\n for ordinal, ni in self.config.get('ordinals', {}).items():\n if isinstance(ni, str):\n # Config only has name, don't care about block\n if props['name'] == ni:\n props['ordinal'] = ordinal\n break\n elif 'instance' not in props:\n # Config has name+instance, block only has name\n continue\n else:\n # Config has name+instance, block has name+instance\n if props['name'] == ni[0] and props['instance'] == ni[1]:\n props['ordinal'] = ordinal\n break\n\n # Compute a block ID\n if 'name' in props:\n bid = props['name'].replace('-', '')\n else:\n bid = \"block\"\n\n if bid in self.blocks:\n i = 1\n while bid+str(i) in self.blocks:\n i += 1\n bid = bid+str(i)\n\n # Actually create block\n self.blocks[bid] = blk = Block(bid, props)\n blk.changed.handler(lambda: self.blockchanged(blk))\n\n self.blockadded(blk)\n\n return blk","def createFirstBlock(self):\n firstBlock = Block(0, self.__currentTransactionsList, 0, '00')\n self.__chain.append(firstBlock)","def add_block(self, block):\n if block.index >= len(self.blockchain):\n self.blockchain.append(block)\n else:\n self.blockchain[block.index] = block\n self.write_to_disk()","def get(block_id):\n _url = get_root_url()\n try:\n block = DB.get_block_details([block_id]).__next__()\n response = block\n\n response['links'] = {\n 'self': '{}'.format(request.url),\n 'list': '{}/processing-blocks'.format(_url),\n 'home': '{}'.format(_url)\n }\n return block\n except IndexError as error:\n response = dict(message='Unable to GET Processing Block',\n id='{}'.format(block_id),\n error=error.__str__())\n response['links'] = {\n 'list': '{}/processing-blocks'.format(_url),\n 'home': '{}'.format(_url)\n }\n return response, HTTPStatus.NOT_FOUND","def _get_block(self, pos):\n return _get_mc().getBlock(pos)","def validate_and_add_block(self, block):\n\n # 1. Validate transaction(s) in block\n tx = block.transactions\n if not self.validate_transaction(tx):\n print(\"Block contains invalid transactions.\")\n return\n\n # 2. Hash transaction(s)\n tx_hash = HashAssist.hash_value(value=tx.to_string_for_hashing())\n\n # 3. Validate header\n header_string = block.prev_hash + tx_hash + block.nonce\n header_hash = HashAssist.hash_value(header_string)\n if not block.header_hash == header_hash:\n print(\"Block header invalid!\")\n return\n\n self.blocks.append(block)","def get_label_block(self, name):\n if name in self.labeled_blocks:\n block = self.labeled_blocks[name]\n else:\n block = self.builder.new_block()\n self.labeled_blocks[name] = block # TODO: use name\n return block","def add_block(self, block):\n # Create a list of transaction objects\n transactions = [Transaction(\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']] \n chipsactions = [Chipsaction(\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']] \n messsactions = [Messsaction(\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']] \n # Validate the proof of work of the block and store the result (True or False) in a variable\n proof_is_valid = Verification.valid_proof(\n transactions[:-1], chipsactions, messsactions, block['previous_hash'], block['proof'])\n # Check if previous_hash stored in the block is equal to the local blockchain's last block's hash and store the result in a block\n hashes_match = hash_block(self.chain[-1]) == block['previous_hash']\n if not proof_is_valid or not hashes_match:\n return False\n # Create a Block object\n converted_block = Block(\n block['index'], block['previous_hash'], transactions, chipsactions, messsactions, block['proof'], block['timestamp'])\n self.__chain.append(converted_block)\n stored_transactions = self.__open_transactions[:]\n stored_chipsactions = self.__open_chipsactions[:]\n stored_messsactions = self.__open_messsactions[:]\n # Check which open transactions were included in the received block and remove them\n # This could be improved by giving each transaction an ID that would uniquely identify it\n for itx in block['transactions']:\n for opentx in stored_transactions:\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\n try:\n self.__open_transactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n\n for itx in block['chipsactions']:\n for opentx in stored_chipsactions:\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.sender == itx['follow'] and opentx.recipient == itx['message'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\n try:\n self.__open_chipsactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n for itx in block['messsactions']:\n for opentx in stored_messsactions:\n if opentx.sender == itx['sender'] and opentx.sender == itx['follower'] and opentx.recipient == itx['message'] and opentx.signature == itx['signature']:\n try:\n self.__open_messsactions.remove(opentx)\n except ValueError:\n print('Item was already removed')\n self.save_data()\n return True","def fetch_block(path, offset, block_size):\n with open(path, 'rb') as file:\n file.seek(offset)\n return bz2.decompress(file.read(block_size))","def allocate(self, name: str, size: int) -> Optional[Block]:\n # create a list of candidate blocks that are free and fit size.\n fits_list = []\n for block in self.free_list:\n if block.length() >= size:\n fits_list.append(block);\n\n if len(fits_list) == 0:\n print(\"malloc FAIL for {} with size={}\".format(name, size))\n return None\n else:\n chosen_block = None\n if self.algorithm == 'random':\n # choose a random block\n block_number = random.randint(0, len(fits_list)-1)\n chosen_block = fits_list[block_number]\n elif self.algorithm == \"first\":\n # choose a block by finding the earliest address that fits\n fits_list = sorted(fits_list, key=lambda b: b.start())\n chosen_block = fits_list[0]\n else:\n raise ValueError(\"Those two fits are enough for the lab.\")\n\n self.free_list.remove(chosen_block) # remove this block from the free list\n # put the given information in the allocated block, and split it if contains more space than asked for\n if chosen_block.length() == size:\n block.name = name\n block.used = True\n self.used_list.append(chosen_block)\n else: # block is bigger than the size requested\n # split it into two:\n\n # First new block - the one to be used\n start: int = chosen_block.start()\n used = Block(start, size, name)\n used.used = True\n # Add this block to the used list\n self.used_list.append(used)\n\n # Second new block - the leftover unused space\n start = start + size\n length = chosen_block.end() - start\n leftover_unused = Block(start, length, chosen_block.name)\n # Add this block back to the free list\n self.free_list.append(leftover_unused)","def find_read_number_block(self):\n\t\tnode = self.find_read_number_block_link()\n\t\tif node is not None:\n\t\t\treturn node\n\n\t\tnode = self.find_read_number_block_fixed_raw()\n\t\tif node is not None:\n\t\t\treturn node\n\n\t\t# Couldn't find the node, bail out.\n\t\tself.hdf_internal_error(\"unknown HDF5 structure: can't find read block item\")","async def create_block_document(\n self,\n block_document: Union[BlockDocument, BlockDocumentCreate],\n include_secrets: bool = True,\n ) -> BlockDocument:\n if isinstance(block_document, BlockDocument):\n block_document = BlockDocumentCreate.parse_obj(\n block_document.dict(\n json_compatible=True,\n include_secrets=include_secrets,\n exclude_unset=True,\n exclude={\"id\", \"block_schema\", \"block_type\"},\n ),\n )\n\n try:\n response = await self._client.post(\n \"/block_documents/\",\n json=block_document.dict(\n json_compatible=True,\n include_secrets=include_secrets,\n exclude_unset=True,\n exclude={\"id\", \"block_schema\", \"block_type\"},\n ),\n )\n except httpx.HTTPStatusError as e:\n if e.response.status_code == status.HTTP_409_CONFLICT:\n raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e\n else:\n raise\n return BlockDocument.parse_obj(response.json())","def addBlock(self, aBlock: gp.Block):\n\n if self.blocks[aBlock.y][aBlock.x] != None:\n raise MovementError('game board space not empty')\n self.blocks[aBlock.y][aBlock.x] = aBlock\n self.groundSprites.append(aBlock.sprite)","def create_block(type: str, color_key, position):\n if type not in BlockCreator.types.keys():\n raise BlockCreator.IncorrectBlockType\n image_name = BlockCreator.types[type]\n return Block(image_name, color_key, position)","def get_a_block(self, usage_id=None):\r\n scope_ids = Mock()\r\n if usage_id is None:\r\n usage_id = \"_auto%d\" % len(self.all_blocks)\r\n scope_ids.usage_id = usage_id\r\n block = self.system.construct_xblock_from_class(\r\n self.TestableInheritingXBlock,\r\n field_data=self.field_data,\r\n scope_ids=scope_ids,\r\n )\r\n self.all_blocks[usage_id] = block\r\n return block","def create_or_read_file(self):\n # make sure the 'files' directory exists\n if not os.path.isdir('../files'):\n os.mkdir('../files')\n try:\n # try to read in files from disk if they exist\n read_file = open(self.pickle_path, 'rb')\n self.blockchain = pickle.load(read_file)\n read_file.close()\n # print('blockchain loaded from file')\n except FileNotFoundError:\n # if no blockchain exists, initialize one with the genesis block\n self.blockchain = [ # Genesis block! as the first block in the chain the hashes are predetermined.\n Block(\n index=0,\n timestamp=str(datetime.datetime.now()),\n transactions=[]\n )\n ]\n self.write_to_disk()","def fetch_proof_by_blocks(self, blocks):\n\n try:\n proof = self.import_proof(blocks)\n except IOError:\n filename = self.make_proof_filename(blocks)\n print(\"File\", filename, \"does not exist. Creating...\")\n proof = self.create_proof(blocks)\n except NameError as err:\n raise err\n finally:\n print(\"...ok\")\n\n return proof","def get_block(self, crypto, block_height='', block_number='', latest=False):\n raise NotImplementedError(\n \"This service does not support getting getting block data. \"\n \"Or rather it has no defined 'get_block' method.\"\n )","def seed(cls, block: Expr) -> Expr:\n return cls(BlockField.block_seed, block)","async def refresh(self):\n block = await self.blockchain.rpc.get_block_header(self.identifier)\n if not block:\n raise BlockDoesNotExistsException\n await super(BlockHeader, self).__init__(\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\n )","async def add_unfinished_block(\n self,\n block: UnfinishedBlock,\n peer: Optional[WSChiaConnection],\n farmed_block: bool = False,\n block_bytes: Optional[bytes] = None,\n ) -> None:\n receive_time = time.time()\n\n if block.prev_header_hash != self.constants.GENESIS_CHALLENGE and not self.blockchain.contains_block(\n block.prev_header_hash\n ):\n # No need to request the parent, since the peer will send it to us anyway, via NewPeak\n self.log.debug(\"Received a disconnected unfinished block\")\n return None\n\n # Adds the unfinished block to seen, and check if it's seen before, to prevent\n # processing it twice. This searches for the exact version of the unfinished block (there can be many different\n # foliages for the same trunk). This is intentional, to prevent DOS attacks.\n # Note that it does not require that this block was successfully processed\n if self.full_node_store.seen_unfinished_block(block.get_hash()):\n return None\n\n block_hash = block.reward_chain_block.get_hash()\n\n # This searched for the trunk hash (unfinished reward hash). If we have already added a block with the same\n # hash, return\n if self.full_node_store.get_unfinished_block(block_hash) is not None:\n return None\n\n peak: Optional[BlockRecord] = self.blockchain.get_peak()\n if peak is not None:\n if block.total_iters < peak.sp_total_iters(self.constants):\n # This means this unfinished block is pretty far behind, it will not add weight to our chain\n return None\n\n if block.prev_header_hash == self.constants.GENESIS_CHALLENGE:\n prev_b = None\n else:\n prev_b = self.blockchain.block_record(block.prev_header_hash)\n\n # Count the blocks in sub slot, and check if it's a new epoch\n if len(block.finished_sub_slots) > 0:\n num_blocks_in_ss = 1 # Curr\n else:\n curr = self.blockchain.try_block_record(block.prev_header_hash)\n num_blocks_in_ss = 2 # Curr and prev\n while (curr is not None) and not curr.first_in_sub_slot:\n curr = self.blockchain.try_block_record(curr.prev_hash)\n num_blocks_in_ss += 1\n\n if num_blocks_in_ss > self.constants.MAX_SUB_SLOT_BLOCKS:\n # TODO: potentially allow overflow blocks here, which count for the next slot\n self.log.warning(\"Too many blocks added, not adding block\")\n return None\n\n # The clvm generator and aggregate signature are validated outside of the lock, to allow other blocks and\n # transactions to get validated\n npc_result: Optional[NPCResult] = None\n pre_validation_time = None\n\n async with self.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):\n start_header_time = time.time()\n _, header_error = await self.blockchain.validate_unfinished_block_header(block)\n if header_error is not None:\n if header_error == Err.TIMESTAMP_TOO_FAR_IN_FUTURE:\n raise TimestampError()\n else:\n raise ConsensusError(header_error)\n validate_time = time.time() - start_header_time\n self.log.log(\n logging.WARNING if validate_time > 2 else logging.DEBUG,\n f\"Time for header validate: {validate_time:0.3f}s\",\n )\n\n if block.transactions_generator is not None:\n pre_validation_start = time.time()\n assert block.transactions_info is not None\n try:\n block_generator: Optional[BlockGenerator] = await self.blockchain.get_block_generator(block)\n except ValueError:\n raise ConsensusError(Err.GENERATOR_REF_HAS_NO_GENERATOR)\n if block_generator is None:\n raise ConsensusError(Err.GENERATOR_REF_HAS_NO_GENERATOR)\n if block_bytes is None:\n block_bytes = bytes(block)\n\n height = uint32(0) if prev_b is None else uint32(prev_b.height + 1)\n npc_result = await self.blockchain.run_generator(block_bytes, block_generator, height)\n pre_validation_time = time.time() - pre_validation_start\n\n # blockchain.run_generator throws on errors, so npc_result is\n # guaranteed to represent a successful run\n assert npc_result.conds is not None\n pairs_pks, pairs_msgs = pkm_pairs(npc_result.conds, self.constants.AGG_SIG_ME_ADDITIONAL_DATA)\n if not cached_bls.aggregate_verify(\n pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature, True\n ):\n raise ConsensusError(Err.BAD_AGGREGATE_SIGNATURE)\n\n async with self.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):\n # TODO: pre-validate VDFs outside of lock\n validation_start = time.time()\n validate_result = await self.blockchain.validate_unfinished_block(block, npc_result)\n if validate_result.error is not None:\n if validate_result.error == Err.COIN_AMOUNT_NEGATIVE.value:\n # TODO: remove in the future, hotfix for 1.1.5 peers to not disconnect older peers\n self.log.info(f\"Consensus error {validate_result.error}, not disconnecting\")\n return\n raise ConsensusError(Err(validate_result.error))\n validation_time = time.time() - validation_start\n\n # respond_block will later use the cache (validated_signature=True)\n validate_result = dataclasses.replace(validate_result, validated_signature=True)\n\n assert validate_result.required_iters is not None\n\n # Perform another check, in case we have already concurrently added the same unfinished block\n if self.full_node_store.get_unfinished_block(block_hash) is not None:\n return None\n\n if block.prev_header_hash == self.constants.GENESIS_CHALLENGE:\n height = uint32(0)\n else:\n height = uint32(self.blockchain.block_record(block.prev_header_hash).height + 1)\n\n ses: Optional[SubEpochSummary] = next_sub_epoch_summary(\n self.constants,\n self.blockchain,\n validate_result.required_iters,\n block,\n True,\n )\n\n self.full_node_store.add_unfinished_block(height, block, validate_result)\n pre_validation_log = (\n f\"pre_validation time {pre_validation_time:0.4f}, \" if pre_validation_time is not None else \"\"\n )\n if farmed_block is True:\n self.log.info(\n f\"🍀 ️Farmed unfinished_block {block_hash}, SP: {block.reward_chain_block.signage_point_index}, \"\n f\"validation time: {validation_time:0.4f} seconds, {pre_validation_log}\"\n f\"cost: {block.transactions_info.cost if block.transactions_info else 'None'} \"\n )\n else:\n percent_full_str = (\n (\n \", percent full: \"\n + str(round(100.0 * float(block.transactions_info.cost) / self.constants.MAX_BLOCK_COST_CLVM, 3))\n + \"%\"\n )\n if block.transactions_info is not None\n else \"\"\n )\n self.log.info(\n f\"Added unfinished_block {block_hash}, not farmed by us,\"\n f\" SP: {block.reward_chain_block.signage_point_index} farmer response time: \"\n f\"{receive_time - self.signage_point_times[block.reward_chain_block.signage_point_index]:0.4f}, \"\n f\"Pool pk {encode_puzzle_hash(block.foliage.foliage_block_data.pool_target.puzzle_hash, 'xch')}, \"\n f\"validation time: {validation_time:0.4f} seconds, {pre_validation_log}\"\n f\"cost: {block.transactions_info.cost if block.transactions_info else 'None'}\"\n f\"{percent_full_str}\"\n )\n\n sub_slot_iters, difficulty = get_next_sub_slot_iters_and_difficulty(\n self.constants,\n len(block.finished_sub_slots) > 0,\n prev_b,\n self.blockchain,\n )\n\n if block.reward_chain_block.signage_point_index == 0:\n res = self.full_node_store.get_sub_slot(block.reward_chain_block.pos_ss_cc_challenge_hash)\n if res is None:\n if block.reward_chain_block.pos_ss_cc_challenge_hash == self.constants.GENESIS_CHALLENGE:\n rc_prev = self.constants.GENESIS_CHALLENGE\n else:\n self.log.warning(f\"Do not have sub slot {block.reward_chain_block.pos_ss_cc_challenge_hash}\")\n return None\n else:\n rc_prev = res[0].reward_chain.get_hash()\n else:\n assert block.reward_chain_block.reward_chain_sp_vdf is not None\n rc_prev = block.reward_chain_block.reward_chain_sp_vdf.challenge\n\n timelord_request = timelord_protocol.NewUnfinishedBlockTimelord(\n block.reward_chain_block,\n difficulty,\n sub_slot_iters,\n block.foliage,\n ses,\n rc_prev,\n )\n\n timelord_msg = make_msg(ProtocolMessageTypes.new_unfinished_block_timelord, timelord_request)\n await self.server.send_to_all([timelord_msg], NodeType.TIMELORD)\n\n full_node_request = full_node_protocol.NewUnfinishedBlock(block.reward_chain_block.get_hash())\n msg = make_msg(ProtocolMessageTypes.new_unfinished_block, full_node_request)\n if peer is not None:\n await self.server.send_to_all([msg], NodeType.FULL_NODE, peer.peer_node_id)\n else:\n await self.server.send_to_all([msg], NodeType.FULL_NODE)\n\n self._state_changed(\"unfinished_block\")","def create_block(world: World, block_id: str, x: int, y: int, *args):\n block_id = BLOCKS[block_id]\n if block_id == \"mystery_empty\":\n block = MysteryBlock()\n elif block_id == \"mystery_coin\":\n block = MysteryBlock(drop=\"coin\", drop_range=(3, 6))\n elif block_id == \"bounce_block\":\n block = BounceBlock()\n elif block_id == \"flag\":\n block = Flagpole()\n elif block_id == \"tunnel\":\n block = Tunnel()\n elif block_id == \"switch\":\n block = Switch()\n else:\n block = Block(block_id)\n\n world.add_block(block, x * BLOCK_SIZE, y * BLOCK_SIZE)","def find_block_mount_point(block):\n # type: (str) -> str\n\n try:\n return subprocess.check_output([\n 'findmnt',\n '-o',\n 'TARGET',\n '-nS',\n block\n ]).strip()\n except subprocess.CalledProcessError as ex:\n return None","def _do_add_block(self, args):\r\n bus_type = args[1]\r\n slave_id = int(args[2])\r\n name = args[3]\r\n block_type = int(args[4])\r\n starting_address = int(args[5])\r\n length = int(args[6])\r\n if bus_type == 'rtu':\r\n slave = self.server._servers[0].get_slave(slave_id)\r\n elif bus_type == 'tcp':\r\n slave = self.server._servers[1].get_slave(slave_id)\r\n slave.add_block(name, block_type, starting_address, length)\r\n return name","def new_block(self, proof, previous_hash=None):\n\n # Create the block\n my_block = Block(proof=proof,\n previous_hash=previous_hash or self.hash(self.last_block))\n my_block.save()\n\n # Update current_transactions with this new block.\n my_block_trans = self.current_transactions_obj\n\n for trans in Transaction.objects.filter(block__isnull=True):\n trans.block = my_block\n trans.save()\n\n block = {\n 'index': my_block.id,\n 'timestamp': my_block.timestamp,\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\n 'proof': my_block.proof,\n 'previous_hash': my_block.previous_hash,\n }\n\n return block","def getBlock(self, hash):\n if hash in self.chain:\n return self.chain[hash]\n return None","def find(self, task_id):\n _structs = [\n self.stack,\n self.backlog,\n self.blocked,\n self.sleeping,\n ]\n for struct in _structs:\n try:\n task_obj = struct.find(task_id)\n return task_obj\n except LookupError:\n # not found; try next structure\n continue\n\n # the graveyard is just a list; search it\n for task_obj in self.graveyard:\n if task_obj.id.startswith(task_id):\n return task_obj\n\n raise LookupError(\"No such task: '{}'\".format(task_id))","def get_block(self, usage_id, for_parent=None):\n def_id = self.id_reader.get_definition_id(usage_id)\n try:\n block_type = self.id_reader.get_block_type(def_id)\n except NoSuchDefinition:\n raise NoSuchUsage(repr(usage_id)) # pylint: disable= raise-missing-from\n keys = ScopeIds(self.user_id, block_type, def_id, usage_id)\n block = self.construct_xblock(block_type, keys, for_parent=for_parent)\n return block","def put_block(self):\n self.blocks[self.editor_cursor_position[1]][\n self.editor_cursor_position[0]] = self.available_block_types[self.current_block_type]","async def read_block_document_by_name(\n self,\n name: str,\n block_type_slug: str,\n include_secrets: bool = True,\n ):\n try:\n response = await self._client.get(\n f\"/block_types/slug/{block_type_slug}/block_documents/name/{name}\",\n params=dict(include_secrets=include_secrets),\n )\n except httpx.HTTPStatusError as e:\n if e.response.status_code == status.HTTP_404_NOT_FOUND:\n raise prefect.exceptions.ObjectNotFound(http_exc=e) from e\n else:\n raise\n return BlockDocument.parse_obj(response.json())","def build_block(self, format_string):\n first_block = Block(None, py3_wrapper=self.py3_wrapper)\n block = first_block\n\n # Tokenize the format string and process them\n for token in self.tokens(format_string):\n value = token.group(0)\n if token.group(\"block_start\"):\n # Create new block\n block = block.new_block()\n elif token.group(\"block_end\"):\n # Close block setting any valid state as needed\n # and return to parent block to continue\n if not block.parent:\n raise Exception(\"Too many `]`\")\n block = block.parent\n elif token.group(\"switch\"):\n # a new option has been created\n block = block.switch()\n elif token.group(\"placeholder\"):\n # Found a {placeholder}\n key = token.group(\"key\")\n format = token.group(\"format\")\n block.add(Placeholder(key, format))\n elif token.group(\"literal\"):\n block.add(Literal(value))\n elif token.group(\"lost_brace\"):\n # due to how parsing happens we can get a lonesome }\n # eg in format_string '{{something}' this fixes that issue\n block.add(Literal(value))\n elif token.group(\"command\"):\n # a block command has been found\n block.set_commands(token.group(\"command\"))\n elif token.group(\"escaped\"):\n # escaped characters add unescaped values\n if value[0] in [\"\\\\\", \"{\", \"}\"]:\n value = value[1:]\n block.add(Literal(value))\n\n if block.parent:\n raise Exception(\"Block not closed\")\n # add to the cache\n self.block_cache[format_string] = first_block","def get_block(\n self, position: typing.Tuple[int, int, int], none_if_str=True\n ) -> typing.Union[typing.Any, str, None]:\n raise NotImplementedError","def new_recv_block(recv_block: Block, sender_id: Optional[int] = None, mute: bool = False) -> bool:\n logging.debug(\"Received block %s\", util.bintos(recv_block.current_hash))\n if not recv_block.verify():\n logging.debug(\"Block %s rejected (failed verification)\",\n util.bintos(recv_block.current_hash))\n return False\n\n r = util.get_db()\n with r.lock(\"blockchain:blocks:lock\"), \\\n r.lock(\"blockchain:last_block:lock\"), \\\n r.lock(\"blockchain:main_branch:lock\"), \\\n r.lock(\"blockchain:orphan_blocks:lock\"), \\\n r.lock(\"blockchain:tx_pool:lock\"), \\\n r.lock(\"blockchain:utxo-block:lock\"), \\\n r.lock(\"blockchain:utxo-tx:lock\"):\n\n # NOTE: Comments like the one below are references to the bitcoin\n # protocol rules\n # OK 2 Reject if duplicate of block we have in any of the three categories\n if r.hexists(\"blockchain:blocks\", recv_block.current_hash) or \\\n r.sismember(\"blockchain:orphan_blocks:\".encode() + recv_block.previous_hash,\n recv_block.dumpb()):\n logging.debug(\"Block %s rejected (already exists)\",\n util.bintos(recv_block.current_hash))\n return False\n\n # Handle the genesis block\n if recv_block.is_genesis():\n r.hset(\"blockchain:blocks\", recv_block.current_hash, recv_block.dumpb())\n t = recv_block.transactions[0]\n o = t.outputs[0]\n ib = TransactionInput(t.id, o.index).dumpb()\n ob = o.dumpb()\n r.hset(\"blockchain:utxo-block:\".encode() + recv_block.current_hash, ib, ob)\n r.hset(\"blockchain:utxo-tx\", ib, ob)\n r.sadd(\"blockchain:main_branch\", recv_block.current_hash)\n _set_last_block_unlocked(r, recv_block)\n logging.debug(\"Genesis block accepted\")\n return True\n\n # OK 11 Check if prev block (matching prev hash) is in main branch or side branches. If not,\n # add this to orphan blocks, then query peer we got this from for 1st missing orphan\n # block in prev chain; done with block\n prev_blockb = r.hget(\"blockchain:blocks\", recv_block.previous_hash)\n if prev_blockb is None:\n logging.debug(\"Block %s is orphan\", util.bintos(recv_block.current_hash))\n r.sadd(\"blockchain:orphan_blocks:\".encode() + recv_block.previous_hash,\n recv_block.dumpb())\n # TODO OPT: Unlock before requesting the block (it could take some time, although\n # the response is asynchronous of course\n if not mute:\n logging.debug(\"Requesting block %s\", util.bintos(recv_block.previous_hash))\n # TODO OPT: Only ask the node we got this from, not everyone, to\n # avoid the flood of incoming blocks later\n chatter.get_blockid(recv_block.previous_hash,\n [sender_id] if sender_id is not None else util.get_peer_ids())\n return False\n\n prev_block = Block.loadb(prev_blockb)\n logging.debug(\"Previous block %s\", util.bintos(prev_block.current_hash))\n if recv_block.index != prev_block.index + 1:\n logging.debug(\"Block %s rejected (wrong index)\", util.bintos(recv_block.current_hash))\n return False\n\n # OK 15 Add block into the tree. There are three cases: 1. block further extends the main\n # branch; 2. block extends a side branch but does not add enough difficulty to make\n # it become the new main branch; 3. block extends a side branch and makes it the new\n # main branch.\n last_block = get_block()\n if recv_block.previous_hash == last_block.current_hash:\n # OK Case 1 (b.previous_hash == last_block):\n logging.debug(\"Block %s extends the main branch\", util.bintos(recv_block.current_hash))\n txos = _validate_block_unlocked(r, recv_block)\n if txos is None:\n return False\n referenced_txos, new_utxos = txos\n \"\"\"\n # NOTE: This is the body of _validate_block_unlocked, annotated, for reference\n referenced_txos: Set[bytes] = set() # the utxos from UTXO-block spent in recv_block\n new_utxos: Dict[bytes, bytes] = {}\n # OK 1 For all but the coinbase transaction, apply the following:\n for t in recv_block.transactions:\n # OK 1 For each input, look in the main branch to find the referenced output\n # transaction. Reject if the output transaction is missing for any input.\n input_amount = 0.0\n for i in t.inputs:\n # Search for i in UTXO-block\n ib = i.dumpb()\n ob = r.hget(\"blockchain:utxo-block:\".encode() + recv_block.previous_hash, ib)\n if ob is None:\n # Not found in UTXO-block, search in new_utxos\n ob = new_utxos.get(ib)\n if ob is None:\n return False\n del new_utxos[ib]\n else:\n # Avoid double-spending of a utxo from UTXO-block in the block\n if ib in referenced_txos:\n return False\n referenced_txos.add(ib)\n o = TransactionOutput.loadb(ob)\n # OK 2 For each input, if we are using the nth output of the earlier transaction,\n # but it has fewer than n+1 outputs, reject.\n # OK 4 Verify crypto signatures for each input; reject if any are bad\n if o.recipient != t.sender:\n return False\n # OK 5 For each input, if the referenced output has already been spent by a\n # transaction in the main branch, reject\n # OK 7 Reject if the sum of input values < sum of output values\n input_amount += o.amount\n if input_amount != sum(o.amount for o in t.outputs):\n return False\n\n new_utxos.update({TransactionInput(t.id, o.index).dumpb(): o.dumpb() \\\n for o in t.outputs})\n \"\"\"\n\n # OK 4 For each transaction, \"Add to wallet if mine\"\n # NOTE: referenced_txos and new_utxos are not empty since we got here\n _create_utxo_block_unlocked(r, recv_block, referenced_txos, new_utxos)\n\n # OK 5 For each transaction in the block, delete any matching transaction from the pool\n # : of the transactions in the pool, keep only the ones that are valid using the\n # new utxo-block to check for validity\n tx_pool = {t.id: t for t in \\\n [Transaction.loadb(tb) for tb in r.hvals(\"blockchain:tx_pool\")]}\n # NOTE: There can't be double spending in the tx pool as it is now\n tx_pool = _rebuild_tx_pool_unlocked(r, tx_pool, recv_block)\n\n _rebuild_utxo_tx_unlocked(r, recv_block, tx_pool)\n\n # Add block to main branch\n r.hset(\"blockchain:blocks\", recv_block.current_hash, recv_block.dumpb())\n r.sadd(\"blockchain:main_branch\", recv_block.current_hash)\n\n _set_last_block_unlocked(r, recv_block)\n logging.debug(\"Block %s accepted\", util.bintos(recv_block.current_hash))\n elif recv_block.index <= last_block.index:\n # OK Case 2 (b.previous_hash != last_block && b.index <= last_block.index)\n # : Add it without doing any validation because validating this now would require a lot\n # of work (actually simulating adding this to its prev as if extending the main branch).\n logging.debug(\"Block %s extends a side branch (not changing main)\",\n util.bintos(recv_block.current_hash))\n r.hset(\"blockchain:blocks\", recv_block.current_hash, recv_block.dumpb())\n else:\n # OK Case 3 (b.previous_hash != last_block && b.index > last_block.index)\n # OK 1 Find the fork block on the main branch which this side branch forks off of\n # : Ascend the side branch, the fork block is the first to be in the main branch\n logging.debug(\"Block %s extends a side branch (changing main)\",\n util.bintos(recv_block.current_hash))\n old_side_branch = [recv_block] # the Blocks in the old side branch\n fork_block = Block.loadb(r.hget(\"blockchain:blocks\", recv_block.previous_hash))\n while not r.sismember(\"blockchain:main_branch\", fork_block.current_hash):\n old_side_branch.append(fork_block)\n fork_block = Block.loadb(r.hget(\"blockchain:blocks\", fork_block.previous_hash))\n old_side_branch.reverse() # starting from the child of the fork block\n # OK 2 Redefine the main branch to only go up to this fork block\n # : Ascend from last_block up to the fork block\n old_main_branch: List[Block] = [] # the Blocks in the old main branch\n b = Block.loadb(r.hget(\"blockchain:blocks\", last_block.current_hash))\n while b != fork_block:\n old_main_branch.append(b)\n b = Block.loadb(r.hget(\"blockchain:blocks\", b.previous_hash))\n old_main_branch.reverse() # starting from the child of the fork block\n logging.debug(\"Fork block %s\", util.bintos(fork_block.current_hash))\n # OK 3 For each block on the side branch, from the child of the fork block to the leaf,\n # add to the main branch:\n for osbi, b in enumerate(old_side_branch):\n # OK 1 Do \"branch\" checks 3-11\n # : Why? we did them when first receiving the block. What could have changed?\n # OK 2 For all the transactions:\n txos = _validate_block_unlocked(r, b)\n if txos is None:\n # Delete invalid blocks and abort\n invalid_ids = [invalid.current_hash for invalid in old_side_branch[osbi:]]\n r.hdel(\"blockchain:blocks\", *invalid_ids)\n return False\n referenced_txos, new_utxos = txos\n \"\"\"\n # NOTE: This is the body of _validate_block_unlocked, annotated, for reference\n referenced_txos: Set[bytes] = set() # the utxos from UTXO-block spent in b\n new_utxos: Dict[bytes, bytes] = {}\n for t in b.transactions:\n # WP 1 For each input, look in the main branch to find the referenced output\n # transaction. Reject if the output transaction is missing for any input.\n # : Search for the referenced outputs in UTXO-block[previous_hash]\n input_amount = 0.0\n for i in t.inputs:\n # Search for i in UTXO-block\n ib = i.dumpb()\n ob = r.hget(\"blockchain:utxo-block:\".encode() + b.previous_hash, ib)\n if ob is None:\n # Not found in UTXO-block, search in new_utxos\n ob = new_utxos.get(ib)\n if ob is None:\n # TODO: Undo any changes, delete invalid blocks and reject\n raise NotImplementedError\n del new_utxos[ib]\n else:\n # Avoid double-spending in the block\n if ib in referenced_txos:\n # TODO: Undo any changes, delete invalid blocks and reject\n raise NotImplementedError\n referenced_txos.add(ib)\n o = TransactionOutput.loadb(ob)\n # OK 2 For each input, if we are using the nth output of the earlier\n # transaction, but it has fewer than n+1 outputs, reject.\n # WP 4 Verify crypto signatures for each input; reject if any are bad\n # : Check that t.sender == o.recipient for each utxo referenced\n if o.recipient != t.sender:\n # TODO: Undo any changes, delete invalid blocks and reject\n raise NotImplementedError\n # OK 5 For each input, if the referenced output has already been spent by a\n # transaction in the main branch, reject\n # WP 7 Reject if the sum of input values < sum of output values\n # : Check that sum(inputs) == sum(outputs)\n input_amount += o.amount\n if input_amount != sum(o.amount for o in t.outputs):\n # TODO: Undo any changes, delete invalid blocks and reject\n raise NotImplementedError\n\n new_utxos.update({TransactionInput(t.id, o.index).dumpb(): o.dumpb() for o \\\n in t.outputs})\n \"\"\"\n\n # OK 5 For each transaction, \"Add to wallet if mine\"\n # NOTE: referenced_txos and new_utxos are not empty since we got here\n _create_utxo_block_unlocked(r, b, referenced_txos, new_utxos)\n\n # OK 5 For each block in the old main branch, from the leaf down to the child of the\n # fork block:\n tx_pool = {t.id: t for t in \\\n [Transaction.loadb(tb) for tb in r.hvals(\"blockchain:tx_pool\")]}\n for b in reversed(old_main_branch):\n # OK 1 For each non-coinbase transaction in the block:\n for t in b.transactions:\n # OK 1 Apply \"tx\" checks 2-9, except in step 8, only look in the transaction\n # pool for duplicates, not the main branch\n # : Why? these have been checked already. There can't be double spending\n # transactions in the pool as it is at this point (current as of the old\n # main branch) + the old main branch, because they wouldn't have gotten\n # there in the first place.\n # OK 2 Add to transaction pool if accepted, else go on to next transaction\n tx_pool[t.id] = t\n\n # OK 6 For each block in the new main branch, from the child of the fork node to the\n # leaf:\n # OK 1 For each transaction in the block, delete any matching transaction from the\n # transaction pool\n # : Of the transactions in the pool, keep only the ones that are valid using the\n # new utxo-block to check for validity\n # NOTE: There can't be double spending in the tx pool as it is now,\n # because it consists of the tx in the previous tx pool and all the\n # tx in the old main branch, and all of these have already been\n # checked for double spending\n tx_pool = _rebuild_tx_pool_unlocked(r, tx_pool, recv_block)\n\n _rebuild_utxo_tx_unlocked(r, recv_block, tx_pool)\n\n # Update main_branch\n for b in old_main_branch:\n r.srem(\"blockchain:main_branch\", b.current_hash)\n for b in old_side_branch:\n r.sadd(\"blockchain:main_branch\", b.current_hash)\n\n r.hset(\"blockchain:blocks\", recv_block.current_hash, recv_block.dumpb())\n _set_last_block_unlocked(r, recv_block)\n logging.debug(\"Block %s accepted\", util.bintos(recv_block.current_hash))\n\n orphans = [Block.loadb(orphanb) for orphanb in \\\n r.smembers(\"blockchain:orphan_blocks:\".encode() + recv_block.current_hash)]\n r.delete(\"blockchain:orphan_blocks:\".encode() + recv_block.current_hash)\n\n logging.debug(\"Block time for %s %f\", util.bintos(recv_block.current_hash),\n time.time() - recv_block.timestamp)\n\n # OK 19 For each orphan block for which this block is its prev, run all these steps (including\n # this one) recursively on that orphan\n for orphan in orphans:\n new_recv_block(orphan, sender_id)\n\n _check_for_new_block()\n return True","def get_block(self, chunk, coords):\n\n return chunk.get_block(coords)","def get_registration_block(self, user_id):\r\n for b in self.blocks:\r\n if type(b) == RegisterBlock and b.user_id == user_id:\r\n return b\r\n raise UserNotRegisteredError","def new_block(self, body_blocks, snake_head):\n\t\tx = randint(0, 35)\n\t\ty = randint(1, 26)\n\t\tself.rect.x = (25 * x) + 1\n\t\tself.rect.bottom = 25 * y\n\t\t\n\t\t# If new block is on snake, get new block\n\t\tif self.rect.x == snake_head.rect.x and self.rect.bottom == snake_head.rect.bottom:\n\t\t\tself.new_block(body_blocks, snake_head)\n\t\t\n\t\t# If new block is on any body block, get new block\n\t\tif body_blocks:\n\t\t\tfor i in range(len(body_blocks)):\n\t\t\t\tif self.rect.x == body_blocks[i].rect.x and self.rect.bottom == body_blocks[i].rect.bottom:\n\t\t\t\t\tself.new_block(body_blocks, snake_head)","def mine_block(last_block, data):\n timestamp = time.time_ns()\n last_hash = last_block.hash\n difficulty = Block.adjust_difficulty(last_block, timestamp)\n nonce = 0\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\n\n while hex_to_binary(hash)[0:difficulty] != '0'* difficulty:\n nonce += 1\n timestamp = time.time_ns()\n difficulty = Block.adjust_difficulty(last_block, timestamp)\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\n\n return Block(timestamp, last_hash, hash, data, difficulty, nonce)","def find_block_containing(self, lfn):\n\n raise NotImplementedError('find_block_containing')","def get_block_from_node(node):\n coords = node.name.split(\",\") # name format is '(row,col)'\n col = int((coords[1])[:-1])\n row = int((coords[0])[1:])\n return Block(row, col)","def get_random_block(a=0, b=269400):\n height = random.randint(a, b)\n return get_block(get_block_hash(height))","def create_block(self, prev_hash=None):\n # Update blockchain and balance state (thread safe)\n if prev_hash is not None and prev_hash not in self._blockchain.hash_block_map.keys():\n print(prev_hash, self._blockchain.hash_block_map)\n prev_blk = None if prev_hash is None else \\\n self._blockchain.hash_block_map[prev_hash]\n last_blk = self._update(prev_blk)\n pending_tx = self._get_tx_pool()\n gathered_tx = self._gather_transactions(pending_tx)\n block = self._mine_new_block(last_blk.header, gathered_tx)\n if block is not None:\n blk_json = block.to_json()\n # Add block to blockchain (thread safe)\n self.add_block(blk_json)\n print(f\"{self.__class__.__name__} {self.name} created a block.\")\n # Broadcast block and the header.\n self._broadcast_block(block)\n # Remove gathered transactions from pool and them to added pile\n with self.added_tx_lock:\n self._added_transactions |= set(gathered_tx)\n self._update()\n return block","def mine_block(self):\n if self.hosting_node == None:\n return None\n # Fetch the currently last block of the blockchain\n last_block = self.__chain[-1]\n print(last_block)\n # Hash the last block (to be able to compare it to the stored hash value)\n hashed_block = hash_block(last_block)\n proof = self.proof_of_work()\n # Miners should be rewarded, so let's create a reward transaction\n reward_transaction = Transfer(self.hosting_node, \"MINING\", MINING_REWARD)\n # Copy transaction instead of manipulating the original open_transactions list\n # This ensures that if for some reason the mining should fail, we don't have the reward transaction stored in the open transactions\n copied_transactions = self.__open_transfers[:]\n for tx in copied_transactions:\n if not Wallet.verify_transfer(tx):\n return None\n copied_transactions.append(reward_transaction)\n block = Block(len(self.__chain), hashed_block, copied_transactions, proof)\n self.__chain.append(block)\n self.__open_transfers = []\n self.save_data()\n return block","def check_block(self, block):\n pass","def find_node(self, name):\n for node in self.get_children():\n if node.read_name() == name:\n break\n else:\n node = None\n return node","def get_or_create(self, **kwargs):\n kwargs = self._preprocess(**kwargs)\n found = self.first(**kwargs)\n if found is not None:\n return found\n\n new = self.create(**kwargs)\n return new","def mine_block(self):\n if self.public_key == None:\n return None\n last_block = self.__chain[-1]\n hashed_block = hash_block(last_block)\n proof = self.proof_of_work()\n reward_transaction = Transaction(\n 'MINING', self.public_key, '', MINING_REWARD)\n\n copied_transactions = self.__open_transactions[:]\n for tx in copied_transactions:\n if not Wallet.verify_transaction(tx):\n return None\n copied_transactions.append(reward_transaction)\n\n copied_chipsactions = self.__open_chipsactions[:]\n for tx in copied_chipsactions:\n if not Wallet.verify_chipsaction(tx):\n return None\n\n copied_messsactions = self.__open_messsactions[:]\n for tx in copied_messsactions:\n if not Wallet.verify_messsaction(tx):\n return None\n\n block = Block(len(self.__chain), hashed_block,\n copied_transactions, copied_chipsactions, copied_messsactions, proof)\n self.__chain.append(block)\n self.__open_transactions = []\n self.__open_chipsactions = []\n self.__open_messsactions = []\n self.save_data()\n for node in self.__peer_nodes:\n url = 'http://{}/broadcast-block'.format(node)\n converted_block = block.__dict__.copy()\n converted_block['transactions'] = [\n tx.__dict__ for tx in converted_block['transactions']]\n converted_block['chipsactions'] = [\n tx.__dict__ for tx in converted_block['chipsactions']]\n converted_block['messsactions'] = [\n tx.__dict__ for tx in converted_block['messsactions']] \n try:\n response = requests.post(url, json={'block': converted_block})\n if response.status_code == 400 or response.status_code == 500:\n print('Block declined, needs resolving')\n if response.status_code == 409:\n self.resolve_conflicts = True\n except requests.exceptions.ConnectionError:\n continue\n return block","def lookup_block_hash(db, block_number):\n validate_uint256(block_number)\n number_to_hash_key = make_block_number_to_hash_lookup_key(block_number)\n # TODO: can raise KeyError\n block_hash = rlp.decode(\n db.get(number_to_hash_key),\n sedes=rlp.sedes.binary,\n )\n return block_hash","def lookup_block_hash(db, block_number):\n validate_uint256(block_number)\n number_to_hash_key = make_block_number_to_hash_lookup_key(block_number)\n # TODO: can raise KeyError\n block_hash = rlp.decode(\n db.get(number_to_hash_key),\n sedes=rlp.sedes.binary,\n )\n return block_hash","def find_cell(app, cell):\n if VALID_BLOCK(cell.block) and VALID_CELL(cell):\n app_block = app.board.blocks[cell.block.column][cell.block.row]\n app_cell = app_block.cells[cell.column][cell.row]\n return app_cell\n else:\n return None","def getFirstBlock(self, blockType=None, exact=False):\n for a in self:\n for b in a:\n if b.hasFlags(blockType, exact):\n return b\n\n return None","def addBlock(self, newBlock):\n newBlock.index = len(self.chain)\n newBlock.previousHash = self.chain[-1].hash\n newBlock.mineBlock(self.difficulty)\n self.chain.append(newBlock)\n self.writeBlocks()","def fetch(self, block_name):\n imag_bot = _ImaginaryBot(self._pos, self._inventory)\n block_id = getattr(block, block_name).id\n block_loc = self._get_block_loc(block_id)\n mine_prob = _MineProblem(imag_bot, block_loc, block_id)\n mine_actions = astar(mine_prob, _mine_heuristic)\n self.take_actions(mine_actions, _DELAY)\n imag_bot = _ImaginaryBot(self._pos, self._inventory)\n player_loc = _player_loc()\n return_prob = _ReturnProblem(imag_bot, block_id, player_loc)\n return_actions = astar(return_prob, _return_heuristic)\n imag_bot.take_actions(return_actions)\n return_actions.append({\n 'func': '_place',\n 'args': (imag_bot.get_pos() + player_loc) / 2,\n 'kwargs': {'block': block_id}\n })\n self.take_actions(return_actions, _DELAY)","def _add_block(self, block: Block, write_to_ledger, mined_ourselves):\n\n with self.lock:\n self.mining_flag = GIVEN_BLOCK\n\n with self.lock:\n if block.parent_hash in self.blocks:\n parent_node = self.blocks[block.parent_hash]\n block_node = BlockNode(block, parent_node)\n parent_node.add_child(block_node)\n\n self._update_latest_pointers(block_node) # Check if the new block makes a longer chain and switch to it\n\n self.log.debug(GREEN + \"%s:[%s] added block to fork %d at depth %d\" + NC, block.miner_key_hash[:6], time.ctime(block.create_time), block_node.fork_num, block_node.depth)\n # self.log.debug(\"Added block to blockchain\")\n elif block.is_root:\n block_node = BlockNode(block, None)\n self.root = block_node\n # self.log.debug(\"Added block as root\")\n self.log.debug(GREEN + \"%s:[%s] added block as root %d\" + NC, block.miner_key_hash[:6], time.ctime(block.create_time), block_node.tree_num)\n self._update_latest_pointers(block_node)\n # self.messages.clear()\n Blockchain.num_trees += 1\n\n self._add_block_msgs(block) # Add all new posts to message table\n if self.message_num % 10000 == 0:\n self._write_new_messages(self.message_num-10000) # Save new messages to file\n self.blocks[block.block_hash] = block_node\n self.total_blocks += 1\n\n # Update ledger.txt with newly added block\n if write_to_ledger:\n with open(self.ledger_file, 'a') as ledger:\n ledger.write(repr(block) + \"\\n\")\n\n if self.total_blocks % STATS_UPDATE_INTERVAL == 0: # Every few blocks update stats.txt\n self._write_stats_file()\n\n self.mining_flag = CONTINUE_MINING\n\n if not mined_ourselves:\n self._update_msg_queue(block)\n\n if time.time() - self.last_msg_update > MSG_UPDATE_DELAY:\n self._reinit_message_table()\n self.last_msg_update = time.time()\n\n return True","def forge_block(offset, plaintext, oracle):\n b_size, _, _ = challenge_12.determine_block_stats(oracle)\n new_padding = b\"A\" * (b_size - offset)\n payload = new_padding + challenge_09.pkcs7(plaintext, b_size)\n ciphertext = oracle(payload)\n\n return challenge_07.as_blocks(ciphertext, b_size)[1]","def getMemoryBlock(self, name: unicode) -> ghidra.program.model.mem.MemoryBlock:\n ...","def mine_block(previous: bytes, height: int, miner: bytes, transactions: List[Transaction], timestamp: int, difficulty: int, cutoff_time: int) -> 'Block':\n print('============================ \\n \\n \\n ============================')\n manager = mp.Manager()\n final_nonce = manager.Value('i', None)\n # Declare a new instance of a block, and change the nonce until it produces a correct block_id\n\n block = Block(miner=miner, transactions=transactions, timestamp=timestamp,\n block_id=None, nonce=0, previous=previous, height=height, difficulty=difficulty)\n processes: List[Process] = []\n\n found_event = Event()\n for _ in range(processors):\n process = Process(target=_mine_block, args=(\n block, final_nonce, found_event, cutoff_time))\n processes.append(process)\n\n for process in processes:\n\n process.start()\n\n found_event.wait()\n\n for process in processes:\n process.terminate()\n\n for process in processes:\n process.join()\n print('============= END =============== \\n \\n \\n ============================')\n if final_nonce.value is not None:\n block.nonce = final_nonce.value\n block.block_id = block.compute_block_id()\n return block\n else:\n return None","def add_block(self, block_name, block_type, starting_address, size):\r\n with self._data_lock: # thread-safe\r\n if size <= 0:\r\n raise InvalidArgumentError, \"size must be a positive number\"\r\n if starting_address < 0:\r\n raise InvalidArgumentError, \"starting address must be zero or positive number\"\r\n if self._blocks.has_key(block_name):\r\n raise DuplicatedKeyError, \"Block %s already exists. \" % (block_name)\r\n\r\n if not self._memory.has_key(block_type):\r\n raise InvalidModbusBlockError, \"Invalid block type %d\" % (block_type)\r\n\r\n # check that the new block doesn't overlap an existing block\r\n # it means that only 1 block per type must correspond to a given address\r\n # for example: it must not have 2 holding registers at address 100\r\n index = 0\r\n for i in xrange(len(self._memory[block_type])):\r\n block = self._memory[block_type][i]\r\n if block.is_in(starting_address, size):\r\n raise OverlapModbusBlockError, \"Overlap block at %d size %d\" % (block.starting_address, block.size)\r\n if block.starting_address > starting_address:\r\n index = i\r\n break\r\n\r\n # if the block is ok: register it\r\n self._blocks[block_name] = (block_type, starting_address)\r\n # add it in the 'per type' shortcut\r\n self._memory[block_type].insert(index, ModbusBlockDatabusMediator(block_name, starting_address, size))","def addBlock(self, data):\n #get the hashVal of last block in blockchain\n lastHash = self.chain[len(self.chain) - 1].hashVal\n timestamp = time()\n hashVal = Block.hashSHA(timestamp, lastHash, data, NONCE, DIFFICULTY)\n adding_block = Block(timestamp, lastHash, hashVal, data, NONCE, DIFFICULTY)\n \n self.chain.append(adding_block)\n return adding_block","def getblock(self, hash):\n return self.proxy.getblock(hash)","def FindBlockIndex(filename, format, num_blocks):\n for block in range(1, num_blocks+1):\n suffix = format % block\n if filename.endswith(suffix):\n return block\n raise Exception(\"Can't find block index: %s\" % filename)","def getDiskAddrOfBlock_recursive(self, fs:FileSystem, block_number, alloc_p, blocks, level):\n\n if level == 0:\n assert block_number < len(blocks), \\\n \"internal error: level 0 blocks overflow {} >= {}\".format(block_number, len(blocks))\n if blocks[block_number] == 0:\n if alloc_p:\n blocks[block_number] = fs.allocBlock()\n else:\n print(\"can't find block {} in {}\".format(block_number, blocks))\n return -1\n return blocks[block_number]\n\n else:\n block_ptrs_per_block = fs.block_size // 4\n block_pointers_per_index = block_ptrs_per_block ** level\n inner_block_num = block_number // block_pointers_per_index\n inner_offset = block_number % block_pointers_per_index\n\n inner_blocks = fs.readBlockCache(inner_block_num, blocks)\n return self.getDiskAddrOfBlock_recursive(fs, inner_offset, alloc_p, inner_blocks, level-1)","def _place(self, loc, exclude=None, block_=None):\n if not self._inventory:\n raise Exception('Inventory empty')\n\n if block_ is None:\n for key in self._inventory:\n if key != exclude:\n block_ = key\n break\n else:\n raise Exception((\n 'You requested not to place %s, but it is the only '\n 'block in the inventory.' % exclude\n ))\n\n if block_ not in self._inventory:\n raise Exception('Block %s is not in the inventory' % block_)\n\n if self._inventory[block_] == 1:\n del self._inventory[block_]\n else:\n self._inventory[block_] -= 1\n\n self._set_block(loc, block_)","def add_block(self, env):\n block_size = (0.04, 0.04, 0.04)\n block_pose = self.random_pose(env, block_size)\n block_urdf = 'assets/stacking/block.urdf'\n block_id = env.add_object(block_urdf, block_pose)\n self.object_points[block_id] = np.float32((0, 0, 0)).reshape(3, 1)\n self._IDs[block_id] = 'block'\n return block_id","def create_item(\r\n self, course_or_parent_locator, category, user_id,\r\n block_id=None, definition_locator=None, fields=None,\r\n force=False, continue_version=False\r\n ):\r\n # find course_index entry if applicable and structures entry\r\n index_entry = self._get_index_if_valid(course_or_parent_locator, force, continue_version)\r\n structure = self._lookup_course(course_or_parent_locator)['structure']\r\n\r\n partitioned_fields = self.partition_fields_by_scope(category, fields)\r\n new_def_data = partitioned_fields.get(Scope.content, {})\r\n # persist the definition if persisted != passed\r\n if (definition_locator is None or isinstance(definition_locator.definition_id, LocalId)):\r\n definition_locator = self.create_definition_from_data(new_def_data, category, user_id)\r\n elif new_def_data is not None:\r\n definition_locator, _ = self.update_definition_from_data(definition_locator, new_def_data, user_id)\r\n\r\n # copy the structure and modify the new one\r\n if continue_version:\r\n new_structure = structure\r\n else:\r\n new_structure = self._version_structure(structure, user_id)\r\n\r\n new_id = new_structure['_id']\r\n\r\n # generate usage id\r\n if block_id is not None:\r\n if LocMapperStore.encode_key_for_mongo(block_id) in new_structure['blocks']:\r\n raise DuplicateItemError(block_id, self, 'structures')\r\n else:\r\n new_block_id = block_id\r\n else:\r\n new_block_id = self._generate_block_id(new_structure['blocks'], category)\r\n\r\n block_fields = partitioned_fields.get(Scope.settings, {})\r\n if Scope.children in partitioned_fields:\r\n block_fields.update(partitioned_fields[Scope.children])\r\n self._update_block_in_structure(new_structure, new_block_id, {\r\n \"category\": category,\r\n \"definition\": definition_locator.definition_id,\r\n \"fields\": self._serialize_fields(category, block_fields),\r\n 'edit_info': {\r\n 'edited_on': datetime.datetime.now(UTC),\r\n 'edited_by': user_id,\r\n 'previous_version': None,\r\n 'update_version': new_id,\r\n }\r\n })\r\n\r\n # if given parent, add new block as child and update parent's version\r\n parent = None\r\n if isinstance(course_or_parent_locator, BlockUsageLocator) and course_or_parent_locator.block_id is not None:\r\n encoded_block_id = LocMapperStore.encode_key_for_mongo(course_or_parent_locator.block_id)\r\n parent = new_structure['blocks'][encoded_block_id]\r\n parent['fields'].setdefault('children', []).append(new_block_id)\r\n if not continue_version or parent['edit_info']['update_version'] != structure['_id']:\r\n parent['edit_info']['edited_on'] = datetime.datetime.now(UTC)\r\n parent['edit_info']['edited_by'] = user_id\r\n parent['edit_info']['previous_version'] = parent['edit_info']['update_version']\r\n parent['edit_info']['update_version'] = new_id\r\n if continue_version:\r\n # db update\r\n self.db_connection.update_structure(new_structure)\r\n # clear cache so things get refetched and inheritance recomputed\r\n self._clear_cache(new_id)\r\n else:\r\n self.db_connection.insert_structure(new_structure)\r\n\r\n # update the index entry if appropriate\r\n if index_entry is not None:\r\n if not continue_version:\r\n self._update_head(index_entry, course_or_parent_locator.branch, new_id)\r\n item_loc = BlockUsageLocator(\r\n course_or_parent_locator.version_agnostic(),\r\n block_type=category,\r\n block_id=new_block_id,\r\n )\r\n else:\r\n item_loc = BlockUsageLocator(\r\n CourseLocator(version_guid=new_id),\r\n block_type=category,\r\n block_id=new_block_id,\r\n )\r\n\r\n # reconstruct the new_item from the cache\r\n return self.get_item(item_loc)"],"string":"[\n \"def _load_block(self, addr):\\n ret_block = None\\n\\n tag, set_index, offset = self._decompose(addr)\\n\\n if set_index not in self._d:\\n self._d[set_index] = []\\n block_list = self._d[set_index]\\n for tag_, block in block_list:\\n if tag == tag_:\\n self._track(addr, read=True, hit=True)\\n return block\\n\\n # block not explicitly present, so might be a miss\\n if self.implicit and len(block_list) <= self.num_blocks_per_set:\\n # even though the addr hasn't been explicitly added to the store\\n # yet, this store is implicity known to have been zerod out\\n # so we just create a new block and store it explicitly, and\\n # pretend it was a hit\\n self._track(addr, read=True, hit=True)\\n base = addr - offset\\n block = Block(self.block_size, base)\\n block_list.append((tag, block))\\n return block\\n\\n # definite miss\\n self._track(addr, read=True, hit=False)\\n\\n # ...and load from the next level of the store\\n block_base = addr - offset\\n block = self._read_block_from_next(block_base)\\n\\n # and add it to the store\\n self._write_block(addr, block, direct=False)\\n\\n return block\",\n \"def get_block_by_hash(self, block_hash):\\n if block_hash in self.block_cache:\\n return self.block_cache[block_hash]\\n\\n mongo_block = self.blocks.find_one({\\\"hash\\\": block_hash})\\n\\n if not mongo_block:\\n raise KeyError(\\\"[get_block_by_hash] Block with hash %s not found.\\\" % block_hash)\\n\\n mongo_block_transactions = self.transactions.find({\\\"blockhash\\\": mongo_block['hash']})\\n return MongoBlockFactory.from_mongo(mongo_block, mongo_block_transactions)\",\n \"def get_block_with_name(self, block_name: str) -> BasicBlock:\\n block: BasicBlock\\n all_blocks: Dict[str, BasicBlock] = self.get_all_blocks()\\n if block_name in all_blocks:\\n return all_blocks[block_name]\\n raise Exception(ERROR_BLOCK_DOESNT_EXIST % block_name)\",\n \"async def add_block(\\n self,\\n position: typing.Tuple[int, int, int],\\n block_name: typing.Union[str, typing.Any],\\n immediate=True,\\n block_update=True,\\n block_update_self=True,\\n lazy_setup: typing.Callable[[typing.Any], None] = None,\\n check_build_range=True,\\n block_state=None,\\n network_sync=True,\\n ) -> typing.Optional[typing.Any]:\\n raise NotImplementedError\",\n \"def _check_for_new_block() -> None:\\n logging.debug(\\\"Checking for new block\\\")\\n CAPACITY = block.get_capacity()\\n\\n r = util.get_db()\\n with r.lock(\\\"blockchain:last_block:lock\\\"), \\\\\\n r.lock(\\\"blockchain:miner_pid:lock\\\"), \\\\\\n r.lock(\\\"blockchain:tx_pool:lock\\\"), \\\\\\n r.lock(\\\"blockchain:utxo-block:lock\\\"):\\n # NOTE: If a miner is running, we expect it to add a new block, so we\\n # abort. If mining succeeds, this function will be called again by\\n # new_recv_block(). If it fails (another valid block is received) this\\n # will again be called by new_recv_block()\\n miner_pidb = r.get(\\\"blockchain:miner_pid\\\")\\n if miner_pidb is not None:\\n logging.debug(\\\"Miner already running with PID %d\\\", util.btoui(miner_pidb))\\n return\\n\\n tx_pool = {Transaction.loadb(tb) for tb in r.hvals(\\\"blockchain:tx_pool\\\")}\\n if len(tx_pool) < CAPACITY:\\n logging.debug(\\\"Cannot create new block yet (not enough transactions)\\\")\\n return\\n\\n last_block = get_block()\\n utxo_block = {TransactionInput.loadb(i): TransactionOutput.loadb(o) for i, o \\\\\\n in r.hgetall(\\\"blockchain:utxo-block:\\\".encode() + last_block.current_hash).items()}\\n new_block_tx: List[Transaction] = []\\n # NOTE: Since there are >= CAPACITY transactions in the pool, and we\\n # don't mind transaction inter-dependence in the same block, a new\\n # block can be created, so this loop will terminate\\n while True:\\n for t in tx_pool:\\n # Search for t.inputs in UTXO-block[last_block] as well as in new_block_tx\\n if all(i in utxo_block or \\\\\\n any(nt.id == i.transaction_id for nt in new_block_tx) for i in t.inputs):\\n new_block_tx.append(t)\\n if len(new_block_tx) == CAPACITY:\\n new_block = Block(index=last_block.index + 1,\\n previous_hash=last_block.current_hash,\\n transactions=new_block_tx)\\n # NOTE: We don't delete the new block_tx from the pool, because\\n # mining might fail. They will be deleted eventually when they\\n # enter the main branch.\\n miner_pid = new_block.finalize()\\n r.set(\\\"blockchain:miner_pid\\\", util.uitob(miner_pid))\\n logging.debug(\\\"Miner started with PID %d\\\", miner_pid)\\n return\\n tx_pool.difference_update(new_block_tx)\",\n \"def find_blk_below(blk, name):\\n if blk == None or len(blk.connections) == 0:\\n return\\n _group = find_group(blk)\\n for _gblk in _group:\\n if _gblk.name == name:\\n return _gblk\\n return None\",\n \"def get_block(block_id: Optional[bytes] = None) -> Optional[Block]:\\n if block_id is not None and not isinstance(block_id, bytes):\\n raise TypeError\\n if block_id is None:\\n logging.debug(\\\"Last block requested\\\")\\n else:\\n logging.debug(\\\"Block %s requested\\\", util.bintos(block_id))\\n\\n r = util.get_db()\\n if block_id is None:\\n block_id = r.get(\\\"blockchain:last_block\\\")\\n if block_id is None:\\n # The blockchain is empty\\n logging.debug(\\\"Blockchain is empty\\\")\\n return None\\n\\n blockb = r.hget(\\\"blockchain:blocks\\\", block_id)\\n if blockb is None:\\n # Requested block not found\\n logging.debug(\\\"Block %s not found\\\", util.bintos(block_id))\\n return None\\n\\n logging.debug(\\\"Block %s retrieved\\\", util.bintos(block_id))\\n return Block.loadb(blockb)\",\n \"async def refresh(self):\\n block = await self.blockchain.rpc.get_block(self.identifier)\\n if not block:\\n raise BlockDoesNotExistsException\\n await super(Block, self).__init__(\\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\\n )\",\n \"def _get_block_from_structure(self, structure, block_id):\\r\\n return structure['blocks'].get(LocMapperStore.encode_key_for_mongo(block_id))\",\n \"def refresh(self):\\n block = self.graphene.rpc.get_block(self.block)\\n if not block:\\n raise BlockDoesNotExistsException\\n super(Block, self).__init__(block)\\n self.cached = True\",\n \"def _get_block_from_structure(self, structure, block_key):\\n return structure['blocks'].get(block_key)\",\n \"def get_best_block(self) -> Block:\\n assert self.indexes is not None\\n block_hash = self.indexes.height.get_tip()\\n block = self.get_transaction(block_hash)\\n assert isinstance(block, Block)\\n assert block.get_metadata().validation.is_fully_connected()\\n return block\",\n \"def createBlock(self, block: ghidra.program.model.mem.MemoryBlock, name: unicode, start: ghidra.program.model.address.Address, length: long) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def _get_block(self, pos):\\n raise NotImplementedError\",\n \"def get_best_block(self, node):\\n block_height = node.getblockcount()\\n blockhash = node.getblockhash(block_height)\\n block = FromHex(CBlock(), node.getblock(blockhash, 0))\\n block.calc_sha256()\\n self.block_heights[block.sha256] = block_height\\n return block\",\n \"def getBlockByName(self, name):\\n try:\\n return self.blocksByName[name]\\n except AttributeError:\\n self._genBlocksByName()\\n return self.blocksByName[name]\",\n \"def get_block_obj(self, vault_id, block_id):\\n path = self._get_block_path(vault_id, block_id)\\n\\n if not os.path.exists(path):\\n return None\\n\\n return open(path, 'rb')\",\n \"def add(self, block):\\n\\n try:\\n self.blocks[block.height]\\n except:\\n\\n self.blocks[block.height] = [block]\\n if self.current_height < block.height:\\n self.current_height = block.height\\n return\\n\\n if not block.hash() in [b.hash() for b in self.blocks[block.height]]:\\n self.blocks[block.height].append(block)\\n loggerutil.debug(\\\"fork detected for height:\\\" + str(block.height) +\\n \\\"block candidats:\\\" + str(self.blocks[block.height]))\\n if self.current_height < block.height:\\n self.current_height = block.height\",\n \"def get_block_by_path(self, path):\\n\\n def walk(block, parts):\\n # Check if instance matches\\n instance = \\\"{}[{}]\\\".format(parts[0].name, parts[0].index)\\n if block.instance != instance:\\n return None\\n\\n # Check if operating mode matches\\n if parts[0].mode is not None:\\n if block.mode != parts[0].mode:\\n return None\\n\\n # Next\\n parts = parts[1:]\\n\\n # No more path parts, this is the block\\n if not parts:\\n return block\\n\\n # Find child block by its instance and recurse\\n instance = \\\"{}[{}]\\\".format(parts[0].name, parts[0].index)\\n if instance in block.blocks:\\n return walk(block.blocks[instance], parts)\\n\\n return None\\n\\n # Prepend self to the path\\n path = \\\"{}[{}]\\\".format(self.instance, self.mode) + \\\".\\\" + path\\n\\n # Split and parse the path\\n path = path.split(\\\".\\\")\\n path = [PathNode.from_string(p) for p in path]\\n\\n # Find the child\\n return walk(self, path)\",\n \"def _get_block(self, pos):\\n if pos in self._changes:\\n return self._changes[pos]\\n else:\\n return _get_mc().getBlock(pos)\",\n \"def get_block(self, blockhash):\\n\\n return self._blocks.get(blockhash)\",\n \"def find_next_block(chunks, pos):\\n\\n\\twhile pos < len(chunks):\\n\\n\\t\\tpos, chunk = find_next_chunk(chunks, pos, [0x100, 0x102])\\n\\n#\\t\\tif chunks[pos][0] == 0x100 or chunks[pos][0] == 0x102:\\n\\n#\\t\\t\\tif len(chunks[pos][1]) > 1:\\n\\n\\t\\tif pos == None:\\n\\n\\t\\t\\treturn None\\n\\t\\telse:\\n\\t\\t\\tif len(chunk[1]) > 1:\\n\\n\\t\\t\\t\\t# Found a block, return this position\\n\\t\\t\\t\\treturn pos\\n\\n\\t\\t# Otherwise continue looking\\n\\t\\tpos = pos + 1\\n\\n\\treturn None\",\n \"def get_block(blockhash):\\n return requests.get(BASE+f'/api/block/{blockhash}').json()\",\n \"def add_block(self, name):\\n\\n if not self.RE_NAME.match(name):\\n raise ValueError(u\\\"Invalid block name '{0}'\\\"\\n .format(common.from_utf8(name)))\\n\\n if name in self._block_map:\\n raise ValueError(u\\\"Block '{0}' already exists\\\"\\n .format(common.from_utf8(name)))\\n\\n # add new block and index mapping\\n self._block_map[name] = len(self._ast[2]) # must come first\\n option_list = []\\n block = [name, option_list]\\n self._ast[2].append(block)\",\n \"def get_cached_block(self, course_key, version_guid, block_id):\\n bulk_write_record = self._get_bulk_ops_record(course_key)\\n if bulk_write_record.active:\\n return bulk_write_record.modules[version_guid].get(block_id, None)\\n else:\\n return None\",\n \"def find_block_to_run(blk):\\n _top = find_top_block(blk)\\n if blk == _top and blk.name[0:3] is not 'def':\\n return True\\n else:\\n return False\",\n \"def find_node(self, name, create=False):\\n\\n name = self._validate_name(name)\\n node = self.nodes.get(name)\\n if node is None:\\n if not create:\\n raise KeyError\\n node = self.node_factory()\\n self.nodes[name] = node\\n return node\",\n \"def find_top_block(blk):\\n if blk is None:\\n return None\\n if len(blk.connections) == 0:\\n return blk\\n while blk.connections[0] is not None:\\n blk = blk.connections[0]\\n return blk\",\n \"def getBlock(self, blockName: unicode) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def pick_block(self):\\n current_block = self.blocks[self.editor_cursor_position[1]][self.editor_cursor_position[0]]\\n if current_block in self.available_block_types:\\n self.current_block_type = self.available_block_types.index(current_block)\",\n \"def add_block(self, block, save=True):\\n if block.hash in self.blocks:\\n return False\\n if not block.is_valid()[0]:\\n return False\\n if not block.height in self.chain:\\n self.chain[block.height] = []\\n if not block.hash in self.chain[block.height]:\\n # add newer blocks to front so they show up first in UI\\n self.chain[block.height] = [block.hash] + self.chain[block.height]\\n if not block.hash in self.blocks:\\n self.blocks[block.hash] = block\\n for tx in block.transactions:\\n self.all_transactions[tx.hash] = tx\\n if not tx.hash in self.blocks_containing_tx:\\n self.blocks_containing_tx[tx.hash] = []\\n self.blocks_containing_tx[tx.hash].append(block.hash)\\n for input_ref in tx.input_refs:\\n if not input_ref in self.blocks_spending_input:\\n self.blocks_spending_input[input_ref] = []\\n self.blocks_spending_input[input_ref].append(block.hash)\\n self._p_changed = True # Marked object as changed so changes get saved to ZODB.\\n if save:\\n transaction.commit() # If we're going to save the block, commit the transaction.\\n return True\",\n \"async def create_block_type(self, block_type: BlockTypeCreate) -> BlockType:\\n try:\\n response = await self._client.post(\\n \\\"/block_types/\\\",\\n json=block_type.dict(\\n json_compatible=True, exclude_unset=True, exclude={\\\"id\\\"}\\n ),\\n )\\n except httpx.HTTPStatusError as e:\\n if e.response.status_code == status.HTTP_409_CONFLICT:\\n raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e\\n else:\\n raise\\n return BlockType.parse_obj(response.json())\",\n \"def add_block(self, block):\\n # checks for errors in new block's position\\n if block.index != 0 and len(self.chain) == 0:\\n raise Exception('Chain was not initiated. Insert Genesis block first')\\n elif len(self.chain) < block.index:\\n raise Exception(\\\"New block's position doesn't fit chain's order\\\")\\n elif block.index == 0 and len(self.chain) == 1:\\n raise Exception(\\\"Genesis block is already exist\\\")\\n elif block.index == 0:\\n self.chain.append(block)\\n return True\\n # validates the block and verifies the chain with the new block\\n elif block.is_valid() and self.verify_chain(block):\\n self.chain.append(block)\\n return True\\n else:\\n return False\",\n \"def locate_block(mm, header, trailer, force_head=False, force_tail=False,\\n skip_header=True, skip_trailer=None):\\n if skip_trailer is None:\\n skip_trailer = not force_tail\\n begin_idx = mm.find(header.encode())\\n if begin_idx == -1:\\n if force_head:\\n begin_idx = 0\\n else:\\n raise RuntimeError('failed to find \\\"%s\\\"' % header)\\n if skip_header:\\n mm.seek(begin_idx)\\n mm.readline()\\n begin_idx = mm.tell()\\n end_idx = mm.find(trailer.encode())\\n whence = 1 # seek from current location by default\\n if end_idx == -1:\\n if force_tail:\\n whence = 2 # seek from end of file\\n else:\\n raise RuntimeError('failed to find \\\"%s\\\"' % trailer)\\n if not skip_trailer:\\n mm.seek(end_idx, whence)\\n mm.readline()\\n end_idx = mm.tell()\\n return begin_idx, end_idx\",\n \"def add_block(self, block_pf):\\n\\n # test si il s'agit du bloc genesis\\n if len(self.blocks) != 0:\\n # check si previous H est coherent avant ajout a chaine\\n if self.check_previousBlockH(block_pf.header['prevBlockH']):\\n self.blocks.append(block_pf)\\n else:\\n print \\\"== Probleme de parent\\\"\\n print \\\"= %s\\\" % block_pf.header['prevBlockH']\\n print \\\"= %s\\\" % getHashBlock(self.get_topBlock())\\n else:\\n self.blocks.append(block_pf)\",\n \"async def add_block(\\n self,\\n block: FullBlock,\\n peer: Optional[WSChiaConnection] = None,\\n raise_on_disconnected: bool = False,\\n ) -> Optional[Message]:\\n if self.sync_store.get_sync_mode():\\n return None\\n\\n # Adds the block to seen, and check if it's seen before (which means header is in memory)\\n header_hash = block.header_hash\\n if self.blockchain.contains_block(header_hash):\\n return None\\n\\n pre_validation_result: Optional[PreValidationResult] = None\\n if (\\n block.is_transaction_block()\\n and block.transactions_info is not None\\n and block.transactions_info.generator_root != bytes([0] * 32)\\n and block.transactions_generator is None\\n ):\\n # This is the case where we already had the unfinished block, and asked for this block without\\n # the transactions (since we already had them). Therefore, here we add the transactions.\\n unfinished_rh: bytes32 = block.reward_chain_block.get_unfinished().get_hash()\\n unf_block: Optional[UnfinishedBlock] = self.full_node_store.get_unfinished_block(unfinished_rh)\\n if (\\n unf_block is not None\\n and unf_block.transactions_generator is not None\\n and unf_block.foliage_transaction_block == block.foliage_transaction_block\\n ):\\n # We checked that the transaction block is the same, therefore all transactions and the signature\\n # must be identical in the unfinished and finished blocks. We can therefore use the cache.\\n pre_validation_result = self.full_node_store.get_unfinished_block_result(unfinished_rh)\\n assert pre_validation_result is not None\\n block = dataclasses.replace(\\n block,\\n transactions_generator=unf_block.transactions_generator,\\n transactions_generator_ref_list=unf_block.transactions_generator_ref_list,\\n )\\n else:\\n # We still do not have the correct information for this block, perhaps there is a duplicate block\\n # with the same unfinished block hash in the cache, so we need to fetch the correct one\\n if peer is None:\\n return None\\n\\n block_response: Optional[Any] = await peer.call_api(\\n FullNodeAPI.request_block, full_node_protocol.RequestBlock(block.height, True)\\n )\\n if block_response is None or not isinstance(block_response, full_node_protocol.RespondBlock):\\n self.log.warning(\\n f\\\"Was not able to fetch the correct block for height {block.height} {block_response}\\\"\\n )\\n return None\\n new_block: FullBlock = block_response.block\\n if new_block.foliage_transaction_block != block.foliage_transaction_block:\\n self.log.warning(f\\\"Received the wrong block for height {block.height} {new_block.header_hash}\\\")\\n return None\\n assert new_block.transactions_generator is not None\\n\\n self.log.debug(\\n f\\\"Wrong info in the cache for bh {new_block.header_hash}, there might be multiple blocks from the \\\"\\n f\\\"same farmer with the same pospace.\\\"\\n )\\n # This recursion ends here, we cannot recurse again because transactions_generator is not None\\n return await self.add_block(new_block, peer)\\n state_change_summary: Optional[StateChangeSummary] = None\\n ppp_result: Optional[PeakPostProcessingResult] = None\\n async with self.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):\\n # After acquiring the lock, check again, because another asyncio thread might have added it\\n if self.blockchain.contains_block(header_hash):\\n return None\\n validation_start = time.time()\\n # Tries to add the block to the blockchain, if we already validated transactions, don't do it again\\n npc_results = {}\\n if pre_validation_result is not None and pre_validation_result.npc_result is not None:\\n npc_results[block.height] = pre_validation_result.npc_result\\n\\n # Don't validate signatures because we want to validate them in the main thread later, since we have a\\n # cache available\\n pre_validation_results = await self.blockchain.pre_validate_blocks_multiprocessing(\\n [block], npc_results, validate_signatures=False\\n )\\n added: Optional[AddBlockResult] = None\\n pre_validation_time = time.time() - validation_start\\n try:\\n if len(pre_validation_results) < 1:\\n raise ValueError(f\\\"Failed to validate block {header_hash} height {block.height}\\\")\\n if pre_validation_results[0].error is not None:\\n if Err(pre_validation_results[0].error) == Err.INVALID_PREV_BLOCK_HASH:\\n added = AddBlockResult.DISCONNECTED_BLOCK\\n error_code: Optional[Err] = Err.INVALID_PREV_BLOCK_HASH\\n elif Err(pre_validation_results[0].error) == Err.TIMESTAMP_TOO_FAR_IN_FUTURE:\\n raise TimestampError()\\n else:\\n raise ValueError(\\n f\\\"Failed to validate block {header_hash} height \\\"\\n f\\\"{block.height}: {Err(pre_validation_results[0].error).name}\\\"\\n )\\n else:\\n result_to_validate = (\\n pre_validation_results[0] if pre_validation_result is None else pre_validation_result\\n )\\n assert result_to_validate.required_iters == pre_validation_results[0].required_iters\\n (added, error_code, state_change_summary) = await self.blockchain.add_block(\\n block, result_to_validate, None\\n )\\n if added == AddBlockResult.ALREADY_HAVE_BLOCK:\\n return None\\n elif added == AddBlockResult.INVALID_BLOCK:\\n assert error_code is not None\\n self.log.error(f\\\"Block {header_hash} at height {block.height} is invalid with code {error_code}.\\\")\\n raise ConsensusError(error_code, [header_hash])\\n elif added == AddBlockResult.DISCONNECTED_BLOCK:\\n self.log.info(f\\\"Disconnected block {header_hash} at height {block.height}\\\")\\n if raise_on_disconnected:\\n raise RuntimeError(\\\"Expected block to be added, received disconnected block.\\\")\\n return None\\n elif added == AddBlockResult.NEW_PEAK:\\n # Only propagate blocks which extend the blockchain (becomes one of the heads)\\n assert state_change_summary is not None\\n ppp_result = await self.peak_post_processing(block, state_change_summary, peer)\\n\\n elif added == AddBlockResult.ADDED_AS_ORPHAN:\\n self.log.info(\\n f\\\"Received orphan block of height {block.height} rh {block.reward_chain_block.get_hash()}\\\"\\n )\\n else:\\n # Should never reach here, all the cases are covered\\n raise RuntimeError(f\\\"Invalid result from add_block {added}\\\")\\n except asyncio.CancelledError:\\n # We need to make sure to always call this method even when we get a cancel exception, to make sure\\n # the node stays in sync\\n if added == AddBlockResult.NEW_PEAK:\\n assert state_change_summary is not None\\n await self.peak_post_processing(block, state_change_summary, peer)\\n raise\\n\\n validation_time = time.time() - validation_start\\n\\n if ppp_result is not None:\\n assert state_change_summary is not None\\n await self.peak_post_processing_2(block, peer, state_change_summary, ppp_result)\\n\\n percent_full_str = (\\n (\\n \\\", percent full: \\\"\\n + str(round(100.0 * float(block.transactions_info.cost) / self.constants.MAX_BLOCK_COST_CLVM, 3))\\n + \\\"%\\\"\\n )\\n if block.transactions_info is not None\\n else \\\"\\\"\\n )\\n self.log.log(\\n logging.WARNING if validation_time > 2 else logging.DEBUG,\\n f\\\"Block validation time: {validation_time:0.2f} seconds, \\\"\\n f\\\"pre_validation time: {pre_validation_time:0.2f} seconds, \\\"\\n f\\\"cost: {block.transactions_info.cost if block.transactions_info is not None else 'None'}\\\"\\n f\\\"{percent_full_str} header_hash: {header_hash} height: {block.height}\\\",\\n )\\n\\n # This code path is reached if added == ADDED_AS_ORPHAN or NEW_TIP\\n peak = self.blockchain.get_peak()\\n assert peak is not None\\n\\n # Removes all temporary data for old blocks\\n clear_height = uint32(max(0, peak.height - 50))\\n self.full_node_store.clear_candidate_blocks_below(clear_height)\\n self.full_node_store.clear_unfinished_blocks_below(clear_height)\\n if peak.height % 1000 == 0 and not self.sync_store.get_sync_mode():\\n await self.sync_store.clear_sync_info() # Occasionally clear sync peer info\\n\\n state_changed_data: Dict[str, Any] = {\\n \\\"transaction_block\\\": False,\\n \\\"k_size\\\": block.reward_chain_block.proof_of_space.size,\\n \\\"header_hash\\\": block.header_hash,\\n \\\"height\\\": block.height,\\n \\\"validation_time\\\": validation_time,\\n \\\"pre_validation_time\\\": pre_validation_time,\\n }\\n\\n if block.transactions_info is not None:\\n state_changed_data[\\\"transaction_block\\\"] = True\\n state_changed_data[\\\"block_cost\\\"] = block.transactions_info.cost\\n state_changed_data[\\\"block_fees\\\"] = block.transactions_info.fees\\n\\n if block.foliage_transaction_block is not None:\\n state_changed_data[\\\"timestamp\\\"] = block.foliage_transaction_block.timestamp\\n\\n if block.transactions_generator is not None:\\n state_changed_data[\\\"transaction_generator_size_bytes\\\"] = len(bytes(block.transactions_generator))\\n\\n state_changed_data[\\\"transaction_generator_ref_list\\\"] = block.transactions_generator_ref_list\\n if added is not None:\\n state_changed_data[\\\"receive_block_result\\\"] = added.value\\n\\n self._state_changed(\\\"block\\\", state_changed_data)\\n\\n record = self.blockchain.block_record(block.header_hash)\\n if self.weight_proof_handler is not None and record.sub_epoch_summary_included is not None:\\n if self._segment_task is None or self._segment_task.done():\\n self._segment_task = asyncio.create_task(self.weight_proof_handler.create_prev_sub_epoch_segments())\\n return None\",\n \"def CreateBlock(self, props):\\n # Set some default properties\\n\\n # blk / cfg | name | name+inst\\n # -----------------------------\\n # name | n==n | False\\n # name+inst | n==n | n==n&&i==i\\n if 'ordinal' not in props and 'name' in props:\\n for ordinal, ni in self.config.get('ordinals', {}).items():\\n if isinstance(ni, str):\\n # Config only has name, don't care about block\\n if props['name'] == ni:\\n props['ordinal'] = ordinal\\n break\\n elif 'instance' not in props:\\n # Config has name+instance, block only has name\\n continue\\n else:\\n # Config has name+instance, block has name+instance\\n if props['name'] == ni[0] and props['instance'] == ni[1]:\\n props['ordinal'] = ordinal\\n break\\n\\n # Compute a block ID\\n if 'name' in props:\\n bid = props['name'].replace('-', '')\\n else:\\n bid = \\\"block\\\"\\n\\n if bid in self.blocks:\\n i = 1\\n while bid+str(i) in self.blocks:\\n i += 1\\n bid = bid+str(i)\\n\\n # Actually create block\\n self.blocks[bid] = blk = Block(bid, props)\\n blk.changed.handler(lambda: self.blockchanged(blk))\\n\\n self.blockadded(blk)\\n\\n return blk\",\n \"def createFirstBlock(self):\\n firstBlock = Block(0, self.__currentTransactionsList, 0, '00')\\n self.__chain.append(firstBlock)\",\n \"def add_block(self, block):\\n if block.index >= len(self.blockchain):\\n self.blockchain.append(block)\\n else:\\n self.blockchain[block.index] = block\\n self.write_to_disk()\",\n \"def get(block_id):\\n _url = get_root_url()\\n try:\\n block = DB.get_block_details([block_id]).__next__()\\n response = block\\n\\n response['links'] = {\\n 'self': '{}'.format(request.url),\\n 'list': '{}/processing-blocks'.format(_url),\\n 'home': '{}'.format(_url)\\n }\\n return block\\n except IndexError as error:\\n response = dict(message='Unable to GET Processing Block',\\n id='{}'.format(block_id),\\n error=error.__str__())\\n response['links'] = {\\n 'list': '{}/processing-blocks'.format(_url),\\n 'home': '{}'.format(_url)\\n }\\n return response, HTTPStatus.NOT_FOUND\",\n \"def _get_block(self, pos):\\n return _get_mc().getBlock(pos)\",\n \"def validate_and_add_block(self, block):\\n\\n # 1. Validate transaction(s) in block\\n tx = block.transactions\\n if not self.validate_transaction(tx):\\n print(\\\"Block contains invalid transactions.\\\")\\n return\\n\\n # 2. Hash transaction(s)\\n tx_hash = HashAssist.hash_value(value=tx.to_string_for_hashing())\\n\\n # 3. Validate header\\n header_string = block.prev_hash + tx_hash + block.nonce\\n header_hash = HashAssist.hash_value(header_string)\\n if not block.header_hash == header_hash:\\n print(\\\"Block header invalid!\\\")\\n return\\n\\n self.blocks.append(block)\",\n \"def get_label_block(self, name):\\n if name in self.labeled_blocks:\\n block = self.labeled_blocks[name]\\n else:\\n block = self.builder.new_block()\\n self.labeled_blocks[name] = block # TODO: use name\\n return block\",\n \"def add_block(self, block):\\n # Create a list of transaction objects\\n transactions = [Transaction(\\n tx['sender'], tx['recipient'], tx['signature'], tx['amount']) for tx in block['transactions']] \\n chipsactions = [Chipsaction(\\n tx['sender'], tx['recipient'], tx['follow'], tx['message'], tx['signature'], tx['amount']) for tx in block['chipsactions']] \\n messsactions = [Messsaction(\\n tx['sender'], tx['follower'], tx['message'], tx['signature']) for tx in block['messsactions']] \\n # Validate the proof of work of the block and store the result (True or False) in a variable\\n proof_is_valid = Verification.valid_proof(\\n transactions[:-1], chipsactions, messsactions, block['previous_hash'], block['proof'])\\n # Check if previous_hash stored in the block is equal to the local blockchain's last block's hash and store the result in a block\\n hashes_match = hash_block(self.chain[-1]) == block['previous_hash']\\n if not proof_is_valid or not hashes_match:\\n return False\\n # Create a Block object\\n converted_block = Block(\\n block['index'], block['previous_hash'], transactions, chipsactions, messsactions, block['proof'], block['timestamp'])\\n self.__chain.append(converted_block)\\n stored_transactions = self.__open_transactions[:]\\n stored_chipsactions = self.__open_chipsactions[:]\\n stored_messsactions = self.__open_messsactions[:]\\n # Check which open transactions were included in the received block and remove them\\n # This could be improved by giving each transaction an ID that would uniquely identify it\\n for itx in block['transactions']:\\n for opentx in stored_transactions:\\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_transactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n\\n for itx in block['chipsactions']:\\n for opentx in stored_chipsactions:\\n if opentx.sender == itx['sender'] and opentx.recipient == itx['recipient'] and opentx.sender == itx['follow'] and opentx.recipient == itx['message'] and opentx.amount == itx['amount'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_chipsactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n for itx in block['messsactions']:\\n for opentx in stored_messsactions:\\n if opentx.sender == itx['sender'] and opentx.sender == itx['follower'] and opentx.recipient == itx['message'] and opentx.signature == itx['signature']:\\n try:\\n self.__open_messsactions.remove(opentx)\\n except ValueError:\\n print('Item was already removed')\\n self.save_data()\\n return True\",\n \"def fetch_block(path, offset, block_size):\\n with open(path, 'rb') as file:\\n file.seek(offset)\\n return bz2.decompress(file.read(block_size))\",\n \"def allocate(self, name: str, size: int) -> Optional[Block]:\\n # create a list of candidate blocks that are free and fit size.\\n fits_list = []\\n for block in self.free_list:\\n if block.length() >= size:\\n fits_list.append(block);\\n\\n if len(fits_list) == 0:\\n print(\\\"malloc FAIL for {} with size={}\\\".format(name, size))\\n return None\\n else:\\n chosen_block = None\\n if self.algorithm == 'random':\\n # choose a random block\\n block_number = random.randint(0, len(fits_list)-1)\\n chosen_block = fits_list[block_number]\\n elif self.algorithm == \\\"first\\\":\\n # choose a block by finding the earliest address that fits\\n fits_list = sorted(fits_list, key=lambda b: b.start())\\n chosen_block = fits_list[0]\\n else:\\n raise ValueError(\\\"Those two fits are enough for the lab.\\\")\\n\\n self.free_list.remove(chosen_block) # remove this block from the free list\\n # put the given information in the allocated block, and split it if contains more space than asked for\\n if chosen_block.length() == size:\\n block.name = name\\n block.used = True\\n self.used_list.append(chosen_block)\\n else: # block is bigger than the size requested\\n # split it into two:\\n\\n # First new block - the one to be used\\n start: int = chosen_block.start()\\n used = Block(start, size, name)\\n used.used = True\\n # Add this block to the used list\\n self.used_list.append(used)\\n\\n # Second new block - the leftover unused space\\n start = start + size\\n length = chosen_block.end() - start\\n leftover_unused = Block(start, length, chosen_block.name)\\n # Add this block back to the free list\\n self.free_list.append(leftover_unused)\",\n \"def find_read_number_block(self):\\n\\t\\tnode = self.find_read_number_block_link()\\n\\t\\tif node is not None:\\n\\t\\t\\treturn node\\n\\n\\t\\tnode = self.find_read_number_block_fixed_raw()\\n\\t\\tif node is not None:\\n\\t\\t\\treturn node\\n\\n\\t\\t# Couldn't find the node, bail out.\\n\\t\\tself.hdf_internal_error(\\\"unknown HDF5 structure: can't find read block item\\\")\",\n \"async def create_block_document(\\n self,\\n block_document: Union[BlockDocument, BlockDocumentCreate],\\n include_secrets: bool = True,\\n ) -> BlockDocument:\\n if isinstance(block_document, BlockDocument):\\n block_document = BlockDocumentCreate.parse_obj(\\n block_document.dict(\\n json_compatible=True,\\n include_secrets=include_secrets,\\n exclude_unset=True,\\n exclude={\\\"id\\\", \\\"block_schema\\\", \\\"block_type\\\"},\\n ),\\n )\\n\\n try:\\n response = await self._client.post(\\n \\\"/block_documents/\\\",\\n json=block_document.dict(\\n json_compatible=True,\\n include_secrets=include_secrets,\\n exclude_unset=True,\\n exclude={\\\"id\\\", \\\"block_schema\\\", \\\"block_type\\\"},\\n ),\\n )\\n except httpx.HTTPStatusError as e:\\n if e.response.status_code == status.HTTP_409_CONFLICT:\\n raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e\\n else:\\n raise\\n return BlockDocument.parse_obj(response.json())\",\n \"def addBlock(self, aBlock: gp.Block):\\n\\n if self.blocks[aBlock.y][aBlock.x] != None:\\n raise MovementError('game board space not empty')\\n self.blocks[aBlock.y][aBlock.x] = aBlock\\n self.groundSprites.append(aBlock.sprite)\",\n \"def create_block(type: str, color_key, position):\\n if type not in BlockCreator.types.keys():\\n raise BlockCreator.IncorrectBlockType\\n image_name = BlockCreator.types[type]\\n return Block(image_name, color_key, position)\",\n \"def get_a_block(self, usage_id=None):\\r\\n scope_ids = Mock()\\r\\n if usage_id is None:\\r\\n usage_id = \\\"_auto%d\\\" % len(self.all_blocks)\\r\\n scope_ids.usage_id = usage_id\\r\\n block = self.system.construct_xblock_from_class(\\r\\n self.TestableInheritingXBlock,\\r\\n field_data=self.field_data,\\r\\n scope_ids=scope_ids,\\r\\n )\\r\\n self.all_blocks[usage_id] = block\\r\\n return block\",\n \"def create_or_read_file(self):\\n # make sure the 'files' directory exists\\n if not os.path.isdir('../files'):\\n os.mkdir('../files')\\n try:\\n # try to read in files from disk if they exist\\n read_file = open(self.pickle_path, 'rb')\\n self.blockchain = pickle.load(read_file)\\n read_file.close()\\n # print('blockchain loaded from file')\\n except FileNotFoundError:\\n # if no blockchain exists, initialize one with the genesis block\\n self.blockchain = [ # Genesis block! as the first block in the chain the hashes are predetermined.\\n Block(\\n index=0,\\n timestamp=str(datetime.datetime.now()),\\n transactions=[]\\n )\\n ]\\n self.write_to_disk()\",\n \"def fetch_proof_by_blocks(self, blocks):\\n\\n try:\\n proof = self.import_proof(blocks)\\n except IOError:\\n filename = self.make_proof_filename(blocks)\\n print(\\\"File\\\", filename, \\\"does not exist. Creating...\\\")\\n proof = self.create_proof(blocks)\\n except NameError as err:\\n raise err\\n finally:\\n print(\\\"...ok\\\")\\n\\n return proof\",\n \"def get_block(self, crypto, block_height='', block_number='', latest=False):\\n raise NotImplementedError(\\n \\\"This service does not support getting getting block data. \\\"\\n \\\"Or rather it has no defined 'get_block' method.\\\"\\n )\",\n \"def seed(cls, block: Expr) -> Expr:\\n return cls(BlockField.block_seed, block)\",\n \"async def refresh(self):\\n block = await self.blockchain.rpc.get_block_header(self.identifier)\\n if not block:\\n raise BlockDoesNotExistsException\\n await super(BlockHeader, self).__init__(\\n block, blockchain_instance=self.blockchain, use_cache=self._use_cache\\n )\",\n \"async def add_unfinished_block(\\n self,\\n block: UnfinishedBlock,\\n peer: Optional[WSChiaConnection],\\n farmed_block: bool = False,\\n block_bytes: Optional[bytes] = None,\\n ) -> None:\\n receive_time = time.time()\\n\\n if block.prev_header_hash != self.constants.GENESIS_CHALLENGE and not self.blockchain.contains_block(\\n block.prev_header_hash\\n ):\\n # No need to request the parent, since the peer will send it to us anyway, via NewPeak\\n self.log.debug(\\\"Received a disconnected unfinished block\\\")\\n return None\\n\\n # Adds the unfinished block to seen, and check if it's seen before, to prevent\\n # processing it twice. This searches for the exact version of the unfinished block (there can be many different\\n # foliages for the same trunk). This is intentional, to prevent DOS attacks.\\n # Note that it does not require that this block was successfully processed\\n if self.full_node_store.seen_unfinished_block(block.get_hash()):\\n return None\\n\\n block_hash = block.reward_chain_block.get_hash()\\n\\n # This searched for the trunk hash (unfinished reward hash). If we have already added a block with the same\\n # hash, return\\n if self.full_node_store.get_unfinished_block(block_hash) is not None:\\n return None\\n\\n peak: Optional[BlockRecord] = self.blockchain.get_peak()\\n if peak is not None:\\n if block.total_iters < peak.sp_total_iters(self.constants):\\n # This means this unfinished block is pretty far behind, it will not add weight to our chain\\n return None\\n\\n if block.prev_header_hash == self.constants.GENESIS_CHALLENGE:\\n prev_b = None\\n else:\\n prev_b = self.blockchain.block_record(block.prev_header_hash)\\n\\n # Count the blocks in sub slot, and check if it's a new epoch\\n if len(block.finished_sub_slots) > 0:\\n num_blocks_in_ss = 1 # Curr\\n else:\\n curr = self.blockchain.try_block_record(block.prev_header_hash)\\n num_blocks_in_ss = 2 # Curr and prev\\n while (curr is not None) and not curr.first_in_sub_slot:\\n curr = self.blockchain.try_block_record(curr.prev_hash)\\n num_blocks_in_ss += 1\\n\\n if num_blocks_in_ss > self.constants.MAX_SUB_SLOT_BLOCKS:\\n # TODO: potentially allow overflow blocks here, which count for the next slot\\n self.log.warning(\\\"Too many blocks added, not adding block\\\")\\n return None\\n\\n # The clvm generator and aggregate signature are validated outside of the lock, to allow other blocks and\\n # transactions to get validated\\n npc_result: Optional[NPCResult] = None\\n pre_validation_time = None\\n\\n async with self.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):\\n start_header_time = time.time()\\n _, header_error = await self.blockchain.validate_unfinished_block_header(block)\\n if header_error is not None:\\n if header_error == Err.TIMESTAMP_TOO_FAR_IN_FUTURE:\\n raise TimestampError()\\n else:\\n raise ConsensusError(header_error)\\n validate_time = time.time() - start_header_time\\n self.log.log(\\n logging.WARNING if validate_time > 2 else logging.DEBUG,\\n f\\\"Time for header validate: {validate_time:0.3f}s\\\",\\n )\\n\\n if block.transactions_generator is not None:\\n pre_validation_start = time.time()\\n assert block.transactions_info is not None\\n try:\\n block_generator: Optional[BlockGenerator] = await self.blockchain.get_block_generator(block)\\n except ValueError:\\n raise ConsensusError(Err.GENERATOR_REF_HAS_NO_GENERATOR)\\n if block_generator is None:\\n raise ConsensusError(Err.GENERATOR_REF_HAS_NO_GENERATOR)\\n if block_bytes is None:\\n block_bytes = bytes(block)\\n\\n height = uint32(0) if prev_b is None else uint32(prev_b.height + 1)\\n npc_result = await self.blockchain.run_generator(block_bytes, block_generator, height)\\n pre_validation_time = time.time() - pre_validation_start\\n\\n # blockchain.run_generator throws on errors, so npc_result is\\n # guaranteed to represent a successful run\\n assert npc_result.conds is not None\\n pairs_pks, pairs_msgs = pkm_pairs(npc_result.conds, self.constants.AGG_SIG_ME_ADDITIONAL_DATA)\\n if not cached_bls.aggregate_verify(\\n pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature, True\\n ):\\n raise ConsensusError(Err.BAD_AGGREGATE_SIGNATURE)\\n\\n async with self.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):\\n # TODO: pre-validate VDFs outside of lock\\n validation_start = time.time()\\n validate_result = await self.blockchain.validate_unfinished_block(block, npc_result)\\n if validate_result.error is not None:\\n if validate_result.error == Err.COIN_AMOUNT_NEGATIVE.value:\\n # TODO: remove in the future, hotfix for 1.1.5 peers to not disconnect older peers\\n self.log.info(f\\\"Consensus error {validate_result.error}, not disconnecting\\\")\\n return\\n raise ConsensusError(Err(validate_result.error))\\n validation_time = time.time() - validation_start\\n\\n # respond_block will later use the cache (validated_signature=True)\\n validate_result = dataclasses.replace(validate_result, validated_signature=True)\\n\\n assert validate_result.required_iters is not None\\n\\n # Perform another check, in case we have already concurrently added the same unfinished block\\n if self.full_node_store.get_unfinished_block(block_hash) is not None:\\n return None\\n\\n if block.prev_header_hash == self.constants.GENESIS_CHALLENGE:\\n height = uint32(0)\\n else:\\n height = uint32(self.blockchain.block_record(block.prev_header_hash).height + 1)\\n\\n ses: Optional[SubEpochSummary] = next_sub_epoch_summary(\\n self.constants,\\n self.blockchain,\\n validate_result.required_iters,\\n block,\\n True,\\n )\\n\\n self.full_node_store.add_unfinished_block(height, block, validate_result)\\n pre_validation_log = (\\n f\\\"pre_validation time {pre_validation_time:0.4f}, \\\" if pre_validation_time is not None else \\\"\\\"\\n )\\n if farmed_block is True:\\n self.log.info(\\n f\\\"🍀 ️Farmed unfinished_block {block_hash}, SP: {block.reward_chain_block.signage_point_index}, \\\"\\n f\\\"validation time: {validation_time:0.4f} seconds, {pre_validation_log}\\\"\\n f\\\"cost: {block.transactions_info.cost if block.transactions_info else 'None'} \\\"\\n )\\n else:\\n percent_full_str = (\\n (\\n \\\", percent full: \\\"\\n + str(round(100.0 * float(block.transactions_info.cost) / self.constants.MAX_BLOCK_COST_CLVM, 3))\\n + \\\"%\\\"\\n )\\n if block.transactions_info is not None\\n else \\\"\\\"\\n )\\n self.log.info(\\n f\\\"Added unfinished_block {block_hash}, not farmed by us,\\\"\\n f\\\" SP: {block.reward_chain_block.signage_point_index} farmer response time: \\\"\\n f\\\"{receive_time - self.signage_point_times[block.reward_chain_block.signage_point_index]:0.4f}, \\\"\\n f\\\"Pool pk {encode_puzzle_hash(block.foliage.foliage_block_data.pool_target.puzzle_hash, 'xch')}, \\\"\\n f\\\"validation time: {validation_time:0.4f} seconds, {pre_validation_log}\\\"\\n f\\\"cost: {block.transactions_info.cost if block.transactions_info else 'None'}\\\"\\n f\\\"{percent_full_str}\\\"\\n )\\n\\n sub_slot_iters, difficulty = get_next_sub_slot_iters_and_difficulty(\\n self.constants,\\n len(block.finished_sub_slots) > 0,\\n prev_b,\\n self.blockchain,\\n )\\n\\n if block.reward_chain_block.signage_point_index == 0:\\n res = self.full_node_store.get_sub_slot(block.reward_chain_block.pos_ss_cc_challenge_hash)\\n if res is None:\\n if block.reward_chain_block.pos_ss_cc_challenge_hash == self.constants.GENESIS_CHALLENGE:\\n rc_prev = self.constants.GENESIS_CHALLENGE\\n else:\\n self.log.warning(f\\\"Do not have sub slot {block.reward_chain_block.pos_ss_cc_challenge_hash}\\\")\\n return None\\n else:\\n rc_prev = res[0].reward_chain.get_hash()\\n else:\\n assert block.reward_chain_block.reward_chain_sp_vdf is not None\\n rc_prev = block.reward_chain_block.reward_chain_sp_vdf.challenge\\n\\n timelord_request = timelord_protocol.NewUnfinishedBlockTimelord(\\n block.reward_chain_block,\\n difficulty,\\n sub_slot_iters,\\n block.foliage,\\n ses,\\n rc_prev,\\n )\\n\\n timelord_msg = make_msg(ProtocolMessageTypes.new_unfinished_block_timelord, timelord_request)\\n await self.server.send_to_all([timelord_msg], NodeType.TIMELORD)\\n\\n full_node_request = full_node_protocol.NewUnfinishedBlock(block.reward_chain_block.get_hash())\\n msg = make_msg(ProtocolMessageTypes.new_unfinished_block, full_node_request)\\n if peer is not None:\\n await self.server.send_to_all([msg], NodeType.FULL_NODE, peer.peer_node_id)\\n else:\\n await self.server.send_to_all([msg], NodeType.FULL_NODE)\\n\\n self._state_changed(\\\"unfinished_block\\\")\",\n \"def create_block(world: World, block_id: str, x: int, y: int, *args):\\n block_id = BLOCKS[block_id]\\n if block_id == \\\"mystery_empty\\\":\\n block = MysteryBlock()\\n elif block_id == \\\"mystery_coin\\\":\\n block = MysteryBlock(drop=\\\"coin\\\", drop_range=(3, 6))\\n elif block_id == \\\"bounce_block\\\":\\n block = BounceBlock()\\n elif block_id == \\\"flag\\\":\\n block = Flagpole()\\n elif block_id == \\\"tunnel\\\":\\n block = Tunnel()\\n elif block_id == \\\"switch\\\":\\n block = Switch()\\n else:\\n block = Block(block_id)\\n\\n world.add_block(block, x * BLOCK_SIZE, y * BLOCK_SIZE)\",\n \"def find_block_mount_point(block):\\n # type: (str) -> str\\n\\n try:\\n return subprocess.check_output([\\n 'findmnt',\\n '-o',\\n 'TARGET',\\n '-nS',\\n block\\n ]).strip()\\n except subprocess.CalledProcessError as ex:\\n return None\",\n \"def _do_add_block(self, args):\\r\\n bus_type = args[1]\\r\\n slave_id = int(args[2])\\r\\n name = args[3]\\r\\n block_type = int(args[4])\\r\\n starting_address = int(args[5])\\r\\n length = int(args[6])\\r\\n if bus_type == 'rtu':\\r\\n slave = self.server._servers[0].get_slave(slave_id)\\r\\n elif bus_type == 'tcp':\\r\\n slave = self.server._servers[1].get_slave(slave_id)\\r\\n slave.add_block(name, block_type, starting_address, length)\\r\\n return name\",\n \"def new_block(self, proof, previous_hash=None):\\n\\n # Create the block\\n my_block = Block(proof=proof,\\n previous_hash=previous_hash or self.hash(self.last_block))\\n my_block.save()\\n\\n # Update current_transactions with this new block.\\n my_block_trans = self.current_transactions_obj\\n\\n for trans in Transaction.objects.filter(block__isnull=True):\\n trans.block = my_block\\n trans.save()\\n\\n block = {\\n 'index': my_block.id,\\n 'timestamp': my_block.timestamp,\\n 'transactions': list(Transaction.objects.filter(block=my_block).values()),\\n 'proof': my_block.proof,\\n 'previous_hash': my_block.previous_hash,\\n }\\n\\n return block\",\n \"def getBlock(self, hash):\\n if hash in self.chain:\\n return self.chain[hash]\\n return None\",\n \"def find(self, task_id):\\n _structs = [\\n self.stack,\\n self.backlog,\\n self.blocked,\\n self.sleeping,\\n ]\\n for struct in _structs:\\n try:\\n task_obj = struct.find(task_id)\\n return task_obj\\n except LookupError:\\n # not found; try next structure\\n continue\\n\\n # the graveyard is just a list; search it\\n for task_obj in self.graveyard:\\n if task_obj.id.startswith(task_id):\\n return task_obj\\n\\n raise LookupError(\\\"No such task: '{}'\\\".format(task_id))\",\n \"def get_block(self, usage_id, for_parent=None):\\n def_id = self.id_reader.get_definition_id(usage_id)\\n try:\\n block_type = self.id_reader.get_block_type(def_id)\\n except NoSuchDefinition:\\n raise NoSuchUsage(repr(usage_id)) # pylint: disable= raise-missing-from\\n keys = ScopeIds(self.user_id, block_type, def_id, usage_id)\\n block = self.construct_xblock(block_type, keys, for_parent=for_parent)\\n return block\",\n \"def put_block(self):\\n self.blocks[self.editor_cursor_position[1]][\\n self.editor_cursor_position[0]] = self.available_block_types[self.current_block_type]\",\n \"async def read_block_document_by_name(\\n self,\\n name: str,\\n block_type_slug: str,\\n include_secrets: bool = True,\\n ):\\n try:\\n response = await self._client.get(\\n f\\\"/block_types/slug/{block_type_slug}/block_documents/name/{name}\\\",\\n params=dict(include_secrets=include_secrets),\\n )\\n except httpx.HTTPStatusError as e:\\n if e.response.status_code == status.HTTP_404_NOT_FOUND:\\n raise prefect.exceptions.ObjectNotFound(http_exc=e) from e\\n else:\\n raise\\n return BlockDocument.parse_obj(response.json())\",\n \"def build_block(self, format_string):\\n first_block = Block(None, py3_wrapper=self.py3_wrapper)\\n block = first_block\\n\\n # Tokenize the format string and process them\\n for token in self.tokens(format_string):\\n value = token.group(0)\\n if token.group(\\\"block_start\\\"):\\n # Create new block\\n block = block.new_block()\\n elif token.group(\\\"block_end\\\"):\\n # Close block setting any valid state as needed\\n # and return to parent block to continue\\n if not block.parent:\\n raise Exception(\\\"Too many `]`\\\")\\n block = block.parent\\n elif token.group(\\\"switch\\\"):\\n # a new option has been created\\n block = block.switch()\\n elif token.group(\\\"placeholder\\\"):\\n # Found a {placeholder}\\n key = token.group(\\\"key\\\")\\n format = token.group(\\\"format\\\")\\n block.add(Placeholder(key, format))\\n elif token.group(\\\"literal\\\"):\\n block.add(Literal(value))\\n elif token.group(\\\"lost_brace\\\"):\\n # due to how parsing happens we can get a lonesome }\\n # eg in format_string '{{something}' this fixes that issue\\n block.add(Literal(value))\\n elif token.group(\\\"command\\\"):\\n # a block command has been found\\n block.set_commands(token.group(\\\"command\\\"))\\n elif token.group(\\\"escaped\\\"):\\n # escaped characters add unescaped values\\n if value[0] in [\\\"\\\\\\\\\\\", \\\"{\\\", \\\"}\\\"]:\\n value = value[1:]\\n block.add(Literal(value))\\n\\n if block.parent:\\n raise Exception(\\\"Block not closed\\\")\\n # add to the cache\\n self.block_cache[format_string] = first_block\",\n \"def get_block(\\n self, position: typing.Tuple[int, int, int], none_if_str=True\\n ) -> typing.Union[typing.Any, str, None]:\\n raise NotImplementedError\",\n \"def new_recv_block(recv_block: Block, sender_id: Optional[int] = None, mute: bool = False) -> bool:\\n logging.debug(\\\"Received block %s\\\", util.bintos(recv_block.current_hash))\\n if not recv_block.verify():\\n logging.debug(\\\"Block %s rejected (failed verification)\\\",\\n util.bintos(recv_block.current_hash))\\n return False\\n\\n r = util.get_db()\\n with r.lock(\\\"blockchain:blocks:lock\\\"), \\\\\\n r.lock(\\\"blockchain:last_block:lock\\\"), \\\\\\n r.lock(\\\"blockchain:main_branch:lock\\\"), \\\\\\n r.lock(\\\"blockchain:orphan_blocks:lock\\\"), \\\\\\n r.lock(\\\"blockchain:tx_pool:lock\\\"), \\\\\\n r.lock(\\\"blockchain:utxo-block:lock\\\"), \\\\\\n r.lock(\\\"blockchain:utxo-tx:lock\\\"):\\n\\n # NOTE: Comments like the one below are references to the bitcoin\\n # protocol rules\\n # OK 2 Reject if duplicate of block we have in any of the three categories\\n if r.hexists(\\\"blockchain:blocks\\\", recv_block.current_hash) or \\\\\\n r.sismember(\\\"blockchain:orphan_blocks:\\\".encode() + recv_block.previous_hash,\\n recv_block.dumpb()):\\n logging.debug(\\\"Block %s rejected (already exists)\\\",\\n util.bintos(recv_block.current_hash))\\n return False\\n\\n # Handle the genesis block\\n if recv_block.is_genesis():\\n r.hset(\\\"blockchain:blocks\\\", recv_block.current_hash, recv_block.dumpb())\\n t = recv_block.transactions[0]\\n o = t.outputs[0]\\n ib = TransactionInput(t.id, o.index).dumpb()\\n ob = o.dumpb()\\n r.hset(\\\"blockchain:utxo-block:\\\".encode() + recv_block.current_hash, ib, ob)\\n r.hset(\\\"blockchain:utxo-tx\\\", ib, ob)\\n r.sadd(\\\"blockchain:main_branch\\\", recv_block.current_hash)\\n _set_last_block_unlocked(r, recv_block)\\n logging.debug(\\\"Genesis block accepted\\\")\\n return True\\n\\n # OK 11 Check if prev block (matching prev hash) is in main branch or side branches. If not,\\n # add this to orphan blocks, then query peer we got this from for 1st missing orphan\\n # block in prev chain; done with block\\n prev_blockb = r.hget(\\\"blockchain:blocks\\\", recv_block.previous_hash)\\n if prev_blockb is None:\\n logging.debug(\\\"Block %s is orphan\\\", util.bintos(recv_block.current_hash))\\n r.sadd(\\\"blockchain:orphan_blocks:\\\".encode() + recv_block.previous_hash,\\n recv_block.dumpb())\\n # TODO OPT: Unlock before requesting the block (it could take some time, although\\n # the response is asynchronous of course\\n if not mute:\\n logging.debug(\\\"Requesting block %s\\\", util.bintos(recv_block.previous_hash))\\n # TODO OPT: Only ask the node we got this from, not everyone, to\\n # avoid the flood of incoming blocks later\\n chatter.get_blockid(recv_block.previous_hash,\\n [sender_id] if sender_id is not None else util.get_peer_ids())\\n return False\\n\\n prev_block = Block.loadb(prev_blockb)\\n logging.debug(\\\"Previous block %s\\\", util.bintos(prev_block.current_hash))\\n if recv_block.index != prev_block.index + 1:\\n logging.debug(\\\"Block %s rejected (wrong index)\\\", util.bintos(recv_block.current_hash))\\n return False\\n\\n # OK 15 Add block into the tree. There are three cases: 1. block further extends the main\\n # branch; 2. block extends a side branch but does not add enough difficulty to make\\n # it become the new main branch; 3. block extends a side branch and makes it the new\\n # main branch.\\n last_block = get_block()\\n if recv_block.previous_hash == last_block.current_hash:\\n # OK Case 1 (b.previous_hash == last_block):\\n logging.debug(\\\"Block %s extends the main branch\\\", util.bintos(recv_block.current_hash))\\n txos = _validate_block_unlocked(r, recv_block)\\n if txos is None:\\n return False\\n referenced_txos, new_utxos = txos\\n \\\"\\\"\\\"\\n # NOTE: This is the body of _validate_block_unlocked, annotated, for reference\\n referenced_txos: Set[bytes] = set() # the utxos from UTXO-block spent in recv_block\\n new_utxos: Dict[bytes, bytes] = {}\\n # OK 1 For all but the coinbase transaction, apply the following:\\n for t in recv_block.transactions:\\n # OK 1 For each input, look in the main branch to find the referenced output\\n # transaction. Reject if the output transaction is missing for any input.\\n input_amount = 0.0\\n for i in t.inputs:\\n # Search for i in UTXO-block\\n ib = i.dumpb()\\n ob = r.hget(\\\"blockchain:utxo-block:\\\".encode() + recv_block.previous_hash, ib)\\n if ob is None:\\n # Not found in UTXO-block, search in new_utxos\\n ob = new_utxos.get(ib)\\n if ob is None:\\n return False\\n del new_utxos[ib]\\n else:\\n # Avoid double-spending of a utxo from UTXO-block in the block\\n if ib in referenced_txos:\\n return False\\n referenced_txos.add(ib)\\n o = TransactionOutput.loadb(ob)\\n # OK 2 For each input, if we are using the nth output of the earlier transaction,\\n # but it has fewer than n+1 outputs, reject.\\n # OK 4 Verify crypto signatures for each input; reject if any are bad\\n if o.recipient != t.sender:\\n return False\\n # OK 5 For each input, if the referenced output has already been spent by a\\n # transaction in the main branch, reject\\n # OK 7 Reject if the sum of input values < sum of output values\\n input_amount += o.amount\\n if input_amount != sum(o.amount for o in t.outputs):\\n return False\\n\\n new_utxos.update({TransactionInput(t.id, o.index).dumpb(): o.dumpb() \\\\\\n for o in t.outputs})\\n \\\"\\\"\\\"\\n\\n # OK 4 For each transaction, \\\"Add to wallet if mine\\\"\\n # NOTE: referenced_txos and new_utxos are not empty since we got here\\n _create_utxo_block_unlocked(r, recv_block, referenced_txos, new_utxos)\\n\\n # OK 5 For each transaction in the block, delete any matching transaction from the pool\\n # : of the transactions in the pool, keep only the ones that are valid using the\\n # new utxo-block to check for validity\\n tx_pool = {t.id: t for t in \\\\\\n [Transaction.loadb(tb) for tb in r.hvals(\\\"blockchain:tx_pool\\\")]}\\n # NOTE: There can't be double spending in the tx pool as it is now\\n tx_pool = _rebuild_tx_pool_unlocked(r, tx_pool, recv_block)\\n\\n _rebuild_utxo_tx_unlocked(r, recv_block, tx_pool)\\n\\n # Add block to main branch\\n r.hset(\\\"blockchain:blocks\\\", recv_block.current_hash, recv_block.dumpb())\\n r.sadd(\\\"blockchain:main_branch\\\", recv_block.current_hash)\\n\\n _set_last_block_unlocked(r, recv_block)\\n logging.debug(\\\"Block %s accepted\\\", util.bintos(recv_block.current_hash))\\n elif recv_block.index <= last_block.index:\\n # OK Case 2 (b.previous_hash != last_block && b.index <= last_block.index)\\n # : Add it without doing any validation because validating this now would require a lot\\n # of work (actually simulating adding this to its prev as if extending the main branch).\\n logging.debug(\\\"Block %s extends a side branch (not changing main)\\\",\\n util.bintos(recv_block.current_hash))\\n r.hset(\\\"blockchain:blocks\\\", recv_block.current_hash, recv_block.dumpb())\\n else:\\n # OK Case 3 (b.previous_hash != last_block && b.index > last_block.index)\\n # OK 1 Find the fork block on the main branch which this side branch forks off of\\n # : Ascend the side branch, the fork block is the first to be in the main branch\\n logging.debug(\\\"Block %s extends a side branch (changing main)\\\",\\n util.bintos(recv_block.current_hash))\\n old_side_branch = [recv_block] # the Blocks in the old side branch\\n fork_block = Block.loadb(r.hget(\\\"blockchain:blocks\\\", recv_block.previous_hash))\\n while not r.sismember(\\\"blockchain:main_branch\\\", fork_block.current_hash):\\n old_side_branch.append(fork_block)\\n fork_block = Block.loadb(r.hget(\\\"blockchain:blocks\\\", fork_block.previous_hash))\\n old_side_branch.reverse() # starting from the child of the fork block\\n # OK 2 Redefine the main branch to only go up to this fork block\\n # : Ascend from last_block up to the fork block\\n old_main_branch: List[Block] = [] # the Blocks in the old main branch\\n b = Block.loadb(r.hget(\\\"blockchain:blocks\\\", last_block.current_hash))\\n while b != fork_block:\\n old_main_branch.append(b)\\n b = Block.loadb(r.hget(\\\"blockchain:blocks\\\", b.previous_hash))\\n old_main_branch.reverse() # starting from the child of the fork block\\n logging.debug(\\\"Fork block %s\\\", util.bintos(fork_block.current_hash))\\n # OK 3 For each block on the side branch, from the child of the fork block to the leaf,\\n # add to the main branch:\\n for osbi, b in enumerate(old_side_branch):\\n # OK 1 Do \\\"branch\\\" checks 3-11\\n # : Why? we did them when first receiving the block. What could have changed?\\n # OK 2 For all the transactions:\\n txos = _validate_block_unlocked(r, b)\\n if txos is None:\\n # Delete invalid blocks and abort\\n invalid_ids = [invalid.current_hash for invalid in old_side_branch[osbi:]]\\n r.hdel(\\\"blockchain:blocks\\\", *invalid_ids)\\n return False\\n referenced_txos, new_utxos = txos\\n \\\"\\\"\\\"\\n # NOTE: This is the body of _validate_block_unlocked, annotated, for reference\\n referenced_txos: Set[bytes] = set() # the utxos from UTXO-block spent in b\\n new_utxos: Dict[bytes, bytes] = {}\\n for t in b.transactions:\\n # WP 1 For each input, look in the main branch to find the referenced output\\n # transaction. Reject if the output transaction is missing for any input.\\n # : Search for the referenced outputs in UTXO-block[previous_hash]\\n input_amount = 0.0\\n for i in t.inputs:\\n # Search for i in UTXO-block\\n ib = i.dumpb()\\n ob = r.hget(\\\"blockchain:utxo-block:\\\".encode() + b.previous_hash, ib)\\n if ob is None:\\n # Not found in UTXO-block, search in new_utxos\\n ob = new_utxos.get(ib)\\n if ob is None:\\n # TODO: Undo any changes, delete invalid blocks and reject\\n raise NotImplementedError\\n del new_utxos[ib]\\n else:\\n # Avoid double-spending in the block\\n if ib in referenced_txos:\\n # TODO: Undo any changes, delete invalid blocks and reject\\n raise NotImplementedError\\n referenced_txos.add(ib)\\n o = TransactionOutput.loadb(ob)\\n # OK 2 For each input, if we are using the nth output of the earlier\\n # transaction, but it has fewer than n+1 outputs, reject.\\n # WP 4 Verify crypto signatures for each input; reject if any are bad\\n # : Check that t.sender == o.recipient for each utxo referenced\\n if o.recipient != t.sender:\\n # TODO: Undo any changes, delete invalid blocks and reject\\n raise NotImplementedError\\n # OK 5 For each input, if the referenced output has already been spent by a\\n # transaction in the main branch, reject\\n # WP 7 Reject if the sum of input values < sum of output values\\n # : Check that sum(inputs) == sum(outputs)\\n input_amount += o.amount\\n if input_amount != sum(o.amount for o in t.outputs):\\n # TODO: Undo any changes, delete invalid blocks and reject\\n raise NotImplementedError\\n\\n new_utxos.update({TransactionInput(t.id, o.index).dumpb(): o.dumpb() for o \\\\\\n in t.outputs})\\n \\\"\\\"\\\"\\n\\n # OK 5 For each transaction, \\\"Add to wallet if mine\\\"\\n # NOTE: referenced_txos and new_utxos are not empty since we got here\\n _create_utxo_block_unlocked(r, b, referenced_txos, new_utxos)\\n\\n # OK 5 For each block in the old main branch, from the leaf down to the child of the\\n # fork block:\\n tx_pool = {t.id: t for t in \\\\\\n [Transaction.loadb(tb) for tb in r.hvals(\\\"blockchain:tx_pool\\\")]}\\n for b in reversed(old_main_branch):\\n # OK 1 For each non-coinbase transaction in the block:\\n for t in b.transactions:\\n # OK 1 Apply \\\"tx\\\" checks 2-9, except in step 8, only look in the transaction\\n # pool for duplicates, not the main branch\\n # : Why? these have been checked already. There can't be double spending\\n # transactions in the pool as it is at this point (current as of the old\\n # main branch) + the old main branch, because they wouldn't have gotten\\n # there in the first place.\\n # OK 2 Add to transaction pool if accepted, else go on to next transaction\\n tx_pool[t.id] = t\\n\\n # OK 6 For each block in the new main branch, from the child of the fork node to the\\n # leaf:\\n # OK 1 For each transaction in the block, delete any matching transaction from the\\n # transaction pool\\n # : Of the transactions in the pool, keep only the ones that are valid using the\\n # new utxo-block to check for validity\\n # NOTE: There can't be double spending in the tx pool as it is now,\\n # because it consists of the tx in the previous tx pool and all the\\n # tx in the old main branch, and all of these have already been\\n # checked for double spending\\n tx_pool = _rebuild_tx_pool_unlocked(r, tx_pool, recv_block)\\n\\n _rebuild_utxo_tx_unlocked(r, recv_block, tx_pool)\\n\\n # Update main_branch\\n for b in old_main_branch:\\n r.srem(\\\"blockchain:main_branch\\\", b.current_hash)\\n for b in old_side_branch:\\n r.sadd(\\\"blockchain:main_branch\\\", b.current_hash)\\n\\n r.hset(\\\"blockchain:blocks\\\", recv_block.current_hash, recv_block.dumpb())\\n _set_last_block_unlocked(r, recv_block)\\n logging.debug(\\\"Block %s accepted\\\", util.bintos(recv_block.current_hash))\\n\\n orphans = [Block.loadb(orphanb) for orphanb in \\\\\\n r.smembers(\\\"blockchain:orphan_blocks:\\\".encode() + recv_block.current_hash)]\\n r.delete(\\\"blockchain:orphan_blocks:\\\".encode() + recv_block.current_hash)\\n\\n logging.debug(\\\"Block time for %s %f\\\", util.bintos(recv_block.current_hash),\\n time.time() - recv_block.timestamp)\\n\\n # OK 19 For each orphan block for which this block is its prev, run all these steps (including\\n # this one) recursively on that orphan\\n for orphan in orphans:\\n new_recv_block(orphan, sender_id)\\n\\n _check_for_new_block()\\n return True\",\n \"def get_block(self, chunk, coords):\\n\\n return chunk.get_block(coords)\",\n \"def get_registration_block(self, user_id):\\r\\n for b in self.blocks:\\r\\n if type(b) == RegisterBlock and b.user_id == user_id:\\r\\n return b\\r\\n raise UserNotRegisteredError\",\n \"def new_block(self, body_blocks, snake_head):\\n\\t\\tx = randint(0, 35)\\n\\t\\ty = randint(1, 26)\\n\\t\\tself.rect.x = (25 * x) + 1\\n\\t\\tself.rect.bottom = 25 * y\\n\\t\\t\\n\\t\\t# If new block is on snake, get new block\\n\\t\\tif self.rect.x == snake_head.rect.x and self.rect.bottom == snake_head.rect.bottom:\\n\\t\\t\\tself.new_block(body_blocks, snake_head)\\n\\t\\t\\n\\t\\t# If new block is on any body block, get new block\\n\\t\\tif body_blocks:\\n\\t\\t\\tfor i in range(len(body_blocks)):\\n\\t\\t\\t\\tif self.rect.x == body_blocks[i].rect.x and self.rect.bottom == body_blocks[i].rect.bottom:\\n\\t\\t\\t\\t\\tself.new_block(body_blocks, snake_head)\",\n \"def mine_block(last_block, data):\\n timestamp = time.time_ns()\\n last_hash = last_block.hash\\n difficulty = Block.adjust_difficulty(last_block, timestamp)\\n nonce = 0\\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\\n\\n while hex_to_binary(hash)[0:difficulty] != '0'* difficulty:\\n nonce += 1\\n timestamp = time.time_ns()\\n difficulty = Block.adjust_difficulty(last_block, timestamp)\\n hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)\\n\\n return Block(timestamp, last_hash, hash, data, difficulty, nonce)\",\n \"def find_block_containing(self, lfn):\\n\\n raise NotImplementedError('find_block_containing')\",\n \"def get_block_from_node(node):\\n coords = node.name.split(\\\",\\\") # name format is '(row,col)'\\n col = int((coords[1])[:-1])\\n row = int((coords[0])[1:])\\n return Block(row, col)\",\n \"def get_random_block(a=0, b=269400):\\n height = random.randint(a, b)\\n return get_block(get_block_hash(height))\",\n \"def create_block(self, prev_hash=None):\\n # Update blockchain and balance state (thread safe)\\n if prev_hash is not None and prev_hash not in self._blockchain.hash_block_map.keys():\\n print(prev_hash, self._blockchain.hash_block_map)\\n prev_blk = None if prev_hash is None else \\\\\\n self._blockchain.hash_block_map[prev_hash]\\n last_blk = self._update(prev_blk)\\n pending_tx = self._get_tx_pool()\\n gathered_tx = self._gather_transactions(pending_tx)\\n block = self._mine_new_block(last_blk.header, gathered_tx)\\n if block is not None:\\n blk_json = block.to_json()\\n # Add block to blockchain (thread safe)\\n self.add_block(blk_json)\\n print(f\\\"{self.__class__.__name__} {self.name} created a block.\\\")\\n # Broadcast block and the header.\\n self._broadcast_block(block)\\n # Remove gathered transactions from pool and them to added pile\\n with self.added_tx_lock:\\n self._added_transactions |= set(gathered_tx)\\n self._update()\\n return block\",\n \"def mine_block(self):\\n if self.hosting_node == None:\\n return None\\n # Fetch the currently last block of the blockchain\\n last_block = self.__chain[-1]\\n print(last_block)\\n # Hash the last block (to be able to compare it to the stored hash value)\\n hashed_block = hash_block(last_block)\\n proof = self.proof_of_work()\\n # Miners should be rewarded, so let's create a reward transaction\\n reward_transaction = Transfer(self.hosting_node, \\\"MINING\\\", MINING_REWARD)\\n # Copy transaction instead of manipulating the original open_transactions list\\n # This ensures that if for some reason the mining should fail, we don't have the reward transaction stored in the open transactions\\n copied_transactions = self.__open_transfers[:]\\n for tx in copied_transactions:\\n if not Wallet.verify_transfer(tx):\\n return None\\n copied_transactions.append(reward_transaction)\\n block = Block(len(self.__chain), hashed_block, copied_transactions, proof)\\n self.__chain.append(block)\\n self.__open_transfers = []\\n self.save_data()\\n return block\",\n \"def check_block(self, block):\\n pass\",\n \"def find_node(self, name):\\n for node in self.get_children():\\n if node.read_name() == name:\\n break\\n else:\\n node = None\\n return node\",\n \"def get_or_create(self, **kwargs):\\n kwargs = self._preprocess(**kwargs)\\n found = self.first(**kwargs)\\n if found is not None:\\n return found\\n\\n new = self.create(**kwargs)\\n return new\",\n \"def mine_block(self):\\n if self.public_key == None:\\n return None\\n last_block = self.__chain[-1]\\n hashed_block = hash_block(last_block)\\n proof = self.proof_of_work()\\n reward_transaction = Transaction(\\n 'MINING', self.public_key, '', MINING_REWARD)\\n\\n copied_transactions = self.__open_transactions[:]\\n for tx in copied_transactions:\\n if not Wallet.verify_transaction(tx):\\n return None\\n copied_transactions.append(reward_transaction)\\n\\n copied_chipsactions = self.__open_chipsactions[:]\\n for tx in copied_chipsactions:\\n if not Wallet.verify_chipsaction(tx):\\n return None\\n\\n copied_messsactions = self.__open_messsactions[:]\\n for tx in copied_messsactions:\\n if not Wallet.verify_messsaction(tx):\\n return None\\n\\n block = Block(len(self.__chain), hashed_block,\\n copied_transactions, copied_chipsactions, copied_messsactions, proof)\\n self.__chain.append(block)\\n self.__open_transactions = []\\n self.__open_chipsactions = []\\n self.__open_messsactions = []\\n self.save_data()\\n for node in self.__peer_nodes:\\n url = 'http://{}/broadcast-block'.format(node)\\n converted_block = block.__dict__.copy()\\n converted_block['transactions'] = [\\n tx.__dict__ for tx in converted_block['transactions']]\\n converted_block['chipsactions'] = [\\n tx.__dict__ for tx in converted_block['chipsactions']]\\n converted_block['messsactions'] = [\\n tx.__dict__ for tx in converted_block['messsactions']] \\n try:\\n response = requests.post(url, json={'block': converted_block})\\n if response.status_code == 400 or response.status_code == 500:\\n print('Block declined, needs resolving')\\n if response.status_code == 409:\\n self.resolve_conflicts = True\\n except requests.exceptions.ConnectionError:\\n continue\\n return block\",\n \"def lookup_block_hash(db, block_number):\\n validate_uint256(block_number)\\n number_to_hash_key = make_block_number_to_hash_lookup_key(block_number)\\n # TODO: can raise KeyError\\n block_hash = rlp.decode(\\n db.get(number_to_hash_key),\\n sedes=rlp.sedes.binary,\\n )\\n return block_hash\",\n \"def lookup_block_hash(db, block_number):\\n validate_uint256(block_number)\\n number_to_hash_key = make_block_number_to_hash_lookup_key(block_number)\\n # TODO: can raise KeyError\\n block_hash = rlp.decode(\\n db.get(number_to_hash_key),\\n sedes=rlp.sedes.binary,\\n )\\n return block_hash\",\n \"def find_cell(app, cell):\\n if VALID_BLOCK(cell.block) and VALID_CELL(cell):\\n app_block = app.board.blocks[cell.block.column][cell.block.row]\\n app_cell = app_block.cells[cell.column][cell.row]\\n return app_cell\\n else:\\n return None\",\n \"def getFirstBlock(self, blockType=None, exact=False):\\n for a in self:\\n for b in a:\\n if b.hasFlags(blockType, exact):\\n return b\\n\\n return None\",\n \"def addBlock(self, newBlock):\\n newBlock.index = len(self.chain)\\n newBlock.previousHash = self.chain[-1].hash\\n newBlock.mineBlock(self.difficulty)\\n self.chain.append(newBlock)\\n self.writeBlocks()\",\n \"def fetch(self, block_name):\\n imag_bot = _ImaginaryBot(self._pos, self._inventory)\\n block_id = getattr(block, block_name).id\\n block_loc = self._get_block_loc(block_id)\\n mine_prob = _MineProblem(imag_bot, block_loc, block_id)\\n mine_actions = astar(mine_prob, _mine_heuristic)\\n self.take_actions(mine_actions, _DELAY)\\n imag_bot = _ImaginaryBot(self._pos, self._inventory)\\n player_loc = _player_loc()\\n return_prob = _ReturnProblem(imag_bot, block_id, player_loc)\\n return_actions = astar(return_prob, _return_heuristic)\\n imag_bot.take_actions(return_actions)\\n return_actions.append({\\n 'func': '_place',\\n 'args': (imag_bot.get_pos() + player_loc) / 2,\\n 'kwargs': {'block': block_id}\\n })\\n self.take_actions(return_actions, _DELAY)\",\n \"def _add_block(self, block: Block, write_to_ledger, mined_ourselves):\\n\\n with self.lock:\\n self.mining_flag = GIVEN_BLOCK\\n\\n with self.lock:\\n if block.parent_hash in self.blocks:\\n parent_node = self.blocks[block.parent_hash]\\n block_node = BlockNode(block, parent_node)\\n parent_node.add_child(block_node)\\n\\n self._update_latest_pointers(block_node) # Check if the new block makes a longer chain and switch to it\\n\\n self.log.debug(GREEN + \\\"%s:[%s] added block to fork %d at depth %d\\\" + NC, block.miner_key_hash[:6], time.ctime(block.create_time), block_node.fork_num, block_node.depth)\\n # self.log.debug(\\\"Added block to blockchain\\\")\\n elif block.is_root:\\n block_node = BlockNode(block, None)\\n self.root = block_node\\n # self.log.debug(\\\"Added block as root\\\")\\n self.log.debug(GREEN + \\\"%s:[%s] added block as root %d\\\" + NC, block.miner_key_hash[:6], time.ctime(block.create_time), block_node.tree_num)\\n self._update_latest_pointers(block_node)\\n # self.messages.clear()\\n Blockchain.num_trees += 1\\n\\n self._add_block_msgs(block) # Add all new posts to message table\\n if self.message_num % 10000 == 0:\\n self._write_new_messages(self.message_num-10000) # Save new messages to file\\n self.blocks[block.block_hash] = block_node\\n self.total_blocks += 1\\n\\n # Update ledger.txt with newly added block\\n if write_to_ledger:\\n with open(self.ledger_file, 'a') as ledger:\\n ledger.write(repr(block) + \\\"\\\\n\\\")\\n\\n if self.total_blocks % STATS_UPDATE_INTERVAL == 0: # Every few blocks update stats.txt\\n self._write_stats_file()\\n\\n self.mining_flag = CONTINUE_MINING\\n\\n if not mined_ourselves:\\n self._update_msg_queue(block)\\n\\n if time.time() - self.last_msg_update > MSG_UPDATE_DELAY:\\n self._reinit_message_table()\\n self.last_msg_update = time.time()\\n\\n return True\",\n \"def forge_block(offset, plaintext, oracle):\\n b_size, _, _ = challenge_12.determine_block_stats(oracle)\\n new_padding = b\\\"A\\\" * (b_size - offset)\\n payload = new_padding + challenge_09.pkcs7(plaintext, b_size)\\n ciphertext = oracle(payload)\\n\\n return challenge_07.as_blocks(ciphertext, b_size)[1]\",\n \"def getMemoryBlock(self, name: unicode) -> ghidra.program.model.mem.MemoryBlock:\\n ...\",\n \"def mine_block(previous: bytes, height: int, miner: bytes, transactions: List[Transaction], timestamp: int, difficulty: int, cutoff_time: int) -> 'Block':\\n print('============================ \\\\n \\\\n \\\\n ============================')\\n manager = mp.Manager()\\n final_nonce = manager.Value('i', None)\\n # Declare a new instance of a block, and change the nonce until it produces a correct block_id\\n\\n block = Block(miner=miner, transactions=transactions, timestamp=timestamp,\\n block_id=None, nonce=0, previous=previous, height=height, difficulty=difficulty)\\n processes: List[Process] = []\\n\\n found_event = Event()\\n for _ in range(processors):\\n process = Process(target=_mine_block, args=(\\n block, final_nonce, found_event, cutoff_time))\\n processes.append(process)\\n\\n for process in processes:\\n\\n process.start()\\n\\n found_event.wait()\\n\\n for process in processes:\\n process.terminate()\\n\\n for process in processes:\\n process.join()\\n print('============= END =============== \\\\n \\\\n \\\\n ============================')\\n if final_nonce.value is not None:\\n block.nonce = final_nonce.value\\n block.block_id = block.compute_block_id()\\n return block\\n else:\\n return None\",\n \"def add_block(self, block_name, block_type, starting_address, size):\\r\\n with self._data_lock: # thread-safe\\r\\n if size <= 0:\\r\\n raise InvalidArgumentError, \\\"size must be a positive number\\\"\\r\\n if starting_address < 0:\\r\\n raise InvalidArgumentError, \\\"starting address must be zero or positive number\\\"\\r\\n if self._blocks.has_key(block_name):\\r\\n raise DuplicatedKeyError, \\\"Block %s already exists. \\\" % (block_name)\\r\\n\\r\\n if not self._memory.has_key(block_type):\\r\\n raise InvalidModbusBlockError, \\\"Invalid block type %d\\\" % (block_type)\\r\\n\\r\\n # check that the new block doesn't overlap an existing block\\r\\n # it means that only 1 block per type must correspond to a given address\\r\\n # for example: it must not have 2 holding registers at address 100\\r\\n index = 0\\r\\n for i in xrange(len(self._memory[block_type])):\\r\\n block = self._memory[block_type][i]\\r\\n if block.is_in(starting_address, size):\\r\\n raise OverlapModbusBlockError, \\\"Overlap block at %d size %d\\\" % (block.starting_address, block.size)\\r\\n if block.starting_address > starting_address:\\r\\n index = i\\r\\n break\\r\\n\\r\\n # if the block is ok: register it\\r\\n self._blocks[block_name] = (block_type, starting_address)\\r\\n # add it in the 'per type' shortcut\\r\\n self._memory[block_type].insert(index, ModbusBlockDatabusMediator(block_name, starting_address, size))\",\n \"def addBlock(self, data):\\n #get the hashVal of last block in blockchain\\n lastHash = self.chain[len(self.chain) - 1].hashVal\\n timestamp = time()\\n hashVal = Block.hashSHA(timestamp, lastHash, data, NONCE, DIFFICULTY)\\n adding_block = Block(timestamp, lastHash, hashVal, data, NONCE, DIFFICULTY)\\n \\n self.chain.append(adding_block)\\n return adding_block\",\n \"def getblock(self, hash):\\n return self.proxy.getblock(hash)\",\n \"def FindBlockIndex(filename, format, num_blocks):\\n for block in range(1, num_blocks+1):\\n suffix = format % block\\n if filename.endswith(suffix):\\n return block\\n raise Exception(\\\"Can't find block index: %s\\\" % filename)\",\n \"def getDiskAddrOfBlock_recursive(self, fs:FileSystem, block_number, alloc_p, blocks, level):\\n\\n if level == 0:\\n assert block_number < len(blocks), \\\\\\n \\\"internal error: level 0 blocks overflow {} >= {}\\\".format(block_number, len(blocks))\\n if blocks[block_number] == 0:\\n if alloc_p:\\n blocks[block_number] = fs.allocBlock()\\n else:\\n print(\\\"can't find block {} in {}\\\".format(block_number, blocks))\\n return -1\\n return blocks[block_number]\\n\\n else:\\n block_ptrs_per_block = fs.block_size // 4\\n block_pointers_per_index = block_ptrs_per_block ** level\\n inner_block_num = block_number // block_pointers_per_index\\n inner_offset = block_number % block_pointers_per_index\\n\\n inner_blocks = fs.readBlockCache(inner_block_num, blocks)\\n return self.getDiskAddrOfBlock_recursive(fs, inner_offset, alloc_p, inner_blocks, level-1)\",\n \"def _place(self, loc, exclude=None, block_=None):\\n if not self._inventory:\\n raise Exception('Inventory empty')\\n\\n if block_ is None:\\n for key in self._inventory:\\n if key != exclude:\\n block_ = key\\n break\\n else:\\n raise Exception((\\n 'You requested not to place %s, but it is the only '\\n 'block in the inventory.' % exclude\\n ))\\n\\n if block_ not in self._inventory:\\n raise Exception('Block %s is not in the inventory' % block_)\\n\\n if self._inventory[block_] == 1:\\n del self._inventory[block_]\\n else:\\n self._inventory[block_] -= 1\\n\\n self._set_block(loc, block_)\",\n \"def add_block(self, env):\\n block_size = (0.04, 0.04, 0.04)\\n block_pose = self.random_pose(env, block_size)\\n block_urdf = 'assets/stacking/block.urdf'\\n block_id = env.add_object(block_urdf, block_pose)\\n self.object_points[block_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n self._IDs[block_id] = 'block'\\n return block_id\",\n \"def create_item(\\r\\n self, course_or_parent_locator, category, user_id,\\r\\n block_id=None, definition_locator=None, fields=None,\\r\\n force=False, continue_version=False\\r\\n ):\\r\\n # find course_index entry if applicable and structures entry\\r\\n index_entry = self._get_index_if_valid(course_or_parent_locator, force, continue_version)\\r\\n structure = self._lookup_course(course_or_parent_locator)['structure']\\r\\n\\r\\n partitioned_fields = self.partition_fields_by_scope(category, fields)\\r\\n new_def_data = partitioned_fields.get(Scope.content, {})\\r\\n # persist the definition if persisted != passed\\r\\n if (definition_locator is None or isinstance(definition_locator.definition_id, LocalId)):\\r\\n definition_locator = self.create_definition_from_data(new_def_data, category, user_id)\\r\\n elif new_def_data is not None:\\r\\n definition_locator, _ = self.update_definition_from_data(definition_locator, new_def_data, user_id)\\r\\n\\r\\n # copy the structure and modify the new one\\r\\n if continue_version:\\r\\n new_structure = structure\\r\\n else:\\r\\n new_structure = self._version_structure(structure, user_id)\\r\\n\\r\\n new_id = new_structure['_id']\\r\\n\\r\\n # generate usage id\\r\\n if block_id is not None:\\r\\n if LocMapperStore.encode_key_for_mongo(block_id) in new_structure['blocks']:\\r\\n raise DuplicateItemError(block_id, self, 'structures')\\r\\n else:\\r\\n new_block_id = block_id\\r\\n else:\\r\\n new_block_id = self._generate_block_id(new_structure['blocks'], category)\\r\\n\\r\\n block_fields = partitioned_fields.get(Scope.settings, {})\\r\\n if Scope.children in partitioned_fields:\\r\\n block_fields.update(partitioned_fields[Scope.children])\\r\\n self._update_block_in_structure(new_structure, new_block_id, {\\r\\n \\\"category\\\": category,\\r\\n \\\"definition\\\": definition_locator.definition_id,\\r\\n \\\"fields\\\": self._serialize_fields(category, block_fields),\\r\\n 'edit_info': {\\r\\n 'edited_on': datetime.datetime.now(UTC),\\r\\n 'edited_by': user_id,\\r\\n 'previous_version': None,\\r\\n 'update_version': new_id,\\r\\n }\\r\\n })\\r\\n\\r\\n # if given parent, add new block as child and update parent's version\\r\\n parent = None\\r\\n if isinstance(course_or_parent_locator, BlockUsageLocator) and course_or_parent_locator.block_id is not None:\\r\\n encoded_block_id = LocMapperStore.encode_key_for_mongo(course_or_parent_locator.block_id)\\r\\n parent = new_structure['blocks'][encoded_block_id]\\r\\n parent['fields'].setdefault('children', []).append(new_block_id)\\r\\n if not continue_version or parent['edit_info']['update_version'] != structure['_id']:\\r\\n parent['edit_info']['edited_on'] = datetime.datetime.now(UTC)\\r\\n parent['edit_info']['edited_by'] = user_id\\r\\n parent['edit_info']['previous_version'] = parent['edit_info']['update_version']\\r\\n parent['edit_info']['update_version'] = new_id\\r\\n if continue_version:\\r\\n # db update\\r\\n self.db_connection.update_structure(new_structure)\\r\\n # clear cache so things get refetched and inheritance recomputed\\r\\n self._clear_cache(new_id)\\r\\n else:\\r\\n self.db_connection.insert_structure(new_structure)\\r\\n\\r\\n # update the index entry if appropriate\\r\\n if index_entry is not None:\\r\\n if not continue_version:\\r\\n self._update_head(index_entry, course_or_parent_locator.branch, new_id)\\r\\n item_loc = BlockUsageLocator(\\r\\n course_or_parent_locator.version_agnostic(),\\r\\n block_type=category,\\r\\n block_id=new_block_id,\\r\\n )\\r\\n else:\\r\\n item_loc = BlockUsageLocator(\\r\\n CourseLocator(version_guid=new_id),\\r\\n block_type=category,\\r\\n block_id=new_block_id,\\r\\n )\\r\\n\\r\\n # reconstruct the new_item from the cache\\r\\n return self.get_item(item_loc)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63424957","0.6085005","0.6040332","0.59542054","0.595163","0.59020936","0.58659786","0.5862695","0.5800195","0.57171696","0.57031226","0.56728184","0.56365144","0.55348146","0.5521383","0.5520552","0.5496947","0.54944897","0.5471456","0.54080755","0.5375902","0.53632444","0.535165","0.5346603","0.53450143","0.5338602","0.5330745","0.5322093","0.53163517","0.5311872","0.52705145","0.526314","0.5258905","0.5252553","0.5248405","0.52252364","0.52169055","0.5213225","0.52062225","0.51977605","0.5182136","0.5177109","0.5144074","0.51420647","0.5129448","0.5111845","0.51057714","0.5098794","0.5096674","0.5096671","0.50948256","0.50781584","0.50594693","0.50477505","0.5044345","0.5035994","0.5023575","0.50234026","0.5019054","0.5015716","0.50122947","0.5002279","0.49978513","0.49888062","0.49884602","0.49882108","0.49768433","0.4975842","0.49757433","0.4974866","0.49725273","0.49507192","0.49471307","0.49379545","0.49378237","0.49377018","0.4933217","0.4932456","0.49304456","0.4922527","0.49184686","0.4916675","0.49151316","0.49151316","0.49137026","0.4911855","0.49113405","0.49090168","0.48963848","0.4895014","0.48914123","0.48904747","0.48877174","0.48850098","0.4884537","0.4883476","0.48826653","0.48815486","0.4879628","0.48785508"],"string":"[\n \"0.63424957\",\n \"0.6085005\",\n \"0.6040332\",\n \"0.59542054\",\n \"0.595163\",\n \"0.59020936\",\n \"0.58659786\",\n \"0.5862695\",\n \"0.5800195\",\n \"0.57171696\",\n \"0.57031226\",\n \"0.56728184\",\n \"0.56365144\",\n \"0.55348146\",\n \"0.5521383\",\n \"0.5520552\",\n \"0.5496947\",\n \"0.54944897\",\n \"0.5471456\",\n \"0.54080755\",\n \"0.5375902\",\n \"0.53632444\",\n \"0.535165\",\n \"0.5346603\",\n \"0.53450143\",\n \"0.5338602\",\n \"0.5330745\",\n \"0.5322093\",\n \"0.53163517\",\n \"0.5311872\",\n \"0.52705145\",\n \"0.526314\",\n \"0.5258905\",\n \"0.5252553\",\n \"0.5248405\",\n \"0.52252364\",\n \"0.52169055\",\n \"0.5213225\",\n \"0.52062225\",\n \"0.51977605\",\n \"0.5182136\",\n \"0.5177109\",\n \"0.5144074\",\n \"0.51420647\",\n \"0.5129448\",\n \"0.5111845\",\n \"0.51057714\",\n \"0.5098794\",\n \"0.5096674\",\n \"0.5096671\",\n \"0.50948256\",\n \"0.50781584\",\n \"0.50594693\",\n \"0.50477505\",\n \"0.5044345\",\n \"0.5035994\",\n \"0.5023575\",\n \"0.50234026\",\n \"0.5019054\",\n \"0.5015716\",\n \"0.50122947\",\n \"0.5002279\",\n \"0.49978513\",\n \"0.49888062\",\n \"0.49884602\",\n \"0.49882108\",\n \"0.49768433\",\n \"0.4975842\",\n \"0.49757433\",\n \"0.4974866\",\n \"0.49725273\",\n \"0.49507192\",\n \"0.49471307\",\n \"0.49379545\",\n \"0.49378237\",\n \"0.49377018\",\n \"0.4933217\",\n \"0.4932456\",\n \"0.49304456\",\n \"0.4922527\",\n \"0.49184686\",\n \"0.4916675\",\n \"0.49151316\",\n \"0.49151316\",\n \"0.49137026\",\n \"0.4911855\",\n \"0.49113405\",\n \"0.49090168\",\n \"0.48963848\",\n \"0.4895014\",\n \"0.48914123\",\n \"0.48904747\",\n \"0.48877174\",\n \"0.48850098\",\n \"0.4884537\",\n \"0.4883476\",\n \"0.48826653\",\n \"0.48815486\",\n \"0.4879628\",\n \"0.48785508\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78933555"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":75097,"cells":{"query":{"kind":"string","value":"Yield the blocks in their defined order"},"document":{"kind":"string","value":"def __iter__(self):\n for block in sorted(self.blocks.values(), key=lambda b: b.ordinal):\n yield block"},"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 blocks(self):\n if self._ast:\n for block in self._ast[2]:\n yield block","def collect_blocks():\n\n # Below are the position of (c,r) in a block.\n\n #########################\n # (0,0) # (1,0) # (2,0) #\n #########################\n #########################\n # (0,1) # (1,1) # (2,1) #\n #########################\n #########################\n # (0,2) # (1,2) # (2,2) #\n #########################\n\n for x in range(72):\n r, c = x // 9 % 3, x % 3\n if r == 0:\n if c == 0:\n yield x, x + 10\n yield x, x + 11\n yield x, x + 19\n yield x, x + 20\n elif c == 1:\n yield x, x + 8\n yield x, x + 10\n yield x, x + 17\n yield x, x + 19\n else:\n yield x, x + 7\n yield x, x + 8\n yield x, x + 16\n yield x, x + 17\n elif r == 1:\n if c == 0:\n yield x, x + 10\n yield x, x + 11\n elif c == 1:\n yield x, x + 8\n yield x, x + 10\n else:\n yield x, x + 8\n yield x, x + 7","def static_order(self):\n self.prepare()\n while self.is_active():\n node_group = self.get_ready()\n yield from node_group\n self.done(*node_group)","def __iter__(self):\n for x in self._order:\n yield x","def sequences(self):\n # i am one\n yield self\n # nothing further\n return","def sort(self):\n for _ in self.stage1():\n yield\n for _ in self.stage2():\n yield","def instructions(self):\n yield self.inst\n for inst in self.arguments[:]:\n yield inst\n for basic_block in self.basic_blocks[:]:\n if basic_block.function is not None:\n yield basic_block.inst\n for inst in basic_block.insts[:]:\n yield inst\n yield self.end_inst","def simple():\n yield 1\n yield 2\n yield 3","def stage2(self):\n start = 0\n while True:\n idx = self.first_unsorted(start)\n if idx is None:\n break\n start = self.nearby_sort(idx)\n if self.viz:\n yield","def test_block_batches_order(self):\n pass","def gen_blocks(self, count=None):\n if not count:\n count = self.num_blk\n for x in range(0, count*32, 32):\n buf = self._read(x)\n yield x, buf","def blocks(self):\n pass","def blockParser(block):\n struct = []\n first = True\n record = False\n for line in block:\n if line.startswith('Structure #'):\n record = True\n if not first:\n yield struct\n struct = []\n first = False\n if record:\n struct.append(line)\n yield struct","def detect_page_blocks():\n block_names_set = set()\n for filename in FILENAMES:\n fd = open(filename)\n for block_name in PAGE_BLOCK_MARKER_CRX.findall(fd.read()):\n block_names_set.add(block_name)\n sorted_block_names = sorted(list(block_names_set))\n for block_name in sorted_block_names:\n yield block_name","def __parse_blocks_pass(self):\n\n self.stack = [DocumentStackToken()]\n\n self.tokenized_document = []\n token_to_use = self.source_provider.get_next_line()\n did_start_close = False\n did_started_close = False\n requeue = []\n ignore_link_definition_start = False\n POGGER.debug(\"---$---\", token_to_use)\n POGGER.debug(\"---\")\n self.__parse_properties.pragma_lines = {}\n line_number = 1\n try:\n (\n token_to_use,\n line_number,\n requeue,\n ) = self.__process_front_matter_header_if_present(\n token_to_use, line_number, requeue\n )\n did_start_close = token_to_use is None\n keep_on_going = True\n while keep_on_going:\n POGGER.debug(\"next-line>>$\", token_to_use)\n POGGER.debug(\"stack>>$\", self.stack)\n POGGER.debug(\"current_block>>$\", self.stack[-1])\n POGGER.debug(\"line_number>>$\", line_number)\n POGGER.debug(\"---\")\n\n position_marker = PositionMarker(line_number, 0, token_to_use)\n parser_state = ParserState(\n self.stack,\n self.tokenized_document,\n TokenizedMarkdown.__close_open_blocks,\n self.__handle_blank_line,\n )\n if did_start_close:\n POGGER.debug(\"\\n\\ncleanup\")\n\n was_link_definition_started_before_close = self.stack[\n -1\n ].was_link_definition_started\n\n did_started_close = True\n (\n tokens_from_line,\n requeue_line_info,\n ) = TokenizedMarkdown.__close_open_blocks(\n parser_state,\n self.tokenized_document,\n include_block_quotes=True,\n include_lists=True,\n caller_can_handle_requeue=True,\n was_forced=True,\n )\n if tokens_from_line and not self.tokenized_document:\n self.tokenized_document.extend(tokens_from_line)\n\n if not (requeue_line_info and requeue_line_info.lines_to_requeue):\n keep_on_going = False\n else:\n assert was_link_definition_started_before_close\n assert not requeue_line_info.lines_to_requeue[0]\n\n del requeue_line_info.lines_to_requeue[0]\n line_number -= 1\n\n did_start_close = False\n tokens_from_line = None\n else:\n POGGER.debug(\">>>>$\", self.tokenized_document)\n\n if not token_to_use or not token_to_use.strip():\n POGGER.debug(\"call __parse_blocks_pass>>handle_blank_line\")\n (\n tokens_from_line,\n requeue_line_info,\n ) = self.__handle_blank_line(\n parser_state,\n token_to_use,\n from_main_transform=True,\n position_marker=position_marker,\n )\n else:\n POGGER.debug(\"\\n\\nnormal lines\")\n (\n tokens_from_line,\n _,\n _,\n requeue_line_info,\n _,\n ) = ContainerBlockProcessor.parse_line_for_container_blocks(\n parser_state,\n position_marker,\n ignore_link_definition_start,\n self.__parse_properties,\n None,\n )\n\n POGGER.debug(\"<<<<$\", self.tokenized_document)\n\n if keep_on_going:\n line_number, ignore_link_definition_start = TokenizedMarkdown.__xx(\n line_number, requeue_line_info, requeue\n )\n\n POGGER.debug(\n \"---\\nbefore>>$\",\n self.tokenized_document,\n )\n POGGER.debug(\"before>>$\", tokens_from_line)\n if tokens_from_line:\n self.tokenized_document.extend(tokens_from_line)\n POGGER.debug(\n \"after>>$\",\n self.tokenized_document,\n )\n if requeue:\n POGGER.debug(\"requeue>>$\", requeue)\n POGGER.debug(\"---\")\n\n (\n token_to_use,\n did_start_close,\n did_started_close,\n ) = self.__determine_next_token_process(\n requeue, did_start_close, did_started_close\n )\n except AssertionError as this_exception:\n error_message = f\"A project assertion failed on line {line_number} of the current document.\"\n raise BadTokenizationError(error_message) from this_exception\n\n if self.__parse_properties.pragma_lines:\n self.tokenized_document.append(\n PragmaToken(self.__parse_properties.pragma_lines)\n )\n return self.tokenized_document","def _iterate_blocks(self):\n ranges = [host_tuple[0:2] for host_tuple in self.parity_hosts]\n flags_sql = \"SELECT id, value FROM {} FINAL WHERE name = 'traces_extracted'\".format(self.indices[\"block_flag\"])\n return self.client.iterate(\n index=self.indices[\"block\"],\n fields=[\"number\"],\n query=\"ANY LEFT JOIN ({}) USING id WHERE value IS NULL AND {}\".format(\n flags_sql,\n utils.make_range_query('number', *ranges)\n ),\n )","def parseBlocks(self, parent, blocks):\r\n while blocks:\r\n for processor in self.blockprocessors.values():\r\n if processor.test(parent, blocks[0]):\r\n processor.run(parent, blocks)\r\n break","def ranges(self):\n for b in self.remaining_blocks:\n yield b, b * DEFAULT_BLOCK_SIZE, min(self.content_length, (b + 1) * DEFAULT_BLOCK_SIZE)","def blocks_iter(lines):\n type_ = None\n content = []\n termdef = re.compile(r\"^\\[([a-zA-Z_]+?)\\]$\")\n for line in lines:\n m = re.search(termdef, line)\n if m:\n if type_ != None and content:\n yield {\"type\": type_, \"content\": content[:]}\n type_ = m.group(1)\n content.clear()\n elif line.rstrip():\n content.append(line.rstrip())\n if content:\n yield {\"type\": type_, \"content\": content[:]}","def _genBlocksByName(self):\n self.blocksByName = {\n block.getName(): block for block in self.getBlocks(includeAll=True)\n }","def exercise_blocks(events):\n events.sort(key=lambda e: (e.start_time, e.end_time))\n\n exercise_block = []\n block_start_event = None\n block_end_event = None\n\n events_with_dummy_exercise = events + [Event(event_type=Event.EXERCISE,\n start_time=datetime.datetime.max, end_time=datetime.datetime.max)]\n\n for event in events_with_dummy_exercise:\n if event.event_type != Event.EXERCISE:\n continue\n\n if not exercise_block:\n exercise_block.append(event)\n elif event.start_time - exercise_block[-1].end_time <= timedelta(hours=1):\n # Put the current event in the same exercise block.\n exercise_block.append(event)\n else:\n yield exercise_block\n # Start a new exercise block.\n exercise_block = [event]","def iter_fragments(self):\n for chain in self.chain_list:\n for frag in chain.fragment_list:\n yield frag","def form_blocks(instrs):\n\n # Start with an empty block.\n cur_block = []\n\n for instr in instrs:\n if 'op' in instr: # It's an instruction.\n # Add the instruction to the currently-being-formed block.\n cur_block.append(instr)\n\n # If this is a terminator (branching instruction), it's the\n # last instruction in the block. Finish this block and\n # start a new one.\n if instr['op'] in TERMINATORS:\n yield cur_block\n cur_block = []\n\n else: # It's a label.\n # End the block here (if it contains anything).\n if cur_block:\n yield cur_block\n\n # Start a new block with the label.\n cur_block = [instr]\n\n # Produce the final block, if any.\n if cur_block:\n yield cur_block","def get_blocks(self) -> list:\n self.clingo = ClingoBridge() # reset clingo\n\n base = ('base', '')\n self.clingo.add_file('initial-states.lp')\n self.clingo.run([base], n=1)\n output = self.clingo.output[0]\n\n blocks = []\n for atom in output:\n if atom.name == 'block':\n blocks.append(atom)\n\n return blocks","def parse_blocks(self):\n if not self.options.blocks:\n return\n block_identifiers, block_aliases = [list(b) for b in zip(*self.options.blocks)]\n while block_identifiers:\n nodelist = self.parser.parse(block_identifiers)\n token = self.parser.next_token()\n current_identifier = block_identifiers.pop(0)\n current_alias = block_aliases.pop(0)\n while token.contents != current_identifier:\n current_identifier = block_identifiers.pop(0)\n self.blocks[block_aliases.pop(0)] = template.NodeList() \n self.blocks[current_alias] = nodelist\n assert len(self.blocks) == len(self.options.blocks), \"%s block parsing failed: %r => %r\" % (self.tagname, self.options.blocks, self.blocks)","def get_building_blocks(self):\n\n yield from self._graph_state.get_building_blocks()","def between_blocks(self, frame):\n return []","def abc():\r\n yield \"a\"\r\n yield \"b\"\r\n yield \"c\"","def loop(self):\n yield self\n e = self.next\n while e is not self:\n yield e\n e = e.next","def _prepare(self, mol):\n\n # Order the building blocks by number of functional groups\n # so that building blocks with more functional groups are\n # always placed first.\n\n bb_verts = dict()\n bbs = sorted(\n mol.building_block_vertices,\n key=lambda bb: len(bb.func_groups),\n reverse=True\n )\n for bb in bbs:\n bb_verts[bb] = mol.building_block_vertices[bb]\n mol.building_block_vertices = bb_verts\n return super()._prepare(mol)","def orders(self):\n self._current_order = self.min_order\n while self._current_order <= self.max_order:\n yield self._current_order\n self._current_order += 1\n del self._current_order","def run(self):\n first_index, last_index = \\\n self.get_initial_blocks()\n while last_index - first_index > self.block_size:\n first_index, last_index = \\\n self.join_blocks(first_index, last_index)\n self.merge_blocks(self.output_file_name, first_index, last_index)","def iter_block_items(parent):\n if isinstance(parent, _Document):\n parent_elm = parent.element.body\n # print(parent_elm.xml)\n elif isinstance(parent, _Cell):\n parent_elm = parent._tc\n else:\n raise ValueError(\"something's not right\")\n\n for child in parent_elm.iterchildren():\n if isinstance(child, CT_P):\n yield Paragraph(child, parent)\n elif isinstance(child, CT_Tbl):\n yield Table(child, parent)","def iter_block_items(parent):\n if isinstance(parent, _Document):\n parent_elm = parent.element.body\n # print(parent_elm.xml)\n elif isinstance(parent, _Cell):\n parent_elm = parent._tc\n else:\n raise ValueError(\"something's not right\")\n\n for child in parent_elm.iterchildren():\n if isinstance(child, CT_P):\n yield Paragraph(child, parent)\n elif isinstance(child, CT_Tbl):\n yield Table(child, parent)","def each_pair_of_blocks(self, accept_first, accept_second):\n\n # Iteration order here is significant: Rather than fixing i and looping\n # over each j, then doing the same, etc. we iterate over the gap between\n # i and j and then over i. The reason for this is that it ensures that\n # we try a different value for i and j on each iteration of the inner\n # loop. This stops us from stalling if we happen to hit on a value of i\n # where nothing useful can be done.\n #\n # In the event that nothing works, this doesn't help and we still make\n # the same number of calls, but by ensuring that we make progress we\n # have more opportunities to make shrinks that speed up the tests or\n # that reduce the number of viable shrinks at the next gap size because\n # we've lowered some values.\n offset = 1\n while offset < len(self.blocks):\n i = 0\n while i + offset < len(self.blocks):\n j = i + offset\n block_i = self.blocks[i]\n block_j = self.blocks[j]\n if accept_first(block_i) and accept_second(block_j):\n yield (block_i, block_j)\n i += 1\n offset += 1","def render_paths_between_yields(paths): # pragma: no cover\n from graphviz import Digraph\n dot = Digraph(name=\"top\")\n for i, path in enumerate(paths):\n prev = None\n for block in path:\n if isinstance(block, Branch):\n label = \"if \" + astor.to_source(block.cond)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"invhouse\"})\n elif isinstance(block, Yield):\n label = \"id: {}\\n\".format(block.yield_id)\n label += astor.to_source(block.value)\n label += \"\\nLive Ins : \" + str(block.live_ins)\n label += \"\\nLive Outs : \" + str(block.live_outs)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"oval\"})\n elif isinstance(block, BasicBlock):\n label = \"\\n\".join(astor.to_source(stmt) for stmt in block.statements)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n label += \"\\nLive Ins : \" + str(block.live_ins)\n label += \"\\nLive Outs : \" + str(block.live_outs)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"box\"})\n elif isinstance(block, HeadBlock):\n label = \"Initial\"\n dot.node(str(i) + str(id(block)) + \"_start\", label.rstrip(), {\"shape\": \"doublecircle\"})\n label = \"\\n\".join(astor.to_source(stmt).rstrip() for stmt in block.initial_statements)\n if hasattr(block, \"initial_yield\"):\n label += \"\\n\" + astor.to_source(block.initial_yield.value)\n label += \"\\nLive Ins : \" + str(block.live_ins)\n label += \"\\nLive Outs : \" + str(block.live_outs)\n # label += \"\\nGen : \" + str(block.gen)\n # label += \"\\nKill : \" + str(block.kill)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"box\"})\n dot.edge(str(i) + str(id(block)) + \"_start\", str(i) + str(id(block)))\n elif isinstance(block, State):\n label = \"{}\".format(astor.to_source(block.yield_state).rstrip())\n if block.conds:\n label += \" && \"\n label += \" && \".join(astor.to_source(cond) for cond in block.conds)\n label += \"\\n\"\n label += \"\\n\".join(astor.to_source(statement) for statement in block.statements)\n dot.node(str(i) + str(id(block)), label.rstrip(), {\"shape\": \"doubleoctagon\"})\n else:\n raise NotImplementedError(type(block))\n if prev is not None:\n if isinstance(prev, Branch):\n if block is prev.false_edge:\n label = \"F\"\n else:\n label = \"T\"\n else:\n label = \"\"\n dot.edge(str(i) + str(id(prev)), str(i) + str(id(block)), label)\n prev = block\n\n file_name = tempfile.mktemp(\"gv\")\n dot.render(file_name, view=True)","def iterator(self):\n yield","def instructions_reversed(self):\n yield self.end_inst\n for basic_block in reversed(self.basic_blocks[:]):\n if basic_block.function is not None:\n for inst in reversed(basic_block.insts[:]):\n yield inst\n yield basic_block.inst\n for inst in reversed(self.arguments[:]):\n yield inst\n yield self.inst","def test_nested_yield():\n yield (yield (yield 1))","def iter_sequence(self):\n for res_name, fragment in self.sequence_fragment_list:\n yield res_name","def pslBlocks(alignmentColumns, alnStarts, letterSizes):\n start1, start2 = alnStarts\n letterSize1, letterSize2 = letterSizes\n size = 0\n for x, y in alignmentColumns:\n if x == \"-\":\n if size:\n yield size, start1, start2\n start1 += size * letterSize1\n start2 += size * letterSize2\n size = 0\n start2 += symbolSize(y, letterSize2)\n elif y == \"-\":\n if size:\n yield size, start1, start2\n start1 += size * letterSize1\n start2 += size * letterSize2\n size = 0\n start1 += symbolSize(x, letterSize1)\n else:\n size += 1\n if size: yield size, start1, start2","def in_order(self):\n for node_data in self._in_order_helper(self._root):\n yield node_data","def get_block(self, maf_lines, as_string=True):\n for line in maf_lines:\n # header line: start new block beginning with the header\n if line.startswith('a'):\n self._current_block = [line]\n\n # sequence line: store AlignmentSequence if ID in self.species\n elif line.startswith('s'):\n species_id = line.split()[1].split('.')[0]\n if species_id in self._species:\n new_sequence = AlignmentSequence(line)\n self._current_block.append(new_sequence)\n\n # block-separator: yield current block\n elif line.startswith('\\n'):\n # yield the current block if >= nonref sequence\n if len(self) > 1:\n # default output: string\n if as_string:\n yield self.block_string\n else:\n yield self.block_data\n\n # check that other lines are in 'ieq' categories like they should be\n else:\n assert line[0] in '#ieq'","def iter_block_items_(self, parent):\n if isinstance(parent, _Document):\n parent_elm = parent.element.body\n elif isinstance(parent, _Cell):\n parent_elm = parent._tc\n elif isinstance(parent, _Row):\n parent_elm = parent._tr\n else:\n raise ValueError(\"something's not right\")\n \n for child in parent_elm.iterchildren():\n if isinstance(child, CT_P):\n yield Paragraph(child, parent)\n elif isinstance(child, CT_Tbl):\n yield Table(child, parent)","def next_block(the_file):\n category = next_line(the_file)\n\n question = next_line(the_file)\n\n answers = []\n for i in range(4):\n answers.append(next_line(the_file))\n\n correct = next_line(the_file)\n if correct:\n correct = correct[0]\n\n explanation = next_line(the_file)\n\n return category, question, answers, correct, explanation","def Block(self):\n self._advance([\"INDENT\"])\n stmts = self.Statements()\n self._advance([\"DEDENT\"])\n return stmts","async def _new_blocks(self) -> AsyncGenerator[Eth1Block, None]:\n while True:\n try:\n block = self._eth1_data_provider.get_block(\"latest\")\n except BlockNotFound:\n raise Eth1MonitorValidationError(\"Fail to get latest block\")\n target_block_number = BlockNumber(block.number - self._num_blocks_confirmed)\n from_block_number = self.highest_processed_block_number\n if target_block_number > from_block_number:\n # From `highest_processed_block_number` to `target_block_number`\n for block_number in range(\n from_block_number + 1, target_block_number + 1\n ):\n try:\n block = self._eth1_data_provider.get_block(\n BlockNumber(block_number)\n )\n except BlockNotFound:\n raise Eth1MonitorValidationError(\n f\"Block does not exist for block number={block_number}\"\n )\n yield block\n await trio.sleep(self._polling_period)","def next_block(the_file):\n category = next_line(the_file)\n question = next_line(the_file)\n answers = []\n for i in range(4):\n answers.append(next_line(the_file))\n\n correct = next_line(the_file)\n if correct:\n correct = correct[0]\n explanation = next_line(the_file)\n\n return category, question, answers, correct, explanation","def yields ( self ) :\n return tuple ( [ i for i in self.alist2 ] )","def yields ( self ) :\n return tuple ( [ i for i in self.alist2 ] )","def find_blocks(self, area, tags, count=None, order=None, point=None):\n\t\tif count != None:\n\t\t\traise NotImplementedError()\n\t\tif order != None:\n\t\t\traise NotImplementedError()\n\t\tif point != None:\n\t\t\traise NotImplementedError()\n\t\tif isinstance(tags, str):\n\t\t\ttags = {tags}\n\t\tassert isinstance(tags, set)\n\t\tassert area != EVERYWHERE\n\n\t\tif area == SOMEWHERE or area == NOWHERE:\n\t\t\treturn\n\n\t\t# get binary box cover of area\n\t\t# get tags for those boxes, if necessary generate the tags\n\t\t# if box is more than one block in size, repeat recursively with subboxes\n\t\tbbs = list(area.binary_box_cover()) #M# could try to find a way to stream this generator and join it with queue of children, (or just do depth first)\n\t\twhile bbs:\n\t\t\tbb = bbs.pop(0)\n\t\t\tbb_tags = self._get_tags(bb)\n\t\t\tif tags.issubset(bb_tags) and bb.bounding_box().collides_with(area): #M# could try to swap and see how performance changes\n\t\t\t\tassert bb.scale >= 0\n\t\t\t\tif bb.scale == 0:\n\t\t\t\t\tyield bb.position\n\t\t\t\telse:\n\t\t\t\t\tbbs.extend(bb.get_children())","def start(self):\n\n while True:\n try:\n _ = self.assigned.pop(0)\n yield self.assemble_substructure()\n\n except IndexError:\n break","def block_splitter(data, block_size):\n buf = []\n for i, datum in enumerate(data):\n buf.append(datum)\n if len(buf) == block_size:\n yield buf\n buf = []\n\n # If there's anything leftover (a partial block),\n # yield it as well.\n if buf:\n yield buf","def __next__(self):\n for child in self.children:\n yield child\n return\n #self.parent.next()","def stage1(self):\n n = self.min\n while True:\n n, bin_ = self.sort_to_bin(n)\n if n is None:\n n = self.get_new_n(bin_)\n if n is None:\n break\n if self.viz:\n yield","def semigroup_generators(self):","def __next__(self):\n for child in self.children:\n yield child","def block_offsets(self):\n ...","def get_initial_blocks(self):\n block = []\n index = 0\n for number in self.numbers_from_file(self.input_file_name):\n block.append(number)\n if len(block) == self.block_size:\n block.sort()\n self.write_block(index, block)\n block = []\n index += 1\n else:\n if block:\n block.sort()\n self.write_block(index, block)\n index += 1\n return 0, index","def iter_all_fragments(self):\n for model in self.model_list:\n for chain in model.chain_list:\n for frag in chain.fragment_list:\n yield frag","def blocks(self): # -> BlockView:\n ...","def list_blocks(self, _):\n print(self.data.name)","def iter_block_items(parent):\n\n if isinstance(parent, Document):\n parent_elm = parent.element.body\n elif isinstance(parent, _Cell):\n parent_elm = parent._tc\n else:\n raise ValueError(\"something's not right\")\n\n for child in parent_elm.iterchildren():\n if isinstance(child, CT_P):\n yield Paragraph(child, parent)\n elif isinstance(child, CT_Tbl):\n yield Table(child, parent)","def genBlocksByLocName(self):\n self.blocksByLocName = {\n block.getLocation(): block for block in self.getBlocks(includeAll=True)\n }","def pre_order(self):\n for node_data in self._pre_order_helper(self._root):\n yield node_data","def test_block_extra_batch(self):\n pass","def __iter__(self):\n for key in self.sprite_order:\n if key not in self.sprite_groups:\n # abstract type\n continue\n for s in self.sprite_groups[key]:\n yield s","def conservedBlocks():\n path = \"./data/\"\n for file in os.listdir(path):\n if file.endswith(\".fa\") or file.endswith(\".fasta\"):\n alignin = AlignIO.read(path + file, \"fasta\")\n try:\n filecore = file.rstrip(\".fa\")\n except:\n filecore = file.rstrip(\".fasta\")\n fileout = path + filecore + \".blocks\"\n \n # constants\n align = []\n cons = []\n border = []\n blocks = []\n \n # alignment\n for pos in range(0,(alignin.get_alignment_length())):\n column=alignin[:,pos]\n if \"-\" not in column:\n align.append(column)\n cons.append(pos)\n \n \n if cons != []: \n border.append(cons[0])\n border.append(cons[len(cons)-1])\n for i in range(0, len(cons)-1):\n if int(cons[i]+1)!=int(cons[i+1]):\n border.append(cons[i])\n \n for j in range((len(cons)-1), 0, -1):\n if int(cons[j]-1)!=int(cons[j-1]):\n border.append(cons[j]) \n \n # list of positions for the blocks\n order=sorted(border)\n \n # get the blocks and writes to the .blocks file\n o=open(fileout, \"w\")\n \n for i in range(0,len(order)-1,2):\n beg=int(order[i])\n end=int(order[i+1])\n count = end-beg \n block=alignin[:,beg:end]\n \n # specify the minimum length of a gap\n if count < 3:\n pass\n else: \n blocks.append(block) \n o.write('***Block***'+\"\\n\"+\"Start:\"+str(beg)+\\\n \"\\n\"+\"Count:\"+str(count)+\"\\n\")\n for record in block:\n o.write(str(record.seq)+\"\\n\")\n o.close()\n else:\n o=open(fileout, \"w\")\n o.close()\n pass\n return","def extract_blocks(lines):\n py_block = False\n block = []\n for line in lines:\n # start of py block\n if line.strip() == '```python':\n py_block = True\n if block:\n yield block, 'md'\n block = []\n\n # exiting py block\n elif py_block and line.strip() == '```':\n py_block = False\n if block:\n yield block, 'py'\n block = []\n\n else:\n block.append(line)\n\n if block:\n yield block, 'md'","def print_block():\n do_twice(do_block)\n do_twice(do_block)\n print_column()","def _ctab_bond_block(number_of_lines, block_type, stream):\n for _ in range(int(number_of_lines)):\n line = stream.popleft()\n line_values = [line[i:i + 3].strip() for i in range(0, 21, 3)]\n line_values = [item if item != \"\" else \"0\" for item in line_values]\n yield block_type(*line_values)","def build_nested_blocks(self):\n pass","def post_order(self):\n for node_data in self._post_order_helper(self._root):\n yield node_data","def Transform(tokenGenerator: Iterator[Token]) -> Generator['Block', Token, None]:\r\n\r\n\t\tstate = ParserState(tokenGenerator)\r\n\t\treturn state.GetGenerator()","def node_gen(self):\n for n in self.child_list:\n yield from n.node_gen\n yield self","def task_output_block_groups():\n for dept in Department.list():\n yield {\n 'name': dept.name,\n 'file_dep': [dept.block_groups_path],\n 'targets': [dept.block_groups_output],\n 'actions': ['cp %(dependencies)s %(targets)s'],\n 'clean': True,\n }","def ordered_edges_iter(self, data=False, keys=False):\n\n # start by sorting nodes in temporal+topological order\n o = self.ordering_graph()\n nodes = nx.topological_sort(o)\n\n # iterate over edges using this very order\n for _ in self.edges_iter(nbunch=nodes, data=data, keys=keys):\n yield _","def iter_structures(self):\n idx_start = 0\n start_name = self.name[idx_start]\n for idx_current, name in enumerate(self.name):\n if start_name != name:\n yield start_name, slice(idx_start, idx_current), self[idx_start:idx_current]\n idx_start = idx_current\n start_name = self.name[idx_start]\n yield start_name, slice(idx_start, None), self[idx_start:]","def run(self, parent, blocks):\r\n pass","def iter_import_chunks(self):\r\n chunk = []\r\n last_line = None\r\n for leaf in self.python_file.tree.body:\r\n if isinstance(leaf, (ast.Import, ast.ImportFrom)):\r\n # we've seen previous imports but this import is not in the same chunk\r\n if last_line and leaf.lineno != last_line[1]:\r\n yield chunk\r\n chunk = [leaf]\r\n # we've either not seen previous imports or this is part of the same chunk\r\n elif not last_line or last_line and leaf.lineno == last_line[1]:\r\n chunk.append(leaf)\r\n last_line = self.python_file.logical_lines[leaf.lineno]\r\n if chunk:\r\n yield chunk","def print_blocks(bril):\n import briltxt\n\n func = bril['functions'][0] # We only process one function.\n for block in form_blocks(func['instrs']):\n # Mark the block.\n leader = block[0]\n if 'label' in leader:\n print('block \"{}\":'.format(leader['label']))\n block = block[1:] # Hide the label, for concision.\n else:\n print('anonymous block:')\n\n # Print the instructions.\n for instr in block:\n print(' {}'.format(briltxt.instr_to_string(instr)))","def __call__(self):\n yield from self","def inorder_generator(self):\n\n for val in self.inorder_helper_generator(self.root):\n yield val","def ascend(self):\n node = self.parent\n while node:\n yield node\n node = node.parent","def do_block():\n print_column()\n print_rows()","def do_block():\n print_column()\n print_rows()","def parse_blocks(fblocks):\n print('Parse blocks: ', end='')\n result = []\n\n for line in fblocks:\n stripped = line.strip()\n if len(stripped) > 0 and stripped[0] != '#':\n match = re.match(r\"([0-9A-F]+)\\.{2}([0-9A-F]+);\\s+(.+)\", stripped)\n result.append({\n 'begin': int(match.group(1), 16),\n 'end': int(match.group(2), 16),\n 'name': match.group(3)\n })\n\n print('done')\n return result","def iter_fragments(self):\n if self.default_model is None:\n raise StopIteration\n\n for chain in self.default_model.chain_list:\n for frag in chain.fragment_list:\n yield frag","def get_docshtest_blocks(lines):\n\n block = []\n consecutive_empty = 0\n for line_nb, line in enumerate(lines):\n is_empty_line = not line.strip()\n if not is_empty_line:\n if not line.startswith(\" \"):\n if block:\n yield block[:-consecutive_empty] \\\n if consecutive_empty else block\n block = []\n continue\n else:\n line = line[4:]\n if line.startswith(\"$ \") or block:\n if line.startswith(\"$ \"):\n line = line[2:]\n if block:\n yield block[:-consecutive_empty] \\\n if consecutive_empty else block\n block = []\n if is_empty_line:\n consecutive_empty += 1\n else:\n consecutive_empty = 0\n block.append((line_nb + 1, line))\n if block:\n yield block[:-consecutive_empty] \\\n if consecutive_empty else block","def _prepare_blocks():\n\n counter = blocks[0]['freeStart']\n maxBlocks = blocks[0]['maxBlocks']\n while(counter < maxBlocks) :\n try:\n # print (mount['parent'] + '/linddata.' + str(counter))\n f = open(mount['parent'] + '/linddata.' + str(counter), 'r') \n except IOError, e:\n return STATUS['M_BD']\n else :\n fdatastring = f.next()\n fdata = deserializedata(fdatastring)\n blocks[counter] = fdata\n counter += 1\n \n return STATUS['OK']","def get_blocks():\n query = iroha.blocks_query()\n IrohaCrypto.sign_query(query, ADMIN_PRIVATE_KEY)\n for block in net.send_blocks_stream_query(query):\n print('\\nThe next block arrived:', block)","def print_block():\n do_twice(do_block)\n print_column()","def __iter__(self):\n # return self.options[:self.idx] + self.options[self.idx:]\n for op in self.queue():\n yield op","def oh_compress(key, seed, blocks, secondary):\n for block, block_size in blocks:\n size_tag = block_size % (CHUNK_SIZE * BLOCK_SIZE)\n tag = (seed ^ size_tag) * W\n yield oh_compress_one_block(key, block, tag, secondary)","def gappyBlocks():\n path = \"./data/\"\n for file in os.listdir(path):\n if file.endswith(\".fa\") or file.endswith(\".fasta\"):\n alignin = AlignIO.read(path + file, \"fasta\")\n try:\n filecore = file.rstrip(\".fa\")\n except:\n filecore = file.rstrip(\".fasta\")\n fileout = path + filecore + \".blocks\"\n \n # constants\n align = []\n gap = []\n border = []\n blocks = []\n \n # specify cut-off of gaps in column (in percentage)\n cut_min = 0.1\n cut_max = 0.9\n \n # alignment\n for pos in range(0,(alignin.get_alignment_length())):\n column=alignin[:,pos]\n align.append(column)\n if \"-\" in column:\n col=list(column)\n gaps=col.count(\"-\")\n if gaps > (cut_min*len(col)) and gaps < (cut_max*len(col)):\n gap.append(pos)\n \n if gap != []:\n border.append(gap[0])\n border.append(gap[len(gap)-1])\n for i in range(0,(len(gap)-1)):\n if int(gap[i]+1)!=int(gap[i+1]):\n border.append(gap[i])\n \n for j in range((len(gap)-1), 0, -1):\n if int(gap[j]-1)!=int(gap[j-1]):\n border.append(gap[j])\n # list of positions for the blocks\n order=sorted(border)\n \n # get the blocks and writes to the .blocks file\n o=open(fileout, \"w\")\n \n for i in range(0,len(order)-1,2):\n beg=int(order[i])\n end=int(order[i+1])\n count = end-beg \n block=alignin[:,beg:end]\n \n # specify the minimum length of a gap\n if count < 3:\n pass\n else: \n blocks.append(block) \n o.write('***Block***'+\"\\n\"+\"Start:\"+str(beg)+\\\n \"\\n\"+\"Count:\"+str(count)+\"\\n\")\n for record in block:\n o.write(str(record.seq)+\"\\n\")\n o.close()\n else:\n o=open(fileout, \"w\")\n o.close()\n pass\n return","def main(start, end):\n for i in range(start, end+1):\n yield i, square(i), cube(i)","def __iter__(self):\n yield from self.gen","def _process_main(self):\n # Cursors to blocks which may be combined\n first = self.match_list[self.i]\n second = self.match_list[self.j]\n if not self.can_combine(first, second):\n if first.a_end == self.a_cursor:\n # Couldn't combine, just add first\n # to the combined list\n self.combined.append(first)\n # Advance cursor\n self.i = self.j\n elif self.is_valid_block(first):\n # Can't combine any more, so combine\n # those that have just been past\n self.combine_and_select_block(first)\n self.i = self.j\n # Advance second cursor\n self.j += 1\n cont = self.j < self.match_count\n if cont:\n self.move_cursors_to_end(second)\n return first, second, cont","def _generate_next_blocks(self):\n next_block = choice(LEVELS)\n if self.is_start is False and self.next_region == 0:\n last = self.string_level_blocks[-1][1]\n self.string_level_blocks.append((self.next_region, last))\n self._get_sprites_block(last, self.next_region)\n else:\n if self.next_region != 0:\n self.string_level_blocks.append((self.next_region, next_block))\n self._get_sprites_block(next_block, self.next_region)\n else:\n if len(self.string_level_blocks) > 0:\n last = self.string_level_blocks[-1][1]\n self.string_level_blocks.append((self.next_region, last))\n self._get_sprites_block(last, self.next_region)\n else:\n self.string_level_blocks.append((self.next_region, next_block))\n self._get_sprites_block(next_block, self.next_region)\n self.next_region += 1\n self.next_region %= AMOUNT_REGIONS_TO_DRAW","def _in_order_helper(self, node):\n curr = node\n if curr._lkid:\n for node_data in self._in_order_helper(curr._lkid):\n yield node_data\n yield curr._data\n if curr._rkid:\n for node_data in self._in_order_helper(curr._rkid):\n yield node_data"],"string":"[\n \"def blocks(self):\\n if self._ast:\\n for block in self._ast[2]:\\n yield block\",\n \"def collect_blocks():\\n\\n # Below are the position of (c,r) in a block.\\n\\n #########################\\n # (0,0) # (1,0) # (2,0) #\\n #########################\\n #########################\\n # (0,1) # (1,1) # (2,1) #\\n #########################\\n #########################\\n # (0,2) # (1,2) # (2,2) #\\n #########################\\n\\n for x in range(72):\\n r, c = x // 9 % 3, x % 3\\n if r == 0:\\n if c == 0:\\n yield x, x + 10\\n yield x, x + 11\\n yield x, x + 19\\n yield x, x + 20\\n elif c == 1:\\n yield x, x + 8\\n yield x, x + 10\\n yield x, x + 17\\n yield x, x + 19\\n else:\\n yield x, x + 7\\n yield x, x + 8\\n yield x, x + 16\\n yield x, x + 17\\n elif r == 1:\\n if c == 0:\\n yield x, x + 10\\n yield x, x + 11\\n elif c == 1:\\n yield x, x + 8\\n yield x, x + 10\\n else:\\n yield x, x + 8\\n yield x, x + 7\",\n \"def static_order(self):\\n self.prepare()\\n while self.is_active():\\n node_group = self.get_ready()\\n yield from node_group\\n self.done(*node_group)\",\n \"def __iter__(self):\\n for x in self._order:\\n yield x\",\n \"def sequences(self):\\n # i am one\\n yield self\\n # nothing further\\n return\",\n \"def sort(self):\\n for _ in self.stage1():\\n yield\\n for _ in self.stage2():\\n yield\",\n \"def instructions(self):\\n yield self.inst\\n for inst in self.arguments[:]:\\n yield inst\\n for basic_block in self.basic_blocks[:]:\\n if basic_block.function is not None:\\n yield basic_block.inst\\n for inst in basic_block.insts[:]:\\n yield inst\\n yield self.end_inst\",\n \"def simple():\\n yield 1\\n yield 2\\n yield 3\",\n \"def stage2(self):\\n start = 0\\n while True:\\n idx = self.first_unsorted(start)\\n if idx is None:\\n break\\n start = self.nearby_sort(idx)\\n if self.viz:\\n yield\",\n \"def test_block_batches_order(self):\\n pass\",\n \"def gen_blocks(self, count=None):\\n if not count:\\n count = self.num_blk\\n for x in range(0, count*32, 32):\\n buf = self._read(x)\\n yield x, buf\",\n \"def blocks(self):\\n pass\",\n \"def blockParser(block):\\n struct = []\\n first = True\\n record = False\\n for line in block:\\n if line.startswith('Structure #'):\\n record = True\\n if not first:\\n yield struct\\n struct = []\\n first = False\\n if record:\\n struct.append(line)\\n yield struct\",\n \"def detect_page_blocks():\\n block_names_set = set()\\n for filename in FILENAMES:\\n fd = open(filename)\\n for block_name in PAGE_BLOCK_MARKER_CRX.findall(fd.read()):\\n block_names_set.add(block_name)\\n sorted_block_names = sorted(list(block_names_set))\\n for block_name in sorted_block_names:\\n yield block_name\",\n \"def __parse_blocks_pass(self):\\n\\n self.stack = [DocumentStackToken()]\\n\\n self.tokenized_document = []\\n token_to_use = self.source_provider.get_next_line()\\n did_start_close = False\\n did_started_close = False\\n requeue = []\\n ignore_link_definition_start = False\\n POGGER.debug(\\\"---$---\\\", token_to_use)\\n POGGER.debug(\\\"---\\\")\\n self.__parse_properties.pragma_lines = {}\\n line_number = 1\\n try:\\n (\\n token_to_use,\\n line_number,\\n requeue,\\n ) = self.__process_front_matter_header_if_present(\\n token_to_use, line_number, requeue\\n )\\n did_start_close = token_to_use is None\\n keep_on_going = True\\n while keep_on_going:\\n POGGER.debug(\\\"next-line>>$\\\", token_to_use)\\n POGGER.debug(\\\"stack>>$\\\", self.stack)\\n POGGER.debug(\\\"current_block>>$\\\", self.stack[-1])\\n POGGER.debug(\\\"line_number>>$\\\", line_number)\\n POGGER.debug(\\\"---\\\")\\n\\n position_marker = PositionMarker(line_number, 0, token_to_use)\\n parser_state = ParserState(\\n self.stack,\\n self.tokenized_document,\\n TokenizedMarkdown.__close_open_blocks,\\n self.__handle_blank_line,\\n )\\n if did_start_close:\\n POGGER.debug(\\\"\\\\n\\\\ncleanup\\\")\\n\\n was_link_definition_started_before_close = self.stack[\\n -1\\n ].was_link_definition_started\\n\\n did_started_close = True\\n (\\n tokens_from_line,\\n requeue_line_info,\\n ) = TokenizedMarkdown.__close_open_blocks(\\n parser_state,\\n self.tokenized_document,\\n include_block_quotes=True,\\n include_lists=True,\\n caller_can_handle_requeue=True,\\n was_forced=True,\\n )\\n if tokens_from_line and not self.tokenized_document:\\n self.tokenized_document.extend(tokens_from_line)\\n\\n if not (requeue_line_info and requeue_line_info.lines_to_requeue):\\n keep_on_going = False\\n else:\\n assert was_link_definition_started_before_close\\n assert not requeue_line_info.lines_to_requeue[0]\\n\\n del requeue_line_info.lines_to_requeue[0]\\n line_number -= 1\\n\\n did_start_close = False\\n tokens_from_line = None\\n else:\\n POGGER.debug(\\\">>>>$\\\", self.tokenized_document)\\n\\n if not token_to_use or not token_to_use.strip():\\n POGGER.debug(\\\"call __parse_blocks_pass>>handle_blank_line\\\")\\n (\\n tokens_from_line,\\n requeue_line_info,\\n ) = self.__handle_blank_line(\\n parser_state,\\n token_to_use,\\n from_main_transform=True,\\n position_marker=position_marker,\\n )\\n else:\\n POGGER.debug(\\\"\\\\n\\\\nnormal lines\\\")\\n (\\n tokens_from_line,\\n _,\\n _,\\n requeue_line_info,\\n _,\\n ) = ContainerBlockProcessor.parse_line_for_container_blocks(\\n parser_state,\\n position_marker,\\n ignore_link_definition_start,\\n self.__parse_properties,\\n None,\\n )\\n\\n POGGER.debug(\\\"<<<<$\\\", self.tokenized_document)\\n\\n if keep_on_going:\\n line_number, ignore_link_definition_start = TokenizedMarkdown.__xx(\\n line_number, requeue_line_info, requeue\\n )\\n\\n POGGER.debug(\\n \\\"---\\\\nbefore>>$\\\",\\n self.tokenized_document,\\n )\\n POGGER.debug(\\\"before>>$\\\", tokens_from_line)\\n if tokens_from_line:\\n self.tokenized_document.extend(tokens_from_line)\\n POGGER.debug(\\n \\\"after>>$\\\",\\n self.tokenized_document,\\n )\\n if requeue:\\n POGGER.debug(\\\"requeue>>$\\\", requeue)\\n POGGER.debug(\\\"---\\\")\\n\\n (\\n token_to_use,\\n did_start_close,\\n did_started_close,\\n ) = self.__determine_next_token_process(\\n requeue, did_start_close, did_started_close\\n )\\n except AssertionError as this_exception:\\n error_message = f\\\"A project assertion failed on line {line_number} of the current document.\\\"\\n raise BadTokenizationError(error_message) from this_exception\\n\\n if self.__parse_properties.pragma_lines:\\n self.tokenized_document.append(\\n PragmaToken(self.__parse_properties.pragma_lines)\\n )\\n return self.tokenized_document\",\n \"def _iterate_blocks(self):\\n ranges = [host_tuple[0:2] for host_tuple in self.parity_hosts]\\n flags_sql = \\\"SELECT id, value FROM {} FINAL WHERE name = 'traces_extracted'\\\".format(self.indices[\\\"block_flag\\\"])\\n return self.client.iterate(\\n index=self.indices[\\\"block\\\"],\\n fields=[\\\"number\\\"],\\n query=\\\"ANY LEFT JOIN ({}) USING id WHERE value IS NULL AND {}\\\".format(\\n flags_sql,\\n utils.make_range_query('number', *ranges)\\n ),\\n )\",\n \"def parseBlocks(self, parent, blocks):\\r\\n while blocks:\\r\\n for processor in self.blockprocessors.values():\\r\\n if processor.test(parent, blocks[0]):\\r\\n processor.run(parent, blocks)\\r\\n break\",\n \"def ranges(self):\\n for b in self.remaining_blocks:\\n yield b, b * DEFAULT_BLOCK_SIZE, min(self.content_length, (b + 1) * DEFAULT_BLOCK_SIZE)\",\n \"def blocks_iter(lines):\\n type_ = None\\n content = []\\n termdef = re.compile(r\\\"^\\\\[([a-zA-Z_]+?)\\\\]$\\\")\\n for line in lines:\\n m = re.search(termdef, line)\\n if m:\\n if type_ != None and content:\\n yield {\\\"type\\\": type_, \\\"content\\\": content[:]}\\n type_ = m.group(1)\\n content.clear()\\n elif line.rstrip():\\n content.append(line.rstrip())\\n if content:\\n yield {\\\"type\\\": type_, \\\"content\\\": content[:]}\",\n \"def _genBlocksByName(self):\\n self.blocksByName = {\\n block.getName(): block for block in self.getBlocks(includeAll=True)\\n }\",\n \"def exercise_blocks(events):\\n events.sort(key=lambda e: (e.start_time, e.end_time))\\n\\n exercise_block = []\\n block_start_event = None\\n block_end_event = None\\n\\n events_with_dummy_exercise = events + [Event(event_type=Event.EXERCISE,\\n start_time=datetime.datetime.max, end_time=datetime.datetime.max)]\\n\\n for event in events_with_dummy_exercise:\\n if event.event_type != Event.EXERCISE:\\n continue\\n\\n if not exercise_block:\\n exercise_block.append(event)\\n elif event.start_time - exercise_block[-1].end_time <= timedelta(hours=1):\\n # Put the current event in the same exercise block.\\n exercise_block.append(event)\\n else:\\n yield exercise_block\\n # Start a new exercise block.\\n exercise_block = [event]\",\n \"def iter_fragments(self):\\n for chain in self.chain_list:\\n for frag in chain.fragment_list:\\n yield frag\",\n \"def form_blocks(instrs):\\n\\n # Start with an empty block.\\n cur_block = []\\n\\n for instr in instrs:\\n if 'op' in instr: # It's an instruction.\\n # Add the instruction to the currently-being-formed block.\\n cur_block.append(instr)\\n\\n # If this is a terminator (branching instruction), it's the\\n # last instruction in the block. Finish this block and\\n # start a new one.\\n if instr['op'] in TERMINATORS:\\n yield cur_block\\n cur_block = []\\n\\n else: # It's a label.\\n # End the block here (if it contains anything).\\n if cur_block:\\n yield cur_block\\n\\n # Start a new block with the label.\\n cur_block = [instr]\\n\\n # Produce the final block, if any.\\n if cur_block:\\n yield cur_block\",\n \"def get_blocks(self) -> list:\\n self.clingo = ClingoBridge() # reset clingo\\n\\n base = ('base', '')\\n self.clingo.add_file('initial-states.lp')\\n self.clingo.run([base], n=1)\\n output = self.clingo.output[0]\\n\\n blocks = []\\n for atom in output:\\n if atom.name == 'block':\\n blocks.append(atom)\\n\\n return blocks\",\n \"def parse_blocks(self):\\n if not self.options.blocks:\\n return\\n block_identifiers, block_aliases = [list(b) for b in zip(*self.options.blocks)]\\n while block_identifiers:\\n nodelist = self.parser.parse(block_identifiers)\\n token = self.parser.next_token()\\n current_identifier = block_identifiers.pop(0)\\n current_alias = block_aliases.pop(0)\\n while token.contents != current_identifier:\\n current_identifier = block_identifiers.pop(0)\\n self.blocks[block_aliases.pop(0)] = template.NodeList() \\n self.blocks[current_alias] = nodelist\\n assert len(self.blocks) == len(self.options.blocks), \\\"%s block parsing failed: %r => %r\\\" % (self.tagname, self.options.blocks, self.blocks)\",\n \"def get_building_blocks(self):\\n\\n yield from self._graph_state.get_building_blocks()\",\n \"def between_blocks(self, frame):\\n return []\",\n \"def abc():\\r\\n yield \\\"a\\\"\\r\\n yield \\\"b\\\"\\r\\n yield \\\"c\\\"\",\n \"def loop(self):\\n yield self\\n e = self.next\\n while e is not self:\\n yield e\\n e = e.next\",\n \"def _prepare(self, mol):\\n\\n # Order the building blocks by number of functional groups\\n # so that building blocks with more functional groups are\\n # always placed first.\\n\\n bb_verts = dict()\\n bbs = sorted(\\n mol.building_block_vertices,\\n key=lambda bb: len(bb.func_groups),\\n reverse=True\\n )\\n for bb in bbs:\\n bb_verts[bb] = mol.building_block_vertices[bb]\\n mol.building_block_vertices = bb_verts\\n return super()._prepare(mol)\",\n \"def orders(self):\\n self._current_order = self.min_order\\n while self._current_order <= self.max_order:\\n yield self._current_order\\n self._current_order += 1\\n del self._current_order\",\n \"def run(self):\\n first_index, last_index = \\\\\\n self.get_initial_blocks()\\n while last_index - first_index > self.block_size:\\n first_index, last_index = \\\\\\n self.join_blocks(first_index, last_index)\\n self.merge_blocks(self.output_file_name, first_index, last_index)\",\n \"def iter_block_items(parent):\\n if isinstance(parent, _Document):\\n parent_elm = parent.element.body\\n # print(parent_elm.xml)\\n elif isinstance(parent, _Cell):\\n parent_elm = parent._tc\\n else:\\n raise ValueError(\\\"something's not right\\\")\\n\\n for child in parent_elm.iterchildren():\\n if isinstance(child, CT_P):\\n yield Paragraph(child, parent)\\n elif isinstance(child, CT_Tbl):\\n yield Table(child, parent)\",\n \"def iter_block_items(parent):\\n if isinstance(parent, _Document):\\n parent_elm = parent.element.body\\n # print(parent_elm.xml)\\n elif isinstance(parent, _Cell):\\n parent_elm = parent._tc\\n else:\\n raise ValueError(\\\"something's not right\\\")\\n\\n for child in parent_elm.iterchildren():\\n if isinstance(child, CT_P):\\n yield Paragraph(child, parent)\\n elif isinstance(child, CT_Tbl):\\n yield Table(child, parent)\",\n \"def each_pair_of_blocks(self, accept_first, accept_second):\\n\\n # Iteration order here is significant: Rather than fixing i and looping\\n # over each j, then doing the same, etc. we iterate over the gap between\\n # i and j and then over i. The reason for this is that it ensures that\\n # we try a different value for i and j on each iteration of the inner\\n # loop. This stops us from stalling if we happen to hit on a value of i\\n # where nothing useful can be done.\\n #\\n # In the event that nothing works, this doesn't help and we still make\\n # the same number of calls, but by ensuring that we make progress we\\n # have more opportunities to make shrinks that speed up the tests or\\n # that reduce the number of viable shrinks at the next gap size because\\n # we've lowered some values.\\n offset = 1\\n while offset < len(self.blocks):\\n i = 0\\n while i + offset < len(self.blocks):\\n j = i + offset\\n block_i = self.blocks[i]\\n block_j = self.blocks[j]\\n if accept_first(block_i) and accept_second(block_j):\\n yield (block_i, block_j)\\n i += 1\\n offset += 1\",\n \"def render_paths_between_yields(paths): # pragma: no cover\\n from graphviz import Digraph\\n dot = Digraph(name=\\\"top\\\")\\n for i, path in enumerate(paths):\\n prev = None\\n for block in path:\\n if isinstance(block, Branch):\\n label = \\\"if \\\" + astor.to_source(block.cond)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"invhouse\\\"})\\n elif isinstance(block, Yield):\\n label = \\\"id: {}\\\\n\\\".format(block.yield_id)\\n label += astor.to_source(block.value)\\n label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"oval\\\"})\\n elif isinstance(block, BasicBlock):\\n label = \\\"\\\\n\\\".join(astor.to_source(stmt) for stmt in block.statements)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"box\\\"})\\n elif isinstance(block, HeadBlock):\\n label = \\\"Initial\\\"\\n dot.node(str(i) + str(id(block)) + \\\"_start\\\", label.rstrip(), {\\\"shape\\\": \\\"doublecircle\\\"})\\n label = \\\"\\\\n\\\".join(astor.to_source(stmt).rstrip() for stmt in block.initial_statements)\\n if hasattr(block, \\\"initial_yield\\\"):\\n label += \\\"\\\\n\\\" + astor.to_source(block.initial_yield.value)\\n label += \\\"\\\\nLive Ins : \\\" + str(block.live_ins)\\n label += \\\"\\\\nLive Outs : \\\" + str(block.live_outs)\\n # label += \\\"\\\\nGen : \\\" + str(block.gen)\\n # label += \\\"\\\\nKill : \\\" + str(block.kill)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"box\\\"})\\n dot.edge(str(i) + str(id(block)) + \\\"_start\\\", str(i) + str(id(block)))\\n elif isinstance(block, State):\\n label = \\\"{}\\\".format(astor.to_source(block.yield_state).rstrip())\\n if block.conds:\\n label += \\\" && \\\"\\n label += \\\" && \\\".join(astor.to_source(cond) for cond in block.conds)\\n label += \\\"\\\\n\\\"\\n label += \\\"\\\\n\\\".join(astor.to_source(statement) for statement in block.statements)\\n dot.node(str(i) + str(id(block)), label.rstrip(), {\\\"shape\\\": \\\"doubleoctagon\\\"})\\n else:\\n raise NotImplementedError(type(block))\\n if prev is not None:\\n if isinstance(prev, Branch):\\n if block is prev.false_edge:\\n label = \\\"F\\\"\\n else:\\n label = \\\"T\\\"\\n else:\\n label = \\\"\\\"\\n dot.edge(str(i) + str(id(prev)), str(i) + str(id(block)), label)\\n prev = block\\n\\n file_name = tempfile.mktemp(\\\"gv\\\")\\n dot.render(file_name, view=True)\",\n \"def iterator(self):\\n yield\",\n \"def instructions_reversed(self):\\n yield self.end_inst\\n for basic_block in reversed(self.basic_blocks[:]):\\n if basic_block.function is not None:\\n for inst in reversed(basic_block.insts[:]):\\n yield inst\\n yield basic_block.inst\\n for inst in reversed(self.arguments[:]):\\n yield inst\\n yield self.inst\",\n \"def test_nested_yield():\\n yield (yield (yield 1))\",\n \"def iter_sequence(self):\\n for res_name, fragment in self.sequence_fragment_list:\\n yield res_name\",\n \"def pslBlocks(alignmentColumns, alnStarts, letterSizes):\\n start1, start2 = alnStarts\\n letterSize1, letterSize2 = letterSizes\\n size = 0\\n for x, y in alignmentColumns:\\n if x == \\\"-\\\":\\n if size:\\n yield size, start1, start2\\n start1 += size * letterSize1\\n start2 += size * letterSize2\\n size = 0\\n start2 += symbolSize(y, letterSize2)\\n elif y == \\\"-\\\":\\n if size:\\n yield size, start1, start2\\n start1 += size * letterSize1\\n start2 += size * letterSize2\\n size = 0\\n start1 += symbolSize(x, letterSize1)\\n else:\\n size += 1\\n if size: yield size, start1, start2\",\n \"def in_order(self):\\n for node_data in self._in_order_helper(self._root):\\n yield node_data\",\n \"def get_block(self, maf_lines, as_string=True):\\n for line in maf_lines:\\n # header line: start new block beginning with the header\\n if line.startswith('a'):\\n self._current_block = [line]\\n\\n # sequence line: store AlignmentSequence if ID in self.species\\n elif line.startswith('s'):\\n species_id = line.split()[1].split('.')[0]\\n if species_id in self._species:\\n new_sequence = AlignmentSequence(line)\\n self._current_block.append(new_sequence)\\n\\n # block-separator: yield current block\\n elif line.startswith('\\\\n'):\\n # yield the current block if >= nonref sequence\\n if len(self) > 1:\\n # default output: string\\n if as_string:\\n yield self.block_string\\n else:\\n yield self.block_data\\n\\n # check that other lines are in 'ieq' categories like they should be\\n else:\\n assert line[0] in '#ieq'\",\n \"def iter_block_items_(self, parent):\\n if isinstance(parent, _Document):\\n parent_elm = parent.element.body\\n elif isinstance(parent, _Cell):\\n parent_elm = parent._tc\\n elif isinstance(parent, _Row):\\n parent_elm = parent._tr\\n else:\\n raise ValueError(\\\"something's not right\\\")\\n \\n for child in parent_elm.iterchildren():\\n if isinstance(child, CT_P):\\n yield Paragraph(child, parent)\\n elif isinstance(child, CT_Tbl):\\n yield Table(child, parent)\",\n \"def next_block(the_file):\\n category = next_line(the_file)\\n\\n question = next_line(the_file)\\n\\n answers = []\\n for i in range(4):\\n answers.append(next_line(the_file))\\n\\n correct = next_line(the_file)\\n if correct:\\n correct = correct[0]\\n\\n explanation = next_line(the_file)\\n\\n return category, question, answers, correct, explanation\",\n \"def Block(self):\\n self._advance([\\\"INDENT\\\"])\\n stmts = self.Statements()\\n self._advance([\\\"DEDENT\\\"])\\n return stmts\",\n \"async def _new_blocks(self) -> AsyncGenerator[Eth1Block, None]:\\n while True:\\n try:\\n block = self._eth1_data_provider.get_block(\\\"latest\\\")\\n except BlockNotFound:\\n raise Eth1MonitorValidationError(\\\"Fail to get latest block\\\")\\n target_block_number = BlockNumber(block.number - self._num_blocks_confirmed)\\n from_block_number = self.highest_processed_block_number\\n if target_block_number > from_block_number:\\n # From `highest_processed_block_number` to `target_block_number`\\n for block_number in range(\\n from_block_number + 1, target_block_number + 1\\n ):\\n try:\\n block = self._eth1_data_provider.get_block(\\n BlockNumber(block_number)\\n )\\n except BlockNotFound:\\n raise Eth1MonitorValidationError(\\n f\\\"Block does not exist for block number={block_number}\\\"\\n )\\n yield block\\n await trio.sleep(self._polling_period)\",\n \"def next_block(the_file):\\n category = next_line(the_file)\\n question = next_line(the_file)\\n answers = []\\n for i in range(4):\\n answers.append(next_line(the_file))\\n\\n correct = next_line(the_file)\\n if correct:\\n correct = correct[0]\\n explanation = next_line(the_file)\\n\\n return category, question, answers, correct, explanation\",\n \"def yields ( self ) :\\n return tuple ( [ i for i in self.alist2 ] )\",\n \"def yields ( self ) :\\n return tuple ( [ i for i in self.alist2 ] )\",\n \"def find_blocks(self, area, tags, count=None, order=None, point=None):\\n\\t\\tif count != None:\\n\\t\\t\\traise NotImplementedError()\\n\\t\\tif order != None:\\n\\t\\t\\traise NotImplementedError()\\n\\t\\tif point != None:\\n\\t\\t\\traise NotImplementedError()\\n\\t\\tif isinstance(tags, str):\\n\\t\\t\\ttags = {tags}\\n\\t\\tassert isinstance(tags, set)\\n\\t\\tassert area != EVERYWHERE\\n\\n\\t\\tif area == SOMEWHERE or area == NOWHERE:\\n\\t\\t\\treturn\\n\\n\\t\\t# get binary box cover of area\\n\\t\\t# get tags for those boxes, if necessary generate the tags\\n\\t\\t# if box is more than one block in size, repeat recursively with subboxes\\n\\t\\tbbs = list(area.binary_box_cover()) #M# could try to find a way to stream this generator and join it with queue of children, (or just do depth first)\\n\\t\\twhile bbs:\\n\\t\\t\\tbb = bbs.pop(0)\\n\\t\\t\\tbb_tags = self._get_tags(bb)\\n\\t\\t\\tif tags.issubset(bb_tags) and bb.bounding_box().collides_with(area): #M# could try to swap and see how performance changes\\n\\t\\t\\t\\tassert bb.scale >= 0\\n\\t\\t\\t\\tif bb.scale == 0:\\n\\t\\t\\t\\t\\tyield bb.position\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tbbs.extend(bb.get_children())\",\n \"def start(self):\\n\\n while True:\\n try:\\n _ = self.assigned.pop(0)\\n yield self.assemble_substructure()\\n\\n except IndexError:\\n break\",\n \"def block_splitter(data, block_size):\\n buf = []\\n for i, datum in enumerate(data):\\n buf.append(datum)\\n if len(buf) == block_size:\\n yield buf\\n buf = []\\n\\n # If there's anything leftover (a partial block),\\n # yield it as well.\\n if buf:\\n yield buf\",\n \"def __next__(self):\\n for child in self.children:\\n yield child\\n return\\n #self.parent.next()\",\n \"def stage1(self):\\n n = self.min\\n while True:\\n n, bin_ = self.sort_to_bin(n)\\n if n is None:\\n n = self.get_new_n(bin_)\\n if n is None:\\n break\\n if self.viz:\\n yield\",\n \"def semigroup_generators(self):\",\n \"def __next__(self):\\n for child in self.children:\\n yield child\",\n \"def block_offsets(self):\\n ...\",\n \"def get_initial_blocks(self):\\n block = []\\n index = 0\\n for number in self.numbers_from_file(self.input_file_name):\\n block.append(number)\\n if len(block) == self.block_size:\\n block.sort()\\n self.write_block(index, block)\\n block = []\\n index += 1\\n else:\\n if block:\\n block.sort()\\n self.write_block(index, block)\\n index += 1\\n return 0, index\",\n \"def iter_all_fragments(self):\\n for model in self.model_list:\\n for chain in model.chain_list:\\n for frag in chain.fragment_list:\\n yield frag\",\n \"def blocks(self): # -> BlockView:\\n ...\",\n \"def list_blocks(self, _):\\n print(self.data.name)\",\n \"def iter_block_items(parent):\\n\\n if isinstance(parent, Document):\\n parent_elm = parent.element.body\\n elif isinstance(parent, _Cell):\\n parent_elm = parent._tc\\n else:\\n raise ValueError(\\\"something's not right\\\")\\n\\n for child in parent_elm.iterchildren():\\n if isinstance(child, CT_P):\\n yield Paragraph(child, parent)\\n elif isinstance(child, CT_Tbl):\\n yield Table(child, parent)\",\n \"def genBlocksByLocName(self):\\n self.blocksByLocName = {\\n block.getLocation(): block for block in self.getBlocks(includeAll=True)\\n }\",\n \"def pre_order(self):\\n for node_data in self._pre_order_helper(self._root):\\n yield node_data\",\n \"def test_block_extra_batch(self):\\n pass\",\n \"def __iter__(self):\\n for key in self.sprite_order:\\n if key not in self.sprite_groups:\\n # abstract type\\n continue\\n for s in self.sprite_groups[key]:\\n yield s\",\n \"def conservedBlocks():\\n path = \\\"./data/\\\"\\n for file in os.listdir(path):\\n if file.endswith(\\\".fa\\\") or file.endswith(\\\".fasta\\\"):\\n alignin = AlignIO.read(path + file, \\\"fasta\\\")\\n try:\\n filecore = file.rstrip(\\\".fa\\\")\\n except:\\n filecore = file.rstrip(\\\".fasta\\\")\\n fileout = path + filecore + \\\".blocks\\\"\\n \\n # constants\\n align = []\\n cons = []\\n border = []\\n blocks = []\\n \\n # alignment\\n for pos in range(0,(alignin.get_alignment_length())):\\n column=alignin[:,pos]\\n if \\\"-\\\" not in column:\\n align.append(column)\\n cons.append(pos)\\n \\n \\n if cons != []: \\n border.append(cons[0])\\n border.append(cons[len(cons)-1])\\n for i in range(0, len(cons)-1):\\n if int(cons[i]+1)!=int(cons[i+1]):\\n border.append(cons[i])\\n \\n for j in range((len(cons)-1), 0, -1):\\n if int(cons[j]-1)!=int(cons[j-1]):\\n border.append(cons[j]) \\n \\n # list of positions for the blocks\\n order=sorted(border)\\n \\n # get the blocks and writes to the .blocks file\\n o=open(fileout, \\\"w\\\")\\n \\n for i in range(0,len(order)-1,2):\\n beg=int(order[i])\\n end=int(order[i+1])\\n count = end-beg \\n block=alignin[:,beg:end]\\n \\n # specify the minimum length of a gap\\n if count < 3:\\n pass\\n else: \\n blocks.append(block) \\n o.write('***Block***'+\\\"\\\\n\\\"+\\\"Start:\\\"+str(beg)+\\\\\\n \\\"\\\\n\\\"+\\\"Count:\\\"+str(count)+\\\"\\\\n\\\")\\n for record in block:\\n o.write(str(record.seq)+\\\"\\\\n\\\")\\n o.close()\\n else:\\n o=open(fileout, \\\"w\\\")\\n o.close()\\n pass\\n return\",\n \"def extract_blocks(lines):\\n py_block = False\\n block = []\\n for line in lines:\\n # start of py block\\n if line.strip() == '```python':\\n py_block = True\\n if block:\\n yield block, 'md'\\n block = []\\n\\n # exiting py block\\n elif py_block and line.strip() == '```':\\n py_block = False\\n if block:\\n yield block, 'py'\\n block = []\\n\\n else:\\n block.append(line)\\n\\n if block:\\n yield block, 'md'\",\n \"def print_block():\\n do_twice(do_block)\\n do_twice(do_block)\\n print_column()\",\n \"def _ctab_bond_block(number_of_lines, block_type, stream):\\n for _ in range(int(number_of_lines)):\\n line = stream.popleft()\\n line_values = [line[i:i + 3].strip() for i in range(0, 21, 3)]\\n line_values = [item if item != \\\"\\\" else \\\"0\\\" for item in line_values]\\n yield block_type(*line_values)\",\n \"def build_nested_blocks(self):\\n pass\",\n \"def post_order(self):\\n for node_data in self._post_order_helper(self._root):\\n yield node_data\",\n \"def Transform(tokenGenerator: Iterator[Token]) -> Generator['Block', Token, None]:\\r\\n\\r\\n\\t\\tstate = ParserState(tokenGenerator)\\r\\n\\t\\treturn state.GetGenerator()\",\n \"def node_gen(self):\\n for n in self.child_list:\\n yield from n.node_gen\\n yield self\",\n \"def task_output_block_groups():\\n for dept in Department.list():\\n yield {\\n 'name': dept.name,\\n 'file_dep': [dept.block_groups_path],\\n 'targets': [dept.block_groups_output],\\n 'actions': ['cp %(dependencies)s %(targets)s'],\\n 'clean': True,\\n }\",\n \"def ordered_edges_iter(self, data=False, keys=False):\\n\\n # start by sorting nodes in temporal+topological order\\n o = self.ordering_graph()\\n nodes = nx.topological_sort(o)\\n\\n # iterate over edges using this very order\\n for _ in self.edges_iter(nbunch=nodes, data=data, keys=keys):\\n yield _\",\n \"def iter_structures(self):\\n idx_start = 0\\n start_name = self.name[idx_start]\\n for idx_current, name in enumerate(self.name):\\n if start_name != name:\\n yield start_name, slice(idx_start, idx_current), self[idx_start:idx_current]\\n idx_start = idx_current\\n start_name = self.name[idx_start]\\n yield start_name, slice(idx_start, None), self[idx_start:]\",\n \"def run(self, parent, blocks):\\r\\n pass\",\n \"def iter_import_chunks(self):\\r\\n chunk = []\\r\\n last_line = None\\r\\n for leaf in self.python_file.tree.body:\\r\\n if isinstance(leaf, (ast.Import, ast.ImportFrom)):\\r\\n # we've seen previous imports but this import is not in the same chunk\\r\\n if last_line and leaf.lineno != last_line[1]:\\r\\n yield chunk\\r\\n chunk = [leaf]\\r\\n # we've either not seen previous imports or this is part of the same chunk\\r\\n elif not last_line or last_line and leaf.lineno == last_line[1]:\\r\\n chunk.append(leaf)\\r\\n last_line = self.python_file.logical_lines[leaf.lineno]\\r\\n if chunk:\\r\\n yield chunk\",\n \"def print_blocks(bril):\\n import briltxt\\n\\n func = bril['functions'][0] # We only process one function.\\n for block in form_blocks(func['instrs']):\\n # Mark the block.\\n leader = block[0]\\n if 'label' in leader:\\n print('block \\\"{}\\\":'.format(leader['label']))\\n block = block[1:] # Hide the label, for concision.\\n else:\\n print('anonymous block:')\\n\\n # Print the instructions.\\n for instr in block:\\n print(' {}'.format(briltxt.instr_to_string(instr)))\",\n \"def __call__(self):\\n yield from self\",\n \"def inorder_generator(self):\\n\\n for val in self.inorder_helper_generator(self.root):\\n yield val\",\n \"def ascend(self):\\n node = self.parent\\n while node:\\n yield node\\n node = node.parent\",\n \"def do_block():\\n print_column()\\n print_rows()\",\n \"def do_block():\\n print_column()\\n print_rows()\",\n \"def parse_blocks(fblocks):\\n print('Parse blocks: ', end='')\\n result = []\\n\\n for line in fblocks:\\n stripped = line.strip()\\n if len(stripped) > 0 and stripped[0] != '#':\\n match = re.match(r\\\"([0-9A-F]+)\\\\.{2}([0-9A-F]+);\\\\s+(.+)\\\", stripped)\\n result.append({\\n 'begin': int(match.group(1), 16),\\n 'end': int(match.group(2), 16),\\n 'name': match.group(3)\\n })\\n\\n print('done')\\n return result\",\n \"def iter_fragments(self):\\n if self.default_model is None:\\n raise StopIteration\\n\\n for chain in self.default_model.chain_list:\\n for frag in chain.fragment_list:\\n yield frag\",\n \"def get_docshtest_blocks(lines):\\n\\n block = []\\n consecutive_empty = 0\\n for line_nb, line in enumerate(lines):\\n is_empty_line = not line.strip()\\n if not is_empty_line:\\n if not line.startswith(\\\" \\\"):\\n if block:\\n yield block[:-consecutive_empty] \\\\\\n if consecutive_empty else block\\n block = []\\n continue\\n else:\\n line = line[4:]\\n if line.startswith(\\\"$ \\\") or block:\\n if line.startswith(\\\"$ \\\"):\\n line = line[2:]\\n if block:\\n yield block[:-consecutive_empty] \\\\\\n if consecutive_empty else block\\n block = []\\n if is_empty_line:\\n consecutive_empty += 1\\n else:\\n consecutive_empty = 0\\n block.append((line_nb + 1, line))\\n if block:\\n yield block[:-consecutive_empty] \\\\\\n if consecutive_empty else block\",\n \"def _prepare_blocks():\\n\\n counter = blocks[0]['freeStart']\\n maxBlocks = blocks[0]['maxBlocks']\\n while(counter < maxBlocks) :\\n try:\\n # print (mount['parent'] + '/linddata.' + str(counter))\\n f = open(mount['parent'] + '/linddata.' + str(counter), 'r') \\n except IOError, e:\\n return STATUS['M_BD']\\n else :\\n fdatastring = f.next()\\n fdata = deserializedata(fdatastring)\\n blocks[counter] = fdata\\n counter += 1\\n \\n return STATUS['OK']\",\n \"def get_blocks():\\n query = iroha.blocks_query()\\n IrohaCrypto.sign_query(query, ADMIN_PRIVATE_KEY)\\n for block in net.send_blocks_stream_query(query):\\n print('\\\\nThe next block arrived:', block)\",\n \"def print_block():\\n do_twice(do_block)\\n print_column()\",\n \"def __iter__(self):\\n # return self.options[:self.idx] + self.options[self.idx:]\\n for op in self.queue():\\n yield op\",\n \"def oh_compress(key, seed, blocks, secondary):\\n for block, block_size in blocks:\\n size_tag = block_size % (CHUNK_SIZE * BLOCK_SIZE)\\n tag = (seed ^ size_tag) * W\\n yield oh_compress_one_block(key, block, tag, secondary)\",\n \"def gappyBlocks():\\n path = \\\"./data/\\\"\\n for file in os.listdir(path):\\n if file.endswith(\\\".fa\\\") or file.endswith(\\\".fasta\\\"):\\n alignin = AlignIO.read(path + file, \\\"fasta\\\")\\n try:\\n filecore = file.rstrip(\\\".fa\\\")\\n except:\\n filecore = file.rstrip(\\\".fasta\\\")\\n fileout = path + filecore + \\\".blocks\\\"\\n \\n # constants\\n align = []\\n gap = []\\n border = []\\n blocks = []\\n \\n # specify cut-off of gaps in column (in percentage)\\n cut_min = 0.1\\n cut_max = 0.9\\n \\n # alignment\\n for pos in range(0,(alignin.get_alignment_length())):\\n column=alignin[:,pos]\\n align.append(column)\\n if \\\"-\\\" in column:\\n col=list(column)\\n gaps=col.count(\\\"-\\\")\\n if gaps > (cut_min*len(col)) and gaps < (cut_max*len(col)):\\n gap.append(pos)\\n \\n if gap != []:\\n border.append(gap[0])\\n border.append(gap[len(gap)-1])\\n for i in range(0,(len(gap)-1)):\\n if int(gap[i]+1)!=int(gap[i+1]):\\n border.append(gap[i])\\n \\n for j in range((len(gap)-1), 0, -1):\\n if int(gap[j]-1)!=int(gap[j-1]):\\n border.append(gap[j])\\n # list of positions for the blocks\\n order=sorted(border)\\n \\n # get the blocks and writes to the .blocks file\\n o=open(fileout, \\\"w\\\")\\n \\n for i in range(0,len(order)-1,2):\\n beg=int(order[i])\\n end=int(order[i+1])\\n count = end-beg \\n block=alignin[:,beg:end]\\n \\n # specify the minimum length of a gap\\n if count < 3:\\n pass\\n else: \\n blocks.append(block) \\n o.write('***Block***'+\\\"\\\\n\\\"+\\\"Start:\\\"+str(beg)+\\\\\\n \\\"\\\\n\\\"+\\\"Count:\\\"+str(count)+\\\"\\\\n\\\")\\n for record in block:\\n o.write(str(record.seq)+\\\"\\\\n\\\")\\n o.close()\\n else:\\n o=open(fileout, \\\"w\\\")\\n o.close()\\n pass\\n return\",\n \"def main(start, end):\\n for i in range(start, end+1):\\n yield i, square(i), cube(i)\",\n \"def __iter__(self):\\n yield from self.gen\",\n \"def _process_main(self):\\n # Cursors to blocks which may be combined\\n first = self.match_list[self.i]\\n second = self.match_list[self.j]\\n if not self.can_combine(first, second):\\n if first.a_end == self.a_cursor:\\n # Couldn't combine, just add first\\n # to the combined list\\n self.combined.append(first)\\n # Advance cursor\\n self.i = self.j\\n elif self.is_valid_block(first):\\n # Can't combine any more, so combine\\n # those that have just been past\\n self.combine_and_select_block(first)\\n self.i = self.j\\n # Advance second cursor\\n self.j += 1\\n cont = self.j < self.match_count\\n if cont:\\n self.move_cursors_to_end(second)\\n return first, second, cont\",\n \"def _generate_next_blocks(self):\\n next_block = choice(LEVELS)\\n if self.is_start is False and self.next_region == 0:\\n last = self.string_level_blocks[-1][1]\\n self.string_level_blocks.append((self.next_region, last))\\n self._get_sprites_block(last, self.next_region)\\n else:\\n if self.next_region != 0:\\n self.string_level_blocks.append((self.next_region, next_block))\\n self._get_sprites_block(next_block, self.next_region)\\n else:\\n if len(self.string_level_blocks) > 0:\\n last = self.string_level_blocks[-1][1]\\n self.string_level_blocks.append((self.next_region, last))\\n self._get_sprites_block(last, self.next_region)\\n else:\\n self.string_level_blocks.append((self.next_region, next_block))\\n self._get_sprites_block(next_block, self.next_region)\\n self.next_region += 1\\n self.next_region %= AMOUNT_REGIONS_TO_DRAW\",\n \"def _in_order_helper(self, node):\\n curr = node\\n if curr._lkid:\\n for node_data in self._in_order_helper(curr._lkid):\\n yield node_data\\n yield curr._data\\n if curr._rkid:\\n for node_data in self._in_order_helper(curr._rkid):\\n yield node_data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.757031","0.6530753","0.65174127","0.63614154","0.63607633","0.63177335","0.63156325","0.6270871","0.6268873","0.62680745","0.6179819","0.6109972","0.6073869","0.60731417","0.6064365","0.60582024","0.6050395","0.6039829","0.5925948","0.5923637","0.5912275","0.5895153","0.58832496","0.5868338","0.5853162","0.58407956","0.5840325","0.58380544","0.5832404","0.5811968","0.58050096","0.57954586","0.5792131","0.5792131","0.5760899","0.5759269","0.5755266","0.5732953","0.57210773","0.57195085","0.5714782","0.5713966","0.57097083","0.56970835","0.5696943","0.56791604","0.56782764","0.5675154","0.5667913","0.5667913","0.56676674","0.5664962","0.5664421","0.5659733","0.56541747","0.5653563","0.5652358","0.56497556","0.56494284","0.56429225","0.5642372","0.56412137","0.56388","0.56374115","0.5623297","0.5613683","0.5612441","0.5594688","0.55941","0.5580211","0.55692834","0.555929","0.5534372","0.55274546","0.5527432","0.55181557","0.55164874","0.5502906","0.5491358","0.5489101","0.54875106","0.54868215","0.5483482","0.5466766","0.54617167","0.54617167","0.54586893","0.5448897","0.5440004","0.5431334","0.5430921","0.54167384","0.541293","0.541283","0.54089355","0.5400333","0.5399136","0.5392101","0.53909767","0.53795373"],"string":"[\n \"0.757031\",\n \"0.6530753\",\n \"0.65174127\",\n \"0.63614154\",\n \"0.63607633\",\n \"0.63177335\",\n \"0.63156325\",\n \"0.6270871\",\n \"0.6268873\",\n \"0.62680745\",\n \"0.6179819\",\n \"0.6109972\",\n \"0.6073869\",\n \"0.60731417\",\n \"0.6064365\",\n \"0.60582024\",\n \"0.6050395\",\n \"0.6039829\",\n \"0.5925948\",\n \"0.5923637\",\n \"0.5912275\",\n \"0.5895153\",\n \"0.58832496\",\n \"0.5868338\",\n \"0.5853162\",\n \"0.58407956\",\n \"0.5840325\",\n \"0.58380544\",\n \"0.5832404\",\n \"0.5811968\",\n \"0.58050096\",\n \"0.57954586\",\n \"0.5792131\",\n \"0.5792131\",\n \"0.5760899\",\n \"0.5759269\",\n \"0.5755266\",\n \"0.5732953\",\n \"0.57210773\",\n \"0.57195085\",\n \"0.5714782\",\n \"0.5713966\",\n \"0.57097083\",\n \"0.56970835\",\n \"0.5696943\",\n \"0.56791604\",\n \"0.56782764\",\n \"0.5675154\",\n \"0.5667913\",\n \"0.5667913\",\n \"0.56676674\",\n \"0.5664962\",\n \"0.5664421\",\n \"0.5659733\",\n \"0.56541747\",\n \"0.5653563\",\n \"0.5652358\",\n \"0.56497556\",\n \"0.56494284\",\n \"0.56429225\",\n \"0.5642372\",\n \"0.56412137\",\n \"0.56388\",\n \"0.56374115\",\n \"0.5623297\",\n \"0.5613683\",\n \"0.5612441\",\n \"0.5594688\",\n \"0.55941\",\n \"0.5580211\",\n \"0.55692834\",\n \"0.555929\",\n \"0.5534372\",\n \"0.55274546\",\n \"0.5527432\",\n \"0.55181557\",\n \"0.55164874\",\n \"0.5502906\",\n \"0.5491358\",\n \"0.5489101\",\n \"0.54875106\",\n \"0.54868215\",\n \"0.5483482\",\n \"0.5466766\",\n \"0.54617167\",\n \"0.54617167\",\n \"0.54586893\",\n \"0.5448897\",\n \"0.5440004\",\n \"0.5431334\",\n \"0.5430921\",\n \"0.54167384\",\n \"0.541293\",\n \"0.541283\",\n \"0.54089355\",\n \"0.5400333\",\n \"0.5399136\",\n \"0.5392101\",\n \"0.53909767\",\n \"0.53795373\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7572616"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":75098,"cells":{"query":{"kind":"string","value":"Get a generator's configuration block"},"document":{"kind":"string","value":"def GetConfig(self, genname):\n if genname in self.config:\n return self.config[genname]\n else:\n return dbus.Dictionary(signature='sv')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_config_template(self) -> cconfig.Config:","def get_block_config():\n ret = {}\n ret[keyword.function] = []\n ret[keyword.inputs] = []\n ret[keyword.expect] = []\n return ret","def get_config():\n return _config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def _get_config(self):\n return self.__config","def get_config():\n return CONFIG","def get_config(self):\n return self.config","def get_config() -> Config:\n return get_or_set('config', build_configuration)","def get_configuration(self) -> dict:\n return self.config","def config(self):\n return self._config","def _GetVirtualEntityBuildingConfigBlock(\n self, entity: VirtualEntity\n ) -> Dict[str, object]:\n virtual_entity_yaml = {CONFIG_CODE: entity.code}\n virtual_entity_yaml.update(self._GetConnections(entity=entity))\n if entity.links:\n virtual_entity_yaml.update({CONFIG_LINKS: self._SortLinks(entity)})\n virtual_entity_yaml.update(\n {CONFIG_TYPE: entity.namespace + '/' + str(entity.type_name)}\n )\n return virtual_entity_yaml","def config(self):\n return self._cfg","def config():\n return _config","def config(self):\r\n return self._config","def get_configuration_template(self):\n return CONFIG_TEMPLATE","def get_config(self):\n return super().get_config()","def get_config(self):\n if self.allow_reco():\n return self.chs_config()\n else:\n return self.get_config_j(self.id)","def config(self):\n return self.namespace['config']","def get_cfg():\n return _assert_and_infer_cfg(_C.clone())","def config(self):\n return self[CONFIG_KEY]","def _config_generator(self, **kwargs):\n self.__logger.info(kwargs)\n generator = GeneratorFactory(self.generator_type, **kwargs)\n self._msg.input.generator.config.CopyFrom(generator.to_msg())","def configuration(self) -> pulumi.Output['outputs.BrokerConfiguration']:\n return pulumi.get(self, \"configuration\")","def get_config():\n return _CONFIG","def config(self):\n annotations = IAnnotations(self.context)\n return annotations.get(CONFIGURATION_KEY, {})","def get_cfg():\n return defcfg._assert_and_infer_cfg(defcfg._C.clone())","def get_next_configuration():\n iteration_config = self.__iterables[self.__iterables_counter]\n\n for static_option in self.__static:\n if static_option not in self._config_dict:\n raise ConfigReaderError(\"Simulation configuration option '{0}' not found. Please check the SimulationConfigReader class for typos.\".format(static_option))\n\n iteration_config[static_option] = self._config_dict[static_option]\n\n return iteration_config","def get_cfg():\n return _C.clone()","def config(self):\n return None","def getConfig(self):\n \n return self.config","def block(self) -> IMockPin:\n return self[\"block\"]","def get_config(self):\n if self.faucet is not None:\n return self.faucet.get_config()\n return None","def _cfg(self):\n if not hasattr(self, '__config'):\n self.__config = cuegui.Utils.getResourceConfig()\n return self.__config","def get_full_config(self):\n return self._read_config()"],"string":"[\n \"def get_config_template(self) -> cconfig.Config:\",\n \"def get_block_config():\\n ret = {}\\n ret[keyword.function] = []\\n ret[keyword.inputs] = []\\n ret[keyword.expect] = []\\n return ret\",\n \"def get_config():\\n return _config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def _get_config(self):\\n return self.__config\",\n \"def get_config():\\n return CONFIG\",\n \"def get_config(self):\\n return self.config\",\n \"def get_config() -> Config:\\n return get_or_set('config', build_configuration)\",\n \"def get_configuration(self) -> dict:\\n return self.config\",\n \"def config(self):\\n return self._config\",\n \"def _GetVirtualEntityBuildingConfigBlock(\\n self, entity: VirtualEntity\\n ) -> Dict[str, object]:\\n virtual_entity_yaml = {CONFIG_CODE: entity.code}\\n virtual_entity_yaml.update(self._GetConnections(entity=entity))\\n if entity.links:\\n virtual_entity_yaml.update({CONFIG_LINKS: self._SortLinks(entity)})\\n virtual_entity_yaml.update(\\n {CONFIG_TYPE: entity.namespace + '/' + str(entity.type_name)}\\n )\\n return virtual_entity_yaml\",\n \"def config(self):\\n return self._cfg\",\n \"def config():\\n return _config\",\n \"def config(self):\\r\\n return self._config\",\n \"def get_configuration_template(self):\\n return CONFIG_TEMPLATE\",\n \"def get_config(self):\\n return super().get_config()\",\n \"def get_config(self):\\n if self.allow_reco():\\n return self.chs_config()\\n else:\\n return self.get_config_j(self.id)\",\n \"def config(self):\\n return self.namespace['config']\",\n \"def get_cfg():\\n return _assert_and_infer_cfg(_C.clone())\",\n \"def config(self):\\n return self[CONFIG_KEY]\",\n \"def _config_generator(self, **kwargs):\\n self.__logger.info(kwargs)\\n generator = GeneratorFactory(self.generator_type, **kwargs)\\n self._msg.input.generator.config.CopyFrom(generator.to_msg())\",\n \"def configuration(self) -> pulumi.Output['outputs.BrokerConfiguration']:\\n return pulumi.get(self, \\\"configuration\\\")\",\n \"def get_config():\\n return _CONFIG\",\n \"def config(self):\\n annotations = IAnnotations(self.context)\\n return annotations.get(CONFIGURATION_KEY, {})\",\n \"def get_cfg():\\n return defcfg._assert_and_infer_cfg(defcfg._C.clone())\",\n \"def get_next_configuration():\\n iteration_config = self.__iterables[self.__iterables_counter]\\n\\n for static_option in self.__static:\\n if static_option not in self._config_dict:\\n raise ConfigReaderError(\\\"Simulation configuration option '{0}' not found. Please check the SimulationConfigReader class for typos.\\\".format(static_option))\\n\\n iteration_config[static_option] = self._config_dict[static_option]\\n\\n return iteration_config\",\n \"def get_cfg():\\n return _C.clone()\",\n \"def config(self):\\n return None\",\n \"def getConfig(self):\\n \\n return self.config\",\n \"def block(self) -> IMockPin:\\n return self[\\\"block\\\"]\",\n \"def get_config(self):\\n if self.faucet is not None:\\n return self.faucet.get_config()\\n return None\",\n \"def _cfg(self):\\n if not hasattr(self, '__config'):\\n self.__config = cuegui.Utils.getResourceConfig()\\n return self.__config\",\n \"def get_full_config(self):\\n return self._read_config()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68650293","0.62197065","0.6217368","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.62074995","0.6202833","0.61551887","0.6142909","0.6140886","0.61261904","0.6117","0.60991627","0.6081301","0.6062766","0.6050191","0.6022202","0.59855664","0.59668654","0.593991","0.59296644","0.5927412","0.5921243","0.59114444","0.590334","0.5903269","0.5895083","0.5882295","0.58755255","0.5865682","0.5859935","0.58510363","0.5851031","0.5815771"],"string":"[\n \"0.68650293\",\n \"0.62197065\",\n \"0.6217368\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.62074995\",\n \"0.6202833\",\n \"0.61551887\",\n \"0.6142909\",\n \"0.6140886\",\n \"0.61261904\",\n \"0.6117\",\n \"0.60991627\",\n \"0.6081301\",\n \"0.6062766\",\n \"0.6050191\",\n \"0.6022202\",\n \"0.59855664\",\n \"0.59668654\",\n \"0.593991\",\n \"0.59296644\",\n \"0.5927412\",\n \"0.5921243\",\n \"0.59114444\",\n \"0.590334\",\n \"0.5903269\",\n \"0.5895083\",\n \"0.5882295\",\n \"0.58755255\",\n \"0.5865682\",\n \"0.5859935\",\n \"0.58510363\",\n \"0.5851031\",\n \"0.5815771\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.584978"},"document_rank":{"kind":"string","value":"99"}}},{"rowIdx":75099,"cells":{"query":{"kind":"string","value":"Performs a bulk update of properties. Issues only one changed event for the entire update."},"document":{"kind":"string","value":"def Update(self, values):\n # XXX: Rewrite to validate without fragile locks\n with self._change_lock:\n for prop, value in values.items():\n if prop in self.__properties__:\n setattr(self, prop, value)\n else:\n self._props[prop] = value\n self.changed()\n self.PropertiesChanged(self.INTERFACE, values, [])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def update_multiple_objects_properties(self, object_list):\n\n #if self.settings.LOG_VERBOSE and self.settings.ENABLE_OBJECT_LOGGING: logger.debug(\"Processing multiple object properties updates: %s\" % (len(object_list)))\n\n for object_properties in object_list:\n\n self.update_object_properties(object_properties)","def update_properties(self, prop_dict):\n ft_dict = {ft.name: ft for ft in self.get_field_types()}\n for name, val in prop_dict.items():\n ft = ft_dict[name]\n if ft.is_parameter():\n key = \"value\"\n else:\n key = \"sample\"\n if issubclass(type(val), Sequence) and ft.array:\n self.set_field_value_array(name, None, [{key: v} for v in val])\n else:\n self.set_field_value(name, None, {key: val})","def _update_bulk(self, iterable):\n self.cursor.executemany(self.UPDATE, iterable)","def update_batch(self, *args, **kwargs):\n pass","def bulk_update(self, objs, fields, batch_size=None):\n if batch_size is not None and batch_size <= 0:\n raise ValueError(\"Batch size must be a positive integer.\")\n if not fields:\n raise ValueError(\"Field names must be given to bulk_update().\")\n objs = tuple(objs)\n if any(obj.pk is None for obj in objs):\n raise ValueError(\"All bulk_update() objects must have a primary key set.\")\n fields = [self.model._meta.get_field(name) for name in fields]\n if any(not f.concrete or f.many_to_many for f in fields):\n raise ValueError(\"bulk_update() can only be used with concrete fields.\")\n if any(f.primary_key for f in fields):\n raise ValueError(\"bulk_update() cannot be used with primary key fields.\")\n if not objs:\n return 0\n for obj in objs:\n obj._prepare_related_fields_for_save(\n operation_name=\"bulk_update\", fields=fields\n )\n # PK is used twice in the resulting update query, once in the filter\n # and once in the WHEN. Each field will also have one CAST.\n self._for_write = True\n connection = connections[self.db]\n max_batch_size = connection.ops.bulk_batch_size([\"pk\", \"pk\"] + fields, objs)\n batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size\n requires_casting = connection.features.requires_casted_case_in_updates\n batches = (objs[i : i + batch_size] for i in range(0, len(objs), batch_size))\n updates = []\n for batch_objs in batches:\n update_kwargs = {}\n for field in fields:\n when_statements = []\n for obj in batch_objs:\n attr = getattr(obj, field.attname)\n if not hasattr(attr, \"resolve_expression\"):\n attr = Value(attr, output_field=field)\n when_statements.append(When(pk=obj.pk, then=attr))\n case_statement = Case(*when_statements, output_field=field)\n if requires_casting:\n case_statement = Cast(case_statement, output_field=field)\n update_kwargs[field.attname] = case_statement\n updates.append(([obj.pk for obj in batch_objs], update_kwargs))\n rows_updated = 0\n queryset = self.using(self.db)\n with transaction.atomic(using=self.db, savepoint=False):\n for pks, update_kwargs in updates:\n rows_updated += queryset.filter(pk__in=pks).update(**update_kwargs)\n return rows_updated","def set_many(self, update_dict):\n for key, value in update_dict.items():\n # We just call `set` directly here, because this is an in-memory representation\n # thus we don't concern ourselves with bulk writes.\n self.set(key, value)","def update(self, **kwargs):\n for key, value in kwargs.items():\n try:\n is_property = isinstance(getattr(self.__class__, key), property)\n except AttributeError:\n continue\n\n if is_property:\n setattr(self, key, value)","def set_many(self, update_dict):\n for key, value in update_dict.items():\n self.set(key, value)","def update(self, events, **kwargs):\n self.collisions.update(self._collidables, self._projectiles)\n for o in list(self._updateables):\n o.update(gm=self, events=events, **kwargs)","def update_properties(self, update_dict: Dict[str, Any]):\n self.event_properties.update(update_dict)","def update_fields(self, *fieldnames, objects=None, batch_size=None, send_signal=True,\n concurrent=False, max_concurrent_workers=None, return_queryset=False):\n if not fieldnames:\n fieldnames = [\n i.name for i in self.model._meta.fields\n ]\n\n if objects is not None:\n if not isinstance(objects, collections.Iterable):\n raise TypeError('objects must be iterable')\n\n self.populate_queryset_values(objects, *fieldnames)\n\n concurrent_write = self._get_concurrent(concurrent)\n\n if send_signal:\n pre_update_fields.send(\n self.model,\n instances = self,\n field_names = fieldnames,\n batch_size = batch_size\n )\n\n # TODO: ensure connected each time an update happens within the loop\n self.model.objects.ensure_connected()\n\n n = 0\n\n if concurrent_write:\n n_concurrent_writers = self._get_n_concurrent_workers(max_concurrent_workers)\n chunks = self.get_chunks(batch_size, n_concurrent_writers)\n\n jobs = [(BulkModelQuerySet._cased_update_chunk, self, chunk, fieldnames,) for chunk in chunks if chunk]\n executor = ConcurrentExecutor(jobs)\n results = executor.run_async()\n n = sum(results)\n\n else:\n chunks = self.get_chunks(batch_size)\n\n for chunk in chunks:\n if not chunk:\n # skip empty chunks (only happens in the case of an empty queryset)\n continue\n\n result = self._cased_update_chunk(chunk, fieldnames)\n n += result\n\n\n if return_queryset:\n _ids = []\n for obj in self:\n _id = getattr(obj, 'id') or getattr(obj, 'pk')\n if _id is not None:\n _ids.append(_id)\n\n qs = self.filter(id__in = _ids)\n else:\n qs = self.none()\n\n\n if send_signal:\n post_update_fields.send(\n self.model,\n instances = self,\n queryset = qs,\n field_names = fieldnames,\n batch_size = batch_size,\n n = n\n )\n\n if return_queryset:\n return qs\n\n return n","def update_values (self, property_list, dest_dict, overwrite_init=False ):\r\n for property in property_list:\r\n visible = True\r\n for attr in property[\"attrs\"]:\r\n if attr[\"type\"] == \"private\":\r\n if attr[\"value\"].lower() == 'true':\r\n visible = False\r\n\r\n if not visible:\r\n continue\r\n\r\n value = {} # Value dict, format: {value, dirty}\r\n value_list = [] # List for multiple values\r\n init_value_list = []\r\n init_value = {}\r\n # Add all the values (object with multiple getters) \r\n # to a list of values\r\n for getter in property['getters']:\r\n getter_name = getter['name']\r\n getter_value = self.execute_getter( getter_name, self.object )\r\n if str(getter_value).startswith('('):\r\n python_value = self.__get_python_format(\r\n property['params'], \r\n getter_value \r\n )\r\n else:\r\n python_value = [getter_value]\r\n\r\n value_list.append(python_value)\r\n if overwrite_init:\r\n init_value_list.append(python_value)\r\n\r\n value['value'] = value_list # Property value\r\n value['dirty'] = False # Must save or not\r\n value['inheritance'] = self.mode # Used for revert\r\n \r\n if overwrite_init:\r\n init_value['value'] = init_value_list\r\n init_value['dirty'] = False \r\n init_value['inheritance'] = self.mode\r\n \r\n dest_dict[property['name']] = value\r\n \r\n if overwrite_init:\r\n self.init_values[property['name']] = init_value","def entityUpdates(self, *args):\n\t\tfor entity in self.members.values():\n\t\t\tentity.update(*args)","def _batch_update(self, query, mutation):\n logger.info(\"Performing batch update on %s. Mutation: %s\", query, mutation)\n modified = 0\n for doc in self.instances.find(query):\n with lock_instance(doc['_id']):\n pre_update_doc = self.instances.find_one({'_id' : doc['_id']})\n result = self.instances.update_one({'_id': doc['_id']}, mutation)\n assert result.modified_count == 1\n modified += 1\n updated_doc = self.instances.find_one({'_id': doc['_id']})\n instance = FixtureInstance.deserialize_mongodoc(updated_doc)\n try:\n self.axdb_client.update_fixture_instance(instance.axdbdoc())\n except Exception:\n logger.exception(\"Failed to persist updates for %s. Undoing cache update\", instance)\n self.instances.replace_one({'_id' : instance.id}, pre_update_doc)\n raise\n logger.info(\"%s fixture instances modified\", modified)","def update(self, **kwargs):\n for name, item in itertools.chain(\n self._cal_objs.items(),\n self._noise_objs.items()):\n logger.debug(\"update {}\".format(item))\n item.update(**kwargs)","def update_targets(self, items):\n items = list(filter(None, chain(*items)))\n items = list(filter(None, items))\n\n if len(items) > 0:\n self.logger.info(\"Updating {} thermo documents\".format(len(items)))\n bulk = self.thermo().initialize_ordered_bulk_op()\n\n for m in items:\n m[self.thermo.lu_field] = datetime.utcnow()\n bulk.find({\"material_id\": m[\"material_id\"]}).upsert().replace_one(m)\n bulk.execute()\n else:\n self.logger.info(\"No items to update\")","def bulk_update(self, iterable):\n inserted, updated = [], []\n for d, h in iterable:\n if d in self:\n updated.append((d, h))\n else:\n inserted.append((d, h))\n self._update_bulk(updated)\n self._insert_bulk(inserted)","def updateall(self, params):\n for gauge in self.gauges:\n self.safexec(gauge.updateall, params)","def update(self, values):\n pass","def update(self, updates, predicate):\n for row in self.rows:\n if predicate(row):\n for column, new_value in updates.items():\n row[column] = new_value","def _update_all(self, criteria: Q, *args, **kwargs):\n raise NotImplementedError","def bulk_update_mappings(\n self, mapper: Mapper[Any], mappings: Iterable[Dict[str, Any]]\n ) -> None:\n self._bulk_save_mappings(\n mapper, mappings, True, False, False, False, False\n )","def updateProperties(self, properties={}):\n for name, data in properties.items():\n if name in self.uniforms.keys():\n self.uniforms[name].data = data\n elif name in self.settings.keys():\n self.settings[name] = data\n else:\n raise Exception(\"material has no property {name}\".format(name=name))","def _sync(self, vals_gen):\n indices = range(len(self._FIELDS))\n for db_values, sheet_cells in vals_gen:\n if self._update_in_sheet(db_values, sheet_cells, indices):\n self._modified = True\n return self._modified","def _object_update(self, obj, items):\n # many to many fields are saved after the main object\n m2ms = {}\n for key, value in items.iteritems():\n try:\n field = obj._meta.get_field(key)\n if isinstance(field, ManyToManyField):\n m2ms[key] = value\n else:\n setattr(obj, key, value)\n\n except FieldDoesNotExist:\n raise InvalidParameter(key)\n\n try:\n obj.full_clean()\n obj.save()\n except ValidationError as e:\n raise InvalidParameter(e.message_dict, override=True)\n\n for key, values in m2ms.iteritems():\n manager = getattr(obj, key)\n manager.clear()\n manager.add(*values)","def update(self, events):\n events = events","def update_many(\n self,\n *args: Union[dict, Mapping],\n session: Optional[ClientSession] = None\n ) -> UpdateMany:\n return self.update(*args, session=session)","def update_data(self, **kwargs):\n self.source_data = self.get_dict()\n for c in self.callbacks[\"update_data\"]:\n c()","def async_update(self, raw):\n changed_keys = set()\n\n for k, v in raw.items():\n changed_keys.add(k)\n\n if isinstance(self.raw.get(k), dict) and isinstance(v, dict):\n changed_keys.update(set(v.keys()))\n self.raw[k].update(v)\n\n else:\n self.raw[k] = v\n\n self.changed_keys = changed_keys\n\n for async_signal_update in self._async_callbacks:\n async_signal_update()","def update_events_in_database(self):\n for i in range(0, len(self._event_id_list), 1):\n e_id = self._event_id_list[i] # DB ID\n e_ind = self._event_index_list[i] # Index of the event\n e_db = Event.objects.get(id=e_id) # Event as stored in the DB\n e_db = e_db[0] # list to Event object\n e_new = self._event_list[i] # new Event object\n\n # Compare the old and the new event, detect which fields have\n # changed and update them in the old.\n change = e_db.compare(e_new)\n for (name, val) in change:\n setattr(e_db, name, val)\n\n # Save the updated old event, saving of only the fields which\n # have changed\n e_db.save(update_fields=[name for (name, val) in change])\n\n # Mark the event status as not requiring an update anymore\n self.gdc.write_update_status_nth_event(e_ind, False)","def update(self, **kwargs):\n for key, val in kwargs.items():\n setattr(self, key, val)","def salesforce_collection_update(self, objects):\n for obj in objects:\n assert obj[\n \"id\"\n ], \"Should be a list of objects with Ids returned by Salesforce Collection Insert\"\n if STATUS_KEY in obj:\n del obj[STATUS_KEY]\n\n assert len(objects) <= SF_COLLECTION_INSERTION_LIMIT, (\n \"Cannot update more than %s objects with this keyword\"\n % SF_COLLECTION_INSERTION_LIMIT\n )\n\n records = self.cumulusci.sf.restful(\n \"composite/sobjects\",\n method=\"PATCH\",\n json={\"allOrNone\": True, \"records\": objects},\n )\n\n for record, obj in zip(records, objects):\n obj[STATUS_KEY] = record","def update_many(objects, fields=[], using=\"default\"):\n if not objects:\n return\n\n import django.db.models\n from django.db import connections\n con = connections[using]\n\n names = fields\n meta = objects[0]._meta\n fields = [f for f in meta.fields if not isinstance(f, django.db.models.AutoField) and (not names or f.name in names)]\n\n if not fields:\n raise ValueError(\"No fields to update, field names are %s.\" % names)\n\n fields_with_pk = fields + [meta.pk]\n parameters = []\n for o in objects:\n parameters.append(tuple(f.get_db_prep_save(f.pre_save(o, True), connection=con) for f in fields_with_pk))\n\n table = meta.db_table\n assignments = \",\".join((\"%s=%%s\"% con.ops.quote_name(f.column)) for f in fields)\n con.cursor().executemany(\n \"update %s set %s where %s=%%s\" % (table, assignments, meta.pk.column),\n parameters)","def partial_update_objects(self, objects):\n requests = []\n for obj in objects:\n requests.append({\"action\": \"partialUpdateObject\", \"objectID\": obj[\"objectID\"], \"body\": obj})\n request = {\"requests\": requests}\n return self.batch(request)","def bulk_update(self, iterable):\n inserted, updated = [], []\n for d, h in iterable:\n if -d in self:\n updated.append((-d, h))\n else:\n inserted.append((-d, h))\n self._update_bulk(updated)\n self._insert_bulk(inserted)","def _update(self, data: Dict[str, Any], fields_to_modify: List[str]):\n pass","def update_all_dict_bywhereclause(cls, updatedict, whereclause):\n return cls.dbm().modelclass_update_all_dict_bywhereclause(cls, updatedict, whereclause)","def update(self, dt):\n for obj in self.objects:\n obj.update(dt)","def manual_update(self):\n for cb, status in zip(self._manual_cbs, self.status_objs):\n cb(status)","def _update(self, datapoints):\r\n if len(datapoints) == 1:\r\n timestamp, value = datapoints[0]\r\n whisper.update(self.path, value, timestamp)\r\n else:\r\n whisper.update_many(self.path, datapoints)","def update_product_values(request, property_group_id):\n property_group = lfs_get_object_or_404(PropertyGroup, pk=property_group_id)\n product_ids = request.POST.getlist(\"product-id\")\n products = Product.objects.filter(pk__in=product_ids)\n \n for product in products:\n for property in property_group.properties.all(): \n value = request.POST.get(\"property-%s-%s\" % (product.id, property.id), \"\")\n if value != \"\":\n try:\n ppv = ProductPropertyValue.objects.get(property = property, product=product)\n except ProductPropertyValue.DoesNotExist:\n ProductPropertyValue.objects.create(property = property, product=product, value=value)\n else: \n ppv.value = value\n ppv.save()\n\n result = simplejson.dumps({\n \"html\" : product_values(request, property_group_id),\n \"message\" : _(u\"Product Values have been saved.\")\n }, cls=LazyEncoder);\n \n return HttpResponse(result)","def update(self, raw, **kwargs):\n changed_keys = set()\n\n for k, v in raw.items():\n changed_keys.add(k)\n\n if isinstance(self.raw.get(k), dict) and isinstance(v, dict):\n changed_keys.update(set(v.keys()))\n self._raw[k].update(v)\n\n else:\n self._raw[k] = v\n\n self._changed_keys = changed_keys\n\n for async_signal_update in self._callbacks:\n async_signal_update(**kwargs)","def _update_all_fields(self, name, value):\n for field in self._field_map.values():\n setattr(field, name, value)","async def _update_values(self, model: Model):\n\n raise NotImplementedError","def test_otoroshi_controllers_adminapi_tcp_service_api_controller_bulk_update_action(self):\n pass","def set_updates(self, updates: dict, dry=False):\n self._updates += (UpdateQueryExpression(updates),)\n return self","def _update_all(self, criteria: Q, *args, **kwargs):\n conn = self._get_session()\n qs = conn.query(self.model_cls).filter(self._build_filters(criteria))\n try:\n values = {}\n if args:\n values = args[\n 0\n ] # `args[0]` is required because `*args` is sent as a tuple\n values.update(kwargs)\n updated_count = qs.update(values)\n except DatabaseError as exc:\n logger.error(f\"Error while updating all: {exc}\")\n raise\n finally:\n if not current_uow:\n conn.commit()\n conn.close()\n\n return updated_count","def update_all(collection: Collection, data_to_update):\n return collection.update_many({}, {'$set': data_to_update}).matched_count","def updateMultipleDocuments(cred, payload):\n\n url = cred.base_url + \"documents:commit\"\n data = { 'writes': [] }\n\n for path, fieldData in payload.iteritems():\n pathData = createFirestoreDataObject(cred, path, fieldData)\n data['writes'].append(pathData)\n \n makeRequest(cred, url, 'POST', data)","def view_update(self, context):\n\n for collection in self._watch_list:\n collection_name = get_collection_name(collection)\n collection_set = set(collection)\n tracking_set = self._tracking_sets[collection_name]\n\n # Check for new items\n add_set = collection_set - tracking_set\n self.add_delta[collection_name] = add_set\n tracking_set |= add_set\n\n # Check for removed items\n remove_set = tracking_set - collection_set\n self.remove_delta[collection_name] = remove_set\n tracking_set -= remove_set\n\n # Check for updates\n update_set = {item for item in collection if item.is_updated}\n self.update_delta[collection_name] = update_set","def update(self, values):\n for k, v in values.items():\n setattr(self, k, v)","def _process(self, start_key, batch_size):\n\n query = self.MODEL.all()\n if start_key:\n query.filter('__key__ > ', start_key)\n\n try:\n entities = query.fetch(batch_size)\n\n if not entities:\n # all entities has already been processed\n return\n\n for entity in entities:\n for field in self.FIELDS_TO_UPDATE:\n old_reference = getattr(entity, field)\n\n if not old_reference:\n continue\n\n # check if the field has not been updated\n if isinstance(old_reference, self.PROFILE_MODEL):\n continue\n\n profile = _getProfileForRole(old_reference, self.PROFILE_MODEL)\n setattr(entity, field, profile)\n\n for list_property in self.LISTS_TO_UPDATE:\n l = getattr(entity, list_property)\n new_l = []\n for key in l:\n new_l.append(_getProfileKeyForRoleKey(key, self.PROFILE_MODEL))\n setattr(entity, list_property, new_l)\n\n db.put(entities)\n start_key = entities[-1].key()\n deferred.defer(self._process, start_key, batch_size)\n except DeadlineExceededError:\n # here we should probably be more careful\n deferred.defer(self._process, start_key, batch_size)","def update(extended):\n def update_properties(main_property_file, other_property_files):\n main_lines = read_file(filename=main_property_file)\n # saved the stripped lines\n write_file(main_property_file, main_lines)\n main_keys = get_keys_from_lines(lines=main_lines)\n\n main_duplicates = get_duplicates(lines=main_lines)\n num_main_duplicates = len(main_duplicates)\n if num_main_duplicates != 0:\n logger.error(\"There are {num_duplicates} duplicates in {file}, please fix them manually\".format(num_duplicates=num_main_duplicates, file=get_filename(filepath=main_property_file)))\n if extended:\n logger.neutral(u\"\\t{}\".format(\", \".join(main_duplicates)))\n return\n\n\n for other_property_file in other_property_files:\n filename = get_filename(filepath=other_property_file)\n lines = read_file(filename=other_property_file)\n keys, not_fixed, fixed = fix_duplicates(lines=lines)\n\n num_keys = len(keys)\n num_not_fixed = len(not_fixed)\n num_fixed = len(fixed)\n\n if num_not_fixed != 0:\n logger.error(\"There are {num_not_fixed_duplicates} ambiguous duplicates in {file}, please fix them manually\".format(num_not_fixed_duplicates=num_not_fixed, file=filename))\n if extended:\n logger.error(u\"\\t{}\".format(u\", \".join(not_fixed)))\n continue\n\n keys_missing = get_missing_keys(main_keys, keys)\n keys_obsolete = get_missing_keys(keys, main_keys)\n\n num_keys_missing = len(keys_missing)\n num_keys_obsolete = len(keys_obsolete)\n\n for missing_key in keys_missing:\n keys[missing_key] = \"\"\n\n for obsolete_key in keys_obsolete:\n del keys[obsolete_key]\n\n other_lines_to_write = []\n for line in main_lines:\n key = get_key_from_line(line)\n if key is not None:\n other_lines_to_write.append(u\"{key}={value}\\r\\n\".format(key=key, value=keys[key]))\n else:\n other_lines_to_write.append(line)\n\n sorted = len(lines) != len(other_lines_to_write)\n if not sorted:\n for old_line, new_lines in zip(lines, other_lines_to_write):\n if old_line != new_lines:\n sorted = True\n\n write_file(filename=other_property_file, content=other_lines_to_write)\n\n logger.ok(\"Processing file '{file}' with {num_keys} Keys\".format(file=filename, num_keys=num_keys))\n if num_fixed != 0:\n logger.ok(\"\\tfixed {} unambiguous duplicates\".format(num_fixed))\n if extended:\n logger.neutral(u\"\\t\\t{}\".format(\", \".join(fixed)))\n\n if num_keys_missing != 0:\n logger.ok(\"\\tadded {} missing keys\".format(num_keys_missing))\n if extended:\n logger.neutral(u\"\\t\\t{}\".format(\", \".join(keys_missing)))\n\n if num_keys_obsolete != 0:\n logger.ok(\"\\tdeleted {} obsolete keys\".format(num_keys_obsolete))\n if extended:\n logger.neutral(u\"\\t\\t{}\".format(\", \".join(keys_obsolete)))\n\n if sorted:\n logger.ok(\"\\thas been sorted successfully\")\n\n update_properties(main_property_file=get_main_jabref_preferences(), other_property_files=get_other_jabref_properties())\n update_properties(main_property_file=get_main_menu_properties(), other_property_files=get_other_menu_properties())","def update(self, values):\n return self.manager.update(self, values)","def apply_updates(self, updates):\n raise NotImplementedError()","def update(self, timeElapsed):\n\n for i in range(len(self._lUpdatables)):\n\n #This calls the Updatable component's update() method.\n self._lUpdatables[i].update(timeElapsed)","def update(self, params):\n for gauge in self.gauges:\n self.safexec(gauge.update, params)","def test_update_multiple(test_store, andy, pandy, candy):\n n_updated = test_store.update(fields={\"age\": 14}, age=12)\n assert n_updated == 2\n items = list(test_store.get_by())\n\n andy.age = pandy.age = 14\n assert andy in items\n assert pandy in items\n assert candy in items","def update(self, values: List[int]) -> None:\n ...","def update(self, values: List[int]) -> None:\n ...","def update_many(\n cls,\n *,\n pks: List[Union[str, int]],\n update: Dict[str, Any],\n sychronize_session: bool = False,\n ) -> None:\n if pks:\n db.session.query(cls).filter(\n getattr(cls, cls.get_primary_key()).in_(pks)\n ).update(update, synchronize_session=sychronize_session)\n db.session.commit()\n cache.delete_many(*(cls.create_cache_key(pk) for pk in pks))","def update(self, *args, **kwargs):\n if kwargs is not None:\n for key, value in kwargs.items():\n setattr(self, key, value)","def update_view(self):\n for row in self.view.obj_list:\n for obj in row:\n obj._update(self.model)","def updateAll(self):\n \tself.idToUpdate=''\n \tself.newState=''\n \tself.save()","def update(self, values):\r\n for k, v in six.iteritems(values):\r\n setattr(self, k, v)","def handle_update(self, json_snippet, tmpl_diff, prop_diff):\n subscription = self._get_subscription()\n subscription.update(prop_diff)","def update(self, values):\n for k, v in six.iteritems(values):\n setattr(self, k, v)","def update_all(self, request):\n\n schema = self.session.info['schema']\n\n for item in self.query().filter_by(schema=schema):\n self.session.delete(item)\n\n for item in ElectionCollection(self.session).query():\n self.update(item, request)\n\n for item in ElectionCompoundCollection(self.session).query():\n self.update(item, request)\n\n for item in VoteCollection(self.session).query():\n self.update(item, request)","def _update_all_tasks(self) -> None:\n for task in self.tasks:\n task.update()","def update_values(self, to_update):\n for key, value in kwargs.iteritems():\n self.params[key] = value\n # update the possibly dependent parameters\n self.set_filenames()","def _update_event(klass, event, *data_dicts):\n # Create d\n d = {}\n for data_dict in data_dicts:\n d.update(data_dict)\n d = klass._remove_none_fields(d)\n d = dict((\"set__\" + k, v) for k, v in d.iteritems())\n\n # Update and save.\n event.update(**d)\n event.save()","def update_many(collection: Collection, query, data_to_update):\n return collection.update_many(query, {'$set': data_to_update}).matched_count","def bulk_update(self, request):\n serializer = MasterySerializer(\n data=request.data,\n many=True,\n )\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data)\n else:\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)","def update(self):\n if self._skip_update:\n self._skip_update = False\n return\n\n try:\n for prop in AIRER_PROPS:\n self.status[prop] = self.send('get_prop', [prop])[0]\n _LOGGER.debug(\"MiioDevice update: %s\", self.status)\n self.available = True\n self._retry = 0\n except Exception as exc:\n _LOGGER.error(\"Error on update: %s\", exc)\n self._retry += 1\n if self._retry > 3:\n self.available = False\n\n for entity in self.update_entities:\n entity.async_schedule_update_ha_state()","def update(cls, values):\n result = yield UpdateQuery(cls, values).execute()\n returnValue(result)","def update(self, **values):\r\n if self.__abstract__:\r\n raise ThunderdomeException('cant update abstract elements')\r\n self.pre_update(**values)\r\n for key in values.keys():\r\n if key not in self._columns:\r\n raise TypeError(\"unrecognized attribute name: '{}'\".format(key))\r\n\r\n for k,v in values.items():\r\n setattr(self, k, v)\r\n\r\n return self.save()","def test_update_values(self):\n partition = uuid4()\n for i in range(5):\n TestQueryUpdateModel.create(partition=partition, cluster=i, count=i, text=str(i))\n\n # sanity check\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\n self.assertEqual(row.cluster, i)\n self.assertEqual(row.count, i)\n self.assertEqual(row.text, str(i))\n\n # perform update\n TestQueryUpdateModel.objects(partition=partition, cluster=3).update(count=6)\n\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\n self.assertEqual(row.cluster, i)\n self.assertEqual(row.count, 6 if i == 3 else i)\n self.assertEqual(row.text, str(i))","def update_settings(self, settings_list):\n for i, x in enumerate(settings_list):\n self.update_settings_at_index(settings=x, index=i)","def _handle_single_update(self, controller):\n result = controller.list_all_items()\n # TODO(jkinkead): Validate `result`? It's unclear if ALL errors will result in an HTTPError,\n # or if some will result in a response field indicating an error.\n logger.debug('Got %s results from %s lookup.', len(result.items), controller.name)\n for item in result.items:\n self._handle_single_item(controller, item)","def update_state(self, **kwargs):\n\n for name in self.metrics:\n\n metric = self.metrics[name]\n\n argspec = inspect.getfullargspec(metric.update_state)\n\n kwargs_to_pass = {k: kwargs[k] for k in kwargs if k in argspec.args}\n\n metric.update_state(**kwargs_to_pass)","def update_lineprops(imageprop):\n db = 'sage'\n j = call_responder('sage', 'cvterms?cv_term=' + imageprop)\n if len(j['cvterm_data']) < 1:\n logger.critical(\"Could not find line property %s\", imageprop)\n sys.exit(-1)\n cursor = READ['unsynced'] % (imageprop, imageprop)\n print(\"Syncing image properties for %s (%s) on %s\" %\n (imageprop, j['cvterm_data'][0]['display_name'], db))\n try:\n CURSOR[db].execute(cursor)\n rows = CURSOR[db].fetchall()\n except MySQLdb.Error as err:\n sql_error(err)\n for row in rows:\n image_id = row[0]\n value = row[1]\n logger.debug(\"Missing %s (%s) for image %s\", imageprop,\n value, image_id)\n cursor2 = WRITE['update'] % (imageprop, value, image_id)\n logger.debug(cursor2)\n try:\n CURSOR[db].execute(cursor2)\n except MySQLdb.Error as err:\n logger.error(\"Could not update row in image_data_mv\")\n sql_error(err)\n COUNT['update'] += 1\n if ARG.TRIGGER:\n logger.debug(WRITE['refresh'] % (image_id))\n try:\n CURSOR[db].execute(WRITE['refresh'] % (image_id))\n except MySQLdb.Error as err:\n logger.error(\"Could not update rows in image_property\")\n sql_error(err)\n COUNT['triggered'] += CURSOR[db].rowcount\n cursor = READ['deleted'] % (imageprop, imageprop, imageprop)\n try:\n CURSOR[db].execute(cursor)\n rows = CURSOR[db].fetchall()\n except MySQLdb.Error as err:\n sql_error(err)\n for row in rows:\n logger.warning(\"Image ID %s has a %s (%s) in image_data_mv, but not in image_property\", row[0], imageprop, row[1])\n if ARG.WRITE:\n CONN[db].commit()\n print(\"Unsynced records: %d\" % (len(rows)))\n print(\"Updated records: %d\" % (COUNT['update']))\n print(\"Triggered updates: %d\" % (COUNT['triggered']))","def update(self, *args, **kwargs):\n sqrlist = [\"id\", \"size\", \"x\", \"y\"]\n if args and len(args) != 0:\n for i in range(len(sqrlist)):\n if i < len(args):\n # call to setter method\n setattr(self, sqrlist[i], args[i])\n else:\n if kwargs and len(kwargs) != 0:\n for k in sqrlist:\n for key, value in kwargs.items():\n if k == key:\n setattr(self, key, value)","def updateProperties(self):\n self.manage_changeProperties(title = self.getTitle(),\n description = self.getDescription(),\n basepath = self.getPath())","def _update(self, data: Dict[str, Any], fields_to_modify: List[str]):\n\n to_set = [\n \"{0} = %({0})s\".format(f) for f in fields_to_modify\n if f in self.editable_fields\n ]\n if len(to_set) == 0:\n print('Warning: No data to set', data)\n return\n\n query = \"UPDATE {} SET {} WHERE {}\".format(\n self._NAME,\n ', '.join(to_set),\n ' AND '.join(\"{0} = %({0})s\".format(f) for f in self.primary_fields),\n )\n self._execute(query, data)","def _refresh(self):\r\n self._tracer.info(\"Refresh called 1\")\r\n for obj in self._filter_objects:\r\n # Only call function if it exists, and is callable.\r\n if hasattr(obj, 'property_refresh') and \\\r\n callable(getattr(obj, 'property_refresh')):\r\n obj.property_refresh()","def onPropertiesChange(self, data):\n pass","def set_properties(self, props=None):\n props = [] if props is None else props\n prop = dav.Prop() + props\n set = dav.Set() + prop\n root = dav.PropertyUpdate() + set\n\n r = self._query(root, query_method=\"proppatch\")\n\n statuses = r.tree.findall(\".//\" + dav.Status.tag)\n for s in statuses:\n if \" 200 \" not in s.text:\n raise error.PropsetError(s.text)\n\n return self","def update_all_behaviors(self):\n for behavior in self.active_behaviors:\n behavior.update()","def updatedata(self, force_update=False):\n\n self._update_counter = self._update_counter + 1\n logging.debug('ParameterViewer: update values')\n for instrument_name in self._instrumentnames:\n instr = self._instruments[self._instrumentnames.index(instrument_name)]\n parameters = {}\n\n try:\n parameters = instr.parameters\n except AttributeError as ex:\n # instrument was removed\n print('instrument was removed, stopping ParameterViewer')\n # logging.exception(ex)\n self._timer.stop()\n\n parameter_names = sorted(parameters.keys())\n\n si = sys.getswitchinterval()\n\n for parameter_name in parameter_names:\n # hack to make this semi thread-safe\n\n for field_name in self._fields:\n if field_name == 'Value':\n sys.setswitchinterval(100)\n value = parameters[parameter_name].get_latest()\n sys.setswitchinterval(si)\n self.update_field_signal.emit(instrument_name, parameter_name, field_name, value, force_update)\n else:\n if self._update_counter % 20 == 1 or 1:\n sys.setswitchinterval(100)\n value = getattr(parameters[parameter_name], field_name, '')\n sys.setswitchinterval(si)\n self.update_field_signal.emit(instrument_name, parameter_name,\n field_name, value, force_update)\n\n for callback_function in self.callbacklist:\n try:\n callback_function()\n except Exception as ex:\n logging.debug('update function failed')\n logging.exception(str(ex))","def update_all():\n req_data = request.get_json()\n jobs = JobModel.get_one_job(job_id)\n if not jobs:\n return custom_response({'Error': 'Job Not Found'}, 404)\n\n data, error = job_schema.load(req_data, partial=True)\n if error:\n return custom_response(error, 400)\n\n for job in jobs:\n job.update(data)\n job_message = job_schema.dump(job)\n\n return custom_response(job_message, 200)","def apply_data(self, objs, old_data, new_data):\n if len(old_data) != len(new_data):\n self._log.warning('number of objects changed from {} to {}',\n len(old_data), len(new_data))\n\n obj_by_id = {o.id: o for o in objs}\n ignore_fields = self.config['ignore_fields'].as_str_seq()\n for old_dict, new_dict in zip(old_data, new_data):\n # Prohibit any changes to forbidden fields to avoid\n # clobbering `id` and such by mistake.\n forbidden = False\n for key in ignore_fields:\n if old_dict.get(key) != new_dict.get(key):\n self._log.warning('ignoring object whose {} changed', key)\n forbidden = True\n break\n if forbidden:\n continue\n\n id_ = int(old_dict['id'])\n apply_(obj_by_id[id_], new_dict)","def UpdateValues(self, grid):\n # This sends an event to the grid table to update all of the values\n msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES)\n grid.ProcessTableMessage(msg)","async def async_update_all(self):\n await self.async_update_transport_state()\n if self._state != STATE_OFF:\n await self.async_update_volume_level()\n await self.async_update_mute()\n await self.async_update_track_info()\n await self.async_update_play_mode()","def test_update_values(self):\r\n partition = uuid4()\r\n for i in range(5):\r\n TestQueryUpdateModel.create(partition=partition, cluster=i, count=i, text=str(i))\r\n\r\n # sanity check\r\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\r\n assert row.cluster == i\r\n assert row.count == i\r\n assert row.text == str(i)\r\n\r\n # perform update\r\n TestQueryUpdateModel.objects(partition=partition, cluster=3).update(count=6)\r\n\r\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\r\n assert row.cluster == i\r\n assert row.count == (6 if i == 3 else i)\r\n assert row.text == str(i)","def update_all_step_settings(self, settings):\n for i, x in enumerate(self):\n self.update_settings_at_index(settings, index=i)","def update_many(self, base_tree_path, values, level=NONTRANSACTIONAL):\n\t\tassert transactional == NONTRANSACTIONAL, 'Transactional updates are not supported'\n\n\t\t# The default implementation, if the chosen backend does not provide a more efficient one\n\t\tbase_tree_path = list(base_tree_path)\n\t\tret_values = []\n\t\tfor tree_path, value in values:\n\t\t\tret_values.append(\n\t\t\t\tself.update(base_tree_path + list(tree_path), value)\n\t\t\t)\n\n\t\treturn ret_values","def _update_all_eval_input_configs(configs, field, value):\n for eval_input_config in configs[\"eval_input_configs\"]:\n setattr(eval_input_config, field, value)","def update_parameters(updates):\r\n for (key, val) in updates.items():\r\n par[key] = val\r\n print('Updating:', key, '-->', val)\r\n update_dependencies()","def set_properties(self):\n for key in self.prop_source.params_data:\n property_grid = self.interpolate(\n self.grid.xmin,\n self.grid.ymin,\n self.grid.dx,\n self.grid.dy,\n self.grid.nx,\n self.grid.ny,\n self.prop_source.params_data[key]['x'],\n self.prop_source.params_data[key]['y'],\n self.prop_source.params_data[key]['z']\n )\n\n self.properties[key] = self.normalize(\n property_grid,\n self.prop_source.params[key]['min'],\n self.prop_source.params[key]['max'],\n self.grid.ibound_mask\n )","def test_update_many(self):\n sample_input = \"\"\"\nfoo=100\nbar=200, baz=300\n\"\"\"\n self.assertNotEquals(self.param_dict.get(\"foo\"), 100)\n self.assertNotEquals(self.param_dict.get(\"bar\"), 200)\n self.assertNotEquals(self.param_dict.get(\"baz\"), 300)\n result = self.param_dict.update_many(sample_input)\n log.debug(\"result: %s\", result)\n self.assertEquals(result[\"foo\"], True)\n self.assertEquals(result[\"bar\"], True)\n self.assertEquals(result[\"baz\"], True)\n self.assertEquals(self.param_dict.get(\"foo\"), 100)\n self.assertEquals(self.param_dict.get(\"bar\"), 200)\n self.assertEquals(self.param_dict.get(\"baz\"), 300)"],"string":"[\n \"def update_multiple_objects_properties(self, object_list):\\n\\n #if self.settings.LOG_VERBOSE and self.settings.ENABLE_OBJECT_LOGGING: logger.debug(\\\"Processing multiple object properties updates: %s\\\" % (len(object_list)))\\n\\n for object_properties in object_list:\\n\\n self.update_object_properties(object_properties)\",\n \"def update_properties(self, prop_dict):\\n ft_dict = {ft.name: ft for ft in self.get_field_types()}\\n for name, val in prop_dict.items():\\n ft = ft_dict[name]\\n if ft.is_parameter():\\n key = \\\"value\\\"\\n else:\\n key = \\\"sample\\\"\\n if issubclass(type(val), Sequence) and ft.array:\\n self.set_field_value_array(name, None, [{key: v} for v in val])\\n else:\\n self.set_field_value(name, None, {key: val})\",\n \"def _update_bulk(self, iterable):\\n self.cursor.executemany(self.UPDATE, iterable)\",\n \"def update_batch(self, *args, **kwargs):\\n pass\",\n \"def bulk_update(self, objs, fields, batch_size=None):\\n if batch_size is not None and batch_size <= 0:\\n raise ValueError(\\\"Batch size must be a positive integer.\\\")\\n if not fields:\\n raise ValueError(\\\"Field names must be given to bulk_update().\\\")\\n objs = tuple(objs)\\n if any(obj.pk is None for obj in objs):\\n raise ValueError(\\\"All bulk_update() objects must have a primary key set.\\\")\\n fields = [self.model._meta.get_field(name) for name in fields]\\n if any(not f.concrete or f.many_to_many for f in fields):\\n raise ValueError(\\\"bulk_update() can only be used with concrete fields.\\\")\\n if any(f.primary_key for f in fields):\\n raise ValueError(\\\"bulk_update() cannot be used with primary key fields.\\\")\\n if not objs:\\n return 0\\n for obj in objs:\\n obj._prepare_related_fields_for_save(\\n operation_name=\\\"bulk_update\\\", fields=fields\\n )\\n # PK is used twice in the resulting update query, once in the filter\\n # and once in the WHEN. Each field will also have one CAST.\\n self._for_write = True\\n connection = connections[self.db]\\n max_batch_size = connection.ops.bulk_batch_size([\\\"pk\\\", \\\"pk\\\"] + fields, objs)\\n batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size\\n requires_casting = connection.features.requires_casted_case_in_updates\\n batches = (objs[i : i + batch_size] for i in range(0, len(objs), batch_size))\\n updates = []\\n for batch_objs in batches:\\n update_kwargs = {}\\n for field in fields:\\n when_statements = []\\n for obj in batch_objs:\\n attr = getattr(obj, field.attname)\\n if not hasattr(attr, \\\"resolve_expression\\\"):\\n attr = Value(attr, output_field=field)\\n when_statements.append(When(pk=obj.pk, then=attr))\\n case_statement = Case(*when_statements, output_field=field)\\n if requires_casting:\\n case_statement = Cast(case_statement, output_field=field)\\n update_kwargs[field.attname] = case_statement\\n updates.append(([obj.pk for obj in batch_objs], update_kwargs))\\n rows_updated = 0\\n queryset = self.using(self.db)\\n with transaction.atomic(using=self.db, savepoint=False):\\n for pks, update_kwargs in updates:\\n rows_updated += queryset.filter(pk__in=pks).update(**update_kwargs)\\n return rows_updated\",\n \"def set_many(self, update_dict):\\n for key, value in update_dict.items():\\n # We just call `set` directly here, because this is an in-memory representation\\n # thus we don't concern ourselves with bulk writes.\\n self.set(key, value)\",\n \"def update(self, **kwargs):\\n for key, value in kwargs.items():\\n try:\\n is_property = isinstance(getattr(self.__class__, key), property)\\n except AttributeError:\\n continue\\n\\n if is_property:\\n setattr(self, key, value)\",\n \"def set_many(self, update_dict):\\n for key, value in update_dict.items():\\n self.set(key, value)\",\n \"def update(self, events, **kwargs):\\n self.collisions.update(self._collidables, self._projectiles)\\n for o in list(self._updateables):\\n o.update(gm=self, events=events, **kwargs)\",\n \"def update_properties(self, update_dict: Dict[str, Any]):\\n self.event_properties.update(update_dict)\",\n \"def update_fields(self, *fieldnames, objects=None, batch_size=None, send_signal=True,\\n concurrent=False, max_concurrent_workers=None, return_queryset=False):\\n if not fieldnames:\\n fieldnames = [\\n i.name for i in self.model._meta.fields\\n ]\\n\\n if objects is not None:\\n if not isinstance(objects, collections.Iterable):\\n raise TypeError('objects must be iterable')\\n\\n self.populate_queryset_values(objects, *fieldnames)\\n\\n concurrent_write = self._get_concurrent(concurrent)\\n\\n if send_signal:\\n pre_update_fields.send(\\n self.model,\\n instances = self,\\n field_names = fieldnames,\\n batch_size = batch_size\\n )\\n\\n # TODO: ensure connected each time an update happens within the loop\\n self.model.objects.ensure_connected()\\n\\n n = 0\\n\\n if concurrent_write:\\n n_concurrent_writers = self._get_n_concurrent_workers(max_concurrent_workers)\\n chunks = self.get_chunks(batch_size, n_concurrent_writers)\\n\\n jobs = [(BulkModelQuerySet._cased_update_chunk, self, chunk, fieldnames,) for chunk in chunks if chunk]\\n executor = ConcurrentExecutor(jobs)\\n results = executor.run_async()\\n n = sum(results)\\n\\n else:\\n chunks = self.get_chunks(batch_size)\\n\\n for chunk in chunks:\\n if not chunk:\\n # skip empty chunks (only happens in the case of an empty queryset)\\n continue\\n\\n result = self._cased_update_chunk(chunk, fieldnames)\\n n += result\\n\\n\\n if return_queryset:\\n _ids = []\\n for obj in self:\\n _id = getattr(obj, 'id') or getattr(obj, 'pk')\\n if _id is not None:\\n _ids.append(_id)\\n\\n qs = self.filter(id__in = _ids)\\n else:\\n qs = self.none()\\n\\n\\n if send_signal:\\n post_update_fields.send(\\n self.model,\\n instances = self,\\n queryset = qs,\\n field_names = fieldnames,\\n batch_size = batch_size,\\n n = n\\n )\\n\\n if return_queryset:\\n return qs\\n\\n return n\",\n \"def update_values (self, property_list, dest_dict, overwrite_init=False ):\\r\\n for property in property_list:\\r\\n visible = True\\r\\n for attr in property[\\\"attrs\\\"]:\\r\\n if attr[\\\"type\\\"] == \\\"private\\\":\\r\\n if attr[\\\"value\\\"].lower() == 'true':\\r\\n visible = False\\r\\n\\r\\n if not visible:\\r\\n continue\\r\\n\\r\\n value = {} # Value dict, format: {value, dirty}\\r\\n value_list = [] # List for multiple values\\r\\n init_value_list = []\\r\\n init_value = {}\\r\\n # Add all the values (object with multiple getters) \\r\\n # to a list of values\\r\\n for getter in property['getters']:\\r\\n getter_name = getter['name']\\r\\n getter_value = self.execute_getter( getter_name, self.object )\\r\\n if str(getter_value).startswith('('):\\r\\n python_value = self.__get_python_format(\\r\\n property['params'], \\r\\n getter_value \\r\\n )\\r\\n else:\\r\\n python_value = [getter_value]\\r\\n\\r\\n value_list.append(python_value)\\r\\n if overwrite_init:\\r\\n init_value_list.append(python_value)\\r\\n\\r\\n value['value'] = value_list # Property value\\r\\n value['dirty'] = False # Must save or not\\r\\n value['inheritance'] = self.mode # Used for revert\\r\\n \\r\\n if overwrite_init:\\r\\n init_value['value'] = init_value_list\\r\\n init_value['dirty'] = False \\r\\n init_value['inheritance'] = self.mode\\r\\n \\r\\n dest_dict[property['name']] = value\\r\\n \\r\\n if overwrite_init:\\r\\n self.init_values[property['name']] = init_value\",\n \"def entityUpdates(self, *args):\\n\\t\\tfor entity in self.members.values():\\n\\t\\t\\tentity.update(*args)\",\n \"def _batch_update(self, query, mutation):\\n logger.info(\\\"Performing batch update on %s. Mutation: %s\\\", query, mutation)\\n modified = 0\\n for doc in self.instances.find(query):\\n with lock_instance(doc['_id']):\\n pre_update_doc = self.instances.find_one({'_id' : doc['_id']})\\n result = self.instances.update_one({'_id': doc['_id']}, mutation)\\n assert result.modified_count == 1\\n modified += 1\\n updated_doc = self.instances.find_one({'_id': doc['_id']})\\n instance = FixtureInstance.deserialize_mongodoc(updated_doc)\\n try:\\n self.axdb_client.update_fixture_instance(instance.axdbdoc())\\n except Exception:\\n logger.exception(\\\"Failed to persist updates for %s. Undoing cache update\\\", instance)\\n self.instances.replace_one({'_id' : instance.id}, pre_update_doc)\\n raise\\n logger.info(\\\"%s fixture instances modified\\\", modified)\",\n \"def update(self, **kwargs):\\n for name, item in itertools.chain(\\n self._cal_objs.items(),\\n self._noise_objs.items()):\\n logger.debug(\\\"update {}\\\".format(item))\\n item.update(**kwargs)\",\n \"def update_targets(self, items):\\n items = list(filter(None, chain(*items)))\\n items = list(filter(None, items))\\n\\n if len(items) > 0:\\n self.logger.info(\\\"Updating {} thermo documents\\\".format(len(items)))\\n bulk = self.thermo().initialize_ordered_bulk_op()\\n\\n for m in items:\\n m[self.thermo.lu_field] = datetime.utcnow()\\n bulk.find({\\\"material_id\\\": m[\\\"material_id\\\"]}).upsert().replace_one(m)\\n bulk.execute()\\n else:\\n self.logger.info(\\\"No items to update\\\")\",\n \"def bulk_update(self, iterable):\\n inserted, updated = [], []\\n for d, h in iterable:\\n if d in self:\\n updated.append((d, h))\\n else:\\n inserted.append((d, h))\\n self._update_bulk(updated)\\n self._insert_bulk(inserted)\",\n \"def updateall(self, params):\\n for gauge in self.gauges:\\n self.safexec(gauge.updateall, params)\",\n \"def update(self, values):\\n pass\",\n \"def update(self, updates, predicate):\\n for row in self.rows:\\n if predicate(row):\\n for column, new_value in updates.items():\\n row[column] = new_value\",\n \"def _update_all(self, criteria: Q, *args, **kwargs):\\n raise NotImplementedError\",\n \"def bulk_update_mappings(\\n self, mapper: Mapper[Any], mappings: Iterable[Dict[str, Any]]\\n ) -> None:\\n self._bulk_save_mappings(\\n mapper, mappings, True, False, False, False, False\\n )\",\n \"def updateProperties(self, properties={}):\\n for name, data in properties.items():\\n if name in self.uniforms.keys():\\n self.uniforms[name].data = data\\n elif name in self.settings.keys():\\n self.settings[name] = data\\n else:\\n raise Exception(\\\"material has no property {name}\\\".format(name=name))\",\n \"def _sync(self, vals_gen):\\n indices = range(len(self._FIELDS))\\n for db_values, sheet_cells in vals_gen:\\n if self._update_in_sheet(db_values, sheet_cells, indices):\\n self._modified = True\\n return self._modified\",\n \"def _object_update(self, obj, items):\\n # many to many fields are saved after the main object\\n m2ms = {}\\n for key, value in items.iteritems():\\n try:\\n field = obj._meta.get_field(key)\\n if isinstance(field, ManyToManyField):\\n m2ms[key] = value\\n else:\\n setattr(obj, key, value)\\n\\n except FieldDoesNotExist:\\n raise InvalidParameter(key)\\n\\n try:\\n obj.full_clean()\\n obj.save()\\n except ValidationError as e:\\n raise InvalidParameter(e.message_dict, override=True)\\n\\n for key, values in m2ms.iteritems():\\n manager = getattr(obj, key)\\n manager.clear()\\n manager.add(*values)\",\n \"def update(self, events):\\n events = events\",\n \"def update_many(\\n self,\\n *args: Union[dict, Mapping],\\n session: Optional[ClientSession] = None\\n ) -> UpdateMany:\\n return self.update(*args, session=session)\",\n \"def update_data(self, **kwargs):\\n self.source_data = self.get_dict()\\n for c in self.callbacks[\\\"update_data\\\"]:\\n c()\",\n \"def async_update(self, raw):\\n changed_keys = set()\\n\\n for k, v in raw.items():\\n changed_keys.add(k)\\n\\n if isinstance(self.raw.get(k), dict) and isinstance(v, dict):\\n changed_keys.update(set(v.keys()))\\n self.raw[k].update(v)\\n\\n else:\\n self.raw[k] = v\\n\\n self.changed_keys = changed_keys\\n\\n for async_signal_update in self._async_callbacks:\\n async_signal_update()\",\n \"def update_events_in_database(self):\\n for i in range(0, len(self._event_id_list), 1):\\n e_id = self._event_id_list[i] # DB ID\\n e_ind = self._event_index_list[i] # Index of the event\\n e_db = Event.objects.get(id=e_id) # Event as stored in the DB\\n e_db = e_db[0] # list to Event object\\n e_new = self._event_list[i] # new Event object\\n\\n # Compare the old and the new event, detect which fields have\\n # changed and update them in the old.\\n change = e_db.compare(e_new)\\n for (name, val) in change:\\n setattr(e_db, name, val)\\n\\n # Save the updated old event, saving of only the fields which\\n # have changed\\n e_db.save(update_fields=[name for (name, val) in change])\\n\\n # Mark the event status as not requiring an update anymore\\n self.gdc.write_update_status_nth_event(e_ind, False)\",\n \"def update(self, **kwargs):\\n for key, val in kwargs.items():\\n setattr(self, key, val)\",\n \"def salesforce_collection_update(self, objects):\\n for obj in objects:\\n assert obj[\\n \\\"id\\\"\\n ], \\\"Should be a list of objects with Ids returned by Salesforce Collection Insert\\\"\\n if STATUS_KEY in obj:\\n del obj[STATUS_KEY]\\n\\n assert len(objects) <= SF_COLLECTION_INSERTION_LIMIT, (\\n \\\"Cannot update more than %s objects with this keyword\\\"\\n % SF_COLLECTION_INSERTION_LIMIT\\n )\\n\\n records = self.cumulusci.sf.restful(\\n \\\"composite/sobjects\\\",\\n method=\\\"PATCH\\\",\\n json={\\\"allOrNone\\\": True, \\\"records\\\": objects},\\n )\\n\\n for record, obj in zip(records, objects):\\n obj[STATUS_KEY] = record\",\n \"def update_many(objects, fields=[], using=\\\"default\\\"):\\n if not objects:\\n return\\n\\n import django.db.models\\n from django.db import connections\\n con = connections[using]\\n\\n names = fields\\n meta = objects[0]._meta\\n fields = [f for f in meta.fields if not isinstance(f, django.db.models.AutoField) and (not names or f.name in names)]\\n\\n if not fields:\\n raise ValueError(\\\"No fields to update, field names are %s.\\\" % names)\\n\\n fields_with_pk = fields + [meta.pk]\\n parameters = []\\n for o in objects:\\n parameters.append(tuple(f.get_db_prep_save(f.pre_save(o, True), connection=con) for f in fields_with_pk))\\n\\n table = meta.db_table\\n assignments = \\\",\\\".join((\\\"%s=%%s\\\"% con.ops.quote_name(f.column)) for f in fields)\\n con.cursor().executemany(\\n \\\"update %s set %s where %s=%%s\\\" % (table, assignments, meta.pk.column),\\n parameters)\",\n \"def partial_update_objects(self, objects):\\n requests = []\\n for obj in objects:\\n requests.append({\\\"action\\\": \\\"partialUpdateObject\\\", \\\"objectID\\\": obj[\\\"objectID\\\"], \\\"body\\\": obj})\\n request = {\\\"requests\\\": requests}\\n return self.batch(request)\",\n \"def bulk_update(self, iterable):\\n inserted, updated = [], []\\n for d, h in iterable:\\n if -d in self:\\n updated.append((-d, h))\\n else:\\n inserted.append((-d, h))\\n self._update_bulk(updated)\\n self._insert_bulk(inserted)\",\n \"def _update(self, data: Dict[str, Any], fields_to_modify: List[str]):\\n pass\",\n \"def update_all_dict_bywhereclause(cls, updatedict, whereclause):\\n return cls.dbm().modelclass_update_all_dict_bywhereclause(cls, updatedict, whereclause)\",\n \"def update(self, dt):\\n for obj in self.objects:\\n obj.update(dt)\",\n \"def manual_update(self):\\n for cb, status in zip(self._manual_cbs, self.status_objs):\\n cb(status)\",\n \"def _update(self, datapoints):\\r\\n if len(datapoints) == 1:\\r\\n timestamp, value = datapoints[0]\\r\\n whisper.update(self.path, value, timestamp)\\r\\n else:\\r\\n whisper.update_many(self.path, datapoints)\",\n \"def update_product_values(request, property_group_id):\\n property_group = lfs_get_object_or_404(PropertyGroup, pk=property_group_id)\\n product_ids = request.POST.getlist(\\\"product-id\\\")\\n products = Product.objects.filter(pk__in=product_ids)\\n \\n for product in products:\\n for property in property_group.properties.all(): \\n value = request.POST.get(\\\"property-%s-%s\\\" % (product.id, property.id), \\\"\\\")\\n if value != \\\"\\\":\\n try:\\n ppv = ProductPropertyValue.objects.get(property = property, product=product)\\n except ProductPropertyValue.DoesNotExist:\\n ProductPropertyValue.objects.create(property = property, product=product, value=value)\\n else: \\n ppv.value = value\\n ppv.save()\\n\\n result = simplejson.dumps({\\n \\\"html\\\" : product_values(request, property_group_id),\\n \\\"message\\\" : _(u\\\"Product Values have been saved.\\\")\\n }, cls=LazyEncoder);\\n \\n return HttpResponse(result)\",\n \"def update(self, raw, **kwargs):\\n changed_keys = set()\\n\\n for k, v in raw.items():\\n changed_keys.add(k)\\n\\n if isinstance(self.raw.get(k), dict) and isinstance(v, dict):\\n changed_keys.update(set(v.keys()))\\n self._raw[k].update(v)\\n\\n else:\\n self._raw[k] = v\\n\\n self._changed_keys = changed_keys\\n\\n for async_signal_update in self._callbacks:\\n async_signal_update(**kwargs)\",\n \"def _update_all_fields(self, name, value):\\n for field in self._field_map.values():\\n setattr(field, name, value)\",\n \"async def _update_values(self, model: Model):\\n\\n raise NotImplementedError\",\n \"def test_otoroshi_controllers_adminapi_tcp_service_api_controller_bulk_update_action(self):\\n pass\",\n \"def set_updates(self, updates: dict, dry=False):\\n self._updates += (UpdateQueryExpression(updates),)\\n return self\",\n \"def _update_all(self, criteria: Q, *args, **kwargs):\\n conn = self._get_session()\\n qs = conn.query(self.model_cls).filter(self._build_filters(criteria))\\n try:\\n values = {}\\n if args:\\n values = args[\\n 0\\n ] # `args[0]` is required because `*args` is sent as a tuple\\n values.update(kwargs)\\n updated_count = qs.update(values)\\n except DatabaseError as exc:\\n logger.error(f\\\"Error while updating all: {exc}\\\")\\n raise\\n finally:\\n if not current_uow:\\n conn.commit()\\n conn.close()\\n\\n return updated_count\",\n \"def update_all(collection: Collection, data_to_update):\\n return collection.update_many({}, {'$set': data_to_update}).matched_count\",\n \"def updateMultipleDocuments(cred, payload):\\n\\n url = cred.base_url + \\\"documents:commit\\\"\\n data = { 'writes': [] }\\n\\n for path, fieldData in payload.iteritems():\\n pathData = createFirestoreDataObject(cred, path, fieldData)\\n data['writes'].append(pathData)\\n \\n makeRequest(cred, url, 'POST', data)\",\n \"def view_update(self, context):\\n\\n for collection in self._watch_list:\\n collection_name = get_collection_name(collection)\\n collection_set = set(collection)\\n tracking_set = self._tracking_sets[collection_name]\\n\\n # Check for new items\\n add_set = collection_set - tracking_set\\n self.add_delta[collection_name] = add_set\\n tracking_set |= add_set\\n\\n # Check for removed items\\n remove_set = tracking_set - collection_set\\n self.remove_delta[collection_name] = remove_set\\n tracking_set -= remove_set\\n\\n # Check for updates\\n update_set = {item for item in collection if item.is_updated}\\n self.update_delta[collection_name] = update_set\",\n \"def update(self, values):\\n for k, v in values.items():\\n setattr(self, k, v)\",\n \"def _process(self, start_key, batch_size):\\n\\n query = self.MODEL.all()\\n if start_key:\\n query.filter('__key__ > ', start_key)\\n\\n try:\\n entities = query.fetch(batch_size)\\n\\n if not entities:\\n # all entities has already been processed\\n return\\n\\n for entity in entities:\\n for field in self.FIELDS_TO_UPDATE:\\n old_reference = getattr(entity, field)\\n\\n if not old_reference:\\n continue\\n\\n # check if the field has not been updated\\n if isinstance(old_reference, self.PROFILE_MODEL):\\n continue\\n\\n profile = _getProfileForRole(old_reference, self.PROFILE_MODEL)\\n setattr(entity, field, profile)\\n\\n for list_property in self.LISTS_TO_UPDATE:\\n l = getattr(entity, list_property)\\n new_l = []\\n for key in l:\\n new_l.append(_getProfileKeyForRoleKey(key, self.PROFILE_MODEL))\\n setattr(entity, list_property, new_l)\\n\\n db.put(entities)\\n start_key = entities[-1].key()\\n deferred.defer(self._process, start_key, batch_size)\\n except DeadlineExceededError:\\n # here we should probably be more careful\\n deferred.defer(self._process, start_key, batch_size)\",\n \"def update(extended):\\n def update_properties(main_property_file, other_property_files):\\n main_lines = read_file(filename=main_property_file)\\n # saved the stripped lines\\n write_file(main_property_file, main_lines)\\n main_keys = get_keys_from_lines(lines=main_lines)\\n\\n main_duplicates = get_duplicates(lines=main_lines)\\n num_main_duplicates = len(main_duplicates)\\n if num_main_duplicates != 0:\\n logger.error(\\\"There are {num_duplicates} duplicates in {file}, please fix them manually\\\".format(num_duplicates=num_main_duplicates, file=get_filename(filepath=main_property_file)))\\n if extended:\\n logger.neutral(u\\\"\\\\t{}\\\".format(\\\", \\\".join(main_duplicates)))\\n return\\n\\n\\n for other_property_file in other_property_files:\\n filename = get_filename(filepath=other_property_file)\\n lines = read_file(filename=other_property_file)\\n keys, not_fixed, fixed = fix_duplicates(lines=lines)\\n\\n num_keys = len(keys)\\n num_not_fixed = len(not_fixed)\\n num_fixed = len(fixed)\\n\\n if num_not_fixed != 0:\\n logger.error(\\\"There are {num_not_fixed_duplicates} ambiguous duplicates in {file}, please fix them manually\\\".format(num_not_fixed_duplicates=num_not_fixed, file=filename))\\n if extended:\\n logger.error(u\\\"\\\\t{}\\\".format(u\\\", \\\".join(not_fixed)))\\n continue\\n\\n keys_missing = get_missing_keys(main_keys, keys)\\n keys_obsolete = get_missing_keys(keys, main_keys)\\n\\n num_keys_missing = len(keys_missing)\\n num_keys_obsolete = len(keys_obsolete)\\n\\n for missing_key in keys_missing:\\n keys[missing_key] = \\\"\\\"\\n\\n for obsolete_key in keys_obsolete:\\n del keys[obsolete_key]\\n\\n other_lines_to_write = []\\n for line in main_lines:\\n key = get_key_from_line(line)\\n if key is not None:\\n other_lines_to_write.append(u\\\"{key}={value}\\\\r\\\\n\\\".format(key=key, value=keys[key]))\\n else:\\n other_lines_to_write.append(line)\\n\\n sorted = len(lines) != len(other_lines_to_write)\\n if not sorted:\\n for old_line, new_lines in zip(lines, other_lines_to_write):\\n if old_line != new_lines:\\n sorted = True\\n\\n write_file(filename=other_property_file, content=other_lines_to_write)\\n\\n logger.ok(\\\"Processing file '{file}' with {num_keys} Keys\\\".format(file=filename, num_keys=num_keys))\\n if num_fixed != 0:\\n logger.ok(\\\"\\\\tfixed {} unambiguous duplicates\\\".format(num_fixed))\\n if extended:\\n logger.neutral(u\\\"\\\\t\\\\t{}\\\".format(\\\", \\\".join(fixed)))\\n\\n if num_keys_missing != 0:\\n logger.ok(\\\"\\\\tadded {} missing keys\\\".format(num_keys_missing))\\n if extended:\\n logger.neutral(u\\\"\\\\t\\\\t{}\\\".format(\\\", \\\".join(keys_missing)))\\n\\n if num_keys_obsolete != 0:\\n logger.ok(\\\"\\\\tdeleted {} obsolete keys\\\".format(num_keys_obsolete))\\n if extended:\\n logger.neutral(u\\\"\\\\t\\\\t{}\\\".format(\\\", \\\".join(keys_obsolete)))\\n\\n if sorted:\\n logger.ok(\\\"\\\\thas been sorted successfully\\\")\\n\\n update_properties(main_property_file=get_main_jabref_preferences(), other_property_files=get_other_jabref_properties())\\n update_properties(main_property_file=get_main_menu_properties(), other_property_files=get_other_menu_properties())\",\n \"def update(self, values):\\n return self.manager.update(self, values)\",\n \"def apply_updates(self, updates):\\n raise NotImplementedError()\",\n \"def update(self, timeElapsed):\\n\\n for i in range(len(self._lUpdatables)):\\n\\n #This calls the Updatable component's update() method.\\n self._lUpdatables[i].update(timeElapsed)\",\n \"def update(self, params):\\n for gauge in self.gauges:\\n self.safexec(gauge.update, params)\",\n \"def test_update_multiple(test_store, andy, pandy, candy):\\n n_updated = test_store.update(fields={\\\"age\\\": 14}, age=12)\\n assert n_updated == 2\\n items = list(test_store.get_by())\\n\\n andy.age = pandy.age = 14\\n assert andy in items\\n assert pandy in items\\n assert candy in items\",\n \"def update(self, values: List[int]) -> None:\\n ...\",\n \"def update(self, values: List[int]) -> None:\\n ...\",\n \"def update_many(\\n cls,\\n *,\\n pks: List[Union[str, int]],\\n update: Dict[str, Any],\\n sychronize_session: bool = False,\\n ) -> None:\\n if pks:\\n db.session.query(cls).filter(\\n getattr(cls, cls.get_primary_key()).in_(pks)\\n ).update(update, synchronize_session=sychronize_session)\\n db.session.commit()\\n cache.delete_many(*(cls.create_cache_key(pk) for pk in pks))\",\n \"def update(self, *args, **kwargs):\\n if kwargs is not None:\\n for key, value in kwargs.items():\\n setattr(self, key, value)\",\n \"def update_view(self):\\n for row in self.view.obj_list:\\n for obj in row:\\n obj._update(self.model)\",\n \"def updateAll(self):\\n \\tself.idToUpdate=''\\n \\tself.newState=''\\n \\tself.save()\",\n \"def update(self, values):\\r\\n for k, v in six.iteritems(values):\\r\\n setattr(self, k, v)\",\n \"def handle_update(self, json_snippet, tmpl_diff, prop_diff):\\n subscription = self._get_subscription()\\n subscription.update(prop_diff)\",\n \"def update(self, values):\\n for k, v in six.iteritems(values):\\n setattr(self, k, v)\",\n \"def update_all(self, request):\\n\\n schema = self.session.info['schema']\\n\\n for item in self.query().filter_by(schema=schema):\\n self.session.delete(item)\\n\\n for item in ElectionCollection(self.session).query():\\n self.update(item, request)\\n\\n for item in ElectionCompoundCollection(self.session).query():\\n self.update(item, request)\\n\\n for item in VoteCollection(self.session).query():\\n self.update(item, request)\",\n \"def _update_all_tasks(self) -> None:\\n for task in self.tasks:\\n task.update()\",\n \"def update_values(self, to_update):\\n for key, value in kwargs.iteritems():\\n self.params[key] = value\\n # update the possibly dependent parameters\\n self.set_filenames()\",\n \"def _update_event(klass, event, *data_dicts):\\n # Create d\\n d = {}\\n for data_dict in data_dicts:\\n d.update(data_dict)\\n d = klass._remove_none_fields(d)\\n d = dict((\\\"set__\\\" + k, v) for k, v in d.iteritems())\\n\\n # Update and save.\\n event.update(**d)\\n event.save()\",\n \"def update_many(collection: Collection, query, data_to_update):\\n return collection.update_many(query, {'$set': data_to_update}).matched_count\",\n \"def bulk_update(self, request):\\n serializer = MasterySerializer(\\n data=request.data,\\n many=True,\\n )\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data)\\n else:\\n return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)\",\n \"def update(self):\\n if self._skip_update:\\n self._skip_update = False\\n return\\n\\n try:\\n for prop in AIRER_PROPS:\\n self.status[prop] = self.send('get_prop', [prop])[0]\\n _LOGGER.debug(\\\"MiioDevice update: %s\\\", self.status)\\n self.available = True\\n self._retry = 0\\n except Exception as exc:\\n _LOGGER.error(\\\"Error on update: %s\\\", exc)\\n self._retry += 1\\n if self._retry > 3:\\n self.available = False\\n\\n for entity in self.update_entities:\\n entity.async_schedule_update_ha_state()\",\n \"def update(cls, values):\\n result = yield UpdateQuery(cls, values).execute()\\n returnValue(result)\",\n \"def update(self, **values):\\r\\n if self.__abstract__:\\r\\n raise ThunderdomeException('cant update abstract elements')\\r\\n self.pre_update(**values)\\r\\n for key in values.keys():\\r\\n if key not in self._columns:\\r\\n raise TypeError(\\\"unrecognized attribute name: '{}'\\\".format(key))\\r\\n\\r\\n for k,v in values.items():\\r\\n setattr(self, k, v)\\r\\n\\r\\n return self.save()\",\n \"def test_update_values(self):\\n partition = uuid4()\\n for i in range(5):\\n TestQueryUpdateModel.create(partition=partition, cluster=i, count=i, text=str(i))\\n\\n # sanity check\\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\\n self.assertEqual(row.cluster, i)\\n self.assertEqual(row.count, i)\\n self.assertEqual(row.text, str(i))\\n\\n # perform update\\n TestQueryUpdateModel.objects(partition=partition, cluster=3).update(count=6)\\n\\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\\n self.assertEqual(row.cluster, i)\\n self.assertEqual(row.count, 6 if i == 3 else i)\\n self.assertEqual(row.text, str(i))\",\n \"def update_settings(self, settings_list):\\n for i, x in enumerate(settings_list):\\n self.update_settings_at_index(settings=x, index=i)\",\n \"def _handle_single_update(self, controller):\\n result = controller.list_all_items()\\n # TODO(jkinkead): Validate `result`? It's unclear if ALL errors will result in an HTTPError,\\n # or if some will result in a response field indicating an error.\\n logger.debug('Got %s results from %s lookup.', len(result.items), controller.name)\\n for item in result.items:\\n self._handle_single_item(controller, item)\",\n \"def update_state(self, **kwargs):\\n\\n for name in self.metrics:\\n\\n metric = self.metrics[name]\\n\\n argspec = inspect.getfullargspec(metric.update_state)\\n\\n kwargs_to_pass = {k: kwargs[k] for k in kwargs if k in argspec.args}\\n\\n metric.update_state(**kwargs_to_pass)\",\n \"def update_lineprops(imageprop):\\n db = 'sage'\\n j = call_responder('sage', 'cvterms?cv_term=' + imageprop)\\n if len(j['cvterm_data']) < 1:\\n logger.critical(\\\"Could not find line property %s\\\", imageprop)\\n sys.exit(-1)\\n cursor = READ['unsynced'] % (imageprop, imageprop)\\n print(\\\"Syncing image properties for %s (%s) on %s\\\" %\\n (imageprop, j['cvterm_data'][0]['display_name'], db))\\n try:\\n CURSOR[db].execute(cursor)\\n rows = CURSOR[db].fetchall()\\n except MySQLdb.Error as err:\\n sql_error(err)\\n for row in rows:\\n image_id = row[0]\\n value = row[1]\\n logger.debug(\\\"Missing %s (%s) for image %s\\\", imageprop,\\n value, image_id)\\n cursor2 = WRITE['update'] % (imageprop, value, image_id)\\n logger.debug(cursor2)\\n try:\\n CURSOR[db].execute(cursor2)\\n except MySQLdb.Error as err:\\n logger.error(\\\"Could not update row in image_data_mv\\\")\\n sql_error(err)\\n COUNT['update'] += 1\\n if ARG.TRIGGER:\\n logger.debug(WRITE['refresh'] % (image_id))\\n try:\\n CURSOR[db].execute(WRITE['refresh'] % (image_id))\\n except MySQLdb.Error as err:\\n logger.error(\\\"Could not update rows in image_property\\\")\\n sql_error(err)\\n COUNT['triggered'] += CURSOR[db].rowcount\\n cursor = READ['deleted'] % (imageprop, imageprop, imageprop)\\n try:\\n CURSOR[db].execute(cursor)\\n rows = CURSOR[db].fetchall()\\n except MySQLdb.Error as err:\\n sql_error(err)\\n for row in rows:\\n logger.warning(\\\"Image ID %s has a %s (%s) in image_data_mv, but not in image_property\\\", row[0], imageprop, row[1])\\n if ARG.WRITE:\\n CONN[db].commit()\\n print(\\\"Unsynced records: %d\\\" % (len(rows)))\\n print(\\\"Updated records: %d\\\" % (COUNT['update']))\\n print(\\\"Triggered updates: %d\\\" % (COUNT['triggered']))\",\n \"def update(self, *args, **kwargs):\\n sqrlist = [\\\"id\\\", \\\"size\\\", \\\"x\\\", \\\"y\\\"]\\n if args and len(args) != 0:\\n for i in range(len(sqrlist)):\\n if i < len(args):\\n # call to setter method\\n setattr(self, sqrlist[i], args[i])\\n else:\\n if kwargs and len(kwargs) != 0:\\n for k in sqrlist:\\n for key, value in kwargs.items():\\n if k == key:\\n setattr(self, key, value)\",\n \"def updateProperties(self):\\n self.manage_changeProperties(title = self.getTitle(),\\n description = self.getDescription(),\\n basepath = self.getPath())\",\n \"def _update(self, data: Dict[str, Any], fields_to_modify: List[str]):\\n\\n to_set = [\\n \\\"{0} = %({0})s\\\".format(f) for f in fields_to_modify\\n if f in self.editable_fields\\n ]\\n if len(to_set) == 0:\\n print('Warning: No data to set', data)\\n return\\n\\n query = \\\"UPDATE {} SET {} WHERE {}\\\".format(\\n self._NAME,\\n ', '.join(to_set),\\n ' AND '.join(\\\"{0} = %({0})s\\\".format(f) for f in self.primary_fields),\\n )\\n self._execute(query, data)\",\n \"def _refresh(self):\\r\\n self._tracer.info(\\\"Refresh called 1\\\")\\r\\n for obj in self._filter_objects:\\r\\n # Only call function if it exists, and is callable.\\r\\n if hasattr(obj, 'property_refresh') and \\\\\\r\\n callable(getattr(obj, 'property_refresh')):\\r\\n obj.property_refresh()\",\n \"def onPropertiesChange(self, data):\\n pass\",\n \"def set_properties(self, props=None):\\n props = [] if props is None else props\\n prop = dav.Prop() + props\\n set = dav.Set() + prop\\n root = dav.PropertyUpdate() + set\\n\\n r = self._query(root, query_method=\\\"proppatch\\\")\\n\\n statuses = r.tree.findall(\\\".//\\\" + dav.Status.tag)\\n for s in statuses:\\n if \\\" 200 \\\" not in s.text:\\n raise error.PropsetError(s.text)\\n\\n return self\",\n \"def update_all_behaviors(self):\\n for behavior in self.active_behaviors:\\n behavior.update()\",\n \"def updatedata(self, force_update=False):\\n\\n self._update_counter = self._update_counter + 1\\n logging.debug('ParameterViewer: update values')\\n for instrument_name in self._instrumentnames:\\n instr = self._instruments[self._instrumentnames.index(instrument_name)]\\n parameters = {}\\n\\n try:\\n parameters = instr.parameters\\n except AttributeError as ex:\\n # instrument was removed\\n print('instrument was removed, stopping ParameterViewer')\\n # logging.exception(ex)\\n self._timer.stop()\\n\\n parameter_names = sorted(parameters.keys())\\n\\n si = sys.getswitchinterval()\\n\\n for parameter_name in parameter_names:\\n # hack to make this semi thread-safe\\n\\n for field_name in self._fields:\\n if field_name == 'Value':\\n sys.setswitchinterval(100)\\n value = parameters[parameter_name].get_latest()\\n sys.setswitchinterval(si)\\n self.update_field_signal.emit(instrument_name, parameter_name, field_name, value, force_update)\\n else:\\n if self._update_counter % 20 == 1 or 1:\\n sys.setswitchinterval(100)\\n value = getattr(parameters[parameter_name], field_name, '')\\n sys.setswitchinterval(si)\\n self.update_field_signal.emit(instrument_name, parameter_name,\\n field_name, value, force_update)\\n\\n for callback_function in self.callbacklist:\\n try:\\n callback_function()\\n except Exception as ex:\\n logging.debug('update function failed')\\n logging.exception(str(ex))\",\n \"def update_all():\\n req_data = request.get_json()\\n jobs = JobModel.get_one_job(job_id)\\n if not jobs:\\n return custom_response({'Error': 'Job Not Found'}, 404)\\n\\n data, error = job_schema.load(req_data, partial=True)\\n if error:\\n return custom_response(error, 400)\\n\\n for job in jobs:\\n job.update(data)\\n job_message = job_schema.dump(job)\\n\\n return custom_response(job_message, 200)\",\n \"def apply_data(self, objs, old_data, new_data):\\n if len(old_data) != len(new_data):\\n self._log.warning('number of objects changed from {} to {}',\\n len(old_data), len(new_data))\\n\\n obj_by_id = {o.id: o for o in objs}\\n ignore_fields = self.config['ignore_fields'].as_str_seq()\\n for old_dict, new_dict in zip(old_data, new_data):\\n # Prohibit any changes to forbidden fields to avoid\\n # clobbering `id` and such by mistake.\\n forbidden = False\\n for key in ignore_fields:\\n if old_dict.get(key) != new_dict.get(key):\\n self._log.warning('ignoring object whose {} changed', key)\\n forbidden = True\\n break\\n if forbidden:\\n continue\\n\\n id_ = int(old_dict['id'])\\n apply_(obj_by_id[id_], new_dict)\",\n \"def UpdateValues(self, grid):\\n # This sends an event to the grid table to update all of the values\\n msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES)\\n grid.ProcessTableMessage(msg)\",\n \"async def async_update_all(self):\\n await self.async_update_transport_state()\\n if self._state != STATE_OFF:\\n await self.async_update_volume_level()\\n await self.async_update_mute()\\n await self.async_update_track_info()\\n await self.async_update_play_mode()\",\n \"def test_update_values(self):\\r\\n partition = uuid4()\\r\\n for i in range(5):\\r\\n TestQueryUpdateModel.create(partition=partition, cluster=i, count=i, text=str(i))\\r\\n\\r\\n # sanity check\\r\\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\\r\\n assert row.cluster == i\\r\\n assert row.count == i\\r\\n assert row.text == str(i)\\r\\n\\r\\n # perform update\\r\\n TestQueryUpdateModel.objects(partition=partition, cluster=3).update(count=6)\\r\\n\\r\\n for i, row in enumerate(TestQueryUpdateModel.objects(partition=partition)):\\r\\n assert row.cluster == i\\r\\n assert row.count == (6 if i == 3 else i)\\r\\n assert row.text == str(i)\",\n \"def update_all_step_settings(self, settings):\\n for i, x in enumerate(self):\\n self.update_settings_at_index(settings, index=i)\",\n \"def update_many(self, base_tree_path, values, level=NONTRANSACTIONAL):\\n\\t\\tassert transactional == NONTRANSACTIONAL, 'Transactional updates are not supported'\\n\\n\\t\\t# The default implementation, if the chosen backend does not provide a more efficient one\\n\\t\\tbase_tree_path = list(base_tree_path)\\n\\t\\tret_values = []\\n\\t\\tfor tree_path, value in values:\\n\\t\\t\\tret_values.append(\\n\\t\\t\\t\\tself.update(base_tree_path + list(tree_path), value)\\n\\t\\t\\t)\\n\\n\\t\\treturn ret_values\",\n \"def _update_all_eval_input_configs(configs, field, value):\\n for eval_input_config in configs[\\\"eval_input_configs\\\"]:\\n setattr(eval_input_config, field, value)\",\n \"def update_parameters(updates):\\r\\n for (key, val) in updates.items():\\r\\n par[key] = val\\r\\n print('Updating:', key, '-->', val)\\r\\n update_dependencies()\",\n \"def set_properties(self):\\n for key in self.prop_source.params_data:\\n property_grid = self.interpolate(\\n self.grid.xmin,\\n self.grid.ymin,\\n self.grid.dx,\\n self.grid.dy,\\n self.grid.nx,\\n self.grid.ny,\\n self.prop_source.params_data[key]['x'],\\n self.prop_source.params_data[key]['y'],\\n self.prop_source.params_data[key]['z']\\n )\\n\\n self.properties[key] = self.normalize(\\n property_grid,\\n self.prop_source.params[key]['min'],\\n self.prop_source.params[key]['max'],\\n self.grid.ibound_mask\\n )\",\n \"def test_update_many(self):\\n sample_input = \\\"\\\"\\\"\\nfoo=100\\nbar=200, baz=300\\n\\\"\\\"\\\"\\n self.assertNotEquals(self.param_dict.get(\\\"foo\\\"), 100)\\n self.assertNotEquals(self.param_dict.get(\\\"bar\\\"), 200)\\n self.assertNotEquals(self.param_dict.get(\\\"baz\\\"), 300)\\n result = self.param_dict.update_many(sample_input)\\n log.debug(\\\"result: %s\\\", result)\\n self.assertEquals(result[\\\"foo\\\"], True)\\n self.assertEquals(result[\\\"bar\\\"], True)\\n self.assertEquals(result[\\\"baz\\\"], True)\\n self.assertEquals(self.param_dict.get(\\\"foo\\\"), 100)\\n self.assertEquals(self.param_dict.get(\\\"bar\\\"), 200)\\n self.assertEquals(self.param_dict.get(\\\"baz\\\"), 300)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66578263","0.6543413","0.6513449","0.64142585","0.64012647","0.6382263","0.6328527","0.6231375","0.6205191","0.6145095","0.6109039","0.6012963","0.5999936","0.5995834","0.59565485","0.5932615","0.58797646","0.5834851","0.5812164","0.57771397","0.57433885","0.5736354","0.57292217","0.571821","0.57070994","0.56622666","0.5653784","0.5641701","0.56328976","0.56299824","0.5629122","0.56153244","0.55956745","0.55884945","0.5579262","0.55278593","0.5524384","0.5519916","0.5513858","0.55077994","0.5506364","0.54973656","0.54864305","0.5483839","0.54788977","0.5478218","0.5475459","0.54720014","0.54582304","0.5451276","0.54388964","0.54308075","0.54103106","0.54019433","0.53992105","0.5394866","0.5391402","0.53818506","0.5378379","0.5378379","0.53774405","0.5369894","0.53686327","0.5364852","0.53525764","0.535168","0.5349269","0.5346193","0.5344513","0.5319884","0.531622","0.5315673","0.53127474","0.53121316","0.53033435","0.53021234","0.53010565","0.5300141","0.52996683","0.52978355","0.52972025","0.5289714","0.52885044","0.5288336","0.5287096","0.52846676","0.5283677","0.5277975","0.5271343","0.52618444","0.5254724","0.5250686","0.525033","0.5238762","0.5234902","0.5233488","0.52293426","0.522363","0.5214174","0.5211417"],"string":"[\n \"0.66578263\",\n \"0.6543413\",\n \"0.6513449\",\n \"0.64142585\",\n \"0.64012647\",\n \"0.6382263\",\n \"0.6328527\",\n \"0.6231375\",\n \"0.6205191\",\n \"0.6145095\",\n \"0.6109039\",\n \"0.6012963\",\n \"0.5999936\",\n \"0.5995834\",\n \"0.59565485\",\n \"0.5932615\",\n \"0.58797646\",\n \"0.5834851\",\n \"0.5812164\",\n \"0.57771397\",\n \"0.57433885\",\n \"0.5736354\",\n \"0.57292217\",\n \"0.571821\",\n \"0.57070994\",\n \"0.56622666\",\n \"0.5653784\",\n \"0.5641701\",\n \"0.56328976\",\n \"0.56299824\",\n \"0.5629122\",\n \"0.56153244\",\n \"0.55956745\",\n \"0.55884945\",\n \"0.5579262\",\n \"0.55278593\",\n \"0.5524384\",\n \"0.5519916\",\n \"0.5513858\",\n \"0.55077994\",\n \"0.5506364\",\n \"0.54973656\",\n \"0.54864305\",\n \"0.5483839\",\n \"0.54788977\",\n \"0.5478218\",\n \"0.5475459\",\n \"0.54720014\",\n \"0.54582304\",\n \"0.5451276\",\n \"0.54388964\",\n \"0.54308075\",\n \"0.54103106\",\n \"0.54019433\",\n \"0.53992105\",\n \"0.5394866\",\n \"0.5391402\",\n \"0.53818506\",\n \"0.5378379\",\n \"0.5378379\",\n \"0.53774405\",\n \"0.5369894\",\n \"0.53686327\",\n \"0.5364852\",\n \"0.53525764\",\n \"0.535168\",\n \"0.5349269\",\n \"0.5346193\",\n \"0.5344513\",\n \"0.5319884\",\n \"0.531622\",\n \"0.5315673\",\n \"0.53127474\",\n \"0.53121316\",\n \"0.53033435\",\n \"0.53021234\",\n \"0.53010565\",\n \"0.5300141\",\n \"0.52996683\",\n \"0.52978355\",\n \"0.52972025\",\n \"0.5289714\",\n \"0.52885044\",\n \"0.5288336\",\n \"0.5287096\",\n \"0.52846676\",\n \"0.5283677\",\n \"0.5277975\",\n \"0.5271343\",\n \"0.52618444\",\n \"0.5254724\",\n \"0.5250686\",\n \"0.525033\",\n \"0.5238762\",\n \"0.5234902\",\n \"0.5233488\",\n \"0.52293426\",\n \"0.522363\",\n \"0.5214174\",\n \"0.5211417\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58494425"},"document_rank":{"kind":"string","value":"17"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":750,"numItemsPerPage":100,"numTotalItems":95772,"offset":75000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjcwOTA4NCwianRpIjoiOGNhZTRlNzUtNjQzZS00Njc4LTk2MDAtODM2OGY0ZjI3MTliIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY3MTI2ODQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.HcAKycAunZFNdl8GmjbmxNZ9_VQPFMXoLMxtw2DYIa_nt1Yaotzn1M5mdvZIjLTojTjFEDnH3Z7zy5AapmsDBQ","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 |
|---|---|---|---|---|---|---|
returns amplitude of fouriertransformed pupil amplitude and phase. | def app(data_pupil,data_phase,oversize=4):
complexr=app_complex(data_pupil,data_phase,oversize)
amp=(abs(complexr)**2)
return amp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def app_phase(data_pupil,data_phase,oversize=4):\n return phaseangle(app_complex(data_pupil,data_phase,oversize))",
"def fourier(data, temp_freq, axis, output = 'amplitude'):\n\t\t\n\t\n\t# take largest possible multiple of F1 from PSTH.\n\t# Generate freq and fft\n\t# generate amplitude\n\t# return amplitude, ... | [
"0.6694252",
"0.66727966",
"0.65830487",
"0.6336781",
"0.61794156",
"0.60287464",
"0.596772",
"0.5951013",
"0.58328754",
"0.58238393",
"0.5785631",
"0.5715169",
"0.57138133",
"0.56761545",
"0.5672074",
"0.565094",
"0.5622279",
"0.55942506",
"0.5587303",
"0.5576583",
"0.557021... | 0.6754119 | 0 |
returns complex image of fouriertransformed pupil amplitude and phase. | def app_complex(data_pupil,data_phase,oversize=4):
#phase colors
# cdict = {'red': ((0.0, 1.0, 1.0),(0.25, 0.0, 0.0),(0.5, 0.0, 0.0),(0.75, 1.0, 1.0),(1.00, 1.0, 1.0)),'green': ((0.0, 0.0, 0.0),(0.25, 1.0, 1.0),(0.5, 0.0, 0.0),(0.75, 1.0, 1.0),(1.0, 0.0, 0.0)),'blue': ((0.0, 0.0, 0.0),(0.25, 0.0, 0.0),(0.5, 1.0, 1.0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def app_phase(data_pupil,data_phase,oversize=4):\n return phaseangle(app_complex(data_pupil,data_phase,oversize))",
"def phaseangle(complexr):\n return numpy.arctan2(complexr.imag,complexr.real)",
"def extract(image):\n # calculate fft\n spectrum = np.fft.fft2(image)\n fshift = np.fft.fftshift(spectrum... | [
"0.61744237",
"0.6044899",
"0.59684455",
"0.58517736",
"0.5830706",
"0.57864714",
"0.57658476",
"0.5755958",
"0.5597331",
"0.55942726",
"0.5590746",
"0.5561673",
"0.5550486",
"0.55422354",
"0.55397385",
"0.5526284",
"0.5515743",
"0.5509431",
"0.54964",
"0.5489239",
"0.5486004... | 0.6352824 | 0 |
returns an apodized pupil of a 6.5 meter diameter telescope with 5 centimeter spacing and a central obscuration of 20%. | def circle():
xmin=0
xmax=6.5
ymin=0.
ymax=6.5
x = arange(xmin, xmax, 0.005)
y = x*1.
[xx, yy] = meshgrid(x, y)
zz=sqrt((xx-3.2475)**2.+(yy-3.2475)**2.)
zz2=zz*1.
zz2[(zz <= 3.25)]=1.
zz2[(zz <= 3.25*0.2)]=0.
zz2[(zz > 3.25)]=0.
zz3=zeros(numpy.array(numpy.shape(zz2))/10)
for i in arange(l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def molar_mass_dry_air():\n return 28.9647",
"def get_radius(size):\n return (size * 10) - 5",
"def get_pupil_diameter(dlc):\r\n diameters = []\r\n # Get the x,y coordinates of the four pupil points\r\n top, bottom, left, right = [np.vstack((dlc[f'pupil_{point}_r_x'], dlc[f'pupil_{point}_r_y']))... | [
"0.5942975",
"0.5920185",
"0.5880531",
"0.5875286",
"0.5806059",
"0.5752864",
"0.5677373",
"0.5635742",
"0.5496963",
"0.54659057",
"0.54656225",
"0.5461751",
"0.5455969",
"0.5445189",
"0.54427916",
"0.5432056",
"0.5422393",
"0.54122436",
"0.53751206",
"0.53562516",
"0.5352133... | 0.0 | -1 |
returns phase of complex image | def phaseangle(complexr):
return numpy.arctan2(complexr.imag,complexr.real) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phase(self):\n return np.arctan(np.sum(np.imag(self.values)) / np.sum(np.real(self.values)))",
"def real_imag_to_mag_phase(real_imag):\n return np.abs(real_imag), np.angle(real_imag, deg=True)",
"def Phase(data):\r\n hil = signal.hilbert(data)\r\n return np.unwrap(np.arctan2(hil.imag, hil.r... | [
"0.7519706",
"0.69542",
"0.6936921",
"0.6922937",
"0.67136526",
"0.6567651",
"0.6505695",
"0.6483315",
"0.64587396",
"0.64508444",
"0.6399734",
"0.6343744",
"0.6315422",
"0.62416685",
"0.62329644",
"0.6231627",
"0.6222406",
"0.62091786",
"0.6205904",
"0.61921215",
"0.6128248"... | 0.7439255 | 1 |
returns phase of fouriertransformed pupil amplitude and phase. | def app_phase(data_pupil,data_phase,oversize=4):
return phaseangle(app_complex(data_pupil,data_phase,oversize)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phase(self):\n return -self.attrs['RFphase']*2*np.pi",
"def phase(self):\n return np.arctan(np.sum(np.imag(self.values)) / np.sum(np.real(self.values)))",
"def signal_phase(signal):\n pi2 = 2.0*np.pi\n\n # Get pro-phase\n prophase = np.mod(np.angle(scipy.signal.hilbert(signal)), pi2)... | [
"0.6958312",
"0.68977565",
"0.68203247",
"0.6671979",
"0.66401994",
"0.66320395",
"0.6632024",
"0.66139495",
"0.6586814",
"0.64967984",
"0.64434147",
"0.6384845",
"0.63592",
"0.6298426",
"0.6295436",
"0.6293789",
"0.6293789",
"0.6293789",
"0.6251911",
"0.6203516",
"0.61936116... | 0.7017998 | 0 |
Refreshes the data in the ArticleView using feed_manager. | def refresh(self) -> None:
if self.current_feed is None:
self.article_view_model.set_articles([])
return
self.article_view_model.set_articles(self.feed_manager.get_articles(self.current_feed.db_id))
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self, view_manager):\n pass",
"def refresh_feed(self, feed: Feed) -> None:\n self._update_thread.force_refresh_feed(feed)",
"def trigger_refresh(self):\n self.get_selected()\n self.manage_loading(loading=True)\n self.current_feed.fetch_content(unread_only=self.sho... | [
"0.72453785",
"0.66812503",
"0.65578246",
"0.6536747",
"0.6526133",
"0.6474975",
"0.63738227",
"0.63738227",
"0.63478214",
"0.63305026",
"0.63305026",
"0.63305026",
"0.627443",
"0.6247356",
"0.6247173",
"0.62367964",
"0.6196782",
"0.61776346",
"0.6155839",
"0.6155839",
"0.609... | 0.8214881 | 0 |
Changes which feed's articles should be shown in the view. If feed is unspecified, the view will be blank. | def select_feed(self, feed: None | Feed = None) -> None:
self.current_feed = feed
self.refresh() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self) -> None:\n if self.current_feed is None:\n self.article_view_model.set_articles([])\n return\n self.article_view_model.set_articles(self.feed_manager.get_articles(self.current_feed.db_id))\n return",
"def set_articles(self, articles: list[Article]) -> ... | [
"0.6986372",
"0.58573174",
"0.5820473",
"0.56910294",
"0.5664006",
"0.56358176",
"0.5605886",
"0.5596966",
"0.55824393",
"0.55172175",
"0.54702145",
"0.53789026",
"0.5349168",
"0.5301037",
"0.5290578",
"0.5282688",
"0.5260703",
"0.5254529",
"0.52241373",
"0.52105814",
"0.5208... | 0.58724 | 1 |
Fires article_selected_event with the current selection, also marks the article as read. Should only be called by event. | def selection_changed(self) -> None:
index = self.currentIndex()
if index.isValid():
article: Article = index.internalPointer()
if article.unread is True:
if self.current_feed is None:
logging.error("current feed is none, but article was selec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _on_articles_selection_changed(self, evt=None):\n \n # get selected articles\n articles = self._articles_view.GetSelectedArticles()\n\n # update menu bar\n self._menu_bar.SetArticles(articles)\n \n # none or multiple articles selected\n if len(articles) !... | [
"0.71925265",
"0.63796103",
"0.6328673",
"0.63187927",
"0.6288228",
"0.62295455",
"0.62144005",
"0.61657417",
"0.6164607",
"0.6152132",
"0.6067495",
"0.60430145",
"0.60293573",
"0.597503",
"0.5960968",
"0.5940282",
"0.592804",
"0.5922907",
"0.5919613",
"0.59188336",
"0.591781... | 0.7677113 | 0 |
Recieves new article data from the feed manager and adds them to the views. Only adds articles which are the same as the currently highlighted feed | def recieve_new_articles(self, articles: list[Article], feed_id: int) -> None:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self) -> None:\n if self.current_feed is None:\n self.article_view_model.set_articles([])\n return\n self.article_view_model.set_articles(self.feed_manager.get_articles(self.current_feed.db_id))\n return",
"def new_article(self, article: Article):\n i... | [
"0.7528689",
"0.720418",
"0.692853",
"0.6921576",
"0.68620986",
"0.6790785",
"0.6565504",
"0.6422929",
"0.6280803",
"0.61094177",
"0.61025864",
"0.59953296",
"0.59412545",
"0.5922389",
"0.5911398",
"0.59093326",
"0.58722866",
"0.5855988",
"0.5800653",
"0.57411635",
"0.5739177... | 0.7575502 | 0 |
Outputs the context menu for items in the article view. | def handle_article_context_menu(self, mouse_position: qtc.QPoint) -> None:
index = self.indexAt(mouse_position)
if self.current_feed is None:
return
if index.isValid():
menu = qtw.QMenu()
article: Article = index.internalPointer()
if article.unr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addContextMenuItems(*args):",
"def aboutToShowContextMenuEvent(self):\n\t\tpass",
"def on_context_menu(self, event):\n self.declaration.context_menu_event()",
"def context_menu(self, treeview, position):\n\n all_item = get_current_item(self,treeview,single=False)\n\n if len(all_item) == 1:\n... | [
"0.6651524",
"0.6598063",
"0.6372928",
"0.63712347",
"0.62982005",
"0.6224799",
"0.6210352",
"0.6162146",
"0.6125073",
"0.6124531",
"0.6112677",
"0.6055606",
"0.60361797",
"0.60010666",
"0.5985895",
"0.5955026",
"0.5944541",
"0.59364676",
"0.59037983",
"0.5878168",
"0.5873257... | 0.65220815 | 2 |
Returns the number of rows. | def rowCount(self, parent: QtModelIndex = qtc.QModelIndex()) -> int:
# so index points to an article
if parent.isValid():
return 0
# must be the root index
return len(self.articles) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNumRows(self) -> int:\n ...",
"def row_count(self) -> int:\n return len(self.rows)",
"def row_count(self) -> int:\n return len(self.rows)",
"def num_rows(self):\n return (len(self.rows))",
"def get_num_rows(self):\n return self._num_rows",
"def num_rows(self):\n ... | [
"0.9179639",
"0.8805268",
"0.8805268",
"0.88044053",
"0.87689143",
"0.87461436",
"0.87428755",
"0.865783",
"0.85970724",
"0.8554916",
"0.84820026",
"0.8481867",
"0.8478176",
"0.8426226",
"0.8415246",
"0.83838",
"0.82410043",
"0.8194653",
"0.81584185",
"0.8157642",
"0.8137413"... | 0.0 | -1 |
Returns QModelIndex for given row/column. | def index(self, row: int, column: int, parent: QtModelIndex = qtc.QModelIndex()):
if not self.hasIndex(row, column, parent):
return qtc.QModelIndex()
return self.createIndex(row, column, self.articles[row]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(self, row, column, parent = QModelIndex()):\n return self.indexArray[row][column]",
"def index(self, row:int, column:int, parent:typing.Optional[QtCore.QModelIndex]=QtCore.QModelIndex()) -> QtCore.QModelIndex:",
"def index(self, row, column, parent):\n if not self._nodes:\n r... | [
"0.71273875",
"0.7005958",
"0.69426274",
"0.657195",
"0.65174204",
"0.64469796",
"0.614924",
"0.6024154",
"0.60059476",
"0.595161",
"0.59437287",
"0.5804318",
"0.5755155",
"0.5720788",
"0.5690307",
"0.5681916",
"0.56117994",
"0.55223745",
"0.5486678",
"0.5438419",
"0.5387351"... | 0.6433995 | 6 |
Returns parent of a node. Articles do not have children so returns an invalid index. | def parent(self, _):
return qtc.QModelIndex() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parent(self, node):\n self._validate_node(node)\n idx = node._index\n if idx == 0:\n return None # Root node has no parent\n if idx % 2 == 0:\n return self._array[(idx-2)//2] # Right child (even number)\n return self._array[(... | [
"0.795875",
"0.7762598",
"0.75650865",
"0.7379317",
"0.73673147",
"0.7256819",
"0.71715546",
"0.7133245",
"0.7133245",
"0.7133245",
"0.7114335",
"0.7103485",
"0.70317864",
"0.70058537",
"0.6993506",
"0.697455",
"0.69730943",
"0.6938846",
"0.69376767",
"0.692707",
"0.6875566",... | 0.6206074 | 87 |
Returns the number of columns in the model. ArticleModel only has 3 columns, title, author, and last updated. | def columnCount(self, parent: QtModelIndex = qtc.QModelIndex()):
return 3 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def no_of_columns(self): \n return len(self.columns) + (1 if self.serialize else 0)",
"def GetNumColumns(self):\n return len(self.columns)",
"def column_count(self):\n return self.column_length",
"def columns_count(self):\n if self.value.count != 0:\n return len(self.value[0... | [
"0.7493944",
"0.74314684",
"0.73839396",
"0.7204568",
"0.71249866",
"0.711785",
"0.7101345",
"0.70408726",
"0.7038658",
"0.6995142",
"0.6970979",
"0.69491917",
"0.69352484",
"0.69334954",
"0.69275934",
"0.68978137",
"0.68380296",
"0.68261844",
"0.6825118",
"0.6824466",
"0.677... | 0.64842874 | 34 |
Returns data about an index. | def data(self, index: QtModelIndex, role: int = 0):
if not index.isValid():
return None
article: Article = index.internalPointer()
if role in (qtc.Qt.DisplayRole, qtc.Qt.ToolTipRole):
if index.column() == 0:
return article.title
if index.colum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index(self):\n return dict(data='index')",
"def index(self):\n return self._data.get('index')",
"def get_index(self):\n with open(self.index_path, \"r\") as f:\n return json.load(f)",
"def index_stats(self):\r\n request = http.Request('GET', '/metadata/index_stats')... | [
"0.76539904",
"0.7606017",
"0.7443384",
"0.7309301",
"0.7210231",
"0.7181145",
"0.71791136",
"0.71590286",
"0.7089561",
"0.7078052",
"0.70224214",
"0.70119",
"0.7006514",
"0.6936691",
"0.6928603",
"0.68539524",
"0.68040735",
"0.68040735",
"0.68040735",
"0.68040735",
"0.680407... | 0.0 | -1 |
Resets whats in the display with new articles. Causes unselecting. | def set_articles(self, articles: list[Article]) -> None:
self.articles = articles
self.sort(self.view.header().sortIndicatorSection(), self.view.header().sortIndicatorOrder()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self) -> None:\n if self.current_feed is None:\n self.article_view_model.set_articles([])\n return\n self.article_view_model.set_articles(self.feed_manager.get_articles(self.current_feed.db_id))\n return",
"def _on_articles_restore(self, evt=None):\n ... | [
"0.62523764",
"0.61738473",
"0.6140437",
"0.6001737",
"0.58389306",
"0.5823976",
"0.57992846",
"0.5742654",
"0.5693008",
"0.5693008",
"0.5693008",
"0.5693008",
"0.5662991",
"0.5656526",
"0.56553006",
"0.56271464",
"0.5616422",
"0.5616422",
"0.5610246",
"0.55862",
"0.5586073",... | 0.5943696 | 4 |
Emits a change in the unread status for a row in the article view. | def update_row_unread_status(self, index: qtc.QModelIndex):
row = index.row()
self.dataChanged.emit(self.index(row, 0), self.index(row, 0), [qtc.Qt.FontRole]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_article_unread_status(self, feed: Feed, article: Article, status: bool) -> None:\n if article.unread != status:\n article.unread = status\n with self._sqlite_connection:\n self._sqlite_connection.execute('''UPDATE articles SET unread = ? WHERE identifier = ? and ... | [
"0.6610092",
"0.6530086",
"0.6439915",
"0.61828715",
"0.5986247",
"0.59600705",
"0.59403056",
"0.5910061",
"0.5779649",
"0.5748323",
"0.5737033",
"0.5721297",
"0.56960934",
"0.55976385",
"0.5596689",
"0.55765176",
"0.55692303",
"0.55309093",
"0.53931606",
"0.5327292",
"0.5294... | 0.765014 | 0 |
Emits a change in the flag status for a row in the article view. | def update_row_flag_status(self, index: qtc.QModelIndex):
row = index.row()
self.dataChanged.emit(self.index(row, 0), self.index(row, 0), [qtc.Qt.ForegroundRole]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toggle_article_flag(self, article: Article) -> None:\n article.flag = not article.flag\n with self._sqlite_connection:\n self._sqlite_connection.execute('''UPDATE articles SET flag = ? WHERE identifier = ? and feed_id = ?''', [article.flag, article.identifier, article.feed_id])",
"de... | [
"0.63821006",
"0.61166525",
"0.5987989",
"0.5966758",
"0.596424",
"0.56890976",
"0.5656554",
"0.56439316",
"0.56411874",
"0.56287074",
"0.55548453",
"0.5519157",
"0.5505614",
"0.5488021",
"0.53846645",
"0.53428745",
"0.5293014",
"0.5261896",
"0.521931",
"0.5217237",
"0.520577... | 0.732064 | 0 |
Updates an existing article in the model with data. | def update_article_data(self, article: Article):
if self.view.current_feed is not None and self.view.current_feed.db_id == article.feed_id:
i = next((i for i, v in enumerate(self.articles) if v.identifier == article.identifier), None)
if i is not None:
self.articles[i].__... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, request, slug=None, **kwargs):\n article_update = self.get_object()\n serializer = self.serializer_class(\n article_update, data=request.data, partial=True\n )\n serializer.is_valid(raise_exception=True)\n serializer.save()\n\n return Response(s... | [
"0.7651817",
"0.76141787",
"0.71987903",
"0.7115245",
"0.70210093",
"0.6938881",
"0.67697966",
"0.64585966",
"0.6399452",
"0.6370451",
"0.6368558",
"0.6308781",
"0.62674147",
"0.62632805",
"0.6221341",
"0.62098825",
"0.6172811",
"0.61564857",
"0.6107473",
"0.60481876",
"0.602... | 0.7509138 | 2 |
Updates the model with a new article. | def new_article(self, article: Article):
if self.view.current_feed is not None and self.view.current_feed.db_id == article.feed_id:
if self.view.header().sortIndicatorOrder() == qtc.Qt.AscendingOrder:
operation = operator.gt
else:
operation = operator.lt
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_article(db:Session, article_id:int, article: ArticleCreate):\n the_article:Article = db.query(ArticleModel).filter(ArticleModel.id==article_id).first()\n\n if the_article is None:\n raise HTTPException(status_code=404, detail=\"The article does not exist\")\n\n the_articl... | [
"0.7390678",
"0.7248694",
"0.702343",
"0.6823167",
"0.67694",
"0.66304827",
"0.6544919",
"0.6527448",
"0.6431118",
"0.6382377",
"0.6343061",
"0.6260893",
"0.6227372",
"0.62246823",
"0.62227994",
"0.61725914",
"0.6136117",
"0.60863453",
"0.60855955",
"0.60831356",
"0.608253",
... | 0.667911 | 5 |
Emits a signal that all data has changed in the model. | def update_all_data(self):
self.dataChanged.emit(qtc.QModelIndex(), qtc.QModelIndex()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_changed(self):\n self.data_changed_signal.emit(self)",
"def modelChanged(self) -> None:\n ...",
"def _modelUpdated(self, *args, **kwargs):\n topLeft = self.index(column=0)\n bottomRight = self.index(column=1)\n model = self.model()\n if model is not None:\n ... | [
"0.7643101",
"0.7086303",
"0.70106286",
"0.6857245",
"0.673427",
"0.6695307",
"0.6660293",
"0.6615431",
"0.6557781",
"0.64898545",
"0.6385076",
"0.6127341",
"0.60768676",
"0.60747784",
"0.60232943",
"0.5948149",
"0.59280175",
"0.59114075",
"0.58620363",
"0.5816855",
"0.577623... | 0.7485482 | 1 |
Returns the microphone coordinates for the 'nearfield' planar microphone array used in the 2016 experiments with the DARP openjet wind tunnel at the ISVR, Univ. of Southampton, UK [Casagrande Hirono, 2018]. The array is a Underbrink multiarm spiral array with 36 electret microphones, with 7 spiral arms containing 5 mic... | def DARP2016_MicArray():
M = 36 # number of mics
array_height = -0.49 # [m] (ref. to airfoil height at z=0)
# mic coordinates (corrected for DARP2016 configuration)
XYZ_array = np.array([[0., 0.025, 0.08477, 0.12044, 0.18311, 0.19394,
0.01559... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def atm241(coord: numpy.array) -> numpy.array:\n ...",
"def pipeRAFT(RAFTframe, offset=128, magFactor=2):\r\n return (RAFTframe.astype(np.float16)-offset)/magFactor",
"def _calc_R_T_amp(self, polarization, n, delta):\n t_amp = np.zeros((len(self.structure), len(self.structure)), dtype=complex)... | [
"0.5171409",
"0.49308997",
"0.4867823",
"0.47905356",
"0.4789269",
"0.47881353",
"0.47333372",
"0.4732265",
"0.4699188",
"0.46344298",
"0.45868972",
"0.4577852",
"0.45531473",
"0.45489898",
"0.45375",
"0.45370263",
"0.45357716",
"0.45343336",
"0.45169133",
"0.45138884",
"0.45... | 0.5984168 | 0 |
Saves the DARP2016_MicArray into a .xml file, compatile with Acoular. | def DARP2016_Acoular_XML():
XYZ_array, array_cal = DARP2016_MicArray()
array_name = "DARP2016"
array_pos = XML_mic(XYZ_array)
array_file = '<?xml version="1.0" encoding="utf-8"?>\n<MicArray name="{name}">\n{pos}</MicArray>'.format(
name=array_name, pos=array_pos)
calib_data = XML_calib(array... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eeg_writeavr(array,tsb,di,file):\t\t\n import shutil as shu\n f=open(file,'w')\n firstline = 'Npts= %i TSB= %i DI= %7.5f SB= %7.5f SC= %i NChan= %i\\n' %(array.shape[1],tsb,di,1,200,array.shape[0]) \n chnam = 'Cz FP1 FP2 F3 F4 C3 C4 P3 P4 O1 O2 F7 F8 T7 T8 P7 P8 Fz Pz FC1 FC2 CP1 ... | [
"0.62274456",
"0.61062884",
"0.5929423",
"0.5853379",
"0.5797951",
"0.57790774",
"0.5768997",
"0.57282346",
"0.5721275",
"0.5709641",
"0.56996006",
"0.56984556",
"0.56654245",
"0.5662644",
"0.56422096",
"0.563271",
"0.5609935",
"0.55975944",
"0.5596958",
"0.5585382",
"0.55847... | 0.7865407 | 0 |
Fix graph data to make it easier to create big graphs. | def process_graph_data(graph_data):
graph_data = deepcopy(graph_data)
for username, info in six.iteritems(graph_data):
# Leave only users with followers info (do not draw huge amount
# of isolated nodes).
info['followers'] = [
f
for f in info.get('followers', [])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_edges(self):",
"def _clean_graph(self):\n for entry_node in self._entry_nodes:\n self._clean_graph_visit(entry_node.get_func_first_node(), {})",
"def reset_graph(self):\n raise NotImplementedError",
"def force_update_graph(self):\n self.updated_data = 1\n self... | [
"0.6939662",
"0.6441675",
"0.6328599",
"0.6206532",
"0.62063557",
"0.61472076",
"0.61259884",
"0.6083007",
"0.60412323",
"0.60402787",
"0.6032492",
"0.59855205",
"0.5852771",
"0.5843403",
"0.58292115",
"0.5812169",
"0.5806837",
"0.57778037",
"0.57677764",
"0.5756598",
"0.5752... | 0.5404651 | 40 |
Shrink avatar image and do some postprocessing. | def process_avatar(data):
image = Image.open(BytesIO(data))
width, height = image.size
mask = Image.new('RGBA', (width, height), (255, 255, 255, 0))
draw = ImageDraw.Draw(mask)
draw.ellipse([0, 0, width, height], fill=(255,255,255,255))
mask.paste(image, mask=mask)
image = mask
image.th... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_image(image):\n image = resize(image)\n return image",
"def resize_profile_pic(sender, instance, **kwargs):\n profile_pic = instance.profile_picture\n if profile_pic.name != \"default.png\":\n img = Image.open(profile_pic.path)\n if img.height > 300 or img.width > 300:\n ... | [
"0.66625637",
"0.65486157",
"0.6045244",
"0.6032749",
"0.5992063",
"0.5970083",
"0.590588",
"0.5903275",
"0.5806341",
"0.57078165",
"0.568309",
"0.5656099",
"0.5650112",
"0.5643821",
"0.5613983",
"0.56020075",
"0.55950457",
"0.55913794",
"0.554321",
"0.5542441",
"0.55221635",... | 0.6294971 | 2 |
Load the required file into mongodb using mongoimport | def load_document(self, file_type, file_name):
status, output = commands.getstatusoutput("mongoimport -h %s -p %s -u %s -p %s -d %s -c %s --type %s --file %s --headerline" % (self.host, self.port, self.username, self.password, self.db_name, self.collection_name, file_type, file_name))
print "status is... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mongoRestore( self, db, infile ):\n\t\tsys_command = \"mongorestore --db \" + db + \" --host \" + self.host + \" --port \" + str( self.port ) + \" \" + infile \n\t\tos.system(sys_command)",
"def import_db(import_file):\n import_data(import_file)",
"def load_testdata(collection_name, testdata):\n # if... | [
"0.6712259",
"0.6410431",
"0.64037097",
"0.6304399",
"0.62620705",
"0.6164453",
"0.6146136",
"0.6092976",
"0.60046375",
"0.5832102",
"0.5781586",
"0.57550126",
"0.57142764",
"0.56969416",
"0.56405246",
"0.5624535",
"0.56068236",
"0.5585002",
"0.5537288",
"0.5528605",
"0.55106... | 0.7651893 | 0 |
Methode zum Einlesen eines CSVFiles. | def readCSV(self):
content = []
with open(self.filename) as file:
sn = csv.Sniffer()
sn.preferred = [self.delimiter]
try:
dialect = sn.sniff(file.read(1024))
except csv.Error:
if not file.endswith("csv"):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv_file(self):\n pass",
"def _read_csv(self):\n self.function_name = '_read_csv'\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\n reader = csv.reader(csv_file, dialect='excel')\n for row in reader:\n self.input_data.a... | [
"0.67021495",
"0.66796035",
"0.6415525",
"0.63893783",
"0.63571215",
"0.63571215",
"0.62839496",
"0.61973256",
"0.6178916",
"0.6149338",
"0.6148069",
"0.61026734",
"0.6032901",
"0.59973955",
"0.59870076",
"0.59391886",
"0.58932555",
"0.5849343",
"0.58126485",
"0.5796141",
"0.... | 0.0 | -1 |
Methode zum Schreiben eines CSVFiles aus einem anderen CSVFile | def writeCSV(self, outfilename, delimiter=';'):
input = open(self.filename)
dialect = csv.Sniffer().sniff(input.read(1024))
input.seek(0)
reader = csv.reader(input, dialect)
out = open(outfilename, "w")
writer = csv.writer(out, delimiter=delimiter, quotechar='"', quoting... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv_file(self):\n pass",
"def _read_csv(self):\n self.function_name = '_read_csv'\n with open(os.path.join(self.task.downloads, self.csv_name)) as csv_file:\n reader = csv.reader(csv_file, dialect='excel')\n for row in reader:\n self.input_data.a... | [
"0.69853",
"0.6747482",
"0.6666084",
"0.65843564",
"0.6577182",
"0.6577182",
"0.6503296",
"0.6310463",
"0.6302597",
"0.6264757",
"0.6225793",
"0.6219438",
"0.62006885",
"0.6180105",
"0.6176315",
"0.60076016",
"0.5969665",
"0.59524417",
"0.59426814",
"0.59176123",
"0.59046376"... | 0.0 | -1 |
the functions first requests all mutual friends of a given vk id and returns a dict with mutual connection per each friend filtering DELETED profiles | def get_edges(profile_id: str, friends: list, token: str, api_version: str) -> dict:
method = 'friends.getMutual'
mutuals = {}
for friend in tqdm(friends):
friend_id = friend['id']
prefix = 'https://api.vk.com/method'
url = f'{prefix}/{method}?source_uid={profile_id}&target_uid={frie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_friends_graph():\n total_users = 0\n count_bad_users = 0\n count_graph_users = 0\n\n result = \"was successful\"\n\n settings.print_message(\"Create VK session for application (app_id={})\".format(settings.VK_APPLICATION_ID))\n logger.debug(\"Create VK session for application (app_id={}).... | [
"0.63382936",
"0.63358456",
"0.6259757",
"0.6252056",
"0.6225435",
"0.62156093",
"0.61834365",
"0.6100285",
"0.6092287",
"0.60497373",
"0.60433984",
"0.5978931",
"0.5970519",
"0.5951681",
"0.59398526",
"0.59226376",
"0.5862549",
"0.5838718",
"0.5835135",
"0.58246464",
"0.5815... | 0.79206866 | 0 |
build a graph from list of friends' vk profiles and mutual connections | def build_graph(friends: list, mutuals: dict) -> nx.classes.graph.Graph:
friends_ids = [friend['id'] for friend in friends]
G = nx.Graph()
G.add_nodes_from(range(len(friends_ids)))
for idx in tqdm(friends_ids):
node_id = friends_ids.index(idx)
G.nodes[node_id]['vk_id'] = idx
G.n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_edges(profile_id: str, friends: list, token: str, api_version: str) -> dict:\n method = 'friends.getMutual'\n mutuals = {}\n for friend in tqdm(friends):\n friend_id = friend['id']\n prefix = 'https://api.vk.com/method'\n url = f'{prefix}/{method}?source_uid={profile_id}&targe... | [
"0.7373844",
"0.73058623",
"0.69654953",
"0.6886941",
"0.6845271",
"0.6301224",
"0.62846696",
"0.62353754",
"0.61969024",
"0.61596584",
"0.6117445",
"0.6060678",
"0.60371196",
"0.6020928",
"0.5997839",
"0.5956715",
"0.59347546",
"0.59099835",
"0.5846529",
"0.5822966",
"0.5815... | 0.75277764 | 0 |
this function will request friends list using VK API and save it as Graph where nodes are people and edges are connections between friends | def main(user_id: str, token: str, api_version, filename: str):
method = 'friends.get'
fields='sex,city,country,relation,universities,schools,tv,career,interests'
prefix = 'https://api.vk.com/method'
url = f'{prefix}/{method}?user_id={user_id}&fields={fields}&v={api_version}&access_token={token}'
fr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_friends_graph():\n total_users = 0\n count_bad_users = 0\n count_graph_users = 0\n\n result = \"was successful\"\n\n settings.print_message(\"Create VK session for application (app_id={})\".format(settings.VK_APPLICATION_ID))\n logger.debug(\"Create VK session for application (app_id={}).... | [
"0.73703367",
"0.7214081",
"0.70524794",
"0.701246",
"0.66725916",
"0.65180856",
"0.644704",
"0.64067024",
"0.6397014",
"0.6273536",
"0.6258503",
"0.62192756",
"0.6215325",
"0.6207193",
"0.6181686",
"0.61775523",
"0.6171369",
"0.6144551",
"0.61109245",
"0.60917157",
"0.608746... | 0.69270384 | 4 |
Check CloudFormation IamInstanceProfile Parameters | def match(self, cfn):
matches = []
# Build the list of keys
trees = cfn.search_deep_keys('Fn::GetAtt')
# Filter only resoureces
# Disable pylint for Pylint 2
# pylint: disable=W0110
trees = filter(lambda x: x[0] == 'Resources', trees)
for tree in trees:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_instance_profile_exists(self) -> None:\n self.assertTrue(self.validate_instance_profile('s3-access-role', is_prod=self.prod_env))",
"def validate_instance_profile(self, role_name: str, is_prod: bool = True):\n if is_prod:\n env = \"prod\"\n else:\n env = \"dev\... | [
"0.65391284",
"0.5888025",
"0.581056",
"0.5371838",
"0.53260696",
"0.5325196",
"0.5248058",
"0.5132747",
"0.5130321",
"0.5122862",
"0.5112415",
"0.51014984",
"0.50906956",
"0.5066749",
"0.5050428",
"0.5037698",
"0.5021853",
"0.50214833",
"0.5020872",
"0.49840295",
"0.49833837... | 0.45581535 | 74 |
The Add Processed Image function takes in the different parameters of the original image of the image, adds them to a database, and returns a .json file. | def add_processed_image(image_proc_type, name, b64_string, export_file_type):
if image_proc_type == "contrast stretching":
info = process_contrast_stretch(name, b64_string, export_file_type)
metrics_list = list(info[4])
num_pixels = metrics_list[0]
x_coord = metrics_list[1]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addImg(in_dict):\n img = Image(name=in_dict[\"name\"],\n b64str=in_dict[\"b64str\"],\n imgsize=in_dict[\"imgsize\"],\n processed=in_dict[\"processed\"],\n timestamp=in_dict[\"timestamp\"])\n ans = img.save()\n return ans.name",
"def add_ima... | [
"0.7195162",
"0.69798815",
"0.6826571",
"0.67380214",
"0.66950214",
"0.65448",
"0.6514869",
"0.64931726",
"0.64848965",
"0.6476641",
"0.64622957",
"0.6457819",
"0.64088136",
"0.6382021",
"0.63806343",
"0.6376806",
"0.6376497",
"0.636513",
"0.6362809",
"0.63574505",
"0.6326902... | 0.6710337 | 4 |
check_proc_type function checks to make sure image_proc_type is a string | def check_proc_type(image_proc_type):
if isinstance(image_proc_type, str):
return True
else:
logging.warning('Image processing type is not a string')
print('Please choose only one processing technique.')
raise ValueError('Please choose only one processing technique.') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_type(filename):\n try:\n im = Image.read(filename)\n except SanperaError:\n return False\n else:\n return im.original_format in [b'JPEG', b'PNG', b'GIF']",
"def is_valid_instance_type(image, instancetype):\n if not is_valid_image(image):\n return False\n\n if ... | [
"0.6204283",
"0.61802596",
"0.6027018",
"0.5975448",
"0.58357644",
"0.5832431",
"0.58170027",
"0.5793092",
"0.57521164",
"0.5702733",
"0.5698444",
"0.56756866",
"0.5604621",
"0.5603396",
"0.5597974",
"0.5592912",
"0.5566657",
"0.5556909",
"0.55315816",
"0.5526065",
"0.5519633... | 0.8995537 | 0 |
This function is used to parse using Selenium Webdriver skywalker's start urls | def parse(self, response):
s = Selector(response)
page_nums = s.xpath('//ul[@class="paging-container"]//a[not(@class="current")]/@data-page').extract()
if page_nums:
last_page = int(page_nums[-1])
else:
last_page = 2
for page in range(1, last_page):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_start_url(self, response):\n self.parse_obj(response)",
"def start_requests(self):\r\n try:\r\n\r\n for url in self.start_urls:\r\n yield scrapy.Request(url,\r\n callback=self.navigate_to)\r\n except Exception as err:\r\... | [
"0.66061246",
"0.6511122",
"0.6243218",
"0.61999667",
"0.6184247",
"0.6030458",
"0.5822003",
"0.58178216",
"0.5758798",
"0.5756209",
"0.5732387",
"0.57283366",
"0.5673722",
"0.5628558",
"0.5621076",
"0.56177944",
"0.5603927",
"0.5594917",
"0.5573787",
"0.55513203",
"0.5547272... | 0.0 | -1 |
This function is used to parse job posting websites that are hidden with JS | def parse_inner_urls(self, response):
s = Selector(response)
jobs_per_site = s.xpath('//div[@class="col-lg-12 col-md-12 col-sm-12 aggelia-view-title"]//a/@href').extract()
print(jobs_per_site)
for inner_site in jobs_per_site:
url = urljoin("https://www.skywalker.gr/", inner... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def each_job(url, header, empty_list):\n time.sleep(2)\n \n response = requests.get(url, headers=header)\n soup = BeautifulSoup(response.text, 'html.parser')\n# code for scraping technology required\n# making target variable out of this column, doing try & except so i can later drop row from df\n te... | [
"0.6127704",
"0.5971106",
"0.56638265",
"0.56530917",
"0.56359464",
"0.55993545",
"0.55926394",
"0.55331105",
"0.5514177",
"0.5509883",
"0.5505712",
"0.53881395",
"0.53608257",
"0.53543705",
"0.5307361",
"0.5305151",
"0.5270828",
"0.5266578",
"0.526253",
"0.52535903",
"0.5249... | 0.5853257 | 2 |
This function is used to parse required items from skywalkers inner job posting URLs | def parse_items(self, response):
items = JobcrawlerItem()
current_date = datetime.now()
current_date_str = current_date.strftime("%b %d %Y %H:%M:%S")
items["timestamp"] = current_date_str
items["site"] = self.allowed_domains[0]
items["full_html"] = response.text
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_inner_urls(self, response):\n s = Selector(response)\n\n jobs_per_site = s.xpath('//div[@class=\"col-lg-12 col-md-12 col-sm-12 aggelia-view-title\"]//a/@href').extract()\n print(jobs_per_site)\n\n for inner_site in jobs_per_site:\n url = urljoin(\"https://www.skywal... | [
"0.6349358",
"0.6019938",
"0.60178125",
"0.59743893",
"0.5815302",
"0.5783507",
"0.57422364",
"0.567971",
"0.5663422",
"0.5663118",
"0.56026596",
"0.5588058",
"0.5546029",
"0.5514448",
"0.54864025",
"0.54769623",
"0.54708314",
"0.54693955",
"0.5353453",
"0.5291266",
"0.525565... | 0.624414 | 1 |
Step to create domain. | def create_domain(self, domain_name, check=True):
domain = self._client.create(domain_name)
if check:
self.check_domain_presence(domain)
return domain | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_domain(DomainName=None):\n pass",
"def createDomain(self):\n if not self.rank:\n logging.info('Creating domain')\n\n if 'box' in self.pargs:\n self.lmp.command('region domain block ' + ('{} ' * len(self.pargs['box'])).format(*self.pargs['box']) + ' units box volume_limit 1e-20')\n ... | [
"0.7444622",
"0.7167191",
"0.7166453",
"0.7118087",
"0.7098876",
"0.6909484",
"0.6714616",
"0.66999555",
"0.6681161",
"0.66756535",
"0.65850854",
"0.6541014",
"0.65184814",
"0.6485162",
"0.6467591",
"0.64588976",
"0.64123565",
"0.6393422",
"0.6371453",
"0.63318425",
"0.630757... | 0.6124499 | 23 |
Step to delete domain. | def delete_domain(self, domain, check=True):
self._client.update(domain, enabled=False)
self._client.delete(domain.id)
if check:
self.check_domain_presence(domain, present=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_domain(DomainName=None):\n pass",
"def delete(self):\r\n return self.connection.delete_domain(self)",
"def test_delete_email_domain(self):\n email_dom = 'delete.domain.loc'\n domain = SpokeEmailDomain(self.org_name)\n domain.create(email_dom)\n self.assertTrue(d... | [
"0.7501985",
"0.70844585",
"0.7071078",
"0.6848985",
"0.6673037",
"0.6643116",
"0.65499026",
"0.6548483",
"0.6412439",
"0.63015497",
"0.6281227",
"0.62730366",
"0.6213483",
"0.61616504",
"0.61217254",
"0.60690784",
"0.60447174",
"0.60137147",
"0.59966785",
"0.59609747",
"0.59... | 0.63397664 | 9 |
Verify step to check domain is present. | def check_domain_presence(self, domain, present=True, timeout=0):
def predicate():
try:
self._client.get(domain.id)
return present
except Exception:
return not present
wait(predicate, timeout_seconds=timeout) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_validate_domain_ok():\n domain = 'python.org'\n assert howisresolved.validate_domain(domain) is None",
"async def test_domain(self, dm):\n request = create_request(\"domain\", \"other\")\n result = await dm.apply_handler(request, create_responder(request))\n assert result.dial... | [
"0.7537094",
"0.6602164",
"0.64030236",
"0.63097614",
"0.6289632",
"0.62611425",
"0.6170221",
"0.6095127",
"0.60865396",
"0.5973214",
"0.5949849",
"0.5928781",
"0.59063774",
"0.58637065",
"0.5860864",
"0.5840164",
"0.58392",
"0.5829409",
"0.5825436",
"0.58174586",
"0.5809893"... | 0.62441576 | 6 |
Initializes the analyticsreporting service object. | def initialize_analyticsreporting():
# Parse command-line arguments.
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
parents=[tools.argparser])
flags = parser.parse_args([])
# Set up a Flow object to be used if we need to authenticate.
flow = client.flow_fr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_analyticsreporting():\n\n # Build the credentials object\n credentials = ServiceAccountCredentials.from_json_keyfile_name(\n KEY_FILE_LOCATION, SCOPES,\n )\n # Build the service object.\n analytics = build('analyticsreporting', 'v4', credentials=credentials)\n return analyti... | [
"0.84118545",
"0.83185613",
"0.8291747",
"0.8291747",
"0.8290348",
"0.8255288",
"0.8019429",
"0.795491",
"0.7928452",
"0.7186668",
"0.6910602",
"0.6881222",
"0.64970446",
"0.629748",
"0.62877536",
"0.62106377",
"0.60482335",
"0.601728",
"0.5947214",
"0.59452003",
"0.58718574"... | 0.7967196 | 7 |
Parses and prints the Analytics Reporting API V4 response | def parse_response(response):
data = []
for report in response.get('reports', []):
columnHeader = report.get('columnHeader', {})
dimensionHeaders = columnHeader.get('dimensions', [])
metricHeaders = columnHeader.get('metricHeader', {}).get('metricHeaderEntries', [])
rows = report.get('data', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_response(response):\n #fyi this is not my code, i grabbed it from github\n #forgot to copy the url though\n for report in response.get('reports', []):\n columnHeader = report.get('columnHeader', {})\n dimensionHeaders = columnHeader.get('dimensions', [])\n metricHeaders = co... | [
"0.70300174",
"0.68019956",
"0.6672298",
"0.6622375",
"0.6249132",
"0.6025547",
"0.5922307",
"0.5881789",
"0.58773905",
"0.58267134",
"0.5765782",
"0.56859326",
"0.5605776",
"0.5571559",
"0.5417549",
"0.5388267",
"0.5385482",
"0.5354932",
"0.5345264",
"0.5321222",
"0.52982104... | 0.6589694 | 4 |
(Stack, object) > NoneType Push e onto the top of the stack | def push(self, e):
# put e at the head of the linked list
node = Node(e, next=self._head)
# Make self._head point to new beginning of list
self._head = node
# Could also do the following, as long we we defined the Node's
# __init__ method to be able to take a "next" argu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_push_on_empty_stack(empty_stack): \n empty_stack.push([1, 'Good Boy'])\n assert empty_stack.top.val == [1, 'Good Boy']",
"def exp_push(self, what: Any) -> None:\n self.exp_stack.appendleft(what)",
"def __init__(self):\n self.stack=[]\n self.top1=-1\n ",
"def push(va... | [
"0.7081698",
"0.6955321",
"0.679092",
"0.67815316",
"0.6778989",
"0.67295027",
"0.6569304",
"0.6556262",
"0.6555656",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.6550413",
"0.65434164",
... | 0.58680403 | 88 |
Stack > object Remove and return the top element on the stack | def pop(self):
# pop the element at the head of the linked list
# Gets data from first node
data = self._head.data
# Remove first node
self._head = self._head.next
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self):\n return self.stack_list.pop()",
"def pop(stack):\n item = top(stack)\n stack.top = stack.top.next\n stack.size = stack.size - 1\n return item",
"def pop(self) -> object:\n if self.is_empty()== True: # if size of array is 0, raise exception\n raise StackExc... | [
"0.8445976",
"0.80671614",
"0.80513096",
"0.79186106",
"0.78085864",
"0.77599984",
"0.7755734",
"0.7738639",
"0.7728655",
"0.7706104",
"0.77042",
"0.76796746",
"0.7634128",
"0.7632137",
"0.76308244",
"0.76254165",
"0.7616855",
"0.75980705",
"0.7593751",
"0.7591183",
"0.757907... | 0.0 | -1 |
Stack > bool Return whether or not the stack is empty | def is_empty(self):
# This is worse style: "return self._head == None"
return self._head is None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def empty_stack(stack):\n if stack.top is None:\n return True\n else:\n return False",
"def empty(self) -> bool:\n if len(self.stack)==0:\n return True\n else:\n return False",
"def is_empty(self):\n return len(self.the_stack) == 0",
"def empty(s... | [
"0.90861845",
"0.9019258",
"0.89500016",
"0.8855821",
"0.88420206",
"0.8841628",
"0.88128847",
"0.8804475",
"0.8804475",
"0.8757786",
"0.86839235",
"0.8648283",
"0.8636743",
"0.86028844",
"0.86028844",
"0.8566519",
"0.85590136",
"0.8550461",
"0.8482702",
"0.84803367",
"0.8475... | 0.70601845 | 80 |
X = [lon, lat, z] K = [k, l , m] Keep Initial Conditions | def __init__(self, X, K, t0, lonpad=1.5, latpad=1.5, tpad=7):
self.X0 = X[:]
self.K0 = K[:]
self.t0 = t0
self.p0 = .02 # random number must be assigned
self.F = gemFuncs() # generate gem functions
self.lonlim, self.latlim, self.tlim = self.F.createFuncs(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def kxyz(self, k: int) -> Point:\n x = self._read_inline(f\"kx({k})\")\n y = self._read_inline(f\"ky({k})\")\n z = self._read_inline(f\"kz({k})\")\n return Point(x, y, z)",
"def find_points(z_k, r, offset_x1=0, offset_x2=0):\n # Assume nu_0 < 0, nu_1 > 0\n t_min = z_k.t_min\n ... | [
"0.6217022",
"0.6040834",
"0.59045315",
"0.5842696",
"0.56379586",
"0.5634639",
"0.56162107",
"0.54975593",
"0.5446809",
"0.540241",
"0.53888613",
"0.5348579",
"0.53472006",
"0.53458637",
"0.5344075",
"0.5328821",
"0.53279793",
"0.5314274",
"0.52960455",
"0.5279399",
"0.52741... | 0.5683767 | 4 |
Training with the iter for validation | def train_with_iter(epoch, interval, batch_iter):
alpha = 1
model.train()
# set the random seed for torch.generator() to shuffle the dataset
trainSampler.set_epoch(epoch)
if hvd.rank() == 0:
print("="*50)
if args.use_ldamloss:
loss_weights = drw_weights(epoch, data_samples)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self):\n self.dataGenerator.printDataStatistics()\n sE = len(self.dataGenerator.ids[\"train\"])// 32\n sV = len(self.dataGenerator.ids[\"validation\"])// 32\n self.model.fit_generator(\n generator=self.dataGenerator.trainingGenerator,\n steps_per_epoch= s... | [
"0.77262723",
"0.7654218",
"0.7504014",
"0.74826247",
"0.74515194",
"0.74515194",
"0.74515194",
"0.74515194",
"0.74515194",
"0.7363969",
"0.7338752",
"0.72962505",
"0.728416",
"0.7278478",
"0.7277872",
"0.7261149",
"0.7237839",
"0.72250354",
"0.72216016",
"0.7198731",
"0.7197... | 0.0 | -1 |
Pick a bunch of digits from MNIST dataset. Input ns = [n1,n2,n3, ...] digits = [1,2,3, ....] both must be the same length. ns contais the number of items for each class determined by digits. Output original images (vector) extracted shapes true labels | def pick_data(ns, digits):
f = gzip.open('data/mnist.pkl.gz', 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()
images, labels = train_set
originals = [];
shapes = [];
true_labels = [];
i = 0
for n, d in zip(ns, digits):
# picking n elements with digit d
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_mnist(dataset=\"training\", digits=np.arange(10), path=\".\"):\n\n if dataset == \"training\":\n fname_img = os.path.join(path, 'train-images-idx3-ubyte')\n fname_lbl = os.path.join(path, 'train-labels-idx1-ubyte')\n elif dataset == \"testing\":\n fname_img = os.path.join(path, ... | [
"0.70157707",
"0.68392736",
"0.67331785",
"0.6488756",
"0.64213294",
"0.6419488",
"0.6350414",
"0.63167334",
"0.62259847",
"0.622325",
"0.621732",
"0.6193779",
"0.61323136",
"0.6043401",
"0.60221046",
"0.5988012",
"0.59595597",
"0.5959284",
"0.59491557",
"0.5924892",
"0.58634... | 0.7900158 | 0 |
Dispatches metrics streamed by collector | def StreamMetrics(self, request_iterator, context):
LOG.debug("StreamMetrics called")
# set up arguments
collect_args = (next(request_iterator))
max_metrics_buffer = 0
max_collect_duration = 0
cfg = Metric(pb=collect_args.Metrics_Arg.metrics[0])
try:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dispatch_metrics(self, payload):\n for item in payload:\n try:\n self._ingest.send(gauges=item['gauges'], counters=item['counters'])\n except Exception as e:\n self._logger.error(\"Exception while sending payload to ingest : {0}\".format(e))",
"def ... | [
"0.70055574",
"0.6102931",
"0.60963494",
"0.6073839",
"0.60243076",
"0.6016677",
"0.5912792",
"0.5852973",
"0.57769173",
"0.57684577",
"0.57476234",
"0.57459253",
"0.57440335",
"0.5738102",
"0.5669972",
"0.56475574",
"0.562813",
"0.5589964",
"0.5565725",
"0.55005115",
"0.5425... | 0.648967 | 1 |
Dispatches the request to the plugins update_catalog method | def GetMetricTypes(self, request, context):
LOG.debug("GetMetricTypes called")
try:
metrics = self.plugin.update_catalog(ConfigMap(pb=request.config))
return MetricsReply(metrics=[m.pb for m in metrics])
except Exception as err:
msg = "message: {}\n\nstack tra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, catalog: Metadata, action: str):\n self._insert_request(self.update_queue, catalog, action)",
"def update_catalog(self, *args, **kwargs):\n # Implemented from kitosid template for -\n # osid.resource.BinAdminSession.update_bin\n # OSID spec does not require returning ... | [
"0.65742266",
"0.6343348",
"0.597685",
"0.5945859",
"0.5700017",
"0.5699237",
"0.5685024",
"0.56759524",
"0.56214786",
"0.56193507",
"0.5605091",
"0.5439433",
"0.5439433",
"0.5439433",
"0.54374146",
"0.54139704",
"0.5389444",
"0.53817743",
"0.53774446",
"0.53708696",
"0.53693... | 0.0 | -1 |
Initialize your data structure here. | def __init__(self):
self.root = TrieNode() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__... | [
"0.7765608",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7595176",
"0.75853467",
"0.7558298",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.74971247",
"0.74971247",
"0.7478105",
"0.7477832",
"0.7477832",
"0.7477832",
... | 0.0 | -1 |
Copy the next node to the middle node, then delete the next node. | def del_middle_node(node):
next_node = node.next
node.value = next_node.value
node.next = next_node.next
next_node.next = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def del_middle_node(node):\n if node == None or node.next == None:\n return\n\n node.data = node.next.data\n node.next = node.next.next",
"def _delete(self):\n self.prev.next = self.next\n self.next.prev = self.prev",
"def middleNode(self, head: Optional[ListNode]) -> Optional[Lis... | [
"0.7971518",
"0.63340133",
"0.62391603",
"0.6204981",
"0.6087874",
"0.60737926",
"0.6041707",
"0.603408",
"0.6032834",
"0.5998454",
"0.5897227",
"0.58756375",
"0.58752173",
"0.57978374",
"0.57974494",
"0.57950276",
"0.5794725",
"0.5786917",
"0.5765584",
"0.5761735",
"0.575359... | 0.8157871 | 0 |
sets the new center for all the basis functions | def set_center(self,structure):
for i,b in enumerate(self.bfs):
b.set_center( structure[ self.LIST1[i] ] )
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_center(self): \r\n \r\n self.grfx[0].center = self.center\r\n\r\n self.update_bbox()",
"def _set_center(self):\n sl_center = np.array(\n [self.sl_list[k].mean_pos for k in range(self.nb_sl)]\n )\n sl_nb_pts = np.array(\n [self.sl_list[k].nb_points fo... | [
"0.72818935",
"0.700697",
"0.66382223",
"0.66292685",
"0.6628437",
"0.655335",
"0.6530293",
"0.65248847",
"0.649866",
"0.6433271",
"0.6419035",
"0.6309602",
"0.63081056",
"0.6298524",
"0.6280932",
"0.6243688",
"0.6211691",
"0.618607",
"0.618607",
"0.618607",
"0.618607",
"0.... | 0.7330404 | 0 |
return list of atom numbers in bfs order (atom numbers are in Python N1 onvention) | def get_bfsl(self):
return array(self.LIST1,int) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def order_bfs(self) -> List[Nodo]:\n\n # Nodos por buscar, es una cola\n pending: List[Nodo] = [self.root]\n # Nodos ya visitados\n visited: List[Nodo] = []\n\n # Mientras la cola tenga items\n while len(pending) > 0:\n # Procesar el primer elemento\n ... | [
"0.6404996",
"0.6225819",
"0.6008345",
"0.59834677",
"0.59646535",
"0.5959953",
"0.593469",
"0.5896187",
"0.5869717",
"0.58591187",
"0.5834373",
"0.5756882",
"0.5729196",
"0.5724245",
"0.569988",
"0.56207097",
"0.5543277",
"0.5542798",
"0.5524622",
"0.5483266",
"0.5472293",
... | 0.5856983 | 10 |
return list of AO types as tuples | def get_bfst(self):
return array(self.LIST2,int) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def typenames(self):\n return tuple((item[0] for item in self))",
"def gettypes(self):\n return [str(self.sd.xlate(t[0])) for t in self.sd.types]",
"def getTypes():\n\t\n\ttranslationTable = []\n\tfor x in typePrimitive:\n\t\ttranslationTable.extend(x[0])\n\t\n\tid = 0\n\ttypes = []\n\tmax = 0\n\... | [
"0.6912616",
"0.65441954",
"0.6470001",
"0.6461701",
"0.6139872",
"0.60317516",
"0.6009162",
"0.59679914",
"0.5884908",
"0.58693093",
"0.5828851",
"0.58188605",
"0.5807686",
"0.57827395",
"0.57802755",
"0.5749791",
"0.5746682",
"0.57454276",
"0.5736468",
"0.5731122",
"0.57146... | 0.0 | -1 |
Automatically call prior to each testcase to check the value of dp_setup.setup_status and skip testcase if zero | def setup_status_check(dp_setup):
if dp_setup.setup_status == 0:
pytest.skip("Skipping testcase because setup \
did not complete properly") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n if not self.flag:\n self.fail(self.err_msg)",
"def _dpdk_pre_post_flight_check(self):\n with self.assertRaises(\n zaza.model.CommandRunFailed,\n msg='openvswitch-switch-dpdk unexpectedly installed'):\n self._openvswitch_switch_d... | [
"0.6697237",
"0.6449809",
"0.6417722",
"0.63475215",
"0.6312798",
"0.63067997",
"0.6280792",
"0.6267606",
"0.6237606",
"0.6232953",
"0.6168967",
"0.6137572",
"0.6071447",
"0.6061301",
"0.60566294",
"0.5981247",
"0.5977145",
"0.5973348",
"0.597259",
"0.59627193",
"0.59577906",... | 0.86521524 | 0 |
cal takes a string as a parameter. It executes the sql and returns the output as a list of tuples. | def cal(sql):
try:
db = psycopg2.connect(dbname="news")
c = db.cursor()
c.execute(sql)
car = c.fetchall()
db.close()
return car
except Exception:
print("Unable to connect to the database") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_with_results(string, args):\n con = connect()\n cursor = con.cursor()\n results = cursor.execute(string, args).fetchall()\n con.close()\n return results",
"def sql_select(self, sqlstr):\n conn = sqlite3.connect('./as400-sqlite-test.db')\n cur = conn.cursor()\n cur.execute(sqls... | [
"0.5887786",
"0.5854971",
"0.5711145",
"0.5693882",
"0.56683975",
"0.56478006",
"0.5559393",
"0.5495691",
"0.54940605",
"0.5488748",
"0.54423237",
"0.5426292",
"0.5425873",
"0.5416398",
"0.53532416",
"0.5326119",
"0.5309507",
"0.53088915",
"0.52948564",
"0.5293744",
"0.528860... | 0.6434578 | 0 |
Get a room's peer host id. | def get(self, room_id):
room = redis_store.get(room_id)
if room is None:
# raise 404
raise ResourceDoesNotExist('Resource not found.')
else:
room = loads(room)
return {'host_id': room.get('host_id')} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPeer(self):\n return \"Peer:PID:\" + str(self.transport.pid)",
"def _LookupPeer(self, peer_id):\n key = self._GetServerKey(peer_id)\n values, placemark = self._dht.Get(key)\n if not values:\n raise NessieError('No peers returned for user id %r.' % peer_id)\n # NOTE(damonkohler): Ne... | [
"0.69762284",
"0.6663655",
"0.6621731",
"0.6372688",
"0.6349436",
"0.6220572",
"0.6173263",
"0.6005997",
"0.5927906",
"0.5926434",
"0.5853759",
"0.5814547",
"0.5752682",
"0.5717726",
"0.5714166",
"0.57134604",
"0.5711973",
"0.5706656",
"0.5688529",
"0.5687277",
"0.56785816",
... | 0.59975874 | 8 |
Delete a room from public listing. | def delete(self, room_id):
# Check for Authorization header in the form of "Bearer <token>"
if "Authorization" not in request.headers:
raise AuthorizationError("No password specified")
temp_pass = request.headers.get("Authorization").split(" ")[1]
room = redis_store.get(room... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def room_delete(room_id):\n room = Room.query.get(room_id)\n if room is None:\n abort(404, 'room not found')\n\n get_db().delete(room)\n get_db().commit()\n\n return '', 204",
"def delete(room_id):\n\n entry = Room.objects.filter(room_id=room_id).first()\n if entry is not None:\n ... | [
"0.75883484",
"0.7249882",
"0.7106703",
"0.6870992",
"0.6845861",
"0.6756054",
"0.6447494",
"0.61066645",
"0.6056316",
"0.60416424",
"0.6032315",
"0.5927218",
"0.5903477",
"0.5894329",
"0.5827776",
"0.5781087",
"0.5772563",
"0.5771816",
"0.56879765",
"0.5668034",
"0.56647044"... | 0.6588966 | 6 |
Train an HMM based on training data | def model_training(train_data, tags):
# unique_words.keys() contains all unique words
unique_words = get_unique_words(train_data)
word2idx = {}
tag2idx = dict()
S = len(tags)
###################################################
# build two dictionaries
# - from a word t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_machine(data,init_model_file):\n M = MyHmmLog(init_model_file)\n M.forward_backward_multi(data)\n\n return(M)",
"def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)",
"def train(self, X, y):\n m,d = X.shape\n D = np.array([1/m] * m)\n for t in ... | [
"0.73257846",
"0.69666076",
"0.67553365",
"0.67345273",
"0.66975105",
"0.66806304",
"0.6637505",
"0.65961576",
"0.6585072",
"0.6513219",
"0.64997244",
"0.64912164",
"0.6443986",
"0.6439488",
"0.64357275",
"0.64325285",
"0.6417168",
"0.6415531",
"0.64106786",
"0.6407315",
"0.6... | 0.680015 | 2 |
This method uses Mpesa's Account Balance API to to enquire the balance on an MPesa BuyGoods (Till Number). | def get_balance(self, initiator=None, security_credential=None, command_id=None, party_a=None, identifier_type=None,
remarks=None, queue_timeout_url=None, result_url=None):
payload = {
"Initiator": initiator,
"SecurityCredential": security_credential,
"Co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_balance(self, params={}):\n self.load_markets()\n response = self.privateGetAccountBalanceV2(params)\n #\n # {\n # \"AVAILABLE_NIS\": 0.0,\n # \"NIS\": 0.0,\n # \"LOCKED_NIS\": 0.0,\n # \"AVAILABLE_BTC\": 0.0,\n ... | [
"0.6183809",
"0.60218394",
"0.5990576",
"0.58276963",
"0.5825441",
"0.57585245",
"0.5736525",
"0.57071286",
"0.5662124",
"0.56582934",
"0.5622757",
"0.5609526",
"0.5600949",
"0.5598767",
"0.5588827",
"0.5532321",
"0.55312675",
"0.5508182",
"0.549749",
"0.5485268",
"0.5472958"... | 0.0 | -1 |
Builds the protocol, with custom __init__ | def buildProtocol(self,addr):
p = self.protocol(self.server)
p.factory = self
return p | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def buildProtocol(self, addr):\n p = self.protocol()\n p.factory = self\n\n return p",
"def __init__(self, protocol):\r\n self._protocol = protocol",
"def __init__(self, proto):\n self.proto = proto",
"def buildProtocol(self, addr):\r\n p = RCERobotProtocol(self._con... | [
"0.77524734",
"0.75429153",
"0.7479376",
"0.72501886",
"0.7247391",
"0.71940553",
"0.716553",
"0.71436805",
"0.7138097",
"0.7100936",
"0.7074004",
"0.70103806",
"0.7001368",
"0.69524616",
"0.69453406",
"0.69388264",
"0.6899926",
"0.6879389",
"0.6875836",
"0.68434674",
"0.6843... | 0.7732145 | 1 |
returns (T/F, , ) | def compare_lists(self, list1, list2):
matching_items = []
list1 = list1.copy()
list2 = list2.copy()
for item in list1:
if item in list2:
matching_items.append(item)
for m in matching_items:
for c in range(list1.count(m)):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_result(self):\r\n return (self.x, self.lambd, self.z)",
"def get_result(self):\r\n return (self.x, self.lambd)",
"def get_tuple(self):\n return (self.r, self.g, self.b)",
"def get_tuple(self):\n return (self.r, self.g, self.b)",
"def tuple(x):\n pass",
"def state_(sta... | [
"0.6303432",
"0.6213342",
"0.5941266",
"0.5941266",
"0.59356415",
"0.5917332",
"0.5840698",
"0.58312476",
"0.5790434",
"0.57337785",
"0.56625915",
"0.5658932",
"0.5611274",
"0.560356",
"0.55711305",
"0.5556784",
"0.55530006",
"0.55530006",
"0.55397177",
"0.55278975",
"0.54703... | 0.0 | -1 |
Removes either requirements files and folderor the Pipfile. | def clean_extra_package_managment_files():
use_pipenv = '{{cookiecutter.use_pipenv}}'
to_delete = []
if use_pipenv == 'yes':
to_delete = to_delete + ['requirements.txt', 'requirements']
else:
to_delete.append('Pipfile')
try:
for file_or_dir in to_delete:
if os.p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleanUpPackage(inProgressFilename, packageFilename, propFilename):\n try:\n for filename in (inProgressFilename, packageFilename, propFilename):\n if (filename is not None and os.path.exists(filename)):\n os.remove(filename)\n\n except OSError, osErr :... | [
"0.68664074",
"0.6558787",
"0.6464328",
"0.64382523",
"0.6396354",
"0.62534225",
"0.6024302",
"0.59059006",
"0.58895797",
"0.58886045",
"0.58619416",
"0.5846468",
"0.5843512",
"0.5818951",
"0.5815958",
"0.58048683",
"0.5797034",
"0.5782184",
"0.57627606",
"0.57581764",
"0.575... | 0.78929734 | 0 |
True iff is executable file (owner, group or other). | def is_executable(fname):
return os.path.isfile(fname) and os.stat(fname)[0] & MASK_EXEC | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_exe(fpath):\n\treturn os.path.isfile(fpath) and os.access(fpath, os.X_OK)",
"def is_exe(fpath):\n return os.path.isfile(fpath) and os.access(fpath, os.X_OK)",
"def is_exe(fpath):\n return os.path.isfile(fpath) and os.access(fpath, os.X_OK)",
"def is_exe(fpath):\n return os.pat... | [
"0.7857346",
"0.78550386",
"0.78550386",
"0.78512764",
"0.78447527",
"0.7804142",
"0.77570915",
"0.77127725",
"0.74625576",
"0.7386272",
"0.73597187",
"0.72010404",
"0.6978311",
"0.6937337",
"0.68281883",
"0.6818289",
"0.6699933",
"0.6605572",
"0.65465957",
"0.64996475",
"0.6... | 0.8172241 | 0 |
Format a subsection, indented from start by pad. | def sub_section(title, lines, pad_len=4, sep='-'):
pad = pad_len * " "
msg = "{pad}{}\n{pad}{}\n".format(title, sep * len(title), pad=pad)
msg += pad + ("\n" + pad).join(lines) + "\n"
return msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_sub_section(self, s, level=0):\n section = s.capitalize()\n\n self.print_newline()\n self._write('%s+ %s\\n' % ('-' * level, section))\n self.print_newline()",
"def print_section(section_name, width=120):\n section_name = ' ' + section_name + ' '\n print('{:=^{ }}'.fo... | [
"0.64485496",
"0.6437143",
"0.6335083",
"0.61184055",
"0.5702746",
"0.5643843",
"0.56366056",
"0.5630538",
"0.5606433",
"0.5604374",
"0.55931115",
"0.5564454",
"0.5529032",
"0.5523129",
"0.54856855",
"0.54148674",
"0.54050434",
"0.54030937",
"0.5379921",
"0.532174",
"0.530255... | 0.7129455 | 0 |
Return a parser for args. | def make_parser():
parser = argparse.ArgumentParser(prog=__file__.replace(".py", ""),
description='simple $PATH tool')
parser.add_argument('-n', '--nocolor', dest="color",
action="store_false", default=True,
help='Turn off ANSI... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_parser():\n\n parser = parser.ArgumentParser()\n return parser",
"def get_parser():\n parser = argparse.ArgumentParser()\n # parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)\n parser.add_argument('files', nargs=... | [
"0.80607295",
"0.79784435",
"0.79425544",
"0.7882554",
"0.78020525",
"0.78020525",
"0.77708155",
"0.7769092",
"0.7721474",
"0.77003515",
"0.7685472",
"0.76680815",
"0.76204103",
"0.7563151",
"0.7546426",
"0.7480144",
"0.74683696",
"0.745643",
"0.7438078",
"0.7414349",
"0.7413... | 0.69266355 | 92 |
Check for possible matches to exe at path. | def check_exec(path, exe, show_version=False):
bin_path = os.path.join(path, exe)
msg = ""
if is_executable(bin_path):
if show_version:
msg += check_version(bin_path)
else:
msg += sub_section("!!! MATCH !!!", [bin_path, ""])
matches = glob.glob(os.path.join(path... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_in_path(self):\n exe = self.command.split()[0]\n for try_path in os.environ[\"PATH\"].split(os.pathsep):\n try_path = try_path.strip('\"')\n exe_try = os.path.join(try_path, exe).strip()\n if os.path.isfile(exe_try) and os.access(exe_try, os.X_OK):\n ... | [
"0.70977217",
"0.68621993",
"0.6842875",
"0.6819586",
"0.6773935",
"0.64745903",
"0.6452131",
"0.64097303",
"0.6400948",
"0.63270223",
"0.63270223",
"0.6325007",
"0.6302778",
"0.6294873",
"0.6289575",
"0.62629926",
"0.62488735",
"0.6189989",
"0.6161732",
"0.6161732",
"0.61418... | 0.75544256 | 0 |
Process the replacements into internal tuple format. | def parse_replacements(args):
line = " ".join(args.terms).strip()
return [term.split(':') for term in line.split(',') if term] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_tuple(self, raw_tuple, sbj, rel, obj):\n pass",
"def replace_tuple(tuple_obj, replace_obj, replace_index):\n if len(tuple_obj) - 1 <= replace_index:\n return tuple_obj[:replace_index] + (replace_obj,) \n else:\n return tuple_obj[:replace_index] + (replace_obj,) + tuple_obj[... | [
"0.60645664",
"0.596352",
"0.5708876",
"0.5707563",
"0.56878066",
"0.5561937",
"0.55278575",
"0.5430097",
"0.53901386",
"0.53640354",
"0.53531736",
"0.53211045",
"0.5271303",
"0.5262148",
"0.52306336",
"0.5228878",
"0.5197838",
"0.5192137",
"0.51294565",
"0.51221627",
"0.5101... | 0.0 | -1 |
Take a list of replacement tuples (search, replace) re patterns. Print out new export line. | def path_replace(args):
print(header("Substitutions Made"))
replacements = parse_replacements(args)
new_parts = []
for part in os.environ["PATH"].split(":"):
for search, replace in replacements:
new_part = re.sub(search, replace, part)
if part != new_part:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def substitute(files: str, pattern: str, replacement: str):\n with fileinput.input(\n files=glob.glob(files, recursive=True), inplace=True\n ) as file:\n for line in file:\n print(re.sub(pattern, replacement, line), end='')",
"def change_content(options):\n call_command('''grep ... | [
"0.62295485",
"0.60328466",
"0.5735031",
"0.57214606",
"0.564846",
"0.56222737",
"0.5562346",
"0.5554081",
"0.5444108",
"0.54035795",
"0.5399312",
"0.53953135",
"0.5350697",
"0.5320748",
"0.528762",
"0.5285287",
"0.52583975",
"0.52429044",
"0.5221077",
"0.52188325",
"0.520866... | 0.0 | -1 |
Print $PATH component per line. | def path_show(args):
print(header("$PATH Components"))
loop_fmt = "{pad}{color}{path}"
pad = 4
cnt = 0
for part in os.environ["PATH"].split(":"):
color = u""
if args.color:
color = CODES[cnt]
cnt = (cnt + 1) % len(CODES)
print(loop_fmt.format(pad=pad... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printPath(path):\r\n result = ''\r\n for i in range(len(path)):\r\n result = result + str(path[i])\r\n if i != len(path) - 1:\r\n result = result + '->'\r\n return result",
"def printPath(path):\n result = ''\n for i in range(len(path)):\n result = result + str(... | [
"0.710203",
"0.70772994",
"0.70381",
"0.66111684",
"0.6318243",
"0.6207814",
"0.61670434",
"0.61619496",
"0.6053944",
"0.5967311",
"0.5917095",
"0.5852896",
"0.58258593",
"0.5720003",
"0.56615204",
"0.5644261",
"0.56284446",
"0.56226504",
"0.5602241",
"0.5601295",
"0.5594626"... | 0.71891445 | 0 |
Look for all possible matches of executable. | def path_which(args):
print(header("$PATH Lookup: {}".format(args.look)))
loop_fmt = "{color}{path}"
cnt = 0
for part in os.environ["PATH"].split(":"):
color = u""
if args.color:
color = CODES[cnt]
msg = check_exec(part, args.look, args.version)
if msg:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_matching(self):\n paradic = self.cfg['param']['paradic']\n print 'in run_matching() n_bins = ' +str(paradic['n_bins'])\n\n f = open(self.work_dir+'matches.txt','w')\n matching = self.run_proc(['match_cli', 'keys_im0.txt',\n 'keys_im... | [
"0.6126602",
"0.6118211",
"0.6090246",
"0.58779657",
"0.5814293",
"0.5814293",
"0.5788314",
"0.5773406",
"0.5773245",
"0.5742053",
"0.5721195",
"0.5708473",
"0.56926095",
"0.5638261",
"0.5595538",
"0.55280715",
"0.5521406",
"0.5521406",
"0.5490311",
"0.5479858",
"0.5479664",
... | 0.0 | -1 |
Allows the calling code to just await the class instance itself to receive the server's response. ``` req_listener = FrameRequestListener(cdp, frame_id) ... Send Page.navigate and wait for the page to load ... response = await req_listener ``` | async def __await__(self):
return await self._update_task | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def test_frame_req_listener(cdp):\n req_listener = FrameRequestListener(cdp, \"frameid1\")\n url = \"http://www.example.com\"\n await cdp.send(\"Page.navigate\", dict(url=url))\n resp = await asyncio.wait_for(req_listener, timeout=1)\n assert resp[\"url\"] == url\n assert resp[\"status\"] =... | [
"0.7781475",
"0.58957887",
"0.5503354",
"0.54924667",
"0.54532903",
"0.5383229",
"0.53202593",
"0.53159255",
"0.52729875",
"0.51289403",
"0.5123881",
"0.5064385",
"0.5061238",
"0.50322825",
"0.502087",
"0.5005481",
"0.49966455",
"0.49933955",
"0.49806064",
"0.49541047",
"0.49... | 0.0 | -1 |
Subscribe to the relevant methods on the CDP client and update our state according to the messages received. Will store the request's response for access at .response but also return it, since implementing code may want to await this task's completion. | async def _get_frame_updates(self):
async for msg in self._cdp.subscribe(
["Network.requestWillBeSent", "Network.responseReceived"]
):
method = msg.get("method")
if (
self._request_id is None
and method == "Network.requestWillBeSent"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dispatch_from_client_request(self):\n # Listen for client connection\n self._from_client_request.listen()\n\n while not self._exit_request:\n readable, _, _ = select([self._from_client_request], [], [self._from_client_request], 0.1)\n\n if readable:\n ... | [
"0.6439713",
"0.6089261",
"0.57868326",
"0.57720816",
"0.5762121",
"0.5738564",
"0.57284933",
"0.5680007",
"0.5658361",
"0.55965817",
"0.55479205",
"0.5536851",
"0.55253345",
"0.5486333",
"0.5360091",
"0.5318257",
"0.53182286",
"0.5277352",
"0.52661777",
"0.5222918",
"0.52136... | 0.5468592 | 14 |
Print message and release semaphore | def run(self):
global frame
#acquire the semaphore
while True:
time.sleep(2)
self.s1.acquire()
self.empty.acquire()
#remove a table from the list
frame += 1
print "Producer1(%s):deliver frame, now frame:%s\n" %(self.name, frame)
self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task(t, msg, sem):\n if not t:\n while True:\n threading.Event().wait(1)\n sem.acquire()\n print(msg)\n sem.release()\n \n threading.Event().wait(t)\n sem.acquire()\n print(msg)\n sem.release()",
"def run(self): \n\n #acquire the sem... | [
"0.6507646",
"0.6247291",
"0.6177225",
"0.60861987",
"0.5935307",
"0.5914156",
"0.5850585",
"0.5694712",
"0.5693247",
"0.56219625",
"0.5570693",
"0.5509171",
"0.54552114",
"0.5356789",
"0.5344732",
"0.53271025",
"0.53266275",
"0.5312645",
"0.53056955",
"0.5161909",
"0.5155182... | 0.60731184 | 4 |
Print message and release semaphore | def run(self):
#acquire the semaphore
global wheel
while True:
time.sleep(2)
self.s2.acquire()
self.empty.acquire()
#remove a table from the list
wheel += 1
print "Producer2(%s):deliver wheels, now wheels:%s\n" %(self.name, wheel)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task(t, msg, sem):\n if not t:\n while True:\n threading.Event().wait(1)\n sem.acquire()\n print(msg)\n sem.release()\n \n threading.Event().wait(t)\n sem.acquire()\n print(msg)\n sem.release()",
"def printTerminal(self,message):\n s... | [
"0.6507004",
"0.61781317",
"0.6085564",
"0.6073453",
"0.5934985",
"0.5912831",
"0.5851326",
"0.5693102",
"0.5692599",
"0.56209695",
"0.5569729",
"0.55099505",
"0.5456613",
"0.535847",
"0.5344952",
"0.53287536",
"0.53285146",
"0.5310402",
"0.53056663",
"0.5160753",
"0.5154181"... | 0.6246595 | 1 |
Print message and release semaphore | def run(self):
#acquire the semaphore
global frame, wheel
while True:
self.frame.acquire()
frame -= 1
print "Consumer(%s):consume frame, now frame:%s, wheels:%s\n" %(self.name, frame,wheel)
self.empty.release()
self.s1.release()
sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task(t, msg, sem):\n if not t:\n while True:\n threading.Event().wait(1)\n sem.acquire()\n print(msg)\n sem.release()\n \n threading.Event().wait(t)\n sem.acquire()\n print(msg)\n sem.release()",
"def run(self): \n\n #acquire the sem... | [
"0.6507004",
"0.6246595",
"0.61781317",
"0.6085564",
"0.6073453",
"0.5934985",
"0.5851326",
"0.5693102",
"0.5692599",
"0.56209695",
"0.5569729",
"0.55099505",
"0.5456613",
"0.535847",
"0.5344952",
"0.53287536",
"0.53285146",
"0.5310402",
"0.53056663",
"0.5160753",
"0.5154181"... | 0.5912831 | 6 |
List all properties of basic device info. | def get_all_properties(self) -> dict:
return self._request(
"post",
URL,
json=attr.asdict(
Body("getAllProperties", API_VERSION),
filter=attr.filters.exclude(attr.fields(Body).params),
),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_device_properties(device):\n results = devices.show(device)\n return jsonify(results)",
"def show_device_information(self):\n\n if self._json_format:\n print(json.dumps(self._devices, indent=4, separators=(',', ': ')))\n return\n\n if self._long_format:\n ... | [
"0.7224436",
"0.69882584",
"0.6870148",
"0.684819",
"0.68050116",
"0.6734287",
"0.6725266",
"0.6722293",
"0.672137",
"0.6707975",
"0.66974556",
"0.66965103",
"0.66915286",
"0.663443",
"0.66337585",
"0.66200083",
"0.6614157",
"0.66104627",
"0.6567677",
"0.655962",
"0.6557591",... | 0.58687687 | 74 |
Supported versions of basic device info. | def get_supported_versions(self) -> dict:
return self._request(
"post",
URL,
json=attr.asdict(
Body("getSupportedVersions", API_VERSION),
filter=attr.filters.include(attr.fields(Body).method),
),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def describe_operating_systems():\n pass",
"async def get_supported_versions(self) -> dict:\n return await self._request(\n \"post\",\n URL,\n json=attr.asdict(\n Body(\"getSupportedVersions\", API_VERSION),\n filter=attr.filters.include(at... | [
"0.6551261",
"0.6519274",
"0.63338304",
"0.63266027",
"0.6314766",
"0.6290253",
"0.6233164",
"0.6215169",
"0.61937606",
"0.6175725",
"0.61719143",
"0.61708254",
"0.61484885",
"0.6137339",
"0.61184305",
"0.6097981",
"0.6070972",
"0.6043239",
"0.6032416",
"0.60188454",
"0.60020... | 0.6517144 | 2 |
Test day 9 pt 1 example | def test_example_day9_pt1():
assert find_first_invalid_value(ex_data, 5) == 127 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def day_07_a() -> int:\n return 0",
"def day_07_b() -> int:\n return 0",
"def day_06_a() -> int:\n return 0",
"def day_06_b() -> int:\n return 0",
"def test_example_day9_pt2():\n assert find_pt2(ex_data, 127) == 62",
"def test_one_date(self):\n result = beautiful_days_at_the_movies(... | [
"0.66768205",
"0.6615932",
"0.6592941",
"0.65676045",
"0.6432809",
"0.6418628",
"0.629521",
"0.6287255",
"0.62436795",
"0.6216219",
"0.620751",
"0.61786187",
"0.6149081",
"0.6050683",
"0.59695494",
"0.5918625",
"0.59050393",
"0.5881981",
"0.5872549",
"0.5864946",
"0.5842901",... | 0.5884818 | 17 |
Test day 9 pt 2 example | def test_example_day9_pt2():
assert find_pt2(ex_data, 127) == 62 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def day_07_b() -> int:\n return 0",
"def day_06_b() -> int:\n return 0",
"def day_07_a() -> int:\n return 0",
"def day_06_a() -> int:\n return 0",
"def doomsday(y):",
"def test_return_day(self):\n self.assertEqual(functions.return_day(1), \"Sunday\")\n self.assertEqual(functions... | [
"0.66136426",
"0.65968823",
"0.65888894",
"0.6534475",
"0.6455408",
"0.62773323",
"0.62683856",
"0.6199411",
"0.61122984",
"0.6112137",
"0.6108768",
"0.60916567",
"0.5983843",
"0.5955555",
"0.59325564",
"0.5862882",
"0.58470434",
"0.58446056",
"0.5806196",
"0.57691044",
"0.57... | 0.6675447 | 0 |
Reads and parses a mobileprovision file. | def _parse_mobileprovision_file(mobileprovision_file):
plist_xml = subprocess.check_output([
"security",
"cms",
"-D",
"-i",
mobileprovision_file,
])
return plist_from_bytes(plist_xml) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_file(cls, filepath):\n hdus = sunpy.io.read_file(filepath)\n return cls._parse_hdus(hdus)",
"def read_file(self, path):\n # pylint: disable=unused-variable\n info, pformat, error = (\n NSPropertyListSerialization.propertyListWithData_options_format_error_(\n ... | [
"0.5590612",
"0.5553365",
"0.54044497",
"0.534706",
"0.5318232",
"0.5283724",
"0.5156748",
"0.5154537",
"0.5145966",
"0.5137374",
"0.5096504",
"0.5045959",
"0.5041562",
"0.50315565",
"0.50198287",
"0.50038105",
"0.49572635",
"0.4953668",
"0.49524236",
"0.4924946",
"0.49201283... | 0.79925627 | 0 |
Extracts a fingerprint given identity in a mobileprovision file. | def _certificate_fingerprint(identity):
fingerprint, stderr = _check_output([
"openssl",
"x509",
"-inform",
"DER",
"-noout",
"-fingerprint",
],
inputstr=identity)
fingerprint = fingerprint.strip()
fingerprint = fingerprint.replace("SHA1 F... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_codesign_identity(mobileprovision):\n mpf = _parse_mobileprovision_file(mobileprovision)\n ids_codesign = set(_find_codesign_identities())\n for id_mpf in _get_identities_from_provisioning_profile(mpf):\n if id_mpf in ids_codesign:\n return id_mpf",
"def get_fingerprint(filepath):\n ssh_f... | [
"0.60970294",
"0.601819",
"0.5771598",
"0.571872",
"0.5426172",
"0.54161966",
"0.52399874",
"0.5210045",
"0.5057412",
"0.5023342",
"0.49945107",
"0.4979701",
"0.49658775",
"0.49546024",
"0.49384612",
"0.48876852",
"0.48820275",
"0.487908",
"0.48705924",
"0.48408952",
"0.48177... | 0.5360046 | 6 |
Iterates through all the identities in a provisioning profile, lazily. | def _get_identities_from_provisioning_profile(mpf):
for identity in mpf["DeveloperCertificates"]:
if not isinstance(identity, bytes):
# Old versions of plistlib return the deprecated plistlib.Data type
# instead of bytes.
identity = identity.data
yield _certificate_fingerprint(identity) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def identities(self, generator=False, **kwargs):\n g = self._iter(body=self._identities_iter(), **kwargs)\n if generator:\n return g\n\n return list(g)",
"def gen_all_identities():\r\n def _build_identity_dict(mail, display_name, given_name, surname):\r\n \"\"\" Helper f... | [
"0.5671057",
"0.5487254",
"0.54406685",
"0.54327255",
"0.5364077",
"0.5348866",
"0.52735037",
"0.52366084",
"0.5212863",
"0.52043575",
"0.51688963",
"0.5133527",
"0.51135033",
"0.50762534",
"0.50690883",
"0.505527",
"0.5040877",
"0.498099",
"0.49657348",
"0.49113193",
"0.4898... | 0.6923592 | 0 |
Finds code signing identities on the current system. | def _find_codesign_identities(identity=None):
ids = []
output, stderr = _check_output([
"security",
"find-identity",
"-v",
"-p",
"codesigning",
])
output = output.strip()
pattern = "(?P<hash>[A-F0-9]{40})"
if identity:
name_requirement = re.escape(identity)
pattern += r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_codesign_identity(mobileprovision):\n mpf = _parse_mobileprovision_file(mobileprovision)\n ids_codesign = set(_find_codesign_identities())\n for id_mpf in _get_identities_from_provisioning_profile(mpf):\n if id_mpf in ids_codesign:\n return id_mpf",
"def select_identity(self, identity=None):... | [
"0.6421708",
"0.54043686",
"0.5334617",
"0.52265114",
"0.522643",
"0.52062505",
"0.5130264",
"0.511829",
"0.50554866",
"0.5008744",
"0.49713695",
"0.49288473",
"0.49230838",
"0.49016324",
"0.48784655",
"0.48597527",
"0.48185772",
"0.4810502",
"0.4771155",
"0.47399005",
"0.472... | 0.7543346 | 0 |
Finds a valid identity on the system given a mobileprovision file. | def _find_codesign_identity(mobileprovision):
mpf = _parse_mobileprovision_file(mobileprovision)
ids_codesign = set(_find_codesign_identities())
for id_mpf in _get_identities_from_provisioning_profile(mpf):
if id_mpf in ids_codesign:
return id_mpf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_mobileprovision_file(mobileprovision_file):\n plist_xml = subprocess.check_output([\n \"security\",\n \"cms\",\n \"-D\",\n \"-i\",\n mobileprovision_file,\n ])\n return plist_from_bytes(plist_xml)",
"def validate_registration(photo_file):\n try:\n print photo_file... | [
"0.6467533",
"0.5665235",
"0.51435935",
"0.513177",
"0.50548524",
"0.5017768",
"0.50087833",
"0.49981916",
"0.4991477",
"0.4970559",
"0.49571303",
"0.4952973",
"0.49484116",
"0.48670015",
"0.4831454",
"0.48018855",
"0.47946084",
"0.47926822",
"0.47809008",
"0.47726947",
"0.47... | 0.76620007 | 0 |
Filters the codesign output which can be extra verbose. | def _filter_codesign_output(codesign_output):
filtered_lines = []
for line in codesign_output.splitlines():
if line and not _BENIGN_CODESIGN_OUTPUT_REGEX.search(line):
filtered_lines.append(line)
return "\n".join(filtered_lines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def code_signing_flag(self) -> pulumi.Output[Optional[bool]]:\n return pulumi.get(self, \"code_signing_flag\")",
"def filter_output(self, request, output):\n return output",
"def code_signing_flag(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"code_signing_flag\")",
"... | [
"0.5447408",
"0.5430029",
"0.51496136",
"0.51496136",
"0.51020837",
"0.49993205",
"0.4966443",
"0.49411124",
"0.49411124",
"0.49401996",
"0.49248642",
"0.49200615",
"0.49023876",
"0.48853683",
"0.4876729",
"0.48188573",
"0.47790682",
"0.47667938",
"0.47568908",
"0.4747938",
"... | 0.77639204 | 0 |
Retrieve all reviews of the place linked to a given place_id. Raise 404 error otherwise | def get_all_reviews(place_id):
if storage.get(Place, place_id) is None:
abort(404)
review_dict = storage.all(Review)
review_list = []
for rev in review_dict.values():
if rev.place_id == place_id:
rev = rev.to_dict()
review_list.append(rev)
return jsonify(revie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_reviews(place_id):\n place_obj = storage.get(Place, place_id)\n if place_obj:\n review_objs = storage.all(Review).values()\n list_review = []\n for review in review_objs:\n if review.place_id == place_id:\n list_review.append(review.to_dict())\n r... | [
"0.8031854",
"0.79805255",
"0.7842225",
"0.78043664",
"0.77307296",
"0.7228094",
"0.63471323",
"0.6223297",
"0.62177956",
"0.61954427",
"0.61514324",
"0.6089859",
"0.60256547",
"0.6015809",
"0.59602535",
"0.59458554",
"0.5896388",
"0.5859244",
"0.58316237",
"0.5791611",
"0.57... | 0.7653365 | 5 |
Retrieve Review object linked to a given id. Raise 404 otherwise. | def get_review(review_id):
obj = storage.get(Review, review_id)
if obj is None:
abort(404)
return jsonify(obj.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def review_by_id(review_id):\n obj = storage.get(\"Review\", review_id)\n if obj is None:\n abort(404)\n return jsonify(obj.to_dict())",
"def get_review(review_id):\n review_obj = storage.get(Review, review_id)\n if review_obj:\n return jsonify(review_obj.to_dict())\n else:\n ... | [
"0.7849977",
"0.7844131",
"0.7713734",
"0.7596643",
"0.7460891",
"0.7426047",
"0.7291556",
"0.72661453",
"0.72548705",
"0.67882025",
"0.675542",
"0.66654414",
"0.6554932",
"0.6416079",
"0.6391107",
"0.6358962",
"0.62568206",
"0.60172886",
"0.59416884",
"0.59282947",
"0.590417... | 0.77692515 | 2 |
Delete Review from storage. If successful, return empty dictionary with status code 200, otherwise raise 404 error. | def delete_review(review_id):
obj = storage.get(Review, review_id)
if obj is None:
abort(404)
storage.delete(obj)
storage.save()
return jsonify({}), 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_review(review_id=None):\n if storage.get(Review, review_id):\n storage.delete(storage.get(Review, review_id))\n storage.save()\n return jsonify({})\n else:\n abort(404)",
"def delete_review(review_id):\n obj = storage.get(\"Review\", review_id)\n if obj is None:... | [
"0.8092912",
"0.7992279",
"0.7952988",
"0.7860057",
"0.76822627",
"0.71988267",
"0.70540226",
"0.70251113",
"0.653468",
"0.6435492",
"0.6234737",
"0.61351496",
"0.61250883",
"0.6110615",
"0.6102468",
"0.6071161",
"0.58521837",
"0.5665856",
"0.56452197",
"0.56336355",
"0.56074... | 0.8044858 | 1 |
Create a new Review object related to the given place, and add to storage. Raise error 400 if request body is not JSON format, if no user_id is given, or if no text is given. Return the new Review with status code 201. | def add_review(place_id):
# Check that user input is correct
user_input = request.get_json()
if user_input is None:
abort(400, {'message': 'Not a JSON'})
elif user_input.get('text') is None:
abort(400, {'message': 'Missing text'})
elif user_input.get('user_id') is None:
abort... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_review(place_id=None):\n place = storage.get(Place, place_id)\n if place:\n review = request.get_json()\n if not review:\n abort(400, \"Not a JSON\")\n if \"user_id\" not in review:\n abort(400, \"Missing user_id\")\n if not storage.get(\"User\", r... | [
"0.8625276",
"0.8415818",
"0.8271317",
"0.80899394",
"0.75445044",
"0.6510882",
"0.6362447",
"0.62583506",
"0.605817",
"0.59935933",
"0.58284825",
"0.5780428",
"0.57760066",
"0.5767837",
"0.5520601",
"0.5484631",
"0.5453185",
"0.5438515",
"0.5425629",
"0.5394038",
"0.53829694... | 0.8275589 | 2 |
Update a Review object. Raise 404 error if review_id is not linked to a Review, 400 if the request body is not valid JSON data. Return Review dictionary with status code 200 otherwise. | def update_review(review_id):
user_input = request.get_json()
if user_input is None:
abort(400, {'message': 'Not a JSON'})
obj = storage.get(Review, review_id)
if obj is None:
abort(404)
for k, v in user_input.items():
if k not in ['id', 'user_id', 'place_id',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_review(review_id):\n review_obj = storage.get(Review, review_id)\n if review_obj:\n body_dic = request.get_json()\n if not body_dic:\n return jsonify({'error': 'Not a JSON'}), 400\n for key, value in body_dic.items():\n setattr(review_obj, key, value)\n ... | [
"0.82450074",
"0.82270336",
"0.8185605",
"0.7904952",
"0.7187071",
"0.6835401",
"0.6708264",
"0.6448361",
"0.6329704",
"0.6321135",
"0.6019502",
"0.6008733",
"0.59540486",
"0.59440637",
"0.58708715",
"0.58403367",
"0.57342505",
"0.57078063",
"0.5680967",
"0.56521666",
"0.5621... | 0.78249574 | 4 |
Returns the running sum of a given list of numbers | def running_sum(nums_li: List[int]) -> List[int]:
for i in range(1, len(nums_li)):
nums_li[i] += nums_li[i - 1]
return nums_li | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum_of_numbers(numbers):\r\n return sum(numbers)",
"def sum_list(numbers):\n\t\n\tif len(numbers) == 0:\n\t\treturn 0 \n\n\tsum = numbers[0] +sum_list(numbers[1:])\n\treturn sum",
"def sum_numbers(sequence):\r\n\r\n total = 0\r\n seq = get_numbers(sequence)\r\n for element in seq:\r\n to... | [
"0.71576524",
"0.69815713",
"0.6841886",
"0.6837456",
"0.6800794",
"0.6772406",
"0.67528427",
"0.67181194",
"0.6673988",
"0.65260226",
"0.65095073",
"0.64830434",
"0.64651746",
"0.6440968",
"0.6426239",
"0.6422132",
"0.6415855",
"0.64094716",
"0.63918203",
"0.63566345",
"0.63... | 0.83650804 | 0 |
Add poisson noise to the sinogram. | def add_poisson_noise_deprecated(self, snr=5):
flag = False
temp = np.copy(self.sinogram)
if np.isclose(temp.max(), 1):
snr += 3
temp = temp * 10000.
flag = True
x_ref_norm_sq = np.linalg.norm(temp) ** 2
lam = x_ref_norm_sq / pow(10., snr/10.) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_poisson_noise(self, sinogram, max_count=1000):\n\n temp = np.copy(sinogram)\n temp = temp * max_count\n temp = np.random.poisson(temp).astype('float')\n return temp / max_count",
"def add_poisson_noise(self):\n\n # Can be done without loops, but this reduces memory requ... | [
"0.8177312",
"0.79445064",
"0.76086766",
"0.74834347",
"0.670996",
"0.66914463",
"0.65419954",
"0.6426317",
"0.6410218",
"0.63080287",
"0.62796485",
"0.62407404",
"0.62318236",
"0.61993545",
"0.61238045",
"0.6062723",
"0.603536",
"0.6005666",
"0.5956273",
"0.59545517",
"0.594... | 0.7924378 | 2 |
Feed raw (not minuslogged) sinogram. | def add_poisson_noise(self, sinogram, max_count=1000):
temp = np.copy(sinogram)
temp = temp * max_count
temp = np.random.poisson(temp).astype('float')
return temp / max_count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spew_fake_data(self, ideal_datapoint=None):\n if not ideal_datapoint:\n ideal_datapoint = 0\n for chan, wsock in self._chan_to_wsocket.items():\n if chan.stream_type == \"Integrated\":\n length = 1\n data = 0.5 + 0.1*(np.random.random(length).as... | [
"0.56662464",
"0.56494576",
"0.5452499",
"0.5403465",
"0.5392977",
"0.5359452",
"0.5254567",
"0.52149475",
"0.5201187",
"0.51998246",
"0.51904345",
"0.5170478",
"0.5113757",
"0.5108657",
"0.50941855",
"0.5092163",
"0.5084607",
"0.5078546",
"0.50472206",
"0.5040828",
"0.503474... | 0.0 | -1 |
Create a block with the given ID and return it. | def CreateBlock(self, props):
# Set some default properties
# blk / cfg | name | name+inst
# -----------------------------
# name | n==n | False
# name+inst | n==n | n==n&&i==i
if 'ordinal' not in props and 'name' in props:
for ordinal, ni in self.config... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_block(world: World, block_id: str, x: int, y: int, *args):\n block_id = BLOCKS[block_id]\n if block_id == \"mystery_empty\":\n block = MysteryBlock()\n elif block_id == \"mystery_coin\":\n block = MysteryBlock(drop=\"coin\", drop_range=(3, 6))\n elif block_id == \"bounce_block\... | [
"0.70892054",
"0.6922745",
"0.6734681",
"0.67146844",
"0.6691439",
"0.66598445",
"0.6569314",
"0.6507948",
"0.6451737",
"0.6438023",
"0.64173955",
"0.631916",
"0.6271522",
"0.6259364",
"0.6188753",
"0.61676276",
"0.6142407",
"0.61034083",
"0.60966974",
"0.60704386",
"0.606842... | 0.6633076 | 6 |
Find a block, or create it if it doesn't exist. | def FindOrCreateBlock(self, name, instance):
try:
return self.FindBlock(name, instance)
except KeyError:
return self.CreateBlock({'name': name, 'instance': instance}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_block(self, addr):\n ret_block = None\n\n tag, set_index, offset = self._decompose(addr)\n\n if set_index not in self._d:\n self._d[set_index] = []\n block_list = self._d[set_index]\n for tag_, block in block_list:\n if tag == tag_:\n ... | [
"0.63424957",
"0.6085005",
"0.6040332",
"0.59542054",
"0.595163",
"0.59020936",
"0.58659786",
"0.5862695",
"0.5800195",
"0.57171696",
"0.57031226",
"0.56728184",
"0.56365144",
"0.55348146",
"0.5521383",
"0.5520552",
"0.5496947",
"0.54944897",
"0.5471456",
"0.54080755",
"0.537... | 0.78933555 | 0 |
Yield the blocks in their defined order | def __iter__(self):
for block in sorted(self.blocks.values(), key=lambda b: b.ordinal):
yield block | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blocks(self):\n if self._ast:\n for block in self._ast[2]:\n yield block",
"def collect_blocks():\n\n # Below are the position of (c,r) in a block.\n\n #########################\n # (0,0) # (1,0) # (2,0) #\n #########################\n #########################... | [
"0.757031",
"0.6530753",
"0.65174127",
"0.63614154",
"0.63607633",
"0.63177335",
"0.63156325",
"0.6270871",
"0.6268873",
"0.62680745",
"0.6179819",
"0.6109972",
"0.6073869",
"0.60731417",
"0.6064365",
"0.60582024",
"0.6050395",
"0.6039829",
"0.5925948",
"0.5923637",
"0.591227... | 0.7572616 | 0 |
Get a generator's configuration block | def GetConfig(self, genname):
if genname in self.config:
return self.config[genname]
else:
return dbus.Dictionary(signature='sv') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config_template(self) -> cconfig.Config:",
"def get_block_config():\n ret = {}\n ret[keyword.function] = []\n ret[keyword.inputs] = []\n ret[keyword.expect] = []\n return ret",
"def get_config():\n return _config",
"def _get_config(self):\n return self.__config",
"def _get_conf... | [
"0.68650293",
"0.62197065",
"0.6217368",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",
"0.62074995",... | 0.584978 | 99 |
Performs a bulk update of properties. Issues only one changed event for the entire update. | def Update(self, values):
# XXX: Rewrite to validate without fragile locks
with self._change_lock:
for prop, value in values.items():
if prop in self.__properties__:
setattr(self, prop, value)
else:
self._props[prop] = v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_multiple_objects_properties(self, object_list):\n\n #if self.settings.LOG_VERBOSE and self.settings.ENABLE_OBJECT_LOGGING: logger.debug(\"Processing multiple object properties updates: %s\" % (len(object_list)))\n\n for object_properties in object_list:\n\n self.update_object_pr... | [
"0.66578263",
"0.6543413",
"0.6513449",
"0.64142585",
"0.64012647",
"0.6382263",
"0.6328527",
"0.6231375",
"0.6205191",
"0.6145095",
"0.6109039",
"0.6012963",
"0.5999936",
"0.5995834",
"0.59565485",
"0.5932615",
"0.58797646",
"0.5834851",
"0.5812164",
"0.57771397",
"0.5743388... | 0.58494425 | 17 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.